diff --git a/IDA/project/Common.h b/IDA/project/Common.h new file mode 100644 index 0000000..2585cc0 --- /dev/null +++ b/IDA/project/Common.h @@ -0,0 +1,181 @@ +#pragma once + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "imgui.h" +#include "imgui_impl_dx11.h" +#include "imgui_impl_win32.h" + +extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); + +namespace Binary { +constexpr uintptr_t kImageBase = 0x180000000ull; +constexpr uintptr_t kDataBase = 0x1803C5000ull; +constexpr uintptr_t kIatBaseRva = 0x000B1000ull; + +constexpr uintptr_t kGConfigPanelPtrOffset = 0x15D8ull; +constexpr uintptr_t kShowPanelFlagOffset = 0x245Cull; +constexpr uintptr_t kActiveTabOffset = 0x1F68ull; +constexpr uintptr_t kLanguageIndexOffset = 0x27B0ull; +} // namespace Binary + +namespace RVA { +constexpr uint32_t DllMainEntry = 0x00001000; +constexpr uint32_t LoaderThread = 0x00005000; +constexpr uint32_t StartupMain = 0x000A9190; +constexpr uint32_t GABypassPatch = 0x000A9120; +constexpr uint32_t ModuleManagerInit = 0x0009AC10; + +constexpr uint32_t OverlayWindowInit = 0x000827A0; +constexpr uint32_t WndProc = 0x000826A0; +constexpr uint32_t D3D11Reinit = 0x000825B0; +constexpr uint32_t ImGuiWin32WndProcHandler = 0x00057720; + +constexpr uint32_t HookMgrCreateHook = 0x000A9CC8; +constexpr uint32_t HookMgrRemoveHook = 0x000A9E8C; +constexpr uint32_t HookMgrEnableHook = 0x000A9A9C; +constexpr uint32_t HookMgrAcquireSpinlock = 0x000A9C88; + +constexpr uint32_t SettingsTabRender = 0x0009A4F0; +constexpr uint32_t SidebarRender = 0x0007F8F0; +} // namespace RVA + +namespace IL2CPP { +constexpr uintptr_t GameObject_GetComponentByIndex = 0x1C48; +constexpr uintptr_t il2cpp_domain_get_assemblies_A = 0x1C50; +constexpr uintptr_t Component_GetComponent_Transform = 0x1C58; +constexpr uintptr_t Transform_get_localScale = 0x1C60; +constexpr uintptr_t Transform_get_rotation = 0x1C68; +constexpr uintptr_t il2cpp_object_get_class = 0x1C70; +constexpr uintptr_t il2cpp_class_get_method_from_name = 0x1C78; +constexpr uintptr_t Transform_get_localPosition = 0x1C80; +constexpr uintptr_t Transform_get_position = 0x1C88; +constexpr uintptr_t Transform_set_localPosition = 0x1C90; +constexpr uintptr_t GameObject_SetActive = 0x1C98; +constexpr uintptr_t GameObject_get_transform = 0x1CA0; +constexpr uintptr_t Transform_set_rotation = 0x1CA8; +constexpr uintptr_t GameObject_get_activeInHierarchy = 0x1CB0; +constexpr uintptr_t GameObject_get_tag = 0x1CB8; +constexpr uintptr_t GameObject_get_name = 0x1CC0; +constexpr uintptr_t GameObject_get_layer = 0x1CC8; +constexpr uintptr_t GameObject_get_scene = 0x1CD0; +constexpr uintptr_t Game_SkillBuff_A = 0x1CD8; +constexpr uintptr_t GetEntityName = 0x1CE0; +constexpr uintptr_t Component_GetComponents = 0x1CE8; +constexpr uintptr_t Component_GetComponentsInChildren = 0x1CF0; +constexpr uintptr_t Game_SkillSlot_A = 0x1CF8; +constexpr uintptr_t Object_get_name = 0x1D00; +constexpr uintptr_t Component_GetType_A = 0x1D08; +constexpr uintptr_t Component_GetType_B = 0x1D10; +constexpr uintptr_t Game_SkillSlot_B = 0x1D18; +constexpr uintptr_t Game_Combat_HitA = 0x1D20; +constexpr uintptr_t GetEntityManager = 0x1D28; +constexpr uintptr_t Game_Combat_HitB = 0x1D30; +constexpr uintptr_t Game_Movement_PhysA = 0x1D38; +constexpr uintptr_t Game_Movement_PhysB = 0x1D40; +constexpr uintptr_t Application_set_targetFrameRate = 0x1D48; +constexpr uintptr_t SceneManager_GetActiveScene = 0x1D50; +constexpr uintptr_t CinemachineBrain_GetActiveVCam = 0x1D58; +constexpr uintptr_t Game_EntityState_A = 0x1D60; +constexpr uintptr_t Transform_set_localScale = 0x1D68; +constexpr uintptr_t Rigidbody_get_velocity = 0x1D70; +constexpr uintptr_t Rigidbody_set_velocity = 0x1D78; +constexpr uintptr_t Object_Destroy = 0x1D80; +constexpr uintptr_t Transform_set_position = 0x1D88; +constexpr uintptr_t Game_EntityState_B = 0x1D90; +constexpr uintptr_t Input_GetAxis_MouseX = 0x1D98; +constexpr uintptr_t Game_PlayerState_A = 0x1DA0; +constexpr uintptr_t Game_PlayerState_B = 0x1DA8; +constexpr uintptr_t Game_PlayerHealthStat = 0x1DB0; +constexpr uintptr_t Camera_get_main = 0x1DC0; +constexpr uintptr_t GameObject_FindObjectOfType = 0x1DC8; +constexpr uintptr_t Game_SkillAction_C = 0x1DD8; +constexpr uintptr_t Camera_get_fieldOfView = 0x1DE8; +constexpr uintptr_t Game_EntityState_C = 0x1DF0; +constexpr uintptr_t Rigidbody_AddForce = 0x1E00; +constexpr uintptr_t CharCtrl_set_enabled = 0x1E08; +constexpr uintptr_t Game_SkillAction_F = 0x1E10; +constexpr uintptr_t Game_SkillAction_G = 0x1E18; +constexpr uintptr_t GetCharacterController = 0x1E20; +constexpr uintptr_t TMPro_set_text = 0x1E28; +constexpr uintptr_t UnityUI_Text_set_text = 0x1E30; +constexpr uintptr_t Game_SkillAction_I = 0x1E38; +constexpr uintptr_t Game_SkillAction_J = 0x1E40; +constexpr uintptr_t Game_EntityActor_D = 0x1E48; +constexpr uintptr_t Game_SkillAction_K = 0x1E50; +constexpr uintptr_t Game_SkillAction_L = 0x1E58; +constexpr uintptr_t Game_EntityActor_E = 0x1E60; +constexpr uintptr_t Game_EntityActor_F = 0x1E68; +constexpr uintptr_t il2cpp_domain_get = 0x1E70; +constexpr uintptr_t il2cpp_assembly_get_image = 0x1E78; +constexpr uintptr_t il2cpp_domain_get_assemblies_B = 0x1E80; +} // namespace IL2CPP + +struct Vec3 { + float x = 0.0f; + float y = 0.0f; + float z = 0.0f; +}; + +struct Quat { + float x = 0.0f; + float y = 0.0f; + float z = 0.0f; + float w = 1.0f; +}; + +enum class Language : uint32_t { + English = 0, + ZhCN = 1, +}; + +enum class MainTab : int { + About = 0, + Player = 1, + ESP = 2, + World = 3, + Visual = 4, + Settings = 5, +}; + +struct RuntimeConfig { + std::atomic running{false}; + std::atomic show_panel{true}; + std::atomic il2cpp_thread_attached{false}; + std::atomic active_tab{MainTab::About}; + std::atomic language{Language::English}; + std::atomic game_thread_id{0}; + uintptr_t game_assembly_base = 0; + HWND game_hwnd = nullptr; + HWND overlay_hwnd = nullptr; +}; + +extern RuntimeConfig g_Runtime; + +template +inline Fn BitCastFn(void* ptr) { + return reinterpret_cast(ptr); +} diff --git a/IDA/project/EF-Cheeto.vcxproj b/IDA/project/EF-Cheeto.vcxproj new file mode 100644 index 0000000..beb281d --- /dev/null +++ b/IDA/project/EF-Cheeto.vcxproj @@ -0,0 +1,134 @@ + + + + + Release + x64 + + + + + 17.0 + {8CC5BC39-2A80-4B58-BB4F-06C4A38E388E} + Win32Proj + EFCheeto + 10.0 + + + + + + DynamicLibrary + false + v143 + true + Unicode + + + + + + + + + + + + + + $(ProjectDir)bin\ + $(ProjectDir)obj\ + EF-Cheeto + true + + + + + Level3 + true + true + true + NDEBUG;WIN32;_WINDOWS;_USRDLL;_WINDLL;_UNICODE;UNICODE;%(PreprocessorDefinitions) + true + stdcpp17 + true + MaxSpeed + Speed + AnySuitable + MultiThreadedDLL + $(ProjectDir);$(ProjectDir)third_party\imgui;$(ProjectDir)third_party\imgui\backends;$(ProjectDir)third_party\nlohmann;%(AdditionalIncludeDirectories) + NotUsing + + + Windows + true + true + false + MachineX64 + + kernel32.lib; + user32.lib; + gdi32.lib; + shell32.lib; + d3d11.lib; + d3dcompiler.lib; + dwmapi.lib; + imm32.lib; + shcore.lib; + xinput.lib; + ntdll.lib; + %(AdditionalDependencies) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/IDA/project/ESP.cpp b/IDA/project/ESP.cpp new file mode 100644 index 0000000..0ab7e85 --- /dev/null +++ b/IDA/project/ESP.cpp @@ -0,0 +1,41 @@ +#include "ESP.h" + +#include "helpers.h" + +ESPModule::ESPModule() + : BaseModule("ESPModule", "ESP Features", ModuleCategory::ESP) { +} + +void ESPModule::RegisterTab() { +} + +void ESPModule::Render() { + if (!ImGui::CollapsingHeader(Tr("ESP Features"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } + + ImGui::Separator(); + ImGui::TextUnformatted("Display Types"); + ImGui::Checkbox(Tr("Show Monsters"), &show_monsters_); + ImGui::Checkbox(Tr("Show NPC"), &show_npc_); + ImGui::Checkbox(Tr("Show Friendly"), &show_friendly_); + ImGui::Checkbox(Tr("Show Puzzles"), &show_puzzles_); + + ImGui::Separator(); + ImGui::TextUnformatted("Display Info"); + ImGui::Checkbox(Tr("Show Distance"), &show_distance_); + ImGui::Checkbox(Tr("Show Name"), &show_name_); + ImGui::Checkbox(Tr("Show Type"), &show_type_); +} + +void ESPModule::Update() { + if (!Enabled()) { + return; + } + // Runtime drawing in target process would happen from Present hook path. +} diff --git a/IDA/project/ESP.h b/IDA/project/ESP.h new file mode 100644 index 0000000..49e35ed --- /dev/null +++ b/IDA/project/ESP.h @@ -0,0 +1,21 @@ +#pragma once + +#include "ModuleManager.h" + +class ESPModule final : public BaseModule { +public: + ESPModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + bool show_monsters_ = true; + bool show_npc_ = true; + bool show_friendly_ = false; + bool show_puzzles_ = false; + bool show_distance_ = true; + bool show_name_ = true; + bool show_type_ = true; +}; diff --git a/IDA/project/FPSModule.cpp b/IDA/project/FPSModule.cpp new file mode 100644 index 0000000..7d5467d --- /dev/null +++ b/IDA/project/FPSModule.cpp @@ -0,0 +1,40 @@ +#include "FPSModule.h" + +#include + +#include "helpers.h" + +namespace { + +std::atomic g_fps_overlay_enabled{false}; + +} // namespace + +FPSModule::FPSModule() + : BaseModule("FPSModule", "FPSModule", ModuleCategory::Visual) {} + +void FPSModule::RegisterTab() { + overlay_enabled_ = false; + SetEnabled(false); + g_fps_overlay_enabled.store(false, std::memory_order_relaxed); +} + +void FPSModule::Render() { + if (!ImGui::CollapsingHeader(Tr("FPSModule"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } +} + +void FPSModule::Update() { + overlay_enabled_ = Enabled(); + g_fps_overlay_enabled.store(overlay_enabled_, std::memory_order_relaxed); +} + +bool IsFPSOverlayEnabled() { + return g_fps_overlay_enabled.load(std::memory_order_relaxed); +} diff --git a/IDA/project/FPSModule.h b/IDA/project/FPSModule.h new file mode 100644 index 0000000..51a123a --- /dev/null +++ b/IDA/project/FPSModule.h @@ -0,0 +1,17 @@ +#pragma once + +#include "ModuleManager.h" + +class FPSModule final : public BaseModule { +public: + FPSModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + bool overlay_enabled_ = false; +}; + +bool IsFPSOverlayEnabled(); diff --git a/IDA/project/FpsUnlocker.cpp b/IDA/project/FpsUnlocker.cpp new file mode 100644 index 0000000..d6b13dc --- /dev/null +++ b/IDA/project/FpsUnlocker.cpp @@ -0,0 +1,34 @@ +#include "FpsUnlocker.h" + +#include "helpers.h" + +FpsUnlockerModule::FpsUnlockerModule() + : BaseModule("FpsUnlocker", "Fps Unlocker", ModuleCategory::Visual) {} + +void FpsUnlockerModule::RegisterTab() { + fps_target_ = 300; +} + +void FpsUnlockerModule::Render() { + if (!ImGui::CollapsingHeader(Tr("Fps Unlocker"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } + + if (Enabled()) { + ImGui::DragInt(Tr("Fps Value"), &fps_target_, 1.0f, 30, 500, "%d"); + } + + using FnSetTargetFrameRate = void (*)(int); + auto set_target_fps = GetIl2cppFn(IL2CPP::Application_set_targetFrameRate); + if (set_target_fps) { + set_target_fps(Enabled() ? fps_target_ : 60); + } +} + +void FpsUnlockerModule::Update() { +} diff --git a/IDA/project/FpsUnlocker.h b/IDA/project/FpsUnlocker.h new file mode 100644 index 0000000..7d0da51 --- /dev/null +++ b/IDA/project/FpsUnlocker.h @@ -0,0 +1,15 @@ +#pragma once + +#include "ModuleManager.h" + +class FpsUnlockerModule final : public BaseModule { +public: + FpsUnlockerModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + int fps_target_ = 300; +}; diff --git a/IDA/project/FreeCam.cpp b/IDA/project/FreeCam.cpp new file mode 100644 index 0000000..8dcea0c --- /dev/null +++ b/IDA/project/FreeCam.cpp @@ -0,0 +1,131 @@ +#include "FreeCam.h" + +#include "helpers.h" + +#include + +FreeCamModule::FreeCamModule() + : BaseModule("FreeCam", "Free Camera", ModuleCategory::Visual) {} + +void FreeCamModule::RegisterTab() { + keys_.toggle = VK_OEM_3; +} + +const char* FreeCamModule::KeyName(int vk) { + static thread_local char name[64]; + if (vk <= 0) { + return "NONE"; + } + + UINT scan = MapVirtualKeyA(static_cast(vk), MAPVK_VK_TO_VSC); + LONG lp = static_cast(scan << 16); + if (GetKeyNameTextA(lp, name, static_cast(sizeof(name))) > 0) { + return name; + } + return "NONE"; +} + +void FreeCamModule::Render() { + if (!ImGui::CollapsingHeader(Tr("Free Camera"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + if (!enabled) { + active_cam_ptr_ = nullptr; + override_cam_ptr_ = nullptr; + cam_override_active_ = false; + } + } + + if (!Enabled()) { + return; + } + + ImGui::DragFloat(Tr("Move Speed"), &move_speed_, 0.1f, 0.1f, 500.0f, "%.3f"); + ImGui::DragFloat(Tr("Look Sensitivity"), &look_sensitivity_, 0.1f, 0.1f, 500.0f, "%.3f"); + ImGui::DragFloat(Tr("Roll Speed"), &roll_speed_, 0.1f, 0.1f, 100.0f, "%.3f"); + ImGui::DragFloat(Tr("FOV Speed"), &fov_speed_, 0.1f, 0.1f, 100.0f, "%.3f"); + ImGui::DragFloat(Tr("FOV"), &fov_value_, 0.1f, 1.0f, 179.0f, "%.1f"); + + char row[96]; + std::snprintf(row, sizeof(row), "Forward Key: %s", KeyName(keys_.forward)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "Backward Key: %s", KeyName(keys_.backward)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "Left Key: %s", KeyName(keys_.left)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "Right Key: %s", KeyName(keys_.right)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "Up Key: %s", KeyName(keys_.up)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "Down Key: %s", KeyName(keys_.down)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "IncFOV Key: %s", KeyName(keys_.inc_fov)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "DecFOV Key: %s", KeyName(keys_.dec_fov)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "LeftRoll Key: %s", KeyName(keys_.left_roll)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "RightRoll Key: %s", KeyName(keys_.right_roll)); + ImGui::TextUnformatted(row); + std::snprintf(row, sizeof(row), "ResetRoll Key: %s", KeyName(keys_.reset_roll)); + ImGui::TextUnformatted(row); +} + +void FreeCamModule::Update() { + if (!Enabled()) { + return; + } + + using FnCameraMain = void* (*)(void*); + using FnGetTransform = void* (*)(void*); + using FnGetPosition = Vec3* (*)(void*); + using FnSetPosition = void (*)(void*, Vec3*); + + auto camera_main = GetIl2cppFn(IL2CPP::Camera_get_main); + auto get_transform = GetIl2cppFn(IL2CPP::GameObject_get_transform); + auto get_position = GetIl2cppFn(IL2CPP::Transform_get_position); + auto set_position = GetIl2cppFn(IL2CPP::Transform_set_position); + if (!camera_main || !get_transform || !get_position || !set_position) { + return; + } + + void* camera = camera_main(nullptr); + if (!camera) { + return; + } + void* transform = get_transform(camera); + if (!transform) { + return; + } + + Vec3 pos = {}; + Vec3* pos_ptr = get_position(transform); + if (!pos_ptr) { + return; + } + pos = *pos_ptr; + + const float dt = ImGui::GetIO().DeltaTime; + const float speed = move_speed_ * dt; + + if (GetAsyncKeyState(keys_.forward) & 0x8000) pos.z += speed; + if (GetAsyncKeyState(keys_.backward) & 0x8000) pos.z -= speed; + if (GetAsyncKeyState(keys_.left) & 0x8000) pos.x -= speed; + if (GetAsyncKeyState(keys_.right) & 0x8000) pos.x += speed; + if (GetAsyncKeyState(keys_.up) & 0x8000) pos.y += speed; + if (GetAsyncKeyState(keys_.down) & 0x8000) pos.y -= speed; + + set_position(transform, &pos); + active_cam_ptr_ = camera; + cam_override_active_ = true; +} + +void FreeCamModule::OnHotkey() { + if (IsKeyPressedOnce(keys_.toggle)) { + SetEnabled(!Enabled()); + } +} diff --git a/IDA/project/FreeCam.h b/IDA/project/FreeCam.h new file mode 100644 index 0000000..89e2311 --- /dev/null +++ b/IDA/project/FreeCam.h @@ -0,0 +1,42 @@ +#pragma once + +#include "ModuleManager.h" + +class FreeCamModule final : public BaseModule { +public: + FreeCamModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + void OnHotkey() override; + +private: + struct KeybindState { + int forward = 'W'; + int backward = 'S'; + int left = 'A'; + int right = 'D'; + int up = VK_SPACE; + int down = VK_CONTROL; + int inc_fov = VK_OEM_PLUS; + int dec_fov = VK_OEM_MINUS; + int left_roll = 'Q'; + int right_roll = 'E'; + int reset_roll = 'R'; + int toggle = VK_OEM_3; + }; + + static const char* KeyName(int vk); + + KeybindState keys_{}; + float move_speed_ = 5.0f; + float look_sensitivity_ = 2.0f; + float roll_speed_ = 2.0f; + float fov_speed_ = 1.0f; + float fov_value_ = 90.0f; + + void* active_cam_ptr_ = nullptr; + void* override_cam_ptr_ = nullptr; + bool cam_override_active_ = false; +}; diff --git a/IDA/project/HookManager.h b/IDA/project/HookManager.h new file mode 100644 index 0000000..b5674b2 --- /dev/null +++ b/IDA/project/HookManager.h @@ -0,0 +1,47 @@ +#pragma once + +#include "Common.h" + +class HookManagerRuntime final { +public: + static HookManagerRuntime& Instance() { + static HookManagerRuntime inst; + return inst; + } + + int CreateHook(void* target, void* callback, void** trampoline_out) { + if (!target || !callback || !trampoline_out) { + return 1; + } + std::scoped_lock lock(mutex_); + hooks_[target] = callback; + *trampoline_out = target; + return 0; + } + + int EnableHook(void* target, bool enabled) { + if (!target) { + return 1; + } + std::scoped_lock lock(mutex_); + enabled_[target] = enabled; + return 0; + } + + int RemoveHook(void* target) { + if (!target) { + return 1; + } + std::scoped_lock lock(mutex_); + hooks_.erase(target); + enabled_.erase(target); + return 0; + } + +private: + HookManagerRuntime() = default; + + std::mutex mutex_; + std::unordered_map hooks_; + std::unordered_map enabled_; +}; diff --git a/IDA/project/ModuleManager.cpp b/IDA/project/ModuleManager.cpp new file mode 100644 index 0000000..7a32ece --- /dev/null +++ b/IDA/project/ModuleManager.cpp @@ -0,0 +1,155 @@ +#include "ModuleManager.h" + +#include "ESP.h" +#include "FPSModule.h" +#include "FreeCam.h" +#include "FpsUnlocker.h" +#include "NoClip.h" +#include "PlayerProfile.h" +#include "PreventScreenshot.h" +#include "SetDither.h" +#include "SkillHack.h" +#include "UnityExplorer.h" +#include "Vacuum.h" +#include "helpers.h" + +void ModuleManager::AddRegistrar(const std::string& name, ModuleFactory factory) { + registrars_.emplace_back(name, std::move(factory)); +} + +void ModuleManager::Init() { + if (initialized_) { + Log("[WARNING] ModuleManager already initialized"); + return; + } + + Log("Initializing ModuleManager"); + + for (const auto& registrar : registrars_) { + try { + std::unique_ptr module = registrar.second(); + if (!module) { + Log("Failed to initialize module %s", registrar.first.c_str()); + continue; + } + module->RegisterTab(); + Log("Module %s initialized", module->Name().c_str()); + modules_.push_back(std::move(module)); + } catch (...) { + Log("Failed to initialize module %s", registrar.first.c_str()); + } + } + + initialized_ = true; + Log("ModuleManager initialization complete"); +} + +void ModuleManager::DispatchRenderByTab(MainTab tab) { + if (!initialized_) { + return; + } + + auto render_for_category = [&](ModuleCategory category) { + for (const auto& module : modules_) { + if (!module || module->Category() != category) { + continue; + } + try { + module->Render(); + } catch (...) { + Log("[ERROR] Failed to render overlay for module %s", module->Name().c_str()); + } + } + }; + + switch (tab) { + case MainTab::Player: + render_for_category(ModuleCategory::Player); + break; + case MainTab::ESP: + render_for_category(ModuleCategory::ESP); + break; + case MainTab::World: + render_for_category(ModuleCategory::World); + break; + case MainTab::Visual: + render_for_category(ModuleCategory::Visual); + break; + default: + break; + } +} + +void ModuleManager::DispatchUpdate() { + if (!initialized_) { + return; + } + + for (const auto& module : modules_) { + if (!module || !module->Enabled()) { + continue; + } + try { + module->Update(); + } catch (...) { + Log("[ERROR] Failed to update module %s", module->Name().c_str()); + } + } +} + +void ModuleManager::DispatchHotkeys() { + if (!initialized_) { + return; + } + + for (const auto& module : modules_) { + if (!module || !module->Enabled()) { + continue; + } + try { + module->OnHotkey(); + } catch (...) { + Log("[ERROR] Failed to process hotkeys for module %s", module->Name().c_str()); + } + } +} + +BaseModule* ModuleManager::FindModule(const std::string& name) { + for (const auto& module : modules_) { + if (module && module->Name() == name) { + return module.get(); + } + } + return nullptr; +} + +std::vector ModuleManager::GetModulesByCategory(ModuleCategory category) { + std::vector result; + for (const auto& module : modules_) { + if (module && module->Category() == category) { + result.push_back(module.get()); + } + } + return result; +} + +ModuleManager& GetModuleManager() { + static ModuleManager manager; + return manager; +} + +void RegisterDefaultModules() { + ModuleManager& manager = GetModuleManager(); + + manager.AddRegistrar("SetDither", []() { return std::make_unique(); }); + manager.AddRegistrar("SkillHack", []() { return std::make_unique(); }); + manager.AddRegistrar("PlayerProfile", []() { return std::make_unique(); }); + manager.AddRegistrar("NoClip", []() { return std::make_unique(); }); + manager.AddRegistrar("Vacuum", []() { return std::make_unique(); }); + manager.AddRegistrar("UnityExplorerModule", []() { return std::make_unique(); }); + manager.AddRegistrar("FpsUnlocker", []() { return std::make_unique(); }); + manager.AddRegistrar("FPSModule", []() { return std::make_unique(); }); + manager.AddRegistrar("FreeCam", []() { return std::make_unique(); }); + manager.AddRegistrar("ESPModule", []() { return std::make_unique(); }); + manager.AddRegistrar("PreventScreenshot", []() { return std::make_unique(); }); +} diff --git a/IDA/project/ModuleManager.h b/IDA/project/ModuleManager.h new file mode 100644 index 0000000..ab9ee47 --- /dev/null +++ b/IDA/project/ModuleManager.h @@ -0,0 +1,63 @@ +#pragma once + +#include "Common.h" + +enum class ModuleCategory : uint8_t { + Player, + ESP, + World, + Visual, + Internal, +}; + +class BaseModule { +public: + BaseModule(std::string module_name, std::string tab_label, ModuleCategory category) + : name_(std::move(module_name)), + tab_label_(std::move(tab_label)), + category_(category) {} + + virtual ~BaseModule() = default; + + virtual void RegisterTab() = 0; + virtual void Render() = 0; + virtual void Update() = 0; + virtual void OnHotkey() {} + + const std::string& Name() const { return name_; } + const std::string& TabLabel() const { return tab_label_; } + ModuleCategory Category() const { return category_; } + + bool Enabled() const { return enabled_; } + void SetEnabled(bool value) { enabled_ = value; } + +protected: + std::string name_; + std::string tab_label_; + ModuleCategory category_; + bool enabled_ = false; +}; + +using ModuleFactory = std::function()>; + +class ModuleManager final { +public: + void AddRegistrar(const std::string& name, ModuleFactory factory); + void Init(); + + void DispatchRenderByTab(MainTab tab); + void DispatchUpdate(); + void DispatchHotkeys(); + + BaseModule* FindModule(const std::string& name); + std::vector GetModulesByCategory(ModuleCategory category); + bool Initialized() const { return initialized_; } + +private: + std::vector> registrars_; + std::vector> modules_; + bool initialized_ = false; +}; + +ModuleManager& GetModuleManager(); +void RegisterDefaultModules(); diff --git a/IDA/project/NoClip.cpp b/IDA/project/NoClip.cpp new file mode 100644 index 0000000..b340101 --- /dev/null +++ b/IDA/project/NoClip.cpp @@ -0,0 +1,54 @@ +#include "NoClip.h" + +#include "helpers.h" + +NoClipModule::NoClipModule() + : BaseModule("NoClip", "NoClip", ModuleCategory::Player) {} + +void NoClipModule::RegisterTab() { +} + +void NoClipModule::Render() { + if (!ImGui::CollapsingHeader(Tr("NoClip"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } + + if (Enabled()) { + ImGui::DragInt(Tr("Move Speed"), &move_speed_, 1.0f, 1, 10, "%d"); + } +} + +void NoClipModule::Update() { + if (!Enabled()) { + return; + } + + using FnGetEntityManager = void* (*)(); + using FnGetCharacterController = void* (*)(void*); + using FnSetCharCtrlEnabled = void (*)(void*, bool, int); + + auto get_entity_manager = GetIl2cppFn(IL2CPP::GetEntityManager); + auto get_character_controller = GetIl2cppFn(IL2CPP::GetCharacterController); + auto set_enabled = GetIl2cppFn(IL2CPP::CharCtrl_set_enabled); + if (!get_entity_manager || !get_character_controller || !set_enabled) { + return; + } + + void* entity_manager = get_entity_manager(); + if (!entity_manager) { + return; + } + + void* character_controller = get_character_controller(entity_manager); + if (!character_controller) { + return; + } + + const bool enable_controller = !Enabled(); + set_enabled(character_controller, enable_controller, 0); +} diff --git a/IDA/project/NoClip.h b/IDA/project/NoClip.h new file mode 100644 index 0000000..fb95d3d --- /dev/null +++ b/IDA/project/NoClip.h @@ -0,0 +1,15 @@ +#pragma once + +#include "ModuleManager.h" + +class NoClipModule final : public BaseModule { +public: + NoClipModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + int move_speed_ = 3; +}; diff --git a/IDA/project/PlayerProfile.cpp b/IDA/project/PlayerProfile.cpp new file mode 100644 index 0000000..7851bae --- /dev/null +++ b/IDA/project/PlayerProfile.cpp @@ -0,0 +1,56 @@ +#include "PlayerProfile.h" + +#include "helpers.h" + +namespace { +constexpr const char* kUidPath = "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text"; +constexpr const char* kManagerNamePath = + "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/" + "LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName"; +} + +PlayerProfileModule::PlayerProfileModule() + : BaseModule("PlayerProfile", "PlayerProfile", ModuleCategory::Visual) {} + +void PlayerProfileModule::RegisterTab() { + uid_text_.clear(); + name_text_.clear(); + uid_input_.fill('\0'); + name_input_.fill('\0'); +} + +void PlayerProfileModule::Render() { + if (!ImGui::CollapsingHeader(Tr("PlayerProfile"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } + + if (ImGui::InputText(Tr("UID text"), uid_input_.data(), uid_input_.size())) { + uid_text_ = Utf8ToWide(uid_input_.data()); + } + if (ImGui::InputText(Tr("Name text"), name_input_.data(), name_input_.size())) { + name_text_ = Utf8ToWide(name_input_.data()); + } + ImGui::Checkbox(Tr("Name changer"), &name_changer_enabled_); +} + +void PlayerProfileModule::Update() { + if (!Enabled()) { + return; + } + + using FnSetText = void (*)(void*, int, void*); + auto set_tmp_text = GetIl2cppFn(IL2CPP::TMPro_set_text); + auto set_ui_text = GetIl2cppFn(IL2CPP::UnityUI_Text_set_text); + if (!set_tmp_text || !set_ui_text) { + return; + } + + (void)kUidPath; + (void)kManagerNamePath; + (void)name_changer_enabled_; +} diff --git a/IDA/project/PlayerProfile.h b/IDA/project/PlayerProfile.h new file mode 100644 index 0000000..72249ee --- /dev/null +++ b/IDA/project/PlayerProfile.h @@ -0,0 +1,21 @@ +#pragma once + +#include "ModuleManager.h" + +#include + +class PlayerProfileModule final : public BaseModule { +public: + PlayerProfileModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + std::array uid_input_{}; + std::array name_input_{}; + std::wstring uid_text_; + std::wstring name_text_; + bool name_changer_enabled_ = false; +}; diff --git a/IDA/project/PreventScreenshot.cpp b/IDA/project/PreventScreenshot.cpp new file mode 100644 index 0000000..aab0861 --- /dev/null +++ b/IDA/project/PreventScreenshot.cpp @@ -0,0 +1,32 @@ +#include "PreventScreenshot.h" + +#include "helpers.h" + +PreventScreenshotModule::PreventScreenshotModule() + : BaseModule("PreventScreenshot", "Prevent Screenshot", ModuleCategory::Visual) {} + +void PreventScreenshotModule::RegisterTab() { +} + +void PreventScreenshotModule::Render() { + if (!ImGui::CollapsingHeader(Tr("Prevent Screenshot"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } +} + +void PreventScreenshotModule::Update() { + if (!g_Runtime.overlay_hwnd) { + return; + } + + const DWORD affinity = Enabled() + ? (IsWindowsBuildAtLeast(19041) ? 0x11u : 0x1u) + : 0u; + + SetWindowDisplayAffinity(g_Runtime.overlay_hwnd, affinity); +} diff --git a/IDA/project/PreventScreenshot.h b/IDA/project/PreventScreenshot.h new file mode 100644 index 0000000..b2d95b6 --- /dev/null +++ b/IDA/project/PreventScreenshot.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ModuleManager.h" + +class PreventScreenshotModule final : public BaseModule { +public: + PreventScreenshotModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; +}; diff --git a/IDA/project/SetDither.cpp b/IDA/project/SetDither.cpp new file mode 100644 index 0000000..345737e --- /dev/null +++ b/IDA/project/SetDither.cpp @@ -0,0 +1,23 @@ +#include "SetDither.h" + +#include "helpers.h" + +SetDitherModule::SetDitherModule() + : BaseModule("SetDither", "Set Dither", ModuleCategory::Visual) {} + +void SetDitherModule::RegisterTab() { +} + +void SetDitherModule::Render() { + if (!ImGui::CollapsingHeader(Tr("Set Dither"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } +} + +void SetDitherModule::Update() { +} diff --git a/IDA/project/SetDither.h b/IDA/project/SetDither.h new file mode 100644 index 0000000..63396d0 --- /dev/null +++ b/IDA/project/SetDither.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ModuleManager.h" + +class SetDitherModule final : public BaseModule { +public: + SetDitherModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; +}; diff --git a/IDA/project/SettingsTAB.cpp b/IDA/project/SettingsTAB.cpp new file mode 100644 index 0000000..1ad273f --- /dev/null +++ b/IDA/project/SettingsTAB.cpp @@ -0,0 +1,37 @@ +#include "SettingsTAB.h" + +#include "helpers.h" + +void RenderSettingsTab() { + ImGui::TextUnformatted("Customize overlay appearance and debugging tools."); + + static int theme_idx = 0; + const char* themes[] = { + "Default", + "Evangelion Unit 01", + "Evangelion Unit 02", + "Matrix", + }; + + if (ImGui::Combo(Tr("Theme"), &theme_idx, themes, IM_ARRAYSIZE(themes))) { + switch (theme_idx) { + case 0: ApplyThemeDefault(); break; + case 1: ApplyThemeEvangelionUnit01(); break; + case 2: ApplyThemeEvangelionUnit02(); break; + case 3: ApplyThemeMatrix(); break; + default: ApplyThemeDefault(); break; + } + } + + if (ImGui::Button("Reset Theme")) { + theme_idx = 0; + ApplyThemeDefault(); + } + + static bool console_enabled = true; + if (ImGui::Checkbox(Tr("Toggle Console"), &console_enabled)) { + ToggleConsole(console_enabled); + } + + ImGui::TextUnformatted(console_enabled ? "Console: Enabled" : "Console: Disabled"); +} diff --git a/IDA/project/SettingsTAB.h b/IDA/project/SettingsTAB.h new file mode 100644 index 0000000..92a3c05 --- /dev/null +++ b/IDA/project/SettingsTAB.h @@ -0,0 +1,3 @@ +#pragma once + +void RenderSettingsTab(); diff --git a/IDA/project/SkillHack.cpp b/IDA/project/SkillHack.cpp new file mode 100644 index 0000000..df94fac --- /dev/null +++ b/IDA/project/SkillHack.cpp @@ -0,0 +1,108 @@ +#include "SkillHack.h" + +#include "HookManager.h" +#include "helpers.h" + +SkillHackModule* SkillHackModule::s_instance_ = nullptr; + +SkillHackModule::SkillHackModule() + : BaseModule("SkillHack", "Free Skill", ModuleCategory::Player) { + s_instance_ = this; +} + +SkillHackModule::~SkillHackModule() { + s_instance_ = nullptr; +} + +void SkillHackModule::RegisterTab() { +} + +void SkillHackModule::InstallHooks() { + if (hooks_installed_) { + return; + } + + HookManagerRuntime& hooks = HookManagerRuntime::Instance(); + + auto create_and_enable = [&](uintptr_t slot, void* callback, void** tramp_out) { + void* target = GetIl2cppSlot(slot); + if (!target) { + return; + } + if (hooks.CreateHook(target, callback, tramp_out) == 0) { + hooks.EnableHook(target, true); + } + }; + + create_and_enable(IL2CPP::Game_EntityActor_E, reinterpret_cast(&DispatcherHook), &tramp_dispatch_1_); + create_and_enable(IL2CPP::Game_EntityActor_F, reinterpret_cast(&DispatcherHook), &tramp_dispatch_2_); + create_and_enable(IL2CPP::Game_SkillAction_K, reinterpret_cast(&CooldownBypassHook), &tramp_cooldown_); + create_and_enable(IL2CPP::Game_SkillAction_L, reinterpret_cast(&AvailBypassHook), &tramp_avail_); + create_and_enable(IL2CPP::Game_SkillAction_J, reinterpret_cast(&CostBypassHook), &tramp_cost_); + create_and_enable(IL2CPP::Game_EntityActor_D, reinterpret_cast(&DispatcherHook), &tramp_dispatch_3_); + + hooks_installed_ = true; +} + +void SkillHackModule::Render() { + InstallHooks(); + + if (!ImGui::CollapsingHeader(Tr("Free Skill"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + } +} + +void SkillHackModule::Update() { +} + +BOOL SkillHackModule::DispatcherHook() { + if (s_instance_ && s_instance_->Enabled()) { + return 1; + } + + if (s_instance_ && s_instance_->tramp_dispatch_1_) { + auto original = reinterpret_cast(s_instance_->tramp_dispatch_1_); + return original(); + } + return 0; +} + +float SkillHackModule::CooldownBypassHook() { + if (s_instance_ && s_instance_->Enabled()) { + return 100.0f; + } + + if (s_instance_ && s_instance_->tramp_cooldown_) { + auto original = reinterpret_cast(s_instance_->tramp_cooldown_); + return original(); + } + return 0.0f; +} + +BOOL SkillHackModule::AvailBypassHook() { + if (s_instance_ && s_instance_->Enabled()) { + return 1; + } + + if (s_instance_ && s_instance_->tramp_avail_) { + auto original = reinterpret_cast(s_instance_->tramp_avail_); + return original(); + } + return 0; +} + +void SkillHackModule::CostBypassHook() { + if (s_instance_ && s_instance_->Enabled()) { + return; + } + + if (s_instance_ && s_instance_->tramp_cost_) { + auto original = reinterpret_cast(s_instance_->tramp_cost_); + original(); + } +} diff --git a/IDA/project/SkillHack.h b/IDA/project/SkillHack.h new file mode 100644 index 0000000..d0844fc --- /dev/null +++ b/IDA/project/SkillHack.h @@ -0,0 +1,31 @@ +#pragma once + +#include "ModuleManager.h" + +class SkillHackModule final : public BaseModule { +public: + SkillHackModule(); + ~SkillHackModule() override; + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + void InstallHooks(); + + static BOOL DispatcherHook(); + static float CooldownBypassHook(); + static BOOL AvailBypassHook(); + static void CostBypassHook(); + + static SkillHackModule* s_instance_; + + bool hooks_installed_ = false; + void* tramp_dispatch_1_ = nullptr; + void* tramp_dispatch_2_ = nullptr; + void* tramp_dispatch_3_ = nullptr; + void* tramp_cooldown_ = nullptr; + void* tramp_avail_ = nullptr; + void* tramp_cost_ = nullptr; +}; diff --git a/IDA/project/UI.cpp b/IDA/project/UI.cpp new file mode 100644 index 0000000..1ef6865 --- /dev/null +++ b/IDA/project/UI.cpp @@ -0,0 +1,653 @@ +#include "UI.h" + +#include "FPSModule.h" +#include "ModuleManager.h" +#include "SettingsTAB.h" +#include "helpers.h" + +#include +#include +#include +#include +#include + +namespace { + +ID3D11Device* g_d3d_device = nullptr; +ID3D11DeviceContext* g_d3d_context = nullptr; +IDXGISwapChain* g_swap_chain = nullptr; +ID3D11RenderTargetView* g_main_rtv = nullptr; +HWND g_overlay_hwnd = nullptr; +bool g_overlay_interactive = false; +WNDPROC g_game_wndproc = nullptr; +bool g_game_wndproc_installed = false; +bool g_game_thread_attached_logged = false; + +constexpr LONG_PTR kOverlayExStyleInteractive = WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW; +constexpr LONG_PTR kOverlayExStylePassthrough = kOverlayExStyleInteractive | WS_EX_TRANSPARENT; +constexpr UINT_PTR kGameThreadTickTimerId = 0xEF01; +constexpr UINT kGameThreadTickMs = 16; + +void CleanupRenderTarget() { + if (g_main_rtv) { + g_main_rtv->Release(); + g_main_rtv = nullptr; + } +} + +void CreateRenderTarget() { + ID3D11Texture2D* back_buffer = nullptr; + if (g_swap_chain && SUCCEEDED(g_swap_chain->GetBuffer(0, IID_PPV_ARGS(&back_buffer)))) { + g_d3d_device->CreateRenderTargetView(back_buffer, nullptr, &g_main_rtv); + back_buffer->Release(); + } +} + +bool CreateDeviceD3D(HWND hwnd) { + DXGI_SWAP_CHAIN_DESC sd{}; + sd.BufferCount = 2; + sd.BufferDesc.Width = 0; + sd.BufferDesc.Height = 0; + sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + sd.BufferDesc.RefreshRate.Numerator = 60; + sd.BufferDesc.RefreshRate.Denominator = 1; + sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; + sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; + sd.OutputWindow = hwnd; + sd.SampleDesc.Count = 1; + sd.SampleDesc.Quality = 0; + sd.Windowed = TRUE; + sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; + + constexpr D3D_FEATURE_LEVEL levels[] = { + D3D_FEATURE_LEVEL_11_0, + D3D_FEATURE_LEVEL_10_0, + }; + + D3D_FEATURE_LEVEL created_level{}; + HRESULT hr = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, + levels, ARRAYSIZE(levels), D3D11_SDK_VERSION, + &sd, &g_swap_chain, &g_d3d_device, + &created_level, &g_d3d_context); + if (FAILED(hr)) { + return false; + } + + CreateRenderTarget(); + return true; +} + +void CleanupDeviceD3D() { + CleanupRenderTarget(); + if (g_swap_chain) { + g_swap_chain->Release(); + g_swap_chain = nullptr; + } + if (g_d3d_context) { + g_d3d_context->Release(); + g_d3d_context = nullptr; + } + if (g_d3d_device) { + g_d3d_device->Release(); + g_d3d_device = nullptr; + } +} + +bool GetGameRect(RECT* rect) { + if (!rect) { + return false; + } + + if (!g_Runtime.game_hwnd || !IsWindow(g_Runtime.game_hwnd)) { + g_Runtime.game_hwnd = FindWindowA("UnityWndClass", nullptr); + } + if (!g_Runtime.game_hwnd || !IsWindow(g_Runtime.game_hwnd)) { + return false; + } + return GetWindowRect(g_Runtime.game_hwnd, rect) == TRUE; +} + +void ApplyOverlayInteractivity(bool interactive) { + if (!g_overlay_hwnd) { + return; + } + if (g_overlay_interactive == interactive) { + return; + } + + const LONG_PTR ex_style = interactive ? kOverlayExStyleInteractive : kOverlayExStylePassthrough; + SetWindowLongPtrW(g_overlay_hwnd, GWL_EXSTYLE, ex_style); + + UINT flags = SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER | SWP_FRAMECHANGED | SWP_SHOWWINDOW; + if (!interactive) { + flags |= SWP_NOACTIVATE; + } + SetWindowPos(g_overlay_hwnd, HWND_TOPMOST, 0, 0, 0, 0, flags); + + if (interactive) { + BringWindowToTop(g_overlay_hwnd); + SetForegroundWindow(g_overlay_hwnd); + SetFocus(g_overlay_hwnd); + } + + g_overlay_interactive = interactive; +} + +bool ContainsNoCase(const std::string& text, const std::string& needle) { + if (needle.empty()) { + return true; + } + + auto lower = [](const std::string& s) { + std::string out = s; + std::transform(out.begin(), out.end(), out.begin(), [](unsigned char c) { + return static_cast(std::tolower(c)); + }); + return out; + }; + + const std::string hay = lower(text); + const std::string ned = lower(needle); + return hay.find(ned) != std::string::npos; +} + +bool MainTabToCategory(MainTab tab, ModuleCategory* out_category) { + if (!out_category) { + return false; + } + + switch (tab) { + case MainTab::Player: + *out_category = ModuleCategory::Player; + return true; + case MainTab::ESP: + *out_category = ModuleCategory::ESP; + return true; + case MainTab::World: + *out_category = ModuleCategory::World; + return true; + case MainTab::Visual: + *out_category = ModuleCategory::Visual; + return true; + default: + break; + } + return false; +} + +void HandleTabHotkeys() { + if (IsKeyPressedOnce(VK_F1)) g_Runtime.active_tab.store(MainTab::About, std::memory_order_relaxed); + if (IsKeyPressedOnce(VK_F2)) g_Runtime.active_tab.store(MainTab::Player, std::memory_order_relaxed); + if (IsKeyPressedOnce(VK_F3)) g_Runtime.active_tab.store(MainTab::ESP, std::memory_order_relaxed); + if (IsKeyPressedOnce(VK_F4)) g_Runtime.active_tab.store(MainTab::World, std::memory_order_relaxed); + if (IsKeyPressedOnce(VK_F5)) g_Runtime.active_tab.store(MainTab::Visual, std::memory_order_relaxed); + if (IsKeyPressedOnce(VK_F6)) g_Runtime.active_tab.store(MainTab::Settings, std::memory_order_relaxed); +} + +void RenderAboutPanel() { + ImGui::Text("%s", "Endfield CTB3"); + ImGui::Text("%s", "Version: 1.0.0"); + ImGui::Text("%s", "Author: gktwo"); + ImGui::Separator(); + ImGui::BulletText("F12: Show/Hide panel"); + ImGui::BulletText("F1..F6: Switch tabs quickly"); + ImGui::BulletText("Use search to filter modules"); + ImGui::BulletText("Use Quick Toggles for fast ON/OFF"); +} + +void RenderCategoryModules(MainTab selected_tab, const std::string& filter) { + if (!g_Runtime.il2cpp_thread_attached.load(std::memory_order_relaxed)) { + ImGui::TextDisabled("IL2CPP thread is not attached."); + ImGui::TextDisabled("Skipping module calls to prevent GC crash."); + return; + } + + ModuleCategory category{}; + if (!MainTabToCategory(selected_tab, &category)) { + return; + } + + ModuleManager& manager = GetModuleManager(); + std::vector modules = manager.GetModulesByCategory(category); + + if (modules.empty()) { + ImGui::TextDisabled("No modules available."); + return; + } + + if (ImGui::CollapsingHeader("Quick Toggles", ImGuiTreeNodeFlags_DefaultOpen)) { + int shown = 0; + for (BaseModule* mod : modules) { + if (!mod) { + continue; + } + const bool visible = filter.empty() || + ContainsNoCase(mod->Name(), filter) || + ContainsNoCase(mod->TabLabel(), filter); + if (!visible) { + continue; + } + bool on = mod->Enabled(); + const std::string label = mod->TabLabel() + "##quick"; + if (ImGui::Checkbox(label.c_str(), &on)) { + mod->SetEnabled(on); + } + shown++; + } + if (shown == 0) { + ImGui::TextDisabled("No module matches \"%s\".", filter.c_str()); + } + } + + ImGui::Separator(); + + int rendered = 0; + for (BaseModule* mod : modules) { + if (!mod) { + continue; + } + + const bool visible = filter.empty() || + ContainsNoCase(mod->Name(), filter) || + ContainsNoCase(mod->TabLabel(), filter); + if (!visible) { + continue; + } + + bool pushed_id = false; + try { + ImGui::PushID(mod->Name().c_str()); + pushed_id = true; + mod->Render(); + ImGui::PopID(); + pushed_id = false; + } catch (...) { + if (pushed_id) { + ImGui::PopID(); + } + Log("[ERROR] Failed to render overlay for module %s", mod->Name().c_str()); + } + rendered++; + } + + if (rendered == 0) { + ImGui::TextDisabled("No module matches \"%s\".", filter.c_str()); + } +} + +void RenderFpsOverlay() { + if (!IsFPSOverlayEnabled()) { + return; + } + + ImGuiIO& io = ImGui::GetIO(); + const int fps_rounded = static_cast(io.Framerate + 0.5f); + + char text[32] = {}; + sprintf_s(text, "FPS: %d", fps_rounded); + + ImU32 color = IM_COL32(255, 64, 64, 255); + if (fps_rounded >= 60) { + color = IM_COL32(64, 255, 96, 255); + } else if (fps_rounded >= 30) { + color = IM_COL32(255, 225, 80, 255); + } + + ImDrawList* draw = ImGui::GetForegroundDrawList(); + draw->AddText(ImVec2(12.0f, 12.0f), IM_COL32(0, 0, 0, 255), text); + draw->AddText(ImVec2(10.0f, 10.0f), color, text); +} + +void RenderSidebar() { + static constexpr const char* tabs[] = { + "About", + "Player", + "ESP", + "World", + "Visual", + "Settings", + }; + static constexpr const char* tab_buttons[] = { + "F1 About", + "F2 Player", + "F3 ESP", + "F4 World", + "F5 Visual", + "F6 Settings", + }; + static char module_filter[96] = {}; + static int language_idx = static_cast(g_Runtime.language.load(std::memory_order_relaxed)); + + HandleTabHotkeys(); + + ImGui::SetNextWindowSize(ImVec2(1320.0f, 980.0f), ImGuiCond_Always); + ImGui::SetNextWindowSizeConstraints(ImVec2(1100.0f, 850.0f), ImVec2(1800.0f, 1500.0f)); + ImGui::SetNextWindowBgAlpha(0.96f); + if (!ImGui::Begin("Sidebar", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar)) { + ImGui::End(); + return; + } + + ImGui::TextUnformatted("EF - Cheeto"); + ImGui::SameLine(); + ImGui::TextDisabled("(F12 show/hide)"); + ImGui::TextUnformatted(Tr("This is free, if you spend money, then you have been deceived")); + ImGui::Separator(); + + const char* languages[] = {"English", "Chinese (Simplified)"}; + ImGui::SetNextItemWidth(320.0f); + if (ImGui::Combo("##Language", &language_idx, languages, IM_ARRAYSIZE(languages))) { + SetLanguage(language_idx == 0 ? Language::English : Language::ZhCN); + } + + MainTab selected = g_Runtime.active_tab.load(std::memory_order_relaxed); + + const float available_width = ImGui::GetContentRegionAvail().x; + const float nav_width = std::clamp(available_width * 0.45f, 460.0f, 620.0f); + ImGui::BeginChild("##nav", ImVec2(nav_width, 0.0f), true); + ImGui::TextDisabled("Navigation"); + ImGui::Separator(); + for (int i = 0; i < static_cast(IM_ARRAYSIZE(tabs)); ++i) { + const bool is_active = (static_cast(selected) == i); + if (is_active) { + ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.30f, 0.45f, 0.63f, 0.95f)); + } + if (ImGui::Button(tab_buttons[i], ImVec2(-1.0f, 62.0f))) { + selected = static_cast(i); + } + if (is_active) { + ImGui::PopStyleColor(); + } + } + ImGui::Separator(); + ImGui::TextDisabled("Hotkeys: F1..F6 switch tabs"); + ImGui::TextDisabled("F12 show/hide menu"); + ImGui::EndChild(); + + g_Runtime.active_tab.store(selected, std::memory_order_relaxed); + + ImGui::SameLine(); + ImGui::BeginChild("##content", ImVec2(0.0f, 0.0f), true); + + if (selected != MainTab::About && selected != MainTab::Settings) { + ImGui::InputTextWithHint("##module_filter", "Search module (name/tab)...", + module_filter, IM_ARRAYSIZE(module_filter)); + ImGui::Separator(); + } else { + module_filter[0] = '\0'; + } + + switch (selected) { + case MainTab::About: + RenderAboutPanel(); + break; + case MainTab::Settings: + RenderSettingsTab(); + break; + default: + RenderCategoryModules(selected, module_filter); + break; + } + + ImGui::EndChild(); + ImGui::End(); +} + +void DispatchModulesOnGameThread() { + SetGameThreadContext(true); + g_Runtime.game_thread_id.store(GetCurrentThreadId(), std::memory_order_relaxed); + + if (EnsureIl2CppThreadAttached()) { + g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed); + if (!g_game_thread_attached_logged) { + Log("IL2CPP game-thread dispatcher attached"); + g_game_thread_attached_logged = true; + } + GetModuleManager().DispatchHotkeys(); + GetModuleManager().DispatchUpdate(); + } else { + g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed); + g_game_thread_attached_logged = false; + } + + SetGameThreadContext(false); +} + +LRESULT CALLBACK GameWndProcHook(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { + if (msg == WM_TIMER && wparam == kGameThreadTickTimerId) { + DispatchModulesOnGameThread(); + return 0; + } + + if (g_game_wndproc) { + return CallWindowProcW(g_game_wndproc, hwnd, msg, wparam, lparam); + } + return DefWindowProcW(hwnd, msg, wparam, lparam); +} + +void InstallGameThreadDispatcher() { + if (g_game_wndproc_installed) { + return; + } + if (!g_Runtime.game_hwnd || !IsWindow(g_Runtime.game_hwnd)) { + return; + } + + SetLastError(0); + LONG_PTR prev = SetWindowLongPtrW(g_Runtime.game_hwnd, GWLP_WNDPROC, + reinterpret_cast(GameWndProcHook)); + if (prev == 0 && GetLastError() != 0) { + return; + } + + g_game_wndproc = reinterpret_cast(prev); + if (SetTimer(g_Runtime.game_hwnd, kGameThreadTickTimerId, kGameThreadTickMs, nullptr) == 0) { + if (g_game_wndproc) { + SetWindowLongPtrW(g_Runtime.game_hwnd, GWLP_WNDPROC, reinterpret_cast(g_game_wndproc)); + } + g_game_wndproc = nullptr; + return; + } + + g_game_wndproc_installed = true; + Log("Installed game-thread dispatcher"); +} + +void UninstallGameThreadDispatcher() { + if (!g_game_wndproc_installed) { + return; + } + + if (g_Runtime.game_hwnd && IsWindow(g_Runtime.game_hwnd)) { + KillTimer(g_Runtime.game_hwnd, kGameThreadTickTimerId); + if (g_game_wndproc) { + SetWindowLongPtrW(g_Runtime.game_hwnd, GWLP_WNDPROC, reinterpret_cast(g_game_wndproc)); + } + } + + g_game_wndproc = nullptr; + g_game_wndproc_installed = false; + g_game_thread_attached_logged = false; + g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed); +} + +} // namespace + +LRESULT CALLBACK OverlayWndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { + if (ImGui::GetCurrentContext() != nullptr) { + if (ImGui_ImplWin32_WndProcHandler(hwnd, msg, wparam, lparam)) { + return 1; + } + } + + switch (msg) { + case WM_DESTROY: + PostQuitMessage(0); + return 0; + case WM_SIZE: + if (g_swap_chain != nullptr && wparam != SIZE_MINIMIZED) { + CleanupRenderTarget(); + g_swap_chain->ResizeBuffers(0, LOWORD(lparam), HIWORD(lparam), DXGI_FORMAT_UNKNOWN, 0); + CreateRenderTarget(); + } + return 0; + case WM_SYSCOMMAND: + if ((wparam & 0xFFF0) == SC_KEYMENU) { + return 0; + } + break; + default: + break; + } + return DefWindowProcW(hwnd, msg, wparam, lparam); +} + +bool InitializeOverlayWindow() { + if (g_overlay_hwnd) { + return true; + } + + WNDCLASSEXW wc{}; + wc.cbSize = sizeof(wc); + wc.style = CS_CLASSDC; + wc.lpfnWndProc = OverlayWndProc; + wc.hInstance = GetModuleHandleW(nullptr); + wc.hCursor = LoadCursorW(nullptr, IDC_ARROW); + wc.lpszClassName = L"EF_Cheeto_OverlayWndClass"; + if (!RegisterClassExW(&wc)) { + return false; + } + + RECT rect{}; + if (!GetGameRect(&rect)) { + rect = {0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN)}; + } + + g_overlay_hwnd = CreateWindowExW( + kOverlayExStylePassthrough, + wc.lpszClassName, + L"EF-Cheeto Overlay", + WS_POPUP, + rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, + nullptr, nullptr, wc.hInstance, nullptr); + if (!g_overlay_hwnd) { + UnregisterClassW(wc.lpszClassName, wc.hInstance); + return false; + } + + SetLayeredWindowAttributes(g_overlay_hwnd, RGB(0, 0, 0), 255, LWA_ALPHA); + MARGINS margins{-1}; + DwmExtendFrameIntoClientArea(g_overlay_hwnd, &margins); + + if (!CreateDeviceD3D(g_overlay_hwnd)) { + DestroyWindow(g_overlay_hwnd); + g_overlay_hwnd = nullptr; + UnregisterClassW(wc.lpszClassName, wc.hInstance); + return false; + } + + ShowWindow(g_overlay_hwnd, SW_SHOWDEFAULT); + UpdateWindow(g_overlay_hwnd); + + IMGUI_CHECKVERSION(); + ImGui::CreateContext(); + ImGuiIO& io = ImGui::GetIO(); + io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; + io.IniFilename = "imgui.ini"; + io.LogFilename = "imgui_log.txt"; + io.FontGlobalScale = 2.00f; + + ImGuiStyle& style = ImGui::GetStyle(); + style.WindowRounding = 7.0f; + style.FrameRounding = 6.0f; + style.GrabRounding = 6.0f; + style.ScrollbarRounding = 8.0f; + style.FramePadding = ImVec2(10.0f, 8.0f); + style.ItemSpacing = ImVec2(10.0f, 10.0f); + style.CellPadding = ImVec2(8.0f, 8.0f); + + ImGui_ImplWin32_Init(g_overlay_hwnd); + ImGui_ImplDX11_Init(g_d3d_device, g_d3d_context); + + g_Runtime.overlay_hwnd = g_overlay_hwnd; + Log("Initialized"); + return true; +} + +void RunOverlayLoop() { + if (!InitializeOverlayWindow()) { + return; + } + + MSG msg{}; + while (g_Runtime.running.load(std::memory_order_relaxed)) { + while (PeekMessageW(&msg, nullptr, 0U, 0U, PM_REMOVE)) { + TranslateMessage(&msg); + DispatchMessageW(&msg); + if (msg.message == WM_QUIT) { + g_Runtime.running.store(false, std::memory_order_relaxed); + } + } + if (!g_Runtime.running.load(std::memory_order_relaxed)) { + break; + } + + RECT rect{}; + const bool show_panel = g_Runtime.show_panel.load(std::memory_order_relaxed); + ApplyOverlayInteractivity(show_panel); + + if (GetGameRect(&rect) && g_overlay_hwnd) { + InstallGameThreadDispatcher(); + UINT pos_flags = SWP_NOOWNERZORDER; + if (!show_panel) { + pos_flags |= SWP_NOACTIVATE; + } + SetWindowPos(g_overlay_hwnd, HWND_TOPMOST, rect.left, rect.top, + rect.right - rect.left, rect.bottom - rect.top, pos_flags); + } + + if (IsKeyPressedOnce(VK_F12)) { + const bool new_state = !g_Runtime.show_panel.load(std::memory_order_relaxed); + g_Runtime.show_panel.store(new_state, std::memory_order_relaxed); + ApplyOverlayInteractivity(new_state); + } + + ImGui_ImplDX11_NewFrame(); + ImGui_ImplWin32_NewFrame(); + ImGui::NewFrame(); + + RenderFpsOverlay(); + + if (show_panel) { + RenderSidebar(); + } + + ImGui::Render(); + + const float clear_color[4] = {0.f, 0.f, 0.f, 0.f}; + g_d3d_context->OMSetRenderTargets(1, &g_main_rtv, nullptr); + g_d3d_context->ClearRenderTargetView(g_main_rtv, clear_color); + ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData()); + g_swap_chain->Present(1, 0); + } +} + +void ShutdownOverlayWindow() { + UninstallGameThreadDispatcher(); + + ImGui_ImplDX11_Shutdown(); + ImGui_ImplWin32_Shutdown(); + if (ImGui::GetCurrentContext()) { + ImGui::DestroyContext(); + } + + CleanupDeviceD3D(); + + if (g_overlay_hwnd) { + DestroyWindow(g_overlay_hwnd); + g_overlay_hwnd = nullptr; + } + + HINSTANCE hinst = GetModuleHandleW(nullptr); + UnregisterClassW(L"EF_Cheeto_OverlayWndClass", hinst); +} diff --git a/IDA/project/UI.h b/IDA/project/UI.h new file mode 100644 index 0000000..ff6fab5 --- /dev/null +++ b/IDA/project/UI.h @@ -0,0 +1,8 @@ +#pragma once + +#include "Common.h" + +LRESULT CALLBACK OverlayWndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam); +bool InitializeOverlayWindow(); +void RunOverlayLoop(); +void ShutdownOverlayWindow(); diff --git a/IDA/project/UnityExplorer.cpp b/IDA/project/UnityExplorer.cpp new file mode 100644 index 0000000..73741ae --- /dev/null +++ b/IDA/project/UnityExplorer.cpp @@ -0,0 +1,514 @@ +#include "UnityExplorer.h" + +#include "helpers.h" + +#include +#include +#include +#include +#include + +namespace { + +struct Il2CppString { + void* klass; + void* monitor; + int32_t length; + wchar_t chars[1]; +}; + +struct Il2CppClassLite { + void* image; + void* gc_desc; + const char* name; + const char* namespaze; +}; + +using FnCameraMain = void* (*)(void*); +using FnSceneGetActive = void* (*)(void*); +using FnSceneGetName = void* (*)(void*); +using FnGameObjectGetTransform = void* (*)(void*); +using FnGameObjectSetActive = void (*)(void*, bool); +using FnGameObjectGetActiveInHierarchy = bool (*)(void*); +using FnComponentGetTransform = void* (*)(void*); +using FnGameObjectGetComponentByIndex = void* (*)(void*, int32_t); +using FnObjectGetName = void* (*)(void*); +using FnIl2CppObjectGetClass = void* (*)(void*); +using FnGetVec3 = Vec3* (*)(void*); +using FnSetVec3 = void (*)(void*, Vec3*); +using FnGetQuat = Quat* (*)(void*); +using FnSetQuat = void (*)(void*, Quat*); + +bool ContainsNoCase(const std::string& text, const char* needle_cstr) { + const std::string needle = needle_cstr ? needle_cstr : ""; + if (needle.empty()) { + return true; + } + + auto lower = [](const std::string& v) { + std::string out = v; + std::transform(out.begin(), out.end(), out.begin(), [](unsigned char c) { + return static_cast(std::tolower(c)); + }); + return out; + }; + + return lower(text).find(lower(needle)) != std::string::npos; +} + +std::string Il2CppStringToUtf8(void* string_ptr) { + if (!string_ptr) { + return {}; + } + + const Il2CppString* str = reinterpret_cast(string_ptr); + if (!str || str->length <= 0 || str->length > 4096) { + return {}; + } + + const wchar_t* begin = str->chars; + const wchar_t* end = begin + str->length; + return WideToUtf8(std::wstring(begin, end)); +} + +bool TryGetClassName(void* object_ptr, std::string* out_ns, std::string* out_name) { + if (!object_ptr) { + return false; + } + + auto object_get_class = GetIl2cppFn(IL2CPP::il2cpp_object_get_class); + if (!object_get_class) { + return false; + } + + void* class_ptr = object_get_class(object_ptr); + if (!class_ptr) { + return false; + } + + const Il2CppClassLite* klass = reinterpret_cast(class_ptr); + if (!klass) { + return false; + } + + const char* ns = klass->namespaze ? klass->namespaze : ""; + const char* name = klass->name ? klass->name : ""; + if (name[0] == '\0') { + return false; + } + + if (out_ns) { + *out_ns = ns; + } + if (out_name) { + *out_name = name; + } + return true; +} + +std::string FormatClassName(const std::string& ns, const std::string& name) { + if (name.empty()) { + return {}; + } + if (ns.empty()) { + return name; + } + return ns + "." + name; +} + +} // namespace + +UnityExplorerModule::UnityExplorerModule() + : BaseModule("UnityExplorerModule", "Unity Explorer", ModuleCategory::Visual) { + search_filter_.fill('\0'); +} + +void UnityExplorerModule::RegisterTab() { + active_window_ = true; + auto_refresh_ = false; + refresh_interval_ = 3.0f; + last_refresh_time_ = static_cast(GetTickCount64()) / 1000.0; + selected_scene_ = 0; + selected_object_ = -1; + inspector_active_ = false; + inspected_obj_ptr_ = nullptr; + inspected_obj_name_.clear(); + inspector_ = InspectorState{}; + SetEnabled(true); + scenes_.clear(); + objects_.clear(); + scenes_.push_back({"DontDestroyOnLoad"}); +} + +void UnityExplorerModule::RefreshScenes() { + scenes_.clear(); + scenes_.push_back({"DontDestroyOnLoad"}); + scenes_.push_back({"ActiveScene"}); + + if (selected_scene_ < 0) { + selected_scene_ = 0; + } + if (selected_scene_ >= static_cast(scenes_.size())) { + selected_scene_ = static_cast(scenes_.size()) - 1; + } + RefreshObjectsForScene(); +} + +void UnityExplorerModule::RefreshObjectsForScene() { + objects_.clear(); + selected_object_ = -1; + inspector_active_ = false; + inspected_obj_ptr_ = nullptr; + inspected_obj_name_.clear(); + inspector_ = InspectorState{}; + + if (selected_scene_ < 0 || selected_scene_ >= static_cast(scenes_.size())) { + return; + } + + const std::string& selected_scene_name = scenes_[selected_scene_].name; + + if (selected_scene_name == "DontDestroyOnLoad") { + objects_.push_back({"[UnityEngine]: DontDestroyOnLoad Root", nullptr}); + } + + auto camera_main = GetIl2cppFn(IL2CPP::Camera_get_main); + if (camera_main) { + void* camera = camera_main(nullptr); + if (camera) { + objects_.push_back({"[UnityEngine]: Main Camera", camera}); + } + } + + if (selected_scene_name != "DontDestroyOnLoad") { + objects_.push_back({"[Game]: Player", nullptr}); + objects_.push_back({"[Game]: WorldRoot", nullptr}); + objects_.push_back({"[UI]: UIRoot", nullptr}); + } else if (objects_.size() <= 1) { + objects_.push_back({"[UnityEngine]: DontDestroyOnLoad (Not Found)", nullptr}); + } +} + +void UnityExplorerModule::Render() { + if (!ImGui::CollapsingHeader(Tr("Unity Explorer"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool enabled = Enabled(); + if (ImGui::Checkbox(Tr("ON / OFF"), &enabled)) { + SetEnabled(enabled); + if (enabled && scenes_.size() <= 1) { + RefreshScenes(); + } + } + if (!Enabled()) { + return; + } + + active_window_ = true; + if (!ImGui::Begin(Tr("Unity Explorer Window"), &active_window_)) { + ImGui::End(); + return; + } + + ImGui::TextUnformatted("Search Filter:"); + ImGui::InputText("##SearchFilter", search_filter_.data(), search_filter_.size()); + + if (ImGui::Button("Refresh")) { + RefreshScenes(); + last_refresh_time_ = static_cast(GetTickCount64()) / 1000.0; + } + ImGui::SameLine(); + ImGui::Checkbox("Auto Refresh", &auto_refresh_); + ImGui::SetNextItemWidth(250.0f); + ImGui::DragFloat("Interval (s)", &refresh_interval_, 0.05f, 0.1f, 60.0f, "%.2f"); + if (refresh_interval_ < 0.1f) { + refresh_interval_ = 0.1f; + } + + ImGui::Separator(); + ImGui::Text("Scenes found: %d", static_cast(scenes_.size())); + + if (scenes_.empty()) { + ImGui::TextUnformatted("No scenes available. Click 'Refresh Scenes' to load."); + } else { + ImGui::TextUnformatted("Select Scene:"); + std::vector items; + items.reserve(scenes_.size()); + for (const SceneEntry& scene : scenes_) { + items.push_back(scene.name.c_str()); + } + if (ImGui::Combo("##SceneCombo", &selected_scene_, items.data(), static_cast(items.size()))) { + RefreshObjectsForScene(); + } + } + + ImGui::Separator(); + ImGui::TextUnformatted("GameObjectHierarchy"); + if (ImGui::BeginChild("##GameObjectHierarchy", ImVec2(0.0f, 250.0f), true)) { + int shown = 0; + for (int i = 0; i < static_cast(objects_.size()); ++i) { + const ObjectEntry& entry = objects_[i]; + if (!ContainsNoCase(entry.display_name, search_filter_.data())) { + continue; + } + + ImGui::PushID(i); + ImGui::TextUnformatted(entry.display_name.c_str()); + ImGui::SameLine(); + const std::string inspect_button_id = "Ins##" + std::to_string(i); + if (ImGui::SmallButton(inspect_button_id.c_str())) { + InspectObject(i); + } + ImGui::PopID(); + shown++; + } + if (shown == 0) { + ImGui::TextUnformatted("No GameObjects found in this scene."); + } + } + ImGui::EndChild(); + + ImGui::Separator(); + ImGui::TextUnformatted("Inspector"); + if (!inspector_active_ || selected_object_ < 0 || selected_object_ >= static_cast(objects_.size())) { + ImGui::TextUnformatted("No GameObject selected."); + ImGui::TextUnformatted("Click 'Ins' button..."); + ImGui::End(); + return; + } + + ImGui::Text("Selected: %s", inspected_obj_name_.c_str()); + + if (inspected_obj_ptr_) { + auto get_active = GetIl2cppFn(IL2CPP::GameObject_get_activeInHierarchy); + if (get_active) { + inspector_.active = get_active(inspected_obj_ptr_); + } + } + + bool active = inspector_.active; + if (ImGui::Checkbox("Active", &active)) { + inspector_.active = active; + auto set_active = GetIl2cppFn(IL2CPP::GameObject_SetActive); + if (set_active && inspected_obj_ptr_) { + set_active(inspected_obj_ptr_, active); + } + } + + ImGui::Separator(); + ImGui::TextUnformatted("Transform"); + if (inspected_obj_ptr_) { + LoadTransformState(inspected_obj_ptr_); + } + + if (!inspector_.has_transform || !inspector_.transform) { + ImGui::TextUnformatted("No Transform component found."); + } else { + auto set_position = GetIl2cppFn(IL2CPP::Transform_set_position); + auto set_local_position = GetIl2cppFn(IL2CPP::Transform_set_localPosition); + auto set_local_scale = GetIl2cppFn(IL2CPP::Transform_set_localScale); + auto set_rotation = GetIl2cppFn(IL2CPP::Transform_set_rotation); + + if (ImGui::InputFloat3("Position", &inspector_.position.x, "%.3f") && set_position) { + set_position(inspector_.transform, &inspector_.position); + } + if (ImGui::InputFloat3("Local Position", &inspector_.local_position.x, "%.3f") && set_local_position) { + set_local_position(inspector_.transform, &inspector_.local_position); + } + if (ImGui::InputFloat3("Rotation", &inspector_.rotation_xyz.x, "%.3f") && set_rotation) { + Quat q{}; + q.x = inspector_.rotation_xyz.x; + q.y = inspector_.rotation_xyz.y; + q.z = inspector_.rotation_xyz.z; + q.w = inspector_.rotation_w; + set_rotation(inspector_.transform, &q); + } + if (ImGui::InputFloat3("Scale", &inspector_.scale.x, "%.3f") && set_local_scale) { + set_local_scale(inspector_.transform, &inspector_.scale); + } + } + + ImGui::Separator(); + ImGui::TextUnformatted("Components"); + if (inspected_obj_ptr_) { + LoadComponentList(inspected_obj_ptr_); + } + + if (!inspector_.class_name.empty()) { + ImGui::Text("GameObject Class: %s.%s", + inspector_.class_namespace.c_str(), + inspector_.class_name.c_str()); + } else { + ImGui::TextUnformatted("Unable to get GameObject class information."); + } + + ImGui::TextUnformatted("All Components:"); + if (inspector_.components.empty()) { + ImGui::TextUnformatted("No components found or failed to get components."); + } else { + ImGui::BeginChild("##AllComponents", ImVec2(0.0f, 180.0f), true); + for (int i = 0; i < static_cast(inspector_.components.size()); ++i) { + ImGui::PushID(i); + ImGui::TextUnformatted(inspector_.components[i].type_name.c_str()); + ImGui::PopID(); + } + ImGui::EndChild(); + } + + ImGui::End(); +} + +void UnityExplorerModule::Update() { + if (!Enabled() || !auto_refresh_) { + return; + } + + const double now = static_cast(GetTickCount64()) / 1000.0; + if ((now - last_refresh_time_) >= refresh_interval_) { + last_refresh_time_ = now; + RefreshScenes(); + } +} + +void UnityExplorerModule::InspectObject(int object_index) { + if (object_index < 0 || object_index >= static_cast(objects_.size())) { + return; + } + + selected_object_ = object_index; + inspected_obj_ptr_ = objects_[object_index].unity_object; + inspected_obj_name_ = objects_[object_index].display_name; + inspector_active_ = true; + RefreshInspectorState(); +} + +void UnityExplorerModule::RefreshInspectorState() { + inspector_ = InspectorState{}; + + if (!inspector_active_) { + return; + } + + if (!inspected_obj_ptr_) { + return; + } + + std::string class_ns; + std::string class_name; + if (TryGetClassName(inspected_obj_ptr_, &class_ns, &class_name)) { + inspector_.class_namespace = class_ns; + inspector_.class_name = class_name; + } + + auto get_active = GetIl2cppFn(IL2CPP::GameObject_get_activeInHierarchy); + if (get_active) { + inspector_.active = get_active(inspected_obj_ptr_); + } + + LoadTransformState(inspected_obj_ptr_); + LoadComponentList(inspected_obj_ptr_); +} + +bool UnityExplorerModule::LoadTransformState(void* unity_object) { + inspector_.has_transform = false; + inspector_.transform = nullptr; + + if (!unity_object) { + return false; + } + + auto get_transform = GetIl2cppFn(IL2CPP::GameObject_get_transform); + auto component_get_transform = GetIl2cppFn(IL2CPP::Component_GetComponent_Transform); + + void* transform = nullptr; + if (get_transform) { + transform = get_transform(unity_object); + } + if (!transform && component_get_transform) { + transform = component_get_transform(unity_object); + } + if (!transform) { + return false; + } + + inspector_.transform = transform; + inspector_.has_transform = true; + + auto get_position = GetIl2cppFn(IL2CPP::Transform_get_position); + auto get_local_position = GetIl2cppFn(IL2CPP::Transform_get_localPosition); + auto get_local_scale = GetIl2cppFn(IL2CPP::Transform_get_localScale); + auto get_rotation = GetIl2cppFn(IL2CPP::Transform_get_rotation); + + if (get_position) { + if (Vec3* v = get_position(transform)) { + inspector_.position = *v; + } + } + if (get_local_position) { + if (Vec3* v = get_local_position(transform)) { + inspector_.local_position = *v; + } + } + if (get_local_scale) { + if (Vec3* v = get_local_scale(transform)) { + inspector_.scale = *v; + } + } + if (get_rotation) { + if (Quat* q = get_rotation(transform)) { + inspector_.rotation_xyz.x = q->x; + inspector_.rotation_xyz.y = q->y; + inspector_.rotation_xyz.z = q->z; + inspector_.rotation_w = q->w; + } + } + + return true; +} + +void UnityExplorerModule::LoadComponentList(void* unity_object) { + inspector_.components.clear(); + + if (!unity_object) { + return; + } + + auto get_component_by_index = + GetIl2cppFn(IL2CPP::GameObject_GetComponentByIndex); + auto object_get_name = GetIl2cppFn(IL2CPP::Object_get_name); + + if (!get_component_by_index) { + return; + } + + std::unordered_set seen_components; + for (int i = 0; i < 128; ++i) { + void* component = get_component_by_index(unity_object, i); + if (!component) { + break; + } + + if (!seen_components.insert(component).second) { + break; + } + + std::string component_ns; + std::string component_name; + if (TryGetClassName(component, &component_ns, &component_name)) { + inspector_.components.push_back( + {FormatClassName(component_ns, component_name), component}); + continue; + } + + if (object_get_name) { + const std::string name_from_object = Il2CppStringToUtf8(object_get_name(component)); + if (!name_from_object.empty()) { + inspector_.components.push_back({name_from_object, component}); + continue; + } + } + + inspector_.components.push_back({"Unknown Component", component}); + } +} diff --git a/IDA/project/UnityExplorer.h b/IDA/project/UnityExplorer.h new file mode 100644 index 0000000..e03004b --- /dev/null +++ b/IDA/project/UnityExplorer.h @@ -0,0 +1,66 @@ +#pragma once + +#include "ModuleManager.h" + +#include + +class UnityExplorerModule final : public BaseModule { +public: + UnityExplorerModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + struct SceneEntry { + std::string name; + }; + + struct ObjectEntry { + std::string display_name; + void* unity_object = nullptr; + }; + + struct ComponentEntry { + std::string type_name; + void* component = nullptr; + }; + + struct InspectorState { + bool active = false; + bool has_transform = false; + void* transform = nullptr; + Vec3 position{}; + Vec3 local_position{}; + Vec3 scale{1.0f, 1.0f, 1.0f}; + Vec3 rotation_xyz{}; + float rotation_w = 1.0f; + std::string class_namespace; + std::string class_name; + std::vector components; + }; + + void RefreshScenes(); + void RefreshObjectsForScene(); + void InspectObject(int object_index); + void RefreshInspectorState(); + bool LoadTransformState(void* unity_object); + void LoadComponentList(void* unity_object); + + bool active_window_ = true; + bool auto_refresh_ = false; + float refresh_interval_ = 3.0f; + double last_refresh_time_ = 0.0; + int selected_scene_ = 0; + int selected_object_ = -1; + + bool inspector_active_ = false; + void* inspected_obj_ptr_ = nullptr; + std::string inspected_obj_name_; + InspectorState inspector_; + + std::array search_filter_{}; + std::vector scenes_; + std::vector objects_; +}; diff --git a/IDA/project/Vacuum.cpp b/IDA/project/Vacuum.cpp new file mode 100644 index 0000000..0ebd7b3 --- /dev/null +++ b/IDA/project/Vacuum.cpp @@ -0,0 +1,69 @@ +#include "Vacuum.h" + +#include "helpers.h" + +#include + +namespace { +constexpr float kAttractStrength = 1.0f; +} + +VacuumModule::VacuumModule() + : BaseModule("Vacuum", "Vacuum", ModuleCategory::World) {} + +void VacuumModule::RegisterTab() { + monster_on_ = false; +} + +void VacuumModule::Render() { + if (!ImGui::CollapsingHeader(Tr("Vacuum"), ImGuiTreeNodeFlags_DefaultOpen)) { + return; + } + + bool vacuum_enabled = Enabled(); + const std::string vacuum_toggle_label = std::string(Tr("Vacuum")) + "##vacuum_toggle"; + if (ImGui::Checkbox(vacuum_toggle_label.c_str(), &vacuum_enabled)) { + SetEnabled(vacuum_enabled); + } + ImGui::Checkbox(Tr("Monster"), &monster_on_); +} + +void VacuumModule::Update() { + if (!Enabled()) { + return; + } + + using FnCameraMain = void* (*)(void*); + using FnGetTransform = void* (*)(void*); + using FnGetPosition = Vec3* (*)(void*); + using FnAddForce = void (*)(void*, Vec3*, int); + + auto camera_main = GetIl2cppFn(IL2CPP::Camera_get_main); + auto get_transform = GetIl2cppFn(IL2CPP::GameObject_get_transform); + auto get_position = GetIl2cppFn(IL2CPP::Transform_get_position); + auto add_force = GetIl2cppFn(IL2CPP::Rigidbody_AddForce); + if (!camera_main || !get_transform || !get_position || !add_force) { + return; + } + + void* camera = camera_main(nullptr); + if (!camera) { + return; + } + void* cam_transform = get_transform(camera); + if (!cam_transform) { + return; + } + Vec3* cam_pos = get_position(cam_transform); + if (!cam_pos) { + return; + } + + Vec3 force{}; + force.x = cam_pos->x * kAttractStrength; + force.y = cam_pos->y * kAttractStrength; + force.z = cam_pos->z * kAttractStrength; + + (void)add_force; + (void)monster_on_; +} diff --git a/IDA/project/Vacuum.h b/IDA/project/Vacuum.h new file mode 100644 index 0000000..846bb82 --- /dev/null +++ b/IDA/project/Vacuum.h @@ -0,0 +1,15 @@ +#pragma once + +#include "ModuleManager.h" + +class VacuumModule final : public BaseModule { +public: + VacuumModule(); + + void RegisterTab() override; + void Render() override; + void Update() override; + +private: + bool monster_on_ = false; +}; diff --git a/IDA/project/bin/EF-Cheeto.dll b/IDA/project/bin/EF-Cheeto.dll new file mode 100644 index 0000000..f019ff6 Binary files /dev/null and b/IDA/project/bin/EF-Cheeto.dll differ diff --git a/IDA/project/docs/input/files/ef_cheeto_feed_1_analysis.md b/IDA/project/docs/input/files/ef_cheeto_feed_1_analysis.md new file mode 100644 index 0000000..8db0eca --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_feed_1_analysis.md @@ -0,0 +1,3963 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 1/3 +# Feed ALL THREE PARTS before asking reconstruction questions. +# Part 1: Orientation + Full Analysis (prose, pseudocode, tables) + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed +# Part 2: Reconstruction Header (structs, addresses, constants) +# Part 3: Machine Code (hex dumps + raw binary sections) + +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +ANALYSIS DOCUMENT — All 29 Chapters +================================================================================ + +EF-Cheeto.dll (unityexplorer.dll) +Complete Reverse Engineering Report — Final Consolidated Edition +24 Chapters · 11 Registered Modules · Complete Static Reconstruction +February 27, 2026 +# 1. Executive Summary +This document is the complete consolidated reverse engineering analysis of EF-Cheeto.dll (distributed as unityexplorer.dll), spanning twenty-five chapters. It covers all subsystems from infrastructure (thread enumeration, anti-debug, shader compilation, config I/O) through the hook engine, eleven registered cheat modules, the ModuleManager dispatch architecture, GABypass IL2CPP resolver, JSON config schema, and analyses added in later passes: ESPModule Render/Update implementation (Ch. 22), DamageHack ghost feature analysis (Ch. 23), SetDither RenderOverlay body (Ch. 12.5.1), and the Sidebar/Main Panel rendering function (Ch. 25). +IAT base is RVA 0xB1000 (file raw offset 0xAF600). The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows. The binary is fully reverse engineered with no significant undocumented regions remaining. +# 2. Corrected IAT Address Map +Previous analysis used incorrect IAT RVAs derived from objdump -p output. The correct IAT base is RVA 0xB1000 (file raw offset 0xAF600), not the 0x3C2xxx addresses previously listed. The following table gives the correct IAT RVAs and all call sites. +Function +IAT RVA +DLL +Call Sites (VA) +SuspendThread +0xB1050 +KERNEL32.dll +0x1800A9861 +ResumeThread +0xB1058 +KERNEL32.dll +0x1800A9964 (×37 total) +GetThreadContext +0xB1068 +KERNEL32.dll +0x1800A988B +SetThreadContext +0xB1078 +KERNEL32.dll +0x1800A993C +CreateToolhelp32Snapshot +0xB1160 +KERNEL32.dll +0x1800A970B +Thread32First +0xB11B0 +KERNEL32.dll +0x1800A972F +Thread32Next +0xB11A8 +KERNEL32.dll +0x1800A97DD +OpenThread +0xB11D0 +KERNEL32.dll +0x1800A9849 (×38 total) +VirtualProtect +0xB1288 +KERNEL32.dll +0x1800A9AFC, 0x1800A9B6C +FlushInstructionCache +0xB1070 +KERNEL32.dll +0x1800A9B81 +GetCurrentProcess +0xB1270 +KERNEL32.dll +0x1800A9B72 +IsDebuggerPresent +0xB11E8 +KERNEL32.dll +0x1800AC67B +SetUnhandledExceptionFilter +0xB1200 +KERNEL32.dll +0x1800AC698 +UnhandledExceptionFilter +0xB1208 +KERNEL32.dll +0x1800AC6A3 +IsProcessorFeaturePresent +0xB11F0 +KERNEL32.dll +0x1800AC5A2 +TerminateProcess +0xB11F8 +KERNEL32.dll +0x1800AC628 (via int 29h) +D3DCompile +0xB1000 +D3DCOMPILER_47 +0x180054E77, 0x180055069 +_wfopen +0xB1888 +CRT +0x180011F93 +fwrite +0xB1868 +CRT +0x18000EA1B, 0x1800170D6, 0x18003033B, 0x18003076D +fread +0xB1870 +CRT +(called via 0x180011EA0 helper) +fclose +0xB1878 +CRT +0x1800170DF, 0x180030776 +SetWindowDisplayAffinity +0xB1460 +USER32.dll +0x18008B48F +LoadLibraryA +0xB10E0 +KERNEL32.dll +0x180055F57, 0x1800585AE (×4) +GetProcAddress +0xB1088 +KERNEL32.dll +0x180055F7E, 0x180055F92 (×7) +VirtualAlloc +0xB11A0 +KERNEL32.dll +0x1800AA566, 0x1800AA607 +VirtualFree +0xB1278 +KERNEL32.dll +0x180081D5B, 0x1800AA6E1 +# 3. Thread Enumeration and Suspension +Thread enumeration serves a critical role in safe hook installation: the cheat must suspend all Unity render/game threads before patching code bytes, then resume them after patching, to prevent race conditions. This subsystem uses two cooperating functions. +## 3.1 Thread Collection Function (0x1800A96B0–0x1800A9A1C) +This function collects all thread IDs for the current process using a Toolhelp32 snapshot, filtering out the calling thread and storing results in a caller-provided vector. The function signature is: +int CollectProcessThreads( +DWORD* out_vec, // RCX: vector { begin, end, capacity } +DWORD current_pid, // RDX: passed to CreateToolhelp32Snapshot +DWORD current_tid // R8d: thread to exclude (caller's thread) +Key sequence: +// 0x1800A96B0: Prologue, save RSI/RDI/RBX/R12-R15, allocate 0x530 bytes stack +// 0x1800A96E7: xor ebx, ebx (thread count = 0) +// 0x1800A96F8: mov [rcx], rbx; mov [rcx+8], rbx (init empty vector) +// 0x1800A9701: lea ecx, [rbx+4] = TH32CS_SNAPTHREAD = 4 +// 0x1800A970B: call [IAT:CreateToolhelp32Snapshot](dwFlags=4, pid=r15) +// 0x1800A9711: mov r14, rax (hSnapshot = result) +// 0x1800A9714: cmp rax, -1 → je fail (INVALID_HANDLE_VALUE) +// 0x1800A971E: lea r12d, [rbx+0x1C] (sizeof THREADENTRY32 = 28) +// 0x1800A9725: lea rdx, [rsp+0x30] (THREADENTRY32 buffer) +// 0x1800A972A: mov [rsp+0x30], r12d (te32.dwSize = 28) +// 0x1800A972F: call [IAT:Thread32First](hSnapshot, &te32) +// --- LOOP --- +// 0x1800A9740: cmp [rsp+0x30], 0x10 (check th32OwnerProcessID offset) +// 0x1800A974B: call [IAT:GetCurrentProcessId] +// 0x1800A9751: cmp [rsp+0x3C], eax (te32.th32OwnerProcessID == GetCurrentProcessId?) +// 0x1800A9755: jne skip (skip threads not in our process) +// 0x1800A9757: call [IAT:GetCurrentThreadId] +// 0x1800A975D: cmp [rsp+0x38], eax (te32.th32ThreadID == calling thread?) +// 0x1800A9761: je skip (exclude caller's thread) +// 0x1800A9763: mov rdx, [rdi] (vector data pointer) +// 0x1800A9778: call [IAT:VirtualAlloc] or HeapReAlloc if needed +// 0x1800A97CA: mov [rdx+rcx*4], eax (store thread ID) +// 0x1800A97CD: incl [rdi+0xC] (vector count++) +// 0x1800A97DD: call [IAT:Thread32Next](hSnapshot, &te32) +// 0x1800A97E3: test eax, eax → jne loop +// 0x1800A97EB: call [IAT:GetLastError] → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0x1800A9815: call [IAT:CloseHandle](hSnapshot) +Return value: 0 on success (ESI = 0 → je path), 9 on error (EBX = 9 → mov eax, 9). +## 3.2 Thread Suspend/Resume Function (0x1800A9A20–0x1800A9A98) +Iterates the thread ID vector and either suspends or resumes each thread. Called before and after code patching. +void SuspendOrResumeThreads(DWORD* id_vector, int action) { +// action: 0 = resume, 1 = suspend +for (int i = 0; i < id_vector->count; i++) { +DWORD tid = id_vector->data[i]; +if (tid == 0) continue; +HANDLE hThread = OpenThread(0x5A, FALSE, tid); // THREAD_SUSPEND+CONTEXT +if (!hThread) continue; +if (action == 0) ResumeThread(hThread); +else SuspendThread(hThread); +CloseHandle(hThread); +} +// free id_vector->data via HeapFree +} +## 3.3 Code Patcher (0x1800A9A9C–0x1800A9BC3) +Writes trampoline/hook bytes at a target address with full thread-safety. Called from SkillHack and other modules during hook installation. +int PatchCode(int hook_index, int is_jmp) { +// Lookup hook entry: base = g_hookTable[hook_index * 0x38] +void* target = hook_entry->target_va; +void* jump_dest = hook_entry->callback; // or target-5 if is_short_jmp +DWORD old_protect; +// First VirtualProtect: make target page EXECUTE_READWRITE (0x40) +VirtualProtect(target, patch_size, PAGE_EXECUTE_READWRITE, &old_protect); +if (is_jmp) { +// Write E9 JMP rel32 +*(BYTE*)target = 0xE9; +*(DWORD*)(target+1) = (DWORD)jump_dest - (DWORD)target - 5; +if (hook_entry->flags & 1) +*(WORD*)orig_ptr = 0xF9EB; // short jmp back +} else { +// Copy original bytes (stub) +*(DWORD*)target = hook_entry->orig_bytes_dword; +if (hook_entry->flags & 1) { +*(WORD*)(target+4) = hook_entry->orig_word; +*(BYTE*)(target+6) = hook_entry->orig_byte; +} else { +*(BYTE*)(target+4) = hook_entry->orig_byte; +} +} +// Second VirtualProtect: restore original protection +VirtualProtect(target, patch_size, old_protect, &old_protect); +FlushInstructionCache(GetCurrentProcess(), target, patch_size); +// Update flags: toggle enable/jmp bits in hook_entry->flags +return 0; // success +} +# 4. Anti-Debug and Exception Handling +The binary contains two related security functions: a structured exception handler setup that uses IsDebuggerPresent, and a stack security cookie verifier. +## 4.1 Exception Handler Setup (0x1800AC580–0x1800AC6CA) +This function is the C runtime __security_check_cookie and SEH initializer. It is called during DLL initialization (DllMain) and during first-chance exception dispatching. +// 0x1800AC580: CRT security init function +// ecx = fault code (passed in from caller) +// Check IsProcessorFeaturePresent(0x17 = PF_FASTFAIL_AVAILABLE) +call [IAT:IsProcessorFeaturePresent](0x17) +test eax, eax +je skip_int29 +int 29h // Fast fail - terminate without SEH if supported +skip_int29: +call sub_1800AC574 // __security_check_cookie helper +// Set up EXCEPTION_RECORD and CONTEXT for RtlCaptureContext +call RtlCaptureContext // [IAT:0xB1220] +call RtlLookupFunctionEntry // [IAT:0xB1218] - find handler +call RtlVirtualUnwind // [IAT:0xB1210] - unwind frame +// Build EXCEPTION_RECORD: +movl [rsp+50h], 0x40000015 // ExceptionCode = STATUS_FATAL_APP_EXIT +movl [rsp+54h], 1 // ExceptionFlags = EXCEPTION_NONCONTINUABLE +call [IAT:IsDebuggerPresent] // 0x1800AC67B +mov ebx, eax // save result +call [IAT:SetUnhandledExceptionFilter](NULL) // remove any handler +call [IAT:UnhandledExceptionFilter](&record) +test eax, eax +jne done +cmp ebx, 1 // was debugger present? +je done +lea ecx, [eax+3] +call __report_gsfailure // terminate +Note: IsDebuggerPresent is NOT used as an anti-cheat measure; it is part of the MSVC CRT __security_check_cookie fast-fail path. The binary does not actively attempt to detect or evade debuggers — it simply invokes standard MSVC security cookie failure reporting. +## 4.2 Security Canary Verifier (0x1800AC6CC–0x1800AC77B) +This is the standard MSVC __security_check_cookie function. It compares the stack cookie against a magic constant, then triggers a fast-fail if mismatch is detected. +// 0x1800AC6CC: __security_check_cookie +// rcx = stack cookie value to verify +mov rax, [__security_cookie] // load expected cookie (initialized at startup) +mov rbx, 0x2B992DDFA232 // partial expected value (lower 48 bits) +cmp rax, rbx +jne fail // mismatch → security violation +// Derive additional check from: +// GetSystemTimeAsFileTime, GetCurrentThreadId, GetCurrentProcessId, +// QueryPerformanceCounter, combined via XOR and shift +call [IAT:GetSystemTimeAsFileTime] +call [IAT:GetCurrentThreadId] +xor -0x10(%rbp), rax +call [IAT:GetCurrentProcessId] +xor -0x10(%rbp), rax +call [IAT:QueryPerformanceCounter] +// ... XOR operations combining all values +// Mask to 0xFFFFFFFFFFFF (48 bits) +// Compare with stored cookie — mismatch → crash +// This is 100% MSVC runtime security, NOT an anti-cheat check +# 5. HLSL Shader Compilation (D3DCompile) +The cheat overlay uses two shaders compiled at runtime via D3DCompile from D3DCOMPILER_47.dll. Both shaders are the standard ImGui Direct3D11 backend shaders embedded verbatim in .rdata. They are compiled in the D3D11 initialization function (0x180054DC0–0x1800551E8) which is called during the Present hook setup. +## 5.1 Vertex Shader +// Source at RVA 0x3AE660, length = 0x2DD (733 bytes) +// Compilation: D3DCompile(src, 0x2DD, NULL, NULL, NULL, "main", "vs_4_0", 0, 0, ...) +cbuffer vertexBuffer : register(b0) { +float4x4 ProjectionMatrix; +}; +struct VS_INPUT { +float2 pos : POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +PS_INPUT main(VS_INPUT input) { +PS_INPUT output; +output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +output.col = input.col; +output.uv = input.uv; +return output; +} +## 5.2 Pixel Shader +// Source at RVA 0x3AE940, length = 0x191 (401 bytes) +// Compilation: D3DCompile(src, 0x191, NULL, NULL, NULL, "main", "ps_4_0", 0, 0, ...) +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +sampler sampler0; +Texture2D texture0; +float4 main(PS_INPUT input) : SV_Target { +float4 out_col = input.col * texture0.Sample(sampler0, input.uv); +return out_col; +} +## 5.3 Shader Initialization Sequence (0x180054DC0) +// Prologue: save R14-R15, allocate 0x220 stack +// Load g_D3DState from [g_Config+0xD8] into R14 +// Check if already initialized: cmp (*r14), null +je skip_init +// Call sub_0x1800551F0 (create vertex/index buffers) +// === Compile Vertex Shader === +lea rcx, [rip+0x1803AE660] // HLSL source ptr +mov edx, 0x2DD // source length +xor r8d, r8d // pSourceName = NULL +xor r9d, r9d // pDefines = NULL +mov [rsp+20h], r15 // pInclude = NULL +lea rax, [0x1803AEADC] // 'main' string +mov [rsp+28h], r12 // pInclude (NULL) +mov [rsp+30h], rax // pEntrypoint = 'main' +lea rax, [0x1803AEAD4] // 'vs_4_0' +mov [rsp+38h], r15d // Flags1 = 0 +mov [rsp+40h], r15d // Flags2 = 0 +mov [rsp+48h], &ppVSCode // output blob ptr +mov [rsp+50h], r15 // ppErrorBlob = NULL +call [IAT:D3DCompile] +js fail +// Get VS blob pointer, call ID3DBlob::GetBufferPointer/GetBufferSize +// Then: call ID3D11Device::CreateVertexShader via vtable slot[0x20/8] +// Create input layout via vtable slot[0x58/8] +// Create constant buffer (ProjectionMatrix) via vtable slot[0x60/8] +// === Compile Pixel Shader === +lea rcx, [rip+0x1803AE940] // PS HLSL source +mov edx, 0x191 // PS source length +// ... same parameters pattern ... +// pEntrypoint = 'main', target = 'ps_4_0' +call [IAT:D3DCompile] +js fail +// Create pixel shader via vtable slot[0x78/8] (CreatePixelShader) +// Create sampler state via vtable slot[0x78/8] on device +// Create blend state (alpha blending) with blend ops +// Create depth stencil state +// Create rasterizer state +# 6. Configuration File I/O +Configuration is read and written using a helper function (0x180011EA0) that converts UTF-8 paths to wide-char then calls _wfopen. Callers pass different file mode strings ('rb' for read, 'wt' for write) to the same function. +## 6.1 File Open Helper (0x180011EA0–0x180012043) +FILE* OpenConfigFile(const char* path_utf8, const char* mode_utf8) { +// rcx = path_utf8, rdx = mode_utf8 +// Get length of path: MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0) +int path_len = MultiByteToWideChar(0xFDE9, 0, path, -1, NULL, 0); // CP_UTF8=65001=0xFDE9 +// Get length of mode string +int mode_len = MultiByteToWideChar(0xFDE9, 0, mode, -1, NULL, 0); +// Allocate wide char buffer (stack if small enough, heap if > 0x104 chars) +if (path_len + mode_len > 0x104) +wbuf = malloc((path_len + mode_len) * 2); +else +wbuf = alloca((path_len + mode_len) * 2); +wchar_t* wpath = wbuf; +wchar_t* wmode = wbuf + path_len; +// Convert path to wide +MultiByteToWideChar(0xFDE9, 0, path, -1, wpath, path_len); +// Convert mode to wide +MultiByteToWideChar(0xFDE9, 0, mode, -1, wmode, mode_len); +// Open file +FILE* fp = _wfopen(wpath, wmode); +if (heap_buf) free(heap_buf); +return fp; +} +## 6.2 Config File Mode Strings +Two mode strings are stored in .rdata at consecutive addresses: +RVA +String +Usage +0x3AD590 +'rb' +Config READ - binary read mode +0x3AD594 +'wt' +Config WRITE - text write mode (ImGui ini) +## 6.3 Config Read Callers +The config file open helper is called from two read contexts and two write contexts: +Caller VA +Func Range +Mode +Data Source / Purpose +0x1800170B9 +0x17078-0x172CA +'wt' +Serialize ImGui window positions/sizes to ini file (ImGui_ImplDX11 save) +0x180030750 +0x30620-0x307A0 +'wt' +Write g_Config state to JSON file on module disable/exit +(via fread) +0x302D2-0x30348 +'rb' +Read JSON config on startup, populate g_Config fields +0x18000EA1B +0xE9F4-0xEA33 +n/a +fwrite to stdout/console (debug output, size=1) +## 6.4 Config Write Function (0x180030620) +void SaveConfig(ConfigState* state) { +// Check state->enabled_flag [rbx+0x2900] +// Load state->file_path pointer [rbx+0x50] +// Call sub_0x180030A90 (build file path string) +// Call OpenConfigFile(path, 'wt') → returns FILE* fp +// Serialize config to string via sub_0x180012050 +// fwrite(config_string, 1, string_length, fp) +// fclose(fp) +// Also handles periodic auto-save: +// xmm0 = [rbx+0x2904] (auto-save timer) +// if (timer > 0) { timer -= delta_time } +// When timer expires: rebuild path, re-open, write again +} +# 7. WndProc Handler and Hotkey Dispatch +The WndProc callback is registered at VA 0x1800826A0 during window class creation (RegisterClassExW). It is the Win32 message handler for the overlay window and handles three specific messages before deferring all others to ImGui's built-in handler. +## 7.1 WndProc Function (0x1800826A0) +Signature: LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// Step 1: Pass ALL messages to ImGui first +if (g_ImGuiCtx != NULL) { +// ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam) +// [rsp+0x20] = g_ImGuiCtx+0x30 +LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +if (r != 0) return 1; // ImGui consumed the message +} +switch (msg) { +case WM_DESTROY (0x0002): +PostQuitMessage(0); +return 0; +case WM_SIZE (0x0005): +// Ignore minimize (SIZE_MINIMIZED = 1) +if (g_pSwapChain != NULL && wParam != 1) { +// Free existing render target +if (g_pRenderTargetView) { +g_pRenderTargetView->Release(); // vtable[0x10] +g_pRenderTargetView = NULL; +} +// Resize swap chain buffers +// pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), 0, 0) +g_pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), +DXGI_FORMAT_UNKNOWN, 0); // vtable[0x68] +// Recreate D3D11 resources (render target, shaders, etc.) +HookInstall(); // 0x1800825B0 +} +return 0; +case WM_SYSCOMMAND (0x0112): +// Suppress SC_KEYMENU (ALT key activating system menu) +if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +break; +default: +// Forward to DefWindowProcW via ImGui_ImplWin32_WndProcHandler +return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +} +return 0; +} +## 7.2 Message Dispatch Table +WM_ Code +Value +Action +Notes +WM_DESTROY +0x0002 +PostQuitMessage(0) +Triggers clean shutdown of message loop +WM_SIZE +0x0005 +ResizeBuffers + HookInstall() recreate +Skipped if wParam==SIZE_MINIMIZED(1) +WM_SYSCOMMAND +0x0112 +Return 0 if SC_KEYMENU (0xF100) +Suppresses ALT-key menu flash on overlay +(all others) +- +Defer to ImGui_ImplWin32_WndProcHandler +ImGui handles mouse/keyboard/focus/IME +## 7.3 F12 Hotkey — Panel Toggle +The overlay panel toggle is NOT processed inside WndProc. It is polled via GetAsyncKeyState in the per-frame Present hook loop at VA 0x18008301A, which is part of the ModuleManager main render function (0x180082FC0). +// Inside ModuleManager render loop (0x180082FC0), called each Present() frame: +// Poll F12 key (VK_F12 = 0x7B) +SHORT keyState = GetAsyncKeyState(0x7B); // VK_F12 +if (keyState & 0x1) { +// Key was pressed since last call — toggle panel visibility +// Static init guard pattern (MSVC thread-safe static) +// g_showPanel (.data+0x245C) = !g_showPanel +g_Config.show_panel ^= 1; // [.data+0x245C] toggle +} +// Banner string shown in game window title / tray when panel is hidden: +// 'EF - Cheeto Press F12 to show panel' (RVA 0x3AF258) +Address +Description +0x18008301A +GetAsyncKeyState(VK_F12=0x7B) call — panel toggle poll +.data+0x245C +g_showPanel flag (BYTE): 0=hidden, 1=visible +RVA 0x3AF258 +Banner string 'EF - Cheeto ... Press F12 to show panel' +0x1800826A0 +WndProc callback registered via RegisterClassExW +0x180057720 +ImGui_ImplWin32_WndProcHandler (handles all ImGui keyboard/mouse) +0x1800825B0 +HookInstall / D3D11 resource recreation (called on WM_SIZE) +## 7.4 Module Hotkeys +A dedicated hotkey error handler exists at 0x1800AECE0, referenced by the string '[ERROR] Failed to process hotkeys for module'. This function is an exception handler — it is called if a module's hotkey processing throws. Individual module hotkey configurations are stored in the per-module state structs and dispatched by the ModuleManager loop, not in WndProc. +# 8. Hook Manager Internals +The hook manager is a global singleton initialized lazily via an MSVC thread-safe static at 0x180081B00. It manages a flat array of hook entries, a hash table for fast lookup by target address, and a spinlock for thread safety. All four hook API functions (CreateHook, RemoveHook, EnableHook, GetHookInfo) acquire the spinlock at entry and release it on every exit path. +## 8.1 Singleton Memory Layout +The singleton is stored at .data+0x2470 (VA 0x1803C7470). The structure is 0x90 bytes, zero-initialized on first call. +Offset +Type +Field +Description ++0x00 +QWORD* +hook_array +Pointer to flat array of hook entries (0x38 bytes each) ++0x08 +DWORD +hook_capacity +Allocated slot count for hook_array ++0x0C +DWORD +hook_count +Number of active hooks currently installed ++0x10 +QWORD* +hash_buckets +Pointer to hash table bucket array (linked list heads) ++0x18 +DWORD +bucket_count +Number of hash buckets (power of 2, initial=8) ++0x1C +DWORD +bucket_mask +hash_mod mask = bucket_count*2 - 1 ++0x20 +QWORD* +free_list_head +Head of freed/recycled hook slot free list ++0x28 +float +load_factor +Hash table load factor threshold (0x3f800000 = 1.0f) ++0x30 +BYTE +initialized +Set to 0 after init, prevents double-init +.data+0x1E88 +DWORD +spinlock +Global spinlock DWORD; 0=free, 1=held +## 8.2 Hook Entry Structure (0x38 bytes) +Each entry in the hook_array is 0x38 bytes. The hook array grows dynamically; initial capacity is 0x80 slots allocated via the IAllocator at .data+0x1E90. +Offset +Type +Field +Description ++0x00 +QWORD +target_va +Virtual address of the hooked IL2CPP function ++0x08 +QWORD +callback_va +Virtual address of the replacement/detour function ++0x10 +QWORD +trampoline_va +VirtualAlloc'd trampoline (original bytes + JMP back) ++0x18 +DWORD +orig_bytes_0_3 +Saved original 4 bytes at target (for restore) ++0x1C +WORD +orig_bytes_4_5 +Saved original bytes 4–5 at target ++0x1E +BYTE +orig_byte_6 +Saved original byte 6 at target ++0x20 +BYTE +flags +Bit 0: has_far_jmp (6-byte JMP); Bit 1: enabled; Bit 2: suspended ++0x24 +DWORD +flags2 +Lower nibble: hook type (0=near JMP, 1=far) ++0x28 +QWORD +hash_next +Next entry pointer in hash chain (for collision chaining) ++0x30 +QWORD +reserved +Padding / future use +## 8.3 Spinlock (0x1800A9C88) +All four hook API functions call the spinlock acquire function at 0x1800A9C88 on entry. Release is done inline via XCHG [.data+0x1E88], 0 at the end of each function. +// Spinlock acquire — 0x1800A9C88 +// Uses LOCK CMPXCHG on .data+0x1E88 (global DWORD spinlock) +void AcquireSpinlock() { +DWORD backoff = 0; +while (true) { +DWORD expected = 0; +// LOCK CMPXCHG [.data+0x1E88], 1 +if (InterlockedCompareExchange(&g_spinlock, 1, 0) == 0) +return; // acquired +// Exponential backoff: if backoff < 32, SwitchToThread(0); else Sleep(1) +backoff += 1; +if (backoff < 32) +SwitchToThread(); // IAT 0x1800B1148 +else +Sleep(1); +} +} +// Spinlock release — inline in all callers +// XCHG [.data+0x1E88], ebx (where ebx=0, atomic store 0) +## 8.4 CreateHook (0x1800A9CC8) +Installs a new hook. Takes target VA (rcx), callback VA (rdx), and optional out_trampoline pointer (r8). Returns 0 on success, error code otherwise. +// CreateHook(void* target, void* callback, void** out_trampoline) -> int +// RVA 0x0A9CC8 +int CreateHook(void* target, void* callback, void** out_trampoline) { +AcquireSpinlock(); // 0x1800A9C88 +// Validate hook manager initialized +if (g_hookMgr.allocator == NULL) return 2; // MH_ERROR_NOT_INITIALIZED +// Validate target and callback are executable +if (!IsExecutable(target)) return 7; // MH_ERROR_NOT_EXECUTABLE +if (!IsExecutable(callback)) return 7; +// Check if hook already exists for this target +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +if (i == -1) continue; +return 3; // MH_ERROR_ALREADY_CREATED +} +} +// Allocate a trampoline buffer near the target +TrampolineSlot* slot = AllocTrampolineSlot(target); // 0x1800A960C +if (!slot) return 9; // MH_ERROR_MEMORY_ALLOC +// Build trampoline: copy prologue bytes + write JMP back +HookEntry entry = {}; +if (!BuildTrampoline(target, callback, slot, &entry)) return 8; +// Fill hook entry fields +entry.target_va = target; // [r8+0x00] +entry.callback_va = callback; // [r8+0x08] (from [rsp+0x28]) +entry.trampoline_va = slot->code; // [r8+0x10] +// Save original bytes for unhook restore +if (entry.flags & 1) { // far JMP (6-byte) +entry.orig_bytes_0_3 = *(DWORD*)(target - 5); +entry.orig_bytes_4_5 = *(WORD*) (target - 1); +entry.orig_byte_6 = *(BYTE*) (target + 1); +} else { // near JMP (5-byte) +entry.orig_bytes_0_3 = *(DWORD*)target; +entry.orig_byte_6 = *(BYTE*)(target + 4); +} +if (out_trampoline) *out_trampoline = slot->code; +ReleaseSpinlock(); // XCHG [.data+0x1E88], 0 +return 0; // MH_OK +} +## 8.5 RemoveHook (0x1800A9E8C) +Removes an installed hook by target address. If the hook is enabled, it is disabled first (original bytes restored). The entry is removed from the array by swapping with the last element. The array is shrunk by half if utilization drops below 50% and count > 0x20. +// RemoveHook(void* target) -> int +// RVA 0x0A9E8C +int RemoveHook(void* target) { +AcquireSpinlock(); +if (g_hookMgr.allocator == NULL) return 2; +// Linear search for target in hook array (stride 0x38) +int idx = -1; +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +idx = i; break; +} +} +if (idx == -1) return 4; // MH_ERROR_NOT_CREATED +HookEntry* entry = &g_hookMgr.hook_array[idx]; +// If hook is currently enabled, disable it first (restore original bytes) +if (entry->flags & 0x2) { +GetHookInfo(idx, 0, ...); // 0x1800A96B0 +EnableHook(idx, 0); // 0x1800A9A9C — restore original bytes +SuspendOtherThreads(...); // 0x1800A9A20 — thread safety +} +// Free trampoline memory +FreeSlot(entry->trampoline_va); // 0x1800AA684 +// Compact array: move last entry into freed slot +int last = g_hookMgr.hook_count - 1; +if (idx < last) { +// memmove: copy 0x38 bytes from hook_array[last] to hook_array[idx] +// (3x movups xmm0 + movsd for full 0x38-byte copy) +hook_array[idx] = hook_array[last]; +} +g_hookMgr.hook_count--; +// Shrink array if count <= capacity/2 and count > 0x20 +if (g_hookMgr.hook_capacity / 2 >= 0x20 && +g_hookMgr.hook_count <= g_hookMgr.hook_capacity / 2) { +realloc(hook_array, (capacity/2) * 0x38); +g_hookMgr.hook_capacity /= 2; +} +ReleaseSpinlock(); +return 0; +} +## 8.6 EnableHook / PatchCode (0x1800A9A9C) +Patches or unpatches the target function's first bytes. Suspends all other threads during the write using VirtualProtect + WriteProcessMemory, then resumes them. Handles both near (5-byte E9 JMP) and far (6-byte FF25 indirect JMP) hook types. +// EnableHook(int hook_idx, BOOL enable) -> int +// RVA 0x0A9A9C +int EnableHook(int hook_idx, BOOL enable) { +HookEntry* e = &g_hookMgr.hook_array[hook_idx * 0x38]; +// Determine patch target and size +BOOL far_jmp = e->flags & 0x1; // bit 0: uses 6-byte far JMP +void* patch_target = far_jmp ? (e->target_va - 5) : e->target_va; +SIZE_T patch_size = far_jmp ? 7 : 5; // [rcx*2 + 5] +// VirtualProtect(patch_target, patch_size, PAGE_EXECUTE_READWRITE, &old) +VirtualProtect(patch_target, patch_size, 0x40, &old_protect); +if (enable) { +// Write JMP hook: +*(BYTE*)patch_target = 0xE9; // near JMP opcode +*(DWORD*)(patch_target+1) = +(DWORD)(e->callback_va - (QWORD)patch_target - 5); +if (far_jmp) { +// Also patch 2 bytes before target_va with short JMP back +*(WORD*)(e->target_va) = 0xF9EB; // JMP -5 (back to patch_target) +} +} else { +// Restore original bytes +*(DWORD*)patch_target = e->orig_bytes_0_3; +if (far_jmp) { +*(WORD*) (patch_target+4) = e->orig_bytes_4_5; +*(BYTE*) (patch_target+6) = e->orig_byte_6; +} else { +*(BYTE*) (patch_target+4) = (BYTE)e->orig_bytes_4_5; +} +} +// Restore page protection +VirtualProtect(patch_target, patch_size, old_protect, &old_protect); +// Flush instruction cache +FlushInstructionCache(GetCurrentProcess(), patch_target, patch_size); +// Update flags: set/clear enabled bit (bit 1) and suspended bit (bit 2) +// Bit manipulation: (enable<<2) XOR flags, AND 0x2, XOR flags, XOR enable_bit +e->flags = (e->flags & ~0x6) | ((enable ? 0x2 : 0x0)); +return 0; // MH_OK +} +## 8.7 FNV-1a Hash Implementation +The hash table uses FNV-1a (Fowler–Noll–Vo) 64-bit hashing to map target VA pointers to hash bucket indices. The compiler has unrolled the byte loop into 8 sequential XOR+MUL pairs operating on each byte of the 8-byte pointer. +// FNV-1a 64-bit hash of a pointer value (unrolled, 0x18008D555) +// r11 = target_va (8 bytes to hash) +// r10 = FNV prime = 0x00000100000001B3 +// r9 = FNV offset = 0xCBF29CE484222325 (init value) +uint64_t FNV1a_64(uint64_t target_va) { +uint64_t hash = 0xCBF29CE484222325ULL; // FNV offset basis +uint64_t prime = 0x00000100000001B3ULL; // FNV prime +// Byte 0 (bits 0-7) +hash ^= (uint8_t)(target_va >> 0); hash *= prime; +// Byte 1 (bits 8-15) +hash ^= (uint8_t)(target_va >> 8); hash *= prime; +// Byte 2 (bits 16-23) +hash ^= (uint8_t)(target_va >> 16); hash *= prime; +// Byte 3 (bits 24-31) +hash ^= (uint8_t)(target_va >> 24); hash *= prime; +// Byte 4 (bits 32-39) +hash ^= (uint8_t)(target_va >> 32); hash *= prime; +// Byte 5 (bits 40-47) +hash ^= (uint8_t)(target_va >> 40); hash *= prime; +// Byte 6 (bits 48-55) +hash ^= (uint8_t)(target_va >> 48); hash *= prime; +// Byte 7 (bits 56-63) +hash ^= (uint8_t)(target_va >> 56); hash *= prime; +// Map to bucket index +uint64_t bucket_idx = hash & bucket_mask; // [r8+0x48] +bucket_idx += bucket_idx; // *2 for pointer-sized bucket entries +return bucket_idx; +} +// Bucket lookup in hash chain: +// head = hash_buckets[bucket_idx] // [rcx + r9*8 + 0x00] +// sentinel = hash_buckets[bucket_idx + 1] // [rcx + r9*8 + 0x08] +// while (node != sentinel): +// if node->target_va == target: return node +// node = node->hash_next +## 8.8 Hook Manager Key Addresses +Address +Function / Field +Notes +0x1800A9C88 +AcquireSpinlock() +LOCK CMPXCHG loop with SwitchToThread/Sleep backoff +0x1800A9CC8 +CreateHook(target, cb, tramp) +Validates, searches array, builds trampoline, patches +0x1800A9E8C +RemoveHook(target) +Finds by linear search, disables if live, frees trampoline, compacts +0x1800A9A9C +EnableHook(idx, enable) +VirtualProtect + write JMP/restore + FlushInstructionCache +0x1800A96B0 +GetHookInfo(idx, ...) +Reads hook entry fields into caller-supplied buffer +0x1800A960C +AllocTrampolineSlot(target) +Finds or allocates VirtualAlloc page near target +0x1800AA684 +FreeTrampolineSlot(tramp) +Returns slot to free list +.data+0x1E88 +g_spinlock (DWORD) +Global spinlock; acquired via CMPXCHG, released via XCHG +.data+0x1E90 +g_allocator (QWORD*) +IAllocator vtable pointer used by hook manager +.data+0x2470 +g_hookMgr (struct, 0x90B) +Hook manager singleton base address +.data+0x2480 +hook_array (QWORD*) +Flat array of 0x38-byte hook entries +.data+0x27E0 +hook_array (mirror ptr) +Second reference to hook_array base +.data+0x27EC +hook_count (DWORD) +Number of currently installed hooks +0x18008D555 +FNV-1a hash body +Unrolled 8-byte XOR/MUL loop, prime=0x100000001B3 +# 9. ESPModule State Layout and Color Table Defaults +The ESPModule state struct is stored at .data+0x1F70 (VA 0x1803C6F70). It is initialized by the lazy singleton at 0x180083E00, which zero-initializes all fields, sets the module name, wires up both vtable pointers, writes boolean defaults for the eight display flags, and loads 12 RGBA color slots from .rdata constants via MOVDQA into 16-byte-aligned slots starting at state+0x40. +## 9.1 ESPModule State Struct Layout +Offset +Type +Field +Default ++0x00 +QWORD* +vtable[0] (init thunk) +0x1803AF9E0 ++0x08 +str* +module_name (std::string) +'ESPModule' ++0x28 +BYTE +enabled +0 (off) ++0x30 +DWORD +max_dist +0x12C = 300 (integer) ++0x34 +BYTE +show_monsters +1 (true) ++0x35 +BYTE +show_npc +1 (true) ++0x36 +BYTE +show_friendly +1 (true) ++0x37 +BYTE +show_puzzles +1 (true) ++0x38 +BYTE +show_all +0 (false) ++0x39 +BYTE +show_distance +1 (true) ++0x3A +BYTE +show_name +1 (true) ++0x3B +BYTE +show_type +0 (false) ++0x3C +DWORD +(alignment padding) +- ++0x40 +float[4] +color[0] RGBA +see table below ++0x50 +float[4] +color[1] RGBA +see table below ++0x60 +float[4] +color[2] RGBA +see table below ++0x70 +float[4] +color[3] RGBA +see table below ++0x80 +float[4] +color[4] RGBA +see table below ++0x90 +float[4] +color[5] RGBA +see table below ++0xA0 +float[4] +color[6] RGBA +see table below ++0xB0 +float[4] +color[7] RGBA +see table below ++0xC0 +float[4] +color[8] RGBA +see table below ++0xD0 +float[4] +color[9] RGBA +see table below ++0xE0 +float[4] +color[10] RGBA +see table below ++0xF0 +float[4] +color[11] RGBA +see table below +## 9.2 Color Table Defaults (12 slots × 16 bytes) +Each slot is a 128-bit XMMWORD (4× IEEE 754 float, little-endian order R, G, B, A). Values are loaded from .rdata constants at init time via MOVDQA. The color slot-to-entity-type mapping follows the order the show_* flags were written in the initializer. +Slot +State Offset +.rdata RVA +R +G +B +A +Color Name +Entity Type +0 ++0x40 +0x3B3510 +1.000 +0.000 +0.000 +1.000 +Red +Monsters / Enemies +1 ++0x50 +0x3B3520 +1.000 +0.647 +0.000 +1.000 +Orange +NPC +2 ++0x60 +0x3B3540 +1.000 +1.000 +0.000 +1.000 +Yellow +Friendly +3 ++0x70 +0x3B3530 +0.000 +1.000 +0.000 +1.000 +Green +Puzzles +4 ++0x80 +0x3B3590 +0.000 +0.000 +1.000 +1.000 +Blue +(spare/all) +5 ++0x90 +0x3B35A0 +0.000 +1.000 +1.000 +1.000 +Cyan +(spare) +6 ++0xA0 +0x3B3580 +0.580 +0.000 +0.827 +1.000 +Purple +(spare) +7 ++0xB0 +0x3B35B0 +1.000 +1.000 +1.000 +1.000 +White +(spare) +8 ++0xC0 +0x3B3560 +1.000 +0.078 +0.576 +1.000 +Hot Pink +(spare) +9 ++0xD0 +0x3B3570 +1.000 +0.753 +0.796 +1.000 +Light Pink +(spare) +10 ++0xE0 +0x3B3500 +0.000 +0.000 +0.000 +1.000 +Black +(spare) +11 ++0xF0 +0x3B3550 +0.502 +0.502 +0.502 +1.000 +Gray +(spare) +All 12 slots have alpha fixed at 1.000 (fully opaque). Slots 0–3 correspond to the four named entity types controlled by show_monsters / show_npc / show_friendly / show_puzzles flags. Slots 4–11 are spare palette entries available for future entity categories; the ImGui color picker in ESPModule::Render exposes all 12 via '##Foreground' color edit widgets. +## 9.3 Show Flag Default Summary +Flag +Offset +Default +Notes +show_monsters ++0x34 +1 (ON) +Draws boxes/labels for monster entities +show_npc ++0x35 +1 (ON) +Draws boxes/labels for NPC entities +show_friendly ++0x36 +1 (ON) +Draws boxes/labels for friendly entities +show_puzzles ++0x37 +1 (ON) +Draws boxes/labels for puzzle objects +show_all ++0x38 +0 (OFF) +Override: draw all entity types regardless of flags above +show_distance ++0x39 +1 (ON) +Appends distance string to entity label +show_name ++0x3A +1 (ON) +Appends entity name string to label +show_type ++0x3B +0 (OFF) +Appends entity type string to label +max_dist ++0x30 +300 +Integer cutoff distance; entities beyond this are not drawn +# 10. SkillHack Hook Callbacks +SkillHack installs up to six IL2CPP hooks across five callback functions. The hooks intercept game methods that govern skill cooldowns, skill availability checks, and skill costs. All five callbacks share the same guard pattern: call SkillHack singleton init (0x180081300), check enabled flag at [singleton+0x28], and either return the bypass value immediately or fall through to the original method via the hook manager's trampoline dispatcher (0x18008FF00). +## 10.1 Hook Installation Map +SkillHack::Render (0x18008D1F0) installs hooks in two stages. Three hooks are installed directly via the hook-installer wrapper (0x18008D8A0). Three more are installed by dedicated patch functions called from Render. All six use the same FNV-1a hash lookup pattern and CreateHook call. +Hook # +Target Ptr +Callback VA +Patch Function +Installed By +1 +[g_Config+0x1E60] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +2 +[g_Config+0x1E68] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +3 +[g_Config+0x1E50] +0x18008D500 (float 100.0) +0x18008E220 +Render → 8E220 → CreateHook +4 +[g_Config+0x1E58] +0x18008D640 (bool true) +0x18008EBC0 +Render → 8EBC0 → CreateHook +5 +[g_Config+0x1E40] +0x18008D780 (void return) +0x18008F560 +Render → 8F560 → CreateHook +6 +[g_Config+0x1E48] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 (tail) +The g_Config IL2CPP function pointer slots are populated at runtime from IL2CPP metadata. Their contents are zero/garbage in the static binary on disk. +## 10.2 Generic Dispatcher — 0x18008D4B0 +Used for hooks 1, 2, and 6. When the skill hack is enabled, returns BOOL true (1) immediately to the caller, bypassing any skill gate check. When disabled, passes through to the original IL2CPP function via the trampoline. +// Generic dispatcher callback — 0x18008D4B0 +// Used for: hooks on [g_Config+0x1E60], [g_Config+0x1E68], [g_Config+0x1E48] +// Return type: BOOL (BYTE in al) +BOOL Callback_Dispatcher(void* self, void* arg) { +// Get SkillHack singleton (lazy init, 0x180081300) +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { // [singleton+0x28] != 0 +return 1; // bypass — skill check always passes +} +// Disabled: look up original function via FNV-1a hash and call trampoline +// HookManager::GetOriginal(hookMgr, this_callback_va, self, arg) +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +return CallOriginal(hookMgr, /*callback=*/0x18008D4B0, self, arg); // → 0x18008FF00 +} +## 10.3 Variant 1: Float Return — 0x18008D500 +Installed by patch function 0x18008E220 on the target at [g_Config+0x1E50]. Intercepts a method that returns a float — most likely GetCooldownPercent() or GetCooldownRemaining(). Returns 100.0 when enabled, indicating the skill is fully cooled down / available. +// Cooldown bypass callback — 0x18008D500 +// Installed on: [g_Config+0x1E50] (via patch fn 0x18008E220) +// Return type: float (xmm0) +float Callback_CooldownBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +// movss xmm0, [rip+0x325de5] -> RVA 0x3B3308 = 100.0f +return 100.0f; // skill cooldown = 100% complete (fully ready) +} +// Hash self VA via FNV-1a, look up hook entry, call original via trampoline +auto* hookMgr = HookManager_GetSingleton(); +return CallOriginal_Float(hookMgr, /*callback=*/0x18008D500, self, arg); +} +// Note: 0x42C80000 = 100.0 IEEE 754 single-precision (confirmed from .rdata RVA 0x3B3308) +// The prior volume summary incorrectly stated this returns 0.0. +## 10.4 Variant 2: Bool True — 0x18008D640 +Installed by patch function 0x18008EBC0 on the target at [g_Config+0x1E58]. Intercepts a method that returns a boolean — most likely IsSkillAvailable() or CanUseSkill(). When enabled, always returns true (1). When disabled, the hash lookup falls through: if the original function is found in the hook table, it is called via tail JMP; otherwise, returns false (0) as a safe default. +// Skill availability bypass callback — 0x18008D640 +// Installed on: [g_Config+0x1E58] (via patch fn 0x18008EBC0) +// Return type: BOOL (BYTE in al) +BOOL Callback_SkillAvailable(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return 1; // skill is always available +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D640); +if (original != NULL) { +// rex.WB JMP r8 — tail call to original +return original(self, arg); +} +// Hash miss — safe fallback +return 0; // xor al,al (0x18008D770) +} +## 10.5 Variant 3: Void Early Return — 0x18008D780 +Installed by patch function 0x18008F560 on the target at [g_Config+0x1E40]. Intercepts a void method — most likely ApplySkillCost() or DeductMana(). When enabled, returns immediately without executing the function body, discarding the cost deduction entirely. When disabled, the hash lookup finds the original and tail-calls it. +// Skill cost bypass callback — 0x18008D780 +// Installed on: [g_Config+0x1E40] (via patch fn 0x18008F560) +// Return type: void +void Callback_SkillCostBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return; // jne 0x18008D894 — skip to ret immediately +// Original cost deduction never executes +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D780); +if (original != NULL) { +// call r8 — call original, then return +original(self, arg); // 0x18008D891: call r8 +} +// If hash miss: no-op (safe for void) +} +## 10.6 Common Trampoline Dispatcher — 0x18008FF00 +When any callback is disabled and needs to call the original IL2CPP method, it calls 0x18008FF00. This function computes the FNV-1a hash of the callback's own VA, looks up the corresponding hook entry's trampoline_va field (+0x18), and tail-jumps to it. It is effectively the 'call original' helper shared by all SkillHack callbacks. +// CallOriginal trampoline dispatcher — 0x18008FF00 +// rcx = hookMgr, rdx = callback_va (used as hash key), r8 = self, r9 = arg +void* CallOriginal(HookManager* mgr, void* callback_va, void* self, void* arg) { +// FNV-1a hash of callback_va -> bucket index +uint64_t hash = FNV1a_64(callback_va); // same unrolled loop as 0x18008D555 +uint64_t bucket_idx = hash & mgr->bucket_mask; +// Walk hash chain to find entry where entry->callback_va == callback_va +HookEntry* entry = FindInHashChain(mgr, bucket_idx, callback_va); +if (entry && entry->trampoline_va) { +// Tail jump to trampoline (original bytes + JMP back) +JMP entry->trampoline_va; // rex.WB jmp r8 +} +// If no entry found: return NULL / no-op +} +## 10.7 Callback Summary Table +VA +Name +Return Type +Enabled Value +Disabled Behavior +Game Method (inferred) +0x18008D4B0 +Dispatcher +BOOL +1 (true) +Call original via 0x8FF00 +Skill gate / permission check +0x18008D500 +CooldownBypass +float +100.0f +Call original via FNV hash + trampoline +GetCooldownPercent / GetCooldownRemaining +0x18008D640 +SkillAvailable +BOOL +1 (true) +Original via tail JMP, or return 0 +IsSkillAvailable / CanUseSkill +0x18008D780 +SkillCostBypass +void +early ret +Original via call r8, or no-op +ApplySkillCost / DeductMana +# 11. DLL Injection Strings — testyip / gatmp.tmp / EF-Cheeto.dll +Three std::string objects are statically pre-initialised in .data and used during the loader's startup sequence. They are not classic injection strings in the sense of being written to a remote process; they are module-path substrings used by the self-presence scanner to confirm that the cheat DLL (or its temp-file loader copy) is already mapped into the target Unity process before the IL2CPP domain is attached. +## 11.1 String Object Layout in .data +All three are MSVC SSO (small-string-optimised) std::string objects with the inline buffer variant active (length ≤ 15, so no heap allocation). Each occupies 24 bytes: 8-byte inline buffer, 8-byte _Mysize, 8-byte _Myres. +String +.data offset (base) +Inline buf offset +Length +Capacity +Content +testyip ++0x308 ++0x318 +7 +15 (0x0F) +testyip\0 (7 bytes) +gatmp.tmp ++0x328 ++0x338 +9 +15 (0x0F) +gatmp.tmp\0 (9 bytes) +EF-Cheeto.dll ++0x348 ++0x358 +13 +15 (0x0F) +EF-Cheeto.dll\0 (13 bytes) +The _Mysize field for testyip reads as zero in the static binary image because the std::string was zero-initialised before the inline buffer was written — the buffer bytes are present but the constructor has not run. At runtime MSVC CRT initialises the object before DllMain executes. +## 11.2 Module Path Scanner — 0x18008B650 +The function at 0x18008B650 receives a process handle (rcx), a pointer array of HMODULE values (rdx), and a count output pointer (r8). For each module handle it calls GetModuleFileNameExW (IAT 0x1800B1168) to obtain the full path as a wide string, then uses the UTF-8→wide converter at 0x18008B4E0 (wrapping MultiByteToWideChar with CP_UTF8 = 0xFDE9) to convert the two search strings, and searches each path with wcsstr. It returns the zero-based array index of the first matching module, or -1 if not found. +// ModulePathScanner — 0x18008B650 +// Scans a process's loaded module list for paths containing known substrings. +// rcx = hProcess rdx = HMODULE[] r8 = DWORD* count_out r9 = extra_arg +int ModulePathScanner(HANDLE hProcess, HMODULE* modules, DWORD* count, void* extra) { +DWORD module_count = *count >> 3; // [rsi] >> 3 = byte-count / sizeof(HMODULE) +if (module_count == 0) return 0; +// Convert search strings from UTF-8 std::string to std::wstring +// 0x18008B4E0: MultiByteToWideChar(CP_UTF8=0xFDE9, 0, src, len, dst, dst_cap) +std::wstring w_gatmp = Utf8ToWide("gatmp.tmp"); // .data+0x338 +std::wstring w_efdll = Utf8ToWide("EF-Cheeto.dll"); // .data+0x358 +int found_count = 0; +for (DWORD i = 0; i < module_count; i++) { +WCHAR path[0x104] = {}; +// GetModuleFileNameExW(hProcess, modules[i], path, 0x104) +if (!GetModuleFileNameExW(hProcess, modules[i], path, 0x104)) +continue; // skip on failure → je 0x18008BA41 +// Convert wide path to std::wstring for wcsstr search +std::wstring wpath = WideToString(path); // 0x18000EB10 +// Search for 'gatmp.tmp' in the path +const wchar_t* pos_gatmp = wcsstr(wpath.c_str(), w_gatmp.c_str()); +// 0x1800AB6A0: custom wcsstr returning iterator, -1 if not found +intptr_t idx_gatmp = (pos_gatmp ? (pos_gatmp - wpath.c_str()) : -1); +if (idx_gatmp == -1) { +// Search for 'EF-Cheeto.dll' in the path instead → 0x18008B937 +const wchar_t* pos_ef = wcsstr(wpath.c_str(), w_efdll.c_str()); +intptr_t idx_ef = (pos_ef ? (pos_ef - wpath.c_str()) : -1); +if (idx_ef != -1) { +// Found — store module handle and record match +modules[found_count] = modules[i]; // compact in-place +found_count++; +} +// else: neither string found, skip module +} else { +// gatmp.tmp match — store module handle +modules[found_count] = modules[i]; +found_count++; +} +} +*count = (found_count * 8); // write back as byte count +return ; // propagates from call r10 (original fn) +} +## 11.3 Hook Installer Wrapper — 0x18008BAF0 +Called at 0x1800A93CC during the main startup sequence (0x1800A9190), after FindWindow('UnityWndClass') confirms the game window exists. Receives the IL2CPP method pointer for a function to hook (rcx = r14 from [IAT+0x7DA4] = EnumProcessModules or similar resolved pointer). Calls CreateHook (0x1800A9CC8) with 0x18008B650 as the callback, handling error codes with log messages 'Failed to remove existing hook: {}' (0x1803AFB30) and 'Failed to create new hook: {}' (0x1803AFB90). +// HookInstallerWrapper — 0x18008BAF0 +// Installs ModulePathScanner (0x18008B650) as hook on a target IL2CPP function. +// Called from main startup (0x1800A9190) once game window is found. +void HookInstallerWrapper(void* target_fn) { +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +// Check if hook already exists — RemoveHook first if so +if (FindExistingHook(hookMgr, target_fn)) { +int rc = RemoveHook(target_fn); // 0x1800A9E8C +if (rc != 0) { +Log("Failed to remove existing hook: {}", FormatError(rc)); // 0x1803AFB30 +return; +} +} +// Install new hook with ModulePathScanner as callback +void* trampoline = nullptr; +int rc = CreateHook(target_fn, /*cb=*/0x18008B650, &trampoline); // 0x1800A9CC8 +if (rc != 0) { +Log("Failed to create new hook: {}", FormatError(rc)); // 0x1803AFB90 +return; +} +// trampoline stored at [rbp-0x1] for later EnableHook call +} +## 11.4 Startup Sequence Context — 0x1800A9190 +The main DLL startup function at 0x1800A9190 establishes the console, hooks the module scanner, then proceeds to IL2CPP domain attachment. The three injection strings serve as the identity check: if neither 'gatmp.tmp' nor 'EF-Cheeto.dll' appears in any loaded module's path, the scanner returns no matches and the cheat does not proceed. +Step +Address +Action +1 +0x1800A91CE +AllocConsole — create 'il2cpp Game Console' window +2 +0x1800A9267 +SetConsoleCP(0xFDE9) — set UTF-8 code page +3 +0x1800A92F7 +FindWindowA(NULL, 'UnityWndClass') — poll until game window present +4 +0x1800A93CC +HookInstallerWrapper(EnumProcessModules) — install module scanner +5 +0x1800A93E6 +Log 'Initializing..' — source: E:\\git\\Endfield_Cheeto\\user\\main.cpp:53 +6 +0x1800A942F +Call [g_Config+0x1E80] — IL2CPP domain resolver +7 +0x1800A945A +Log 'IL2CPP Domain Found: ' if domain non-null +8 +0x1800A94C4 +Log 'IL2CPP Thread Attached Successfully: ' on attach +9 +0x1800A9506 +Error branch: Log ‘Failed to Attach IL2CPP Thread!’ (source: main.cpp) +10 +0x1800A9545 +Error branch: Log ‘IL2CPP Domain Not Found!’ (source: main.cpp) if domain is null +11 +0x1800A959F +Success path: Log ‘Initialized’ (source: main.cpp); function returns +Console initialisation detail (steps 1–2): AllocConsole (IAT[0xB1108]) allocates the console window. Three freopen_s calls (IAT[0xB1878]) redirect stdin, stdout, and stderr to CONIN$ and CONOUT$. SetConsoleOutputCP(0xFDE9) sets the UTF-8 code page. GetConsoleMode (IAT[0xB1120]) reads the current output mode flags and SetConsoleMode (IAT[0xB1128]) adds ENABLE_VIRTUAL_TERMINAL_PROCESSING for ANSI colour support. SetConsoleTitleA (IAT[0xB12A0]) sets the window caption to ‘il2cpp Game Console’. The overlay window thread is then launched (call 0x1800827A0) at step 12 (see Ch. 29), running independently of the IL2CPP attach sequence. +The source path 'E:\\git\\Endfield_Cheeto\\user\\main.cpp' (RVA 0x3B3148) confirms the project name and local build directory. 'Endfield_Cheeto' matches the cheat's internal identity; the published DLL name 'EF-Cheeto.dll' abbreviates this. +## 11.5 Injection String Summary +String +.data VA +Role +Search context +testyip +0x1803C5318 +Alternate temp-file loader name +wcsstr scan against each loaded module's full path +gatmp.tmp +0x1803C5338 +Primary temp-file loader name +wcsstr scan — match means loader copy is present +EF-Cheeto.dll +0x1803C5358 +Published DLL name +wcsstr fallback if gatmp.tmp not found in path +The naming pattern indicates a two-stage loader: the cheat is first written as a temp file (gatmp.tmp or testyip) via a dropper, then optionally renamed or loaded directly as EF-Cheeto.dll. The module path scanner confirms whichever form is loaded before proceeding with IL2CPP hooking. +# 12. Module Render() and Update() Implementations +Each module exposes two callable entry points registered with ModuleManager: a Render() function that draws the ImGui tab panel and handles one-shot toggle/config writes, and an Update() callback (stored as a .rdata function pointer) that runs the per-frame game-state mutation. SetDither and the SkillHack 'Free Skill' tab share a no-op stub at 0x18008/3DC0 whose entire job is to free a string and optionally call operator delete on the module object — meaning those two tabs perform all their work at Render time, not per-frame. The seven implementations are documented below. +## 12.1 Shared g_Config Panel-Width Sequence +All modules that expand their ImGui tab panel write an identical five-instruction sequence at panel-open and invert it at panel-close. This sequence adjusts the panel scroll region width in the global config object g_Config ([.data+0x1c00]). The fields involved are: +Field +g_Config offset +Role +panel_ptr ++0x15D8 +Pointer to the active ImGui panel/window struct +scroll_step ++0x0E0C +Per-frame scroll delta (float, typically a small positive value) +scroll_accum ++0x194 +Accumulated horizontal scroll position (float) +scroll_base ++0x58 +Base horizontal offset for child panels (float) +scroll_total ++0x198 +Total scroll range (float) +panel_width ++0x150 +Rendered panel content width (float, written each frame) +// Panel-open sequence (addss — widens panel each frame module is visible) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; // mark panel as active/dirty +rax = g_Config->panel_ptr; +xmm0 = g_Config->scroll_step; // [g_Config+0x0E0C] +xmm0 += rax->scroll_accum; // [panel+0x194] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; // [panel+0x58] +xmm0 += rax->scroll_total; // [panel+0x198] +rax->panel_width = xmm0; // [panel+0x150] — expand +// Panel-close sequence (subss — narrows panel each frame module is hidden) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; +rax = g_Config->panel_ptr; +xmm0 = rax->scroll_accum; // [panel+0x194] +xmm0 -= g_Config->scroll_step; // [g_Config+0x0E0C] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; +xmm0 += rax->scroll_total; +rax->panel_width = xmm0; // shrink +This pattern appears verbatim in every module's Render body and is not repeated in the per-module pseudocode below — it is implied by 'panel-open sequence' and 'panel-close sequence'. +## 12.2 NoClip +Function +RVA +Role +NoClip::RegisterTab +0x180081300 +One-time tab registration (Render stub #1) +NoClip::Render +0x1800813D0 +ImGui tab panel — checkbox + Move Speed slider +NoClip::Update +0x180089B50 +Per-frame: CharacterController.enabled toggle + speed slider +NoClip::Update stub +0x180089B00 +Tab-manager destructor/cleanup wrapper +NoClip disables/re-enables the Unity CharacterController component on matching entities each frame. When enabled the controller's collision is suppressed, allowing the player to pass through geometry. A Move Speed integer slider ([module+0x30], range 1–10, step 1) controls movement rate while noclip is active. +// NoClip::Render RVA 0x1800813D0 +// rcx = NoClip* this +void NoClip::Render() { +// Panel-open sequence (g_Config+0x1c00, +0x15D8/0xE0C/0x194/0x58/0x198/0x150) +std::string title = MakeString("NoClip", 6); // 0x18000FCB0 +std::string tmp; +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &title); // 0x18009D7D0 +// resolve std::string to char* via SSO check (cmp [rax+0x18], 0xF) +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 — returns true if clicked +// free tmp, title +if (!clicked) { panel-close sequence; return; } +// Panel-open sequence +// second tab header: 'ON / OFF' +bool on_off_clicked = TabManager_BeginTab([.data+0x27B0], &tmp, &title); +// resolve buf, call 0x180085320 (CheckboxToggle) with &this->enabled [+0x28] +// CheckboxToggle: if edx (new_val) != *rdx (current), flip and update +// Panel-open/close based on [this+0x28] +if ([this+0x28] enabled) { +// 'Move Speed' DragInt slider: [this+0x30], range [1,10], step 1, format '%d' +// 0x180066750 — ImGui::DragInt4-variant +panel-open sequence; +} else { +panel-close sequence; +} +} +// NoClip::Update RVA 0x180089B50 +// Called per-frame by ModuleManager hook +void NoClip::Update() { +// Same 'NoClip' tab header + ON/OFF checkbox pattern as Render +if (!clicked) return; +panel-open sequence (if enabled) +'Move Speed' DragInt slider — same as Render, writes [this+0x30] +// Entity iterator loop (0x180089DC0) +bool noclip_on = [this+0x28]; +void* entity_mgr = g_Config->GetEntityManager(); // [g_Config+0x1D28] — IL2CPP call +if (!entity_mgr) return; +void* list = entity_mgr->GetComponentList(); // [entity_mgr+0x10]->field_0x10 +int count = list->count; // [list+0x20] +void** arr = list->items; // [list+0x10][+0x10] +arr += 0x20; // skip header slots +for (int i = 0; i < count; i++, arr++) { +void* component = *arr; +if (!component) continue; +void* ctrl = GetCharacterController(component); // [g_Config+0x1E20] IL2CPP call +if (!ctrl) continue; +// CharacterController.set_enabled(!noclip_on, 0) +// [g_Config+0x1E08]: IL2CPP setter — dl = !noclip_on, r8d = 0 +bool enable_cc = !noclip_on; +SetEnabled(ctrl, enable_cc, 0); // 0x1803C6E08 +} +// Move Speed DragInt — panel sequence at close +} +## 12.3 FreeCam +Function +RVA +Role +FreeCam::RegisterFpsTab +0x1800814C0 +Registers FPS Monitor overlay tab +FreeCam::RegisterMainTab +0x180081590 +Registers FreeCam main tab (0xD8-byte zeroed state) +FreeCam::FpsUpdate stub +0x180087150 +FPS overlay destructor wrapper; tab cleanup +FreeCam::Update +0x1800871A0 +Per-frame: camera override, WASD+mouse input, speed sliders +FreeCam overrides the game camera's transform each frame when enabled. RegisterMainTab zeroes a 0xD8-byte state block in .data ([.data+0x2200]) and writes hard-coded default key bindings (0x44415357 = 'WASD', 0x6D6BA220, 0x2725, 0x60) and clears floats for pitch/yaw/roll/FOV accumulators. It also clears an 8-byte 'active camera' pointer and related state. Move Speed defaults to 30.0f (0x41F00000 IEEE 754), step 0.1f (0x3DCCCCCD). Look Sensitivity defaults to 100.0f (0x42C80000), step 0.1f (0x3DCCCCCD). Roll Speed ([this+0x34]) and FOV Speed ([this+0x38]) have dedicated sliders with format '%.3f'. +// FreeCam::RegisterMainTab RVA 0x180081590 +// Runs once at DLL init; zeroes FreeCam state block and writes defaults +void FreeCam::RegisterMainTab() { +// Zero [.data+0x2200] block (0xD8 bytes via memset-like call 0x1800AC86A) +std::string tab = MakeString("FreeCam", 7); +// register tab with TabManager (0x18000F7D0), clear active flag, free strings +// Write update fn ptr: [.data+0x2200] = 0x1803AFE10 → FreeCam::Update +// Write default key bindings to [.data+0x2230..0x225E]: +// movdqa [+0x2230] = [0x1803B34F0] (key config block 1) +// movdqa [+0x2240] = [0x1803B35C0] (key config block 2) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier default) +// [+0x2254] = 0x44415357 ('WASD' key code mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind) +// [+0x225E] = 0x60 (backtick key code) +// Zero floats: pitch/yaw/roll/FOV [+0x2260..0x22A8], camera ptr [+0x22B0..0x22D0] +} +// FreeCam::Update RVA 0x1800871A0 +void FreeCam::Update() { +std::string hdr = MakeString("Free Camera", 11); +bool open = TabManager_BeginTab(&tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// ON/OFF checkbox → [this+0x28] +bool on_off = TabManager_BeginTab(...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 +if (!this->enabled) { +// Disable camera override: clear active cam ptr [this+0x70] and [this+0x68] +// [g_Config+0x1DB8]: IL2CPP Camera.set_enabled(false/true calls) +Camera_SetEnabled([this+0x70], false, 0); // 0x1803C6DB8 +Camera_SetEnabled([this+0x68], true, 0); +[this+0xB8] = 0; // clear 'cam override active' flag +panel-close sequence; +return; +} +// Move Speed float slider: [this+0x30], max 500.0f, min 0.1f, fmt '%.3f' +// 0x180065570 — ImGui::SliderFloat8 variant (8 = DragFloat with extra params) +// [rsp+0x40]=500.0f (max), [rsp+0x48]=0.1f (min), xmm3=step +// Roll Speed float slider: [this+0x34], max 100.0f (0x42C80000), min 0.1f +// Look Sensitivity float slider: [this+0x38]? (identified from 'FOV Speed' string) +// (Three consecutive float sliders: Move Speed, Roll Speed, FOV Speed) +// Key input + camera transform written via IL2CPP calls on camera component +// (Camera.get_main, Transform.set_position, Transform.set_rotation via vtable) +} +## 12.4 FpsUnlocker +Function +RVA +Role +FpsUnlocker::RegisterTab +0x180081730 +Registers 'Fps Unlocker' tab; writes default fps=300 ([.data+0x21E8]) +FpsUnlocker::Render +0x180085B90 +ImGui panel: checkbox + Fps Value DragInt, calls Application.targetFrameRate +FpsUnlocker::Update stub +0x180085B40 +Tab destructor/cleanup wrapper; cleanup size 0x38 +FpsUnlocker calls the IL2CPP Application.set_targetFrameRate setter ([.data+0x1D48]) on every Render call (not per-frame Update). When the checkbox is off, it passes 60 (0x3C) as the frame rate. When on, it passes [this+0x30] — the user's chosen value. A Fps Value DragInt slider ([this+0x30], max 500, min 30, step 1, format '%d') is displayed in a second tab header. RegisterTab writes a default of 300 (0x12C) to the .data slot backing [this+0x30]. +// FpsUnlocker::Render RVA 0x180085B90 +void FpsUnlocker::Render() { +std::string hdr = MakeString("Fps Unlocker", 12); +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// First action on open: call Application.set_targetFrameRate +// (regardless of enabled state — immediate effect) +int fps_val = this->enabled ? this->fps_target : 60; +Application_SetTargetFrameRate(fps_val); // [.data+0x1D48] IL2CPP +// ON/OFF checkbox → CheckboxToggle([this+0x28]) +if (this->enabled) { +panel-open sequence; +// 'Fps Value' DragInt: [this+0x30], max=500, min=30, step=1, fmt='%d' +// 0x180065570 ImGui::DragInt variant +// On each interaction: call Application.set_targetFrameRate([this+0x30]) +// ... then subss panel-close sequence +} else { +// panel-close sequences x2 (one per BeginTab call) +} +} +## 12.5 SetDither +Function +RVA +Role +SetDither::RegisterTab +0x180081810 +Registers 'SetDither' tab; stores update ptr 0x1803B01B0 → stub 0x180083DC0 +SetDither::Render +0x180081810 +Identical to RegisterTab (same address — no separate Render body) +SetDither::Update +0x180083DC0 +No-op stub: frees string [this+0x8], optionally operator delete(this, 0x30) +SetDither is the simplest module. Its registration function and Render body coincide at the same RVA — the 'tab' it registers has no interactive widgets beyond the standard tab header registration. The stored update pointer leads to the shared no-op stub at 0x180083DC0. The stub frees a std::string at [rcx+0x8] then, if the dirty bit (bl & 1) is set, calls operator delete on the module pointer with size 0x30. There is no per-frame game-state write associated with SetDither in this binary; the feature is either not yet implemented or was stripped before release. +// SetDither::RegisterTab / Render RVA 0x180081810 +void SetDither::RegisterTab() { +std::string hdr = MakeString("SetDither", 9); +// Register tab with TabManager (0x18000F7D0) +// Write update fn ptr: [.data+0x2180] = 0x1803B01B0 → 0x180083DC0 (stub) +// Cleanup string, return [.data+0x2180] +} +// Shared no-op Update stub RVA 0x180083DC0 +// Used by SetDither, FreeCam FPS overlay, and SkillHack 'Free Skill' tab +void* NoOpUpdateStub(void* this_ptr, BOOL dirty) { +std::string& s = *(std::string*)((char*)this_ptr + 8); +std::string_destroy(&s); // 0x18000FA60 +if (dirty & 1) { +operator_delete(this_ptr, 0x30); // 0x1800AB758 +} +return this_ptr; +} +## 12.5.1 SetDither::RenderOverlay (RVA 0x8C4A0) +SetDither::RenderOverlay is a separate callable entry point distinct from RegisterTab. It is invoked by the ModuleManager render loop on every Present() frame. The function (0x8C4A0–0x8C70D, 621 bytes) draws the “Set Dither” (i18n key RVA 0x3B0198) panel inside the main cheat overlay. Its control flow follows the standard module pattern: +// SetDither::RenderOverlay RVA 0x18008C4A0 +void SetDither::RenderOverlay(SetDither* this) { +// Tab guard: i18n lookup for "Set Dither" key (RVA 0x3B0198, 10 chars) +std::string tabName = i18n_lookup("Set Dither"); // 0x18000FCB0 +bool open = TabManager_BeginTab(tabName, g_locale); // 0x18009D7D0 +if (!open) { string_destroy(tabName); return; } +// Panel-open: addss [g_Config+0x15D8]+0x194 with [g_Config+0xE0C] +g_Config->panel_state->height += g_Config->dither_panel_height; // expand +// "ON / OFF" toggle bound to [this+0x28] (dither_enabled BOOL) +std::string label = i18n_lookup("ON / OFF"); // RVA 0x3AF848, 8 chars +DitherToggle(label, &this->dither_enabled); // 0x180085320 (rcx=label, rdx=&[rsi+0x28]) +// Panel-close: subss restores height +g_Config->panel_state->height -= g_Config->dither_panel_height; +} +The singleton state block for SetDither is accessed via [g_Config+0x15D8] (pointer to the active game state node at runtime). The field [this+0x28] is the dither_enabled BOOL; the DitherToggle helper at 0x180085320 is the same ImGui toggle helper used by other modules. The “ON / OFF” i18n label at RVA 0x3AF848 distinguishes this from the other modules which use a module-name toggle pattern. +## 12.6 PlayerProfile +Function +RVA +Role +PlayerProfile::RegisterTab +0x1800818E0 +Registers tab, zeroes two std::string fields, stores IL2CPP find fn ptrs +PlayerProfile::Render +0x1800818E0 +Same RVA — tab registration IS the render registration +PlayerProfile::Update +0x18008A4F0 +Per-frame: UI node traversal, SetText on two TMP labels, Name Changer input +PlayerProfile::Update stub +0x18008A4A0 +Destructor wrapper: frees [this+0x50], [this+0x30], [this+0x8], delete(0x78) +PlayerProfile resolves two Unity UI node paths each frame when enabled. The first path '/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text' (RVA 0x3AFED0, len 0x2F) finds the UID display TextMeshProUGUI component and overwrites its text with the content of [this+0x30] (an internal std::wstring). The second path '/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName' (RVA 0x3AFFD0, len 0x8D) finds the name label and overwrites it with [this+0x50]. A 'UID text' input box and a 'Name text' input box are shown in the panel. A 'Name changer' checkbox ([this+0x70]) enables the ManagerName write. RegisterTab zeroes both std::string fields via 0x18000FFF0 (wstring init) and stores find-by-path and get-component IL2CPP function pointers. +// PlayerProfile::Update RVA 0x18008A4F0 +void PlayerProfile::Update() { +std::string hdr = MakeString("PlayerProfile", 13); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +CheckboxToggle(&this->enabled, ...); // ON/OFF → [this+0x28] +if (this->enabled) { +// Resolve UID text node +std::string path1 = "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text"; +void* uid_node = IL2CPP_FindByPath(path1); // 0x18009BCB0 +if (uid_node) { +// Get TextMeshProUGUI component +void* tmp_comp = GetComponent(uid_node, "TextMeshProUGUI"); +if (tmp_comp) { +// SetText(tmp_comp, 0, this->uid_wstring) — [g_Config+0x1E28] +SetText(tmp_comp, 0, &this->uid_str); // 0x1803C6E28 +} +} +// Resolve second name node (for first name label) +// Same pattern: path → find → GetComponent → SetText +// 'UID text' InputText: writes [this+0x30] (displayed uid string) +// call 0x18008AC20 — InputText_wstring wrapper +// 'Name text' InputText: writes [this+0x50] (player name buffer) +// 'Name changer' checkbox → [this+0x70] +if (this->name_changer_enabled) { // [this+0x70] +// Resolve ManagerName node via long world path +void* name_node = IL2CPP_FindByPath( +"/UINode/WorldUIRoot/WatchPanel/.../ManagerName"); +if (name_node) { +void* tmp_comp = GetComponent(name_node, "TextMeshProUGUI"); +if (tmp_comp) { +SetText(tmp_comp, 0, &this->name_str); // [this+0x50] wstring +} +} +} +} +panel-close sequence; +} +## 12.7 Vacuum +Function +RVA +Role +Vacuum::RegisterTab +0x180081A20 +Registers 'Vacuum' tab, stores update fn ptr 0x1803B0680 → 0x180085B40 stub +Vacuum::Render +0x180093CA0 +ImGui panel: 'Vacuum' checkbox + 'Monster' sub-checkbox; panel-width logic +Vacuum::PhysicsLoop +0x180093F10 +Per-frame Rigidbody.AddForce attraction loop over entity list +Vacuum::Update stub +0x180085B40 +Destructor wrapper: frees [this+0x8], optionally delete(0x38) +Vacuum renders two checkboxes: 'Vacuum' ([this+0x28]) and 'Monster' ([this+0x30]). The physics loop at 0x180093F10 runs each frame when any vacuum flag is active. It obtains the camera's position via IL2CPP (Camera.main → transform → position), then iterates all rigidbody entities and applies an AddForce call that pulls each toward the camera origin. The force vector is computed per-entity as: forceX = (entity.x × attractStrength) + camera.x, forceY similarly, forceZ similarly, where attractStrength (xmm8) is loaded from [.rdata+0x1803B32B4] — a compile-time constant. The 'Monster' flag controls whether monster-type entities are included in the iteration. +// Vacuum::Render RVA 0x180093CA0 +void Vacuum::Render() { +std::string hdr = MakeString("Vacuum", 6); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// 'Vacuum' checkbox: CheckboxToggle(&this->vacuum_on [+0x28]) +// 'Monster' checkbox: CheckboxToggle(&this->monster_on [+0x30]) +// — Monster sub-checkbox uses panel-open/subss sequence at 0x180093EAC +} +// Vacuum::PhysicsLoop RVA 0x180093F10 (called from physics hook each frame) +// rcx = Vacuum* this, xmm1 = attract_vector, r8 = entity_array +void Vacuum::PhysicsLoop(void* this_ptr, vec3 attract_vec, void** entities) { +if (!this->vacuum_on) return; // [this+0x30] +// Get camera position +void* cam_mgr = g_Config->GetCameraManager(); // [g_Config+0x1D28] +if (!cam_mgr) return; +void* main_cam = cam_mgr->GetMainCamera(); // [g_Config+0x1CF0] +void* cam_rb = main_cam->GetRigidbody(); // [g_Config+0x1D60] +void* cam_pos = cam_rb->GetPosition(0); // [g_Config+0x1DC8] +// cam_pos struct: {double x, double y, int z_int, ...} +double cam_x = cam_pos->x; +double cam_y = cam_pos->y; +int cam_z = cam_pos->z_int; +float attract = *(float*)0x1803B32B4; // compile-time attraction constant +// Iterate entity array (from Vacuum::Update inner call 0x180094000) +for each entity in entities { +if (!entity) continue; +void* rb = GetRigidbody(entity); // [g_Config+0x1DF8] +if (!rb) continue; +vec3 pos = rb->GetPosition(0); // [g_Config+0x1D18] +vec3 force; +// Get entity world position +void* rb2 = GetEntityRoot(entity); // [g_Config+0x1D60] +vec3 rb2pos = rb2->GetWorldPos(0); // [g_Config+0x1DC8] +vec3 rb2pos2 = rb2->GetAltPos(0); // [g_Config+0x1DA8] +vec3 rb3pos = rb2->GetFwd(0); // [g_Config+0x1D90] +// force = attract * rb3pos + camera_pos (component-wise) +force.x = rb3pos.x * attract + cam_x; +force.y = rb3pos.y * attract + cam_y_component; +force.z = rb3pos.z * attract + cam_z_component; +// Rigidbody.AddForce(rb, &force, ForceMode=0) [g_Config+0x1E00] +AddForce(rb, &force, 0); +} +} +## 12.8 SkillHack::Render — Complete Panel Body +Function +RVA +Role +SkillHack::Render +0x18008D1F0 +Hook installer entry: installs six IL2CPP hooks, then falls to panel fn +SkillHack::RenderPanel +0x18008D240 +ImGui panel: 'Free Skill' checkbox + ON/OFF toggle + panel-width sequence +SkillHack::Update +0x180083DC0 +No-op stub (shared with SetDither — no per-frame game write) +SkillHack::Dispatcher +0x18008D4B0 +BOOL hook callback: returns 1 when [SkillHack+0x28] is set +SkillHack::CooldownBypass +0x18008D500 +float hook callback: returns 100.0f when enabled +SkillHack::AvailBypass +0x18008D640 +BOOL hook callback: returns 1 when enabled +SkillHack::CostBypass +0x18008D780 +void hook callback: early-return (skip cost deduction) when enabled +SkillHack::Render at 0x18008D1F0 is a pure hook-installation function — it does not itself draw any ImGui widgets. It installs the six IL2CPP hooks (documented in Section 10) and then tail-jumps to 0x18008D8A0 (the CreateHook wrapper / EnableHook dispatcher). The actual ImGui panel rendering is at 0x18008D240, referenced via the .rdata tab-callback pointer chain. That panel body contains the standard 'SkillHack'/'Free Skill' tab header pair followed by the ON/OFF checkbox and the full panel-width sequence. +// SkillHack::Render RVA 0x18008D1F0 — hook installer, NOT the ImGui panel +void SkillHack::Render() { +// Install hooks on six IL2CPP function pointers (see Section 10) +InstallHook(g_Config->il2cpp_fn[0x1E60], &Dispatcher); // 0x18008D8A0 +InstallHook(g_Config->il2cpp_fn[0x1E68], &Dispatcher); +InstallHook_CooldownBypass(); // 0x18008E220 → 0x18008D500 +InstallHook_AvailBypass(); // 0x18008EBC0 → 0x18008D640 +InstallHook_CostBypass(); // 0x18008F560 → 0x18008D780 +InstallHook(g_Config->il2cpp_fn[0x1E48], &Dispatcher); // tail jmp +} +// SkillHack::RenderPanel RVA 0x18008D240 — actual ImGui panel +void SkillHack::RenderPanel() { +// Tab header: 'Free Skill' (10 chars) via TabManager_BeginTab +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// Second tab: 'ON / OFF' +bool on_off = TabManager_BeginTab(..., &tmp_str, ...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 → [this+0x28] +if (this->enabled) { +panel-open sequence; // addss path +// (no additional sliders or sub-widgets beyond the toggle) +} else { +panel-close sequence; // subss path +} +// All six hook callbacks read [SkillHack_singleton+0x28] at call time +// — no deferred write needed here +} +## 12.9 Module Render/Update Address Summary +Module +RegisterTab RVA +Render RVA +Update RVA +Update type +Key field offsets +NoClip +0x181300 +0x1813D0 +0x189B50 +Per-frame entity loop +[+0x28] enabled, [+0x30] move_speed (int) +FreeCam +0x181590 +0x1871A0 +0x1871A0 +Per-frame camera override +[+0x28] enabled, [+0x30] move_speed (float), [+0x34] roll_spd, [+0x38] fov_spd, [+0x68/70] cam ptrs +FpsUnlocker +0x181730 +0x185B90 +stub/none +Render-time only +[+0x28] enabled, [+0x30] fps_target (int, default 300) +SetDither +0x181810 +0x181810 +stub/none +No-op +[+0x28] enabled (unused) +PlayerProfile +0x1818E0 +0x18A4F0 +0x18A4F0 +Per-frame UI path walk +[+0x28] enabled, [+0x30] uid_str, [+0x50] name_str, [+0x70] name_changer +Vacuum +0x181A20 +0x193CA0 +0x193F10 +Per-frame AddForce loop +[+0x28] vacuum_on, [+0x30] monster_on +SkillHack +N/A +0x18D1F0 +stub/none +No-op (hook callbacks handle IL2CPP) +[+0x28] enabled (read by all 6 callbacks) +# 13. Gap Closure Status +Gap +Status +Volume Resolved +Notes +Module Update() bodies +COMPLETE +Ch. 22 +ESPModule::Update completed in Ch. 22; all others in Ch. 12 +Module Render() bodies +COMPLETE +Ch. 22 +ESPModule::RenderOverlay completed in Ch. 22; all others in Ch. 12 +ModuleManager main loop +COMPLETE +Ch. 15 +Present hook + module dispatch; see Ch. 15 +GABypass IL2CPP patching +COMPLETE +Ch. 18 +71 function pointers patched; see Ch. 18 +Config file I/O +COMPLETE +Ch. 6 +UTF-8→wide→_wfopen, 'rb'/'wt' +DLL injection (testyip/gatmp) +COMPLETE +Ch. 11 +Temp file injection pattern; see Ch. 11 +Thread enumeration +COMPLETE +Ch. 3 +Toolhelp32 snapshot loop; see Ch. 3 +Anti-debug checks +COMPLETE +Ch. 4 +MSVC CRT only, no active anti-debug; see Ch. 4 +Shader compilation +COMPLETE +Ch. 5 +Two ImGui HLSL shaders, vs/ps 4_0 +SetWindowDisplayAffinity +COMPLETE +Ch. 21 +PreventScreenshot registered module; full analysis in Ch. 21 +ImGui integration +COMPLETE +Ch. 12 +Win32+D3D11 backends; see Ch. 12. Overlay window init (DPI, CreateWindowExW, D3D11CreateDeviceAndSwapChain, message loop, FindGameWindow, GetOverlayRect) see Ch. 29 +Exception handling +COMPLETE +Ch. 4 +MSVC __security_check_cookie; see Ch. 4 +JSON parsing +COMPLETE +Ch. 19 +Full schema, save/load path, and IAT traced; see Ch. 19 +# 14. Definitive Function Address Table +Complete map of all significant functions identified across all twenty-five chapters: +Function / Purpose +VA Start +VA End +Key Operations +DllMain +0x180001000 +- +Entry point, spawns loader thread +LoaderThread +0x180005000 +- +Init IL2CPP, create window, Present hook +ModuleManager::RegisterAll +0x18009AE00 +- +11 modules registered via stubs +ModuleManager::MainLoop +0x180082000 +0x180082300 +Present hook, ImGui render loop +D3D11Init (shaders) +0x180054DC0 +0x1800551E8 +2× D3DCompile, create D3D resources +ImGui Win32+D3D11 Setup +0x180082500 +- +Backend init, WndProc subclass +CollectProcessThreads +0x1800A96B0 +0x1800A9A1C +Toolhelp32 thread enumeration +SuspendOrResumeThreads +0x1800A9A20 +0x1800A9A98 +OpenThread + Suspend/Resume +PatchCode +0x1800A9A9C +0x1800A9BC3 +VirtualProtect + write hook bytes +HookManager::Install +0x1800A9CC8 +- +Alloc trampoline + FNV hash +HookManager::Remove +0x1800A9E8C +- +Remove and restore bytes +HookManager::Enable +0x1800A9A9C +- +Toggle enabled bit + patch +GABypass::Init +0x18009D1E0 +- +71 IL2CPP stubs patched +OpenConfigFile +0x180011EA0 +0x180012043 +_wfopen(UTF8→wide path, mode) +SaveConfig +0x180030620 +0x1800307A0 +fwrite JSON config to disk +ReadConfig +0x1800302D2 +0x180030348 +fread JSON config from disk +ImGuiSaveIni +0x180017078 +0x1800172CA +fwrite ImGui window layout +__security_init +0x1800AC580 +0x1800AC6CA +CRT SEH + IsDebuggerPresent +__security_check_cookie +0x1800AC6CC +0x1800AC77B +Stack canary: magic 0x2B992DDFA232 +NoClip::Render +0x180089B40 +- +CharacterController enable toggle +SkillHack::Render +0x18008D1F0 +- +IL2CPP hook installer +FreeCam::Render +0x180087150 +- +CinemachineBrain override +FpsUnlocker::Render +0x180085B80 +- +Application.targetFrameRate +SetDither::Render +0x18008C490 +- +Graphics dither toggle +PlayerProfile::Render +0x18008A4A0 +- +Unity UI text manipulation +Vacuum::Render +0x180093C90 +- +Monster item collection +ESPModule::Render +0x180083F60 +- +See Ch. 22 (§22.1) +DamageHack (ghost) +N/A (no code) +- +Ghost feature — no code; see Ch. 23 +PreventScreenshot +0x18008B490 +- +SetWindowDisplayAffinity +ESPModule::DrawOverlay +0x180083000 +- +See Ch. 22 (§22.2) +WndProc +0x1800826A0 +- +Win32 message + WM_SIZE/DESTROY handler; see Ch. 7 +SkillHack::Dispatcher +0x18008D4B0 +- +Generic hook dispatcher (2 hooks); see Ch. 10 +SkillHack::FloatReturn +0x18008D500 +- +Hook cb: return 100.0f (float skills); see Ch. 10 +SkillHack::BoolTrue +0x18008D640 +- +Hook cb: return true (bool checks); see Ch. 10 +SkillHack::VoidReturn +0x18008D780 +- +Hook cb: early void return; see Ch. 10 +SkillHack::TrampolineDispatch +0x18008FF00 +- +Common trampoline dispatcher; see Ch. 10 +ModuleManager::Init +0x18009AC10 +- +Construct + register all modules; see Ch. 15 +ModuleManager::DispatchRender +0x18009AE80 +- +Per-frame Render() dispatch loop; see Ch. 15 +ModuleManager::DispatchHotkeys +0x18009AEF0 +- +Per-frame hotkey dispatch; see Ch. 15 +ModuleManager::DispatchRegInit +0x18009AF60 +- +Registrar init dispatcher; see Ch. 15 +ModuleManager::PresentHook +0x180082F00 +- +D3D11 Present hook; calls Render+Hotkey loops; see Ch. 15 +ModulePathScanner +0x18008B650 +- +Scans loaded modules for testyip/gatmp/EF-Cheeto; see Ch. 11 +HookInstallerWrapper +0x18008BAF0 +- +Wraps CreateHook; validates target ptr; see Ch. 11 +StartupSequence +0x1800A9190 +- +DLL loader startup context; see Ch. 11 +ESPModule::Init +0x180083E00 +- +Lazy singleton init; sets color defaults; see Ch. 9 +ESPModule::RenderOverlay +0x180083FA0 +0x18008499E +ImGui ESP panel (full); see Ch. 22 +ESPModule::Update +0x180084A00 +0x1800852A5 +Entity label draw loop; see Ch. 22 +FPSModule::Initialize +0x1800814C0 +- +once_flag guarded init; see Ch. 20 +FPSModule::RenderOverlay +0x180085700 +0x180085900 +FPS panel + overlay counter; see Ch. 20 +PreventScreenshot::Initialize +0x18008AD70 +- +once_flag guarded init; see Ch. 21 +PreventScreenshot::Render +0x18008AE60 +- +ImGui checkbox; see Ch. 21 +PreventScreenshot::Update +0x18008AFC0 +- +SetWindowDisplayAffinity dispatch; see Ch. 21 +PreventScreenshot::OsCheck +0x18008B220 +- +Win10 build check + affinity call; see Ch. 21 +UnityExplorer::RegisterTab +0x180090060 +- +Tab init, scene hierarchy setup; see Ch. 16 +UnityExplorer::Render +0x180090250 +- +Per-frame scene inspector; see Ch. 16 +UnityExplorer::RefreshScenes +0x180090D40 +- +Scene list refresh helper; see Ch. 16 +HookManager::Spinlock +0x1800A9C88 +- +Spinlock acquire/release; see Ch. 8 +WideToString +0x18000EB10 +- +UTF-8 path to wstring for wcsstr; see Ch. 11 +FreeCam::RegisterTab +0x18000F7D0 +- +Registers FreeCam main tab; see Ch. 12 +BaseModule::Dtor +0x18000FA60 +- +Shared dtor: destroy name string + optional delete; see Ch. 12 +NoClip::RegisterTab +0x18000FCB0 +- +Registers NoClip tab; stores update fn ptr; see Ch. 12 +ManagerName::Init +0x18000FFF0 +- +Zeroes std::string fields for ModuleManager name; see Ch. 15 +ConfigSerialize +0x180012050 +- +Serialize config struct to string for fwrite; see Ch. 6 +ImGui::EndFrame +0x18001C2D0 +- +D3D11/ImGui frame boundary EndFrame call; see Ch. 15 +BuildFilePath +0x180030A90 +- +Build config file path string from state+0x50; see Ch. 6 +D3D11::CreateBuffers +0x1800551F0 +- +Create vertex/index buffers post shader compile; see Ch. 5 +ImGui_ImplWin32_WndProcHandler +0x180057720 +- +ImGui Win32 WndProc message handler; see Ch. 7 +FreeCam::SliderFloat +0x180065570 +- +Move Speed SliderFloat (max 500.0f); see Ch. 12 +FreeCam::DragInt +0x180066750 +- +Move Speed DragInt (range 1-10); see Ch. 12 +TabManager::BeginTab +0x180070820 +- +ImGui tab begin + toggle helper; see Ch. 12 +ImGui::Selectable +0x1800708D0 +- +Preset selector; Per-Config preset writer dispatch; see Ch. 17 +SkillHack::GetSingleton +0x180081300 +- +Lazy once_flag singleton init for SkillHack; see Ch. 10 +NoClip::Render +0x1800813D0 +- +ImGui panel: checkbox + Move Speed slider; see Ch. 12 +FPSModule::RegisterTab +0x180081590 +- +Registers FPS Monitor overlay tab; see Ch. 20 +FpsUnlocker::RegisterTab +0x180081730 +- +Registers Fps Unlocker tab; see Ch. 12 +SetDither::RegisterTab +0x180081810 +- +Registers SetDither tab; stores update ptr; see Ch. 12 +PlayerProfile::RegisterTab +0x1800818E0 +- +Registers PlayerProfile tab; see Ch. 12 +Vacuum::RegisterTab +0x180081A20 +- +Registers Vacuum tab; stores update fn ptr; see Ch. 12 +HookManager::GetSingleton +0x180081B00 +- +Thread-safe static singleton init for HookManager; see Ch. 8 +NoOpUpdateStub +0x180083DC0 +- +Shared no-op Update stub (SetDither, SkillHack free); see Ch. 12 +ESPModule::CheckboxToggle +0x180085320 +- +Toggle checkbox helper used in ESPModule panel; see Ch. 22 +NoClip::EntityIterator +0x180089DC0 +- +Entity iterator loop inner call; see Ch. 12 +InputText::WString +0x18008AC20 +- +ImGui InputText wrapper for wstring fields; see Ch. 12 +SkillHack::InstallHooks +0x18008D8A0 +- +Installs 3 hooks via HookInstallerWrapper; see Ch. 10 +SkillHack::PatchFloat +0x18008E220 +- +Installs FloatReturn hook on [g_Config+0x1E50]; see Ch. 10 +SkillHack::PatchBool +0x18008EBC0 +- +Installs BoolTrue hook on [g_Config+0x1E58]; see Ch. 10 +SkillHack::PatchVoid +0x18008F560 +- +Installs VoidReturn hook on [g_Config+0x1E40]; see Ch. 10 +UnityExplorer::GuardReturn +0x1800901D8 +- +Early return after once_flag sealed; see Ch. 16 +ImGui::Begin +0x1800937D0 +- +ImGui::Begin wrapper (Unity Explorer Window); see Ch. 16 +UnityExplorer::AutoRefresh +0x180093B10 +- +Auto-refresh timer check for scene list; see Ch. 16 +Vacuum::PhysicsLoop +0x180093F10 +- +Per-frame entity attraction physics loop; see Ch. 12 +PlayerProfile::FindUINode +0x18009BCB0 +- +IL2CPP_FindByPath for UI text/UID node; see Ch. 12 +TabManager::BeginTabFull +0x18009D7D0 +- +Full BeginTab with state+title resolution; see Ch. 12 +HookManager::FreeSlot +0x1800AA684 +- +Free trampoline + compact hook array; see Ch. 8 +WideStr::wcsstr +0x1800AB6A0 +- +Custom wcsstr for wide path scanning; see Ch. 11 +WideStr::Dtor +0x1800AB758 +- +wstring destructor in path scanner; see Ch. 11 +HotkeyErrorHandler +0x1800AECE0 +- +Hotkey error handler, logs '[hotkey error]'; see Ch. 7 +std::once_flag::Execute +0x1800AFF60 +- +MSVC once_flag _Execute_once; used by UnityExplorer; see Ch. 16 +D3D11::Reinit +0x1800825B0 +- +Recreate D3D11 render target+shaders on WM_SIZE; see Ch. 7 +ModuleManager::RenderFrame +0x180082FC0 +- +ImGui NewFrame + per-module Render dispatch; see Ch. 15 +FpsUnlocker::UpdateStub +0x180085B40 +- +Tab destructor/cleanup wrapper for FpsUnlocker; see Ch. 12 +FpsUnlocker::Render +0x180085B90 +- +ImGui panel: FPS cap checkbox + DragInt; see Ch. 12 +FreeCam::Update +0x1800871A0 +- +Per-frame: CinemachineBrain camera override; see Ch. 12 +NoClip::UpdateStub +0x180089B00 +- +Tab destructor/cleanup wrapper for NoClip; see Ch. 12 +NoClip::Update +0x180089B50 +- +Per-frame: CharacterController.enabled toggle; see Ch. 12 +PlayerProfile::Update +0x18008A4F0 +- +Per-frame: UI node traversal + text injection; see Ch. 12 +UTF8ToWide +0x18008B4E0 +- +MultiByteToWideChar wrapper for path conversion; see Ch. 11 +ModulePathScanner::EFSearch +0x18008B937 +- +wcsstr branch: search for EF-Cheeto.dll in path; see Ch. 11 +SkillHack::RenderPanel +0x18008D240 +- +ImGui panel body after hook install; see Ch. 10 +Vacuum::Render +0x180093CA0 +- +ImGui panel: Vacuum checkbox + monster sub-checkbox; see Ch. 12 +Vacuum::EntityIterator +0x180094000 +- +Inner entity array iteration for item vacuum; see Ch. 12 +HookManager::AllocTrampoline +0x1800A960C +- +Allocate trampoline slot near target VA; see Ch. 8 +UnityExplorer::MemsetBlock +0x1800AC86A +- +Memset 0xD8 bytes at [.data+0x2200] during init; see Ch. 16 +# 15. ModuleManager Dispatch Architecture +Source file: E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp (string at RVA 0x3B0BC0). The ModuleManager is the central runtime controller responsible for: (1) maintaining the registrar list, (2) constructing module instances during Init, (3) dispatching per-frame Render calls from the D3D11 Present hook, and (4) dispatching per-frame hotkey processing. +## 15.1 Key Data Structures +ModuleManager object layout (rcx in all dispatch calls): +struct ModuleManager { +BaseModule** instances_begin; // [+0x00] begin ptr (vector) +BaseModule** instances_end; // [+0x08] end ptr +BaseModule** instances_cap; // [+0x10] capacity ptr +bool initialized; // [+0x18] set to 1 after Init() completes +// [+0x19..+0x1F] padding +// [+0x20..+0x57] registrar list (vector — 0x60-byte stride elements) +}; +Global singleton pointers in .data: +[.data+0x23B8] ModuleManager.instances_begin (registrar slots array begin) +[.data+0x23C0] ModuleManager.instances_end +[.data+0x23C8] ModuleManager.instances_cap +[.data+0x2398] ModuleManager object ptr (passed as rcx to dispatch loops) +[.data+0x23A8] secondary ptr (capacity end) +BaseModule vtable layout (confirmed from factory stubs at 0x9B660–0x9B7A0 and dispatch call sites): +Slot +Offset +Description +Notes +[0] ++0x00 +copy-ctor/factory() +placement-new style ctor; writes vtable ptr, returns this +[1] ++0x08 +copy-ctor/factory() +same as [0] +[2] ++0x10 +Init()/RegisterTab() +jmp stub -> actual RegisterTab fn for the module +[3] ++0x18 +Render() +per-frame UI + game-state dispatch — called by Present hook loop +[4] ++0x20 +~BaseModule() +destructor: frees name string, conditional operator delete +[5] ++0x28 +getNamePtr() +returns &this->name_string (this+0x08) +[6] ++0x30 +onHotkey() +pure virtual (value = 1 sentinel); not implemented in any module +[7] ++0x38 +getLinkedModuleFactory() +returns factory ptr for a paired module (e.g. FpsOverlay) +BaseModule instance layout (from dispatch loop field access and RegisterTab writes): +struct BaseModule { +void* vtable; // [+0x00] +std::string name; // [+0x08] SSO string (24 bytes) +std::string tab_name; // [+0x20] secondary name / tab label +bool enabled; // [+0x28] ON/OFF flag — checked by dispatch loops +// [+0x29..+0x2F] padding +// [+0x30..] module-specific fields (move_speed, fps_target, etc.) +}; +## 15.2 Registrar Lambda Registration (startup) +During DLL initialization (before ModuleManager::Init is called), ten registrar lambdas fire. Each calls ModuleManager::AddRegistrar (RVA 0x9B2C0) passing the module name string and a factory std::function. The registrar slots are pushed into the vector at [.data+0x23B8] with stride 0x60 bytes per slot. Registration order (determined from code order in .text): +Order +Module Name +Registrar code RVA +Factory .rdata RVA +vtable RVA +1 +SetDither +0x001C41 +0x3B0D58 +0x3B0D58 +2 +FreeCam (fps) +0x001C80 +0x3B0E70 +0x3B0E70 +3 +SkillHack +0x001D50 +0x3B0EE0 +0x3B0EE0 +4 +PlayerProfile +0x001E20 +0x3B0D90 +0x3B0D90 +5 +NoClip +0x001EF0 +0x3B0DC8 +0x3B0DC8 +6 +Vacuum +0x001FC0 +0x3B0E38 +0x3B0E38 +7 +UnityExplorer +0x002090 +0x3B0D28 +— +8 +FpsUnlocker +0x001B80 +0x3B0E00 +0x3B0E00 +9 +FreeCam (main) +0x001AB0 +0x3B0E70 +0x3B0E70 +10 +ESPModule +0x001980 +— +— +ModuleManager::AddRegistrar (RVA 0x9B2C0) logic: constructs a std::string from the name argument, calls 0x18000F7D0 (TabManager::RegisterTab), then appends the registrar's std::function wrapper to the instances array. If the vector is full it calls the grow helper at 0x9B3C0. +## 15.3 ModuleManager::Init (RVA 0x9AC10) +Called once from startup sequence (RVA 0xA9190). Guards against double-init via [rcx+0x18] flag. Log messages: 'Initializing ModuleManager' (0x3B0C08) and 'ModuleManager initialization complete' (0x3B0C60). Asserts at source lines 34 and 52 reference ModuleManager.cpp. +Init body: +void ModuleManager::Init(ModuleManager* self) { +if (self->initialized) { +Log('[WARNING] ModuleManager already initialized'); +return; +} +Log('Initializing ModuleManager'); +// Assert (line 34 in ModuleManager.cpp) +// Move instances_begin ptr to match registrar list +rsi = &self->instances_begin; +if (self->instances_begin != self->instances_end) +*rsi = self->instances_begin; +// Wait for std::once_flag at [.data+0x23D0] +// (once_flag guards module instance allocation) +// Iterate registrar array ([.data+0x23B8]..[.data+0x23C0]) +// stride = 0x60 bytes per registrar slot +for (rbx = registrars_begin; rbx < registrars_end; rbx += 0x60) { +std::function* factory = rbx->invoke_ptr; // [rbx+0x58] +BaseModule* mod = factory->operator()(); // vtable[+0x10]() +// Append to instances list +*instances_end = mod; +instances_end += 0x8; +// (grow vector if needed via 0x9B0D0) +// Call vtable[+0x8] on module = getName() +const char* name = mod->vtable[+0x8](mod); +// Log 'Module {name} initialized' +// Log formatted assert (line 45 in ModuleManager.cpp) +assert_log(mod->name, ModuleManager_cpp, line=45); +} +self->initialized = true; +Log('ModuleManager initialization complete'); +// Assert (line 52 in ModuleManager.cpp) +} +## 15.4 Per-Frame Dispatch Loops +Three dispatch functions iterate the instances array each frame. All share the same structure: guard on initialized flag, pointer-chase loop over [begin..end], null check, enabled flag check at [module+0x28], then vtable call. +Dispatch Loop 1 — ModuleManager::DispatchRender (RVA 0x9AE80): +// Called from Present hook with rcx = &ModuleManager (at [.data+0x2398]) +void ModuleManager::DispatchRender(ModuleManager* self) { +if (!self->initialized) return; +BaseModule** it = self->instances_begin; +BaseModule** end = self->instances_end; +while (it != end) { +BaseModule* mod = *it; +if (mod && mod->enabled) // [mod+0x28] != 0 +mod->vtable[0x18](mod); // Render() +it++; +} +} +Dispatch Loop 2 — ModuleManager::DispatchHotkeys (RVA 0x9AEF0): +void ModuleManager::DispatchHotkeys(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod && mod->enabled) +mod->vtable[0x30](mod); // onHotkey() — pure virtual, no-op for all current modules +} +} +Dispatch Loop 3 — ModuleManager::DispatchRegistrarInit (RVA 0x9AF60): +// Called at 0x180083348 — initializes ImGui panel layout after first Present +void ModuleManager::DispatchRegistrarInit(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod) +mod->vtable[0x38](mod); // getLinkedModuleFactory() — installs linked tab +} +// After loop: copy default panel config block +// movups xmm0, [.data+0x1F08]; movups [.data+0x1F28], xmm0 +// movups xmm1, [.data+0x1F18]; movups [.data+0x1F38], xmm1 +// (16-byte config copy for initial panel state) +} +15.4.1 Exception Handling in Dispatch Loops +The pseudocode above omits the C++ exception-handling wrappers that the compiler generated around each vtable call. Each dispatch loop body is actually enclosed in a __try/__except block; the MSVC runtime (__CxxFrameHandler4, thunk table at RVA 0xAC840, imported from VCRUNTIME140.dll) is registered as the Structured Exception Handler via the .pdata unwind tables. If a module's virtual method throws, the runtime calls one of three catch-handler functions: 0xAEBC0 logs “[ERROR] Failed to update module ‘’” (associated with DispatchRender / Update), 0xAEC50 logs “[ERROR] Failed to render overlay for module ‘’”, and 0xAECE0 logs “[ERROR] Failed to process hotkeys for module ‘’”. All three handlers call the shared logging helper at 0x18000FDA0 (Log/Print) and then resume normally rather than propagating the exception, so a single misbehaving module cannot crash the entire frame. +## 15.5 Present Hook Call Site (RVA 0x082F00) +The Present hook callback contains all three dispatch calls plus the ImGui frame boundary calls. Relevant excerpt (from context around RVA 0x083386): +// 1. DispatchRegistrarInit (once_flag guarded) — installs linked tabs +rcx = &ModuleManager; // [.data+0x2398] +call ModuleManager::DispatchRegistrarInit; // 0x18009AF60 +// 2. DispatchRender — calls Render() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchRender; // 0x18009AE80 +// 3. DispatchHotkeys — calls onHotkey() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchHotkeys; // 0x18009AEF0 +// 4. Continue to D3D11 frame boundary / ImGui EndFrame +call 0x18001C2D0; +## 15.6 Per-Module vtable[+0x10] and vtable[+0x18] Resolved Targets +vtable[+0x10] = Init/RegisterTab (called once during ModuleManager::Init). vtable[+0x18] = Render (called every frame from DispatchRender). +Module +vtable RVA +vtable[+0x10] target +vtable[+0x18] target +Notes +Vacuum +0x3B0E38 +0x090060 (RegisterTab) +0x09B640 -> [.data+0x05D0] fn ptr +NoClip +0x3B0DC8 +0x081A20 (RegisterTab) +0x09B670 -> [.data+0x06D0] fn ptr +PlayerProfile +0x3B0D90 +0x0813D0 (RegisterTab) +0x09B6A0 -> [.data+0x0580] fn ptr +SkillHack +0x3B0EE0 +0x0818E0 (RegisterTab) +0x09B6D0 -> [.data+0x0770] fn ptr +hook installer +FreeCam +0x3B0E70 +0x081300 (RegisterTab) +0x09B700 -> [.data+0x07D0] fn ptr +SetDither +0x3B0D58 +0x081590 (RegisterTab) +0x09B730 -> [.data+0x0630] fn ptr +no-op +FpsOverlay +0x3B0E00 +0x081810 (RegisterTab) +0x09B760 -> [.data+0x0530] fn ptr +overlay +Note: vtable[+0x18] for each module returns a .data block ptr via a 2-instruction lea/ret stub. This stub serves as the state block accessor used during object cleanup. The actual Render dispatch uses this indirection: the stub returns the module's .data state block, which at offset [+0x00] stores a direct fn ptr to the Render/Update function installed by RegisterTab. The dispatch loop calls the stub (vtable[+0x18]) to get this function pointer, then calls through it. +## 15.7 ModuleManager Log Strings +String +RVA +Context +'[WARNING] ModuleManager already initialized' +0x3B0B88 +Init guard +'Initializing ModuleManager' +0x3B0C08 +Init begin +'Module {} initialized' +0x3B0C48 +Per-module Init success +'ModuleManager initialization complete' +0x3B0C60 +Init end +'Failed to initialize module {}' +0x3B0C28 +Init error handler +'[ERROR] Failed to update module ' +0x3B0C90 +Update error handler +'[ERROR] Failed to render overlay for module ' +0x3B0CB8 +Render error handler +'[ERROR] Failed to process hotkeys for module ' +0x3B0CE8 +Hotkey error handler +ModuleManager.cpp source path +0x3B0BC0 +Assert source file string +# 16. UnityExplorerModule +UnityExplorerModule is a fully implemented, live developer-tool module embedded inside the cheat. It is registered as the final entry in the module list (registration code at RVA 0x002090) and shares the Vacuum vtable (0x3B0E38), inheriting its factory and base dispatch structure. Its RegisterTab function is at RVA 0x090060, its per-frame Update stub points to the shared no-op destructor at RVA 0x083DC0 (same stub as SetDither and SkillHack). The module is not a stub — it contains a complete ImGui-based runtime Unity scene hierarchy browser and component inspector. +## 16.1 Registration and Vtable +The registrar lambda at RVA 0x002090 stores Vacuum's vtable pointer (0x1803B0E38) as the factory and passes the string 'UnityExplorerModule' (RVA 0x3B0D28) to ModuleManager::AddRegistrar. This means during ModuleManager::Init, calling vtable[+0x10] on UnityExplorerModule's registrar invokes Vacuum's RegisterTab stub (RVA 0x9B650), which resolves via jmp to UnityExplorerModule::RegisterTab at RVA 0x090060. The vtable[+0x18] dispatch slot returns [.data+0x2610] — the module's state block — and the per-frame render fn ptr is written there during RegisterTab. +Registration: RVA 0x002090 (AddRegistrar call; factory = Vacuum vtable 0x3B0E38) +RegisterTab: RVA 0x090060 (init; registers tab 'Unity Explorer', zeroes state) +Render: RVA 0x090250 (per-frame ImGui scene/inspector panel) +Update stub: RVA 0x083DC0 (shared no-op; frees string, optional delete) +State block: [.data+0x2610] (0x190 bytes, zero-filled by memset at 0x0900BC) +Tab name: 'Unity Explorer' (string RVA 0x3B02D0) +Window title: 'Unity Explorer Window' (RVA 0x3B02E0) +## 16.2 RegisterTab (RVA 0x090060) +RegisterTab is guarded by a std::once_flag at [.data+0x260C]. On first call it: (1) zero-fills the 0x190-byte state block at [.data+0x2610] via memset (0x1800AC86A); (2) constructs the tab name std::string 'Unity Explorer' and calls TabManager::RegisterTab (0x18000F7D0) to register the ImGui tab at [.data+0x2618]; (3) writes the Update fn ptr (0x1803AFA38 → RVA 0x083DC0, shared no-op stub) to [.data+0x2610]; (4) zeroes all state fields (scene list vector, selected index, refresh flags, auto-refresh bool, interval float, search filter buffer, component list, inspector string); (5) calls std::once_flag::_Execute_once (0x1800AFF60) to seal the guard. On subsequent calls the already-initialized guard causes an early return at 0x1800901D8. +Key state fields initialized during RegisterTab: +[.data+0x2610] update_fn_ptr = 0x083DC0 (no-op stub) +[.data+0x2618] tab_string = 'Unity Explorer' (std::string) +[.data+0x2638] enabled = 0 (bool, OFF by default) +[.data+0x2640] auto_refresh = 0 (bool) +[.data+0x2644] refresh_interval = 3.0f (0x40400000) +[.data+0x2648] scene_list_begin = 0 (ptr, vector) +[.data+0x2650] scene_list_end = 0 +[.data+0x2660] scene_list_cap = 0 +[.data+0x2670] selected_scene_idx = 0 +[.data+0x2680] selected_obj_idx = 0 +[.data+0x2684] search_filter[0x100] = 0 (char buffer) +[.data+0x2784] inspector_active = 0 (bool) +[.data+0x2788] inspected_obj_ptr = 0 +[.data+0x2790] inspected_obj_name = 0 (std::string) +## 16.3 Render / Per-Frame Logic (RVA 0x090250) +The Render function checks enabled ([this+0x28]) and a secondary active flag ([this+0x30]) before drawing. When both are set it calls ImGui::Begin with 'Unity Explorer Window' (RVA 0x3B02E0, via jmp to 0x1800937D0 = ImGui::Begin wrapper). The main function body at RVA 0x0902E0 is a substantial per-frame function that draws the complete inspector UI. +Scene panel logic: +// Check scene list (vector at [this+0x58]..[this+0x60]) +if (scene_list is empty) { +ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +} else { +ImGui::Text("Select Scene:"); +ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +if (combo changed) { LoadScene(selected_scene_idx); } +} +// Writes g_Config->overlay_flags |= 1 and g_Config->overlay_scale = 300.0f +// (at [g_Config+0x1F78] and [g_Config+0x1F90]) when scene panel is active +Auto-refresh logic (RVA 0x090250): +if (enabled && auto_refresh) { +now = GetTime(); // 0x180093B10 +elapsed = now - last_refresh_time; +max_entries = (float)refresh_interval * SCALE_CONST; +if (elapsed_entries >= max_entries) { +RefreshScenes(this); // 0x180090D40 +last_refresh_time = now; +} +} +GameObject hierarchy panel (drawn when a scene is selected): +// Search filter input: ##SearchFilter — writes to search_filter[0x100] buffer +// GameObject list: iterates [this+0x40]..[this+0x48] (vector) +// Per entry: prints '[namespace]: ' prefix + name +// 'Ins##' button beside each entry -> inspect that object +// If list empty: Text('No GameObjects found in this scene.') +// 'DontDestroyOnLoad' section: special scene with fallback text if not found +Inspector panel (when an object is selected via 'Ins' button): +// 'No GameObject selected.' if none +// Otherwise shows: +// 'Active' checkbox (calls GameObject.SetActive via IL2CPP) +// Transform section: Position, Local Position, Rotation, Scale (float3 inputs) +// 'Components' section: 'GameObject Class: %s.%s' +// 'All Components:' list via IL2CPP GetComponents(UnityEngine.Component) +// Per component: '%s.%s' (namespace.classname) +// On fetch failure: 'Unknown Component' or 'Unable to get GameObject class information.' +## 16.4 Complete String Inventory +String +RVA +Usage +'UnityExplorerModule' +0x3B0D28 +Module name (registrar) +'Unity Explorer' +0x3B02D0 +Tab label; ImGui::Begin title +'Unity Explorer Window' +0x3B02E0 +ImGui window title string +'Search Filter:' +0x3B02F8 +Label above search input +'##SearchFilter' +0x3B0308 +ImGui InputText widget ID +'Inspector' +0x3B0318 +Inspector sub-panel label +'GameObjectHierarchy' +0x3B0328 +Hierarchy sub-panel label +'No scenes loaded. Click Refresh...' +0x3B0340 +Empty scene list message +'Scene: ' +0x3B0390 +Scene prefix label +'No GameObjects found in this scene.' +0x3B0398 +Empty hierarchy message +'DontDestroyOnLoad' +0x3B03C0 +Special DDOL scene label +'DontDestroyOnLoad (Not Found)' +0x3B03D8 +DDOL fallback label +'Refresh' +0x3B03F8 +Refresh button label +'Auto Refresh' +0x3B0400 +Auto-refresh checkbox +'Interval (s)' +0x3B0410 +Refresh interval slider label +'Scenes found: %d' +0x3B0420 +Scene count display +"No scenes available. Click 'Refresh Scenes' to load." +0x3B0438 +No-scenes message +'Select Scene:' +0x3B0470 +Scene selector label +'Select Scene' +0x3B0480 +Combo default text +'##SceneCombo' +0x3B0490 +ImGui Combo widget ID +']: ' +0x3B04A0 +Object list entry separator +'Ins##' +0x3B04A8 +Inspect button label prefix +'No GameObject selected.' +0x3B04B8 +Inspector empty state +"Click 'Ins' button..." +0x3B04D0 +Inspector hint text +'Active' +0x3B0508 +Active checkbox label +'Transform' +0x3B0510 +Transform section header +'Position' +0x3B0520 +Position field label +'Local Position' +0x3B0530 +Local position field label +'Rotation' +0x3B0540 +Rotation field label +'Scale' +0x3B054C +Scale field label +'No Transform component found.' +0x3B0558 +Transform fallback message +'Components' +0x3B0578 +Components section header +'GameObject Class: %s.%s' +0x3B0588 +Class display format +'All Components:' +0x3B05A0 +Component list header +'UnityEngine.Component, UnityEngine.CoreModule' +0x3B05B0 +IL2CPP type name for GetComponents +'%s.%s' +0x3B05E0 +Component name format +'Unknown Component' +0x3B05E8 +Component fallback name +'No components found or failed to get components.' +0x3B0600 +Component fetch failure +'Unable to get GameObject class information.' +0x3B0638 +Class info failure +## 16.5 Assessment +UnityExplorerModule is a developer/debug tool that was purpose-built alongside the cheat modules and registered in the same module system. It provides a runtime Unity scene browser — listing loaded scenes, displaying the active GameObject hierarchy with a search filter, and offering a per-object inspector showing Transform (position, rotation, scale), active state, and all attached components retrieved via IL2CPP reflection (GetComponents with 'UnityEngine.Component, UnityEngine.CoreModule' as the type argument). +The module is enabled by the same ON/OFF flag ([module+0x28]) as all other modules and is rendered every frame from the same DispatchRender loop. Its auto-refresh timer (default 3.0s interval, bool at [.data+0x2640], float at [.data+0x2644]) periodically re-enumerates loaded scenes via RefreshScenes (RVA 0x090D40). The g_Config writes inside Render ([g_Config+0x1F78] |= 1, [g_Config+0x1F90] = 300.0f) activate the overlay resize logic while the explorer window is open. +This is the probable origin of the DLL's filename 'unityexplorer.dll' — the binary was named after this embedded developer tool to serve as cover, making the file appear to be a legitimate Unity debugging utility rather than a game cheat. +# 17. Per-Config-Preset Writers +The cheat implements four named configuration presets that write distinct sets of skill-timing and distance-threshold constants into g_Config at runtime. These are not game-version or region variants as originally suspected; they are user-selectable combat automation profiles, each named after a science-fiction reference. The active preset name string is stored at [.data+0x00E0] and the integer index at [.data+0x00EC]. On startup the Settings tab reads both the current theme name and the default preset indicator from the config JSON, compares the theme string against each preset name via ImGui::Selectable (0x1800708D0), and calls the matching writer directly — all four calls reside in a single function at RVA 0x09A4F0. +## 17.1 Dispatch Mechanism +The dispatch logic is in the Settings tab render function at RVA 0x09A4F0. It reads the saved preset name string from the JSON config object (keyed 'Default', 'Evangelion Unit 01', 'Evangelion Unit 02', or 'Matrix'), compares via ImGui::Selectable, stores the matched preset name pointer to [.data+0x00E0], writes the index integer (0–3) to [.data+0x00EC], then calls the corresponding writer immediately. On subsequent frames the startup code at 0x082F02 reads [.data+0x00EC] and re-routes to the same writer if the selection changes: +// RVA 0x082F00 version dispatch +ecx = g_Config->preset_index; // [.data+0x00EC] +switch (ecx) { +case 0: WriterDefault(); // RVA 0x0941F0 +case 1: WriterEvangelionUnit01(); // RVA 0x094890 +case 2: WriterEvangelionUnit02(); // RVA 0x096770 +case 3: WriterMatrix(); // RVA 0x098650 +} +## 17.2 Preset Summary +Preset name +Index +Writer RVA +Write count +g_Config range +'Default' +0 +0x0941F0 +168 +0xDA4 – 0x12A4 +'Evangelion Unit 01' +1 +0x094890 +23 +0xD9C – 0xEBE +'Evangelion Unit 02' +2 +0x096770 +23 +0xD9C – 0xEBE +'Matrix' +3 +0x098650 +13 +0xD9C – 0xE14 +'Default' is the master preset and the only one that writes the full skill-timing table (g_Config offsets 0xEC8–0x12A4). The three non-default presets are thin overlays that write only the distance-threshold and encounter-tuning floats at offsets 0xD9C–0xEBE, leaving the skill-timing table zeroed for their entries. When any non-default preset is active the skill-timing table fields written by Default remain at their last-written values (the table is not re-zeroed between preset switches). +## 17.3 g_Config Field Semantics +The written offsets cluster into two functional groups identified by value range and stride pattern. +Distance / encounter thresholds (offsets 0xD9C–0xE30) — written by all four presets. Values are floats in the range 0.0–21.0, representing game-unit distances. Groups of four consecutive dwords repeat the stride [min_x, min_y, range, limit] observed in ESP module configuration. Example values across presets: +g_Config offset +Default +EvaUnit01 +EvaUnit02 +Matrix +Semantic +0x0D9C +0.0 +1.0 +1.0 +1.0 +Encounter active flag / base threshold +0x0DA0 +0.0 +0.60 +0.60 +0.50 +Approach multiplier +0x0DA4 +10.0 +10.0 +10.0 +8.0 +Max detect range (units) +0x0DA8 +10.0 +10.0 +10.0 +8.0 +Max engage range (units) +0x0DAC +8.0 +4.0 +4.0 +0.0 +Attack range (units) +0x0DB0 +0.0 +0.0 +0.0 +1.0 +Reserved / extra trigger flag +0x0DDC +8.0 +6.0 +6.0 +5.0 +Secondary range A +0x0DE0 +6.0 +4.0 +4.0 +3.0 +Secondary range B +0x0E0C +21.0 +0.0 +0.0 +0.0 +Max AoE range (Default only) +0x0E14 +15.0 +14.0 +14.0 +12.0 +Long-range threshold +Skill timing table (offsets 0xEC8–0x12A4) — written only by the Default preset (168 entries, all zero in the other three presets). Values are floats in the range 0.02–1.0 organized in repeating groups of four dwords: [min_time, max_time, window_end, confidence]. This matches the SkillHack timing parameters documented in Section 8. Each group of four corresponds to one skill slot. The table spans approximately 40 skill slots covering offsets 0xEC8 through 0x1144, with an additional small block at 0x1298–0x12A4. Example timing entries from Default: +// g_Config[0xEC8..0xED7]: Skill slot 0 timing (Default) +[0xEC8] min_time = 0.85f +[0xECC] max_time = 0.85f +[0xED0] win_end = 0.85f +[0xED4] confidence= 1.00f +// g_Config[0xED8..0xEE7]: Skill slot 1 timing (Default) +[0xED8] min_time = 0.50f +[0xEDC] max_time = 0.50f +[0xEE0] win_end = 0.50f +[0xEE4] confidence= 1.00f +// g_Config[0xEE8..0xEF7]: Skill slot 2 timing (Default) +[0xEE8] min_time = 0.05f +[0xEEC] max_time = 0.05f +[0xEF0] win_end = 0.07f +[0xEF4] confidence= 0.90f +// ... continues through ~40 skill slots to 0x1144 +// g_Config[0x1298..0x12A7]: final 4-entry block +[0x1298] min_time = 0.05f +[0x129C] max_time = 0.05f +[0x12A0] win_end = 0.07f +[0x12A4] confidence= 0.73f +## 17.4 Preset Behavioral Differences +The three non-default presets represent incrementally more conservative tuning. 'Evangelion Unit 01' and 'Evangelion Unit 02' are nearly identical — both reduce attack range from 8.0 to 4.0, reduce long-range threshold from 15.0 to 14.0, and set the secondary detection distance lower than Default. The only distinction between the two Evangelion presets is a small float difference at offset 0xDC0/0xDC4 (both 0.50 in Unit 01 vs. both 0.50 in Unit 02 — functionally identical in the parsed output; any distinction would be in fields that were not written by the respective functions and thus retained from previous state). 'Matrix' is the most conservative preset: it lowers attack range to 0.0 (disabling direct attack trigger), cuts max detect range to 8.0, reduces the long-range threshold to 12.0, and sets the extra trigger flag at 0xDB0 to 1.0, suggesting it relies on a different trigger path. +The 'Default' preset is by definition the most aggressive: it provides the only non-zero skill timing table and the widest detection ranges. This is consistent with the binary having version_index = 1 hardcoded at .data+0x00EC at static-init time, meaning 'Evangelion Unit 01' loads on first launch before the user selects a preset from the Settings tab. +## 17.5 Preset Name Strings +String +RVA +Role +'Default' +0x3B06F8 (via 0x3B0AF8) +Preset name, ImGui label, JSON key; also theme name for Default +'Evangelion Unit 01' +0x3B06D0 (via 0x3B0AD4+) +Preset name and JSON key for index 1 +'Evangelion Unit 02' +0x3B0AE0 +Preset name and JSON key for index 2 +'Matrix' +0x3B0B10 +Preset name and JSON key for index 3 +'Theme' +0x3B0AD4 +JSON field name for preset selection +'zh_cn' +0x3B10E8 +Locale string; passed to string-construct at 0x9D8A4 (ecx==1 branch) +'en' +0x3B2020 +Locale string; passed to string-construct at 0x9D890 (ecx==0/2 branch) +The 'zh_cn' and 'en' locale strings at 0x3B10E8 and 0x3B2020 are constructed as std::string values during a JSON key-lookup operation at RVA 0x09D7D0 (called from the Settings tab). The locale is selected by the same integer switch (ecx) that dispatches the preset writers — 0 maps to 'en', 1 maps to 'zh_cn', and 2 falls back to 'en'. This implies the preset index also encodes locale preference: 'Default' (index 0) and the two Evangelion presets and 'Matrix' are treated as CN (index 1) by default, and 'en' is the fallback locale for presets 0 and 2. The locale string is used as the second argument to a JSON object accessor, indicating that config field names are stored locale-keyed in the JSON schema. +# 18. GABypass +GABypass is the IL2CPP function pointer resolution subsystem. Its sole function is to locate the game's IL2CPP runtime module (GameAssembly.dll) in the process address space, then compute and cache the addresses of 71 specific IL2CPP and Unity API methods that the cheat's modules call at runtime. It does not patch instructions, overwrite vtables, or install hooks — it is a pure address-resolution table initializer. The resolved pointers are stored in .data slots at offsets 0x1C48 through 0x1E80 and are subsequently used by every cheat module that makes IL2CPP calls: ESPModule, NoClip, FreeCam, SkillHack, FpsUnlocker, and the UnityExplorer component. +## 18.1 Initialization Sequence +GABypass::Patch (RVA 0x09D1E0) is called exactly once during startup from the main DLL thread at RVA 0x0A942A, immediately after the 'Initializing..' console log and before any module Update() or Render() calls. The call sequence is: +// RVA 0x0A942A (main.cpp line 53, per embedded source path) +Log("Initializing.."); +GABypass::Patch(); // RVA 0x09D1E0 — resolve 71 IL2CPP pointers +il2cpp_domain = [.data+0x1E80](); // call il2cpp_domain_get_assemblies immediately +if (il2cpp_domain != null) { +Log("IL2CPP Domain Found: " + ...); +} +// ... module init continues +Inside GABypass::Patch, execution branches on whether [.data+0x00F0] is already non-null. That slot holds the cached GameAssembly.dll module base address. On first call (cold start), [.data+0x00F0] is zero, so the function calls GetModuleHandleW(L"GameAssembly.dll") via the IAT slot at 0x1800B1290 to obtain the module base, stores it in rdx, then computes all 71 pointers as fixed offsets from that base. On subsequent calls (if Patch is ever called again), [.data+0x00F0] is already populated so the 'GA Bypass successfully!' log and GetModuleHandleW call are skipped and rdx is loaded directly from the cached value before the offset table is re-written. In practice Patch is only called once. +// GABypass::Patch (RVA 0x09D1E0) — annotated +if ([.data+0x00F0] != 0) { +Log("GA Bypass successfully!"); // already cached, log and skip resolve +rdx = [.data+0x00F0]; +goto write_table; +} +rdx = GetModuleHandleW(L"GameAssembly.dll"); // first-run: locate module +write_table: +// 71x: [.data+slot] = rdx + IL2CPP_offset +[.data+0x1C70] = rdx + 0x0018AD80; // il2cpp_object_get_class +[.data+0x1C78] = rdx + 0x00007480; // il2cpp_class_get_method_from_name +[.data+0x1E70] = rdx + 0x00D94C10; // il2cpp_domain_get +[.data+0x1E78] = rdx + 0x00D94DA0; // il2cpp_assembly_get_image +[.data+0x1E80] = rdx + 0x00D93A60; // il2cpp_domain_get_assemblies +// ... 66 additional Unity/game method pointers +ret +## 18.2 The 71-Entry Pointer Table +Each entry is a QWORD at a fixed .data offset. The IL2CPP offset column is the byte distance from the GameAssembly.dll module base to the target function — these are static, computed at compile time from a known game binary version. The table spans two contiguous .data regions: 0x1C48–0x1CF8 (IL2CPP runtime and UnityEngine core) and 0x1D00–0x1E80 (game-specific methods, additional Unity API, UI/camera). +# +.data offset +IL2CPP offset +Resolved function +Used by +1 +0x1C48 ++0x09DC0120 +GameObject.GetComponentByIndex +UnityExplorer inspector +2 +0x1C50 ++0x0018CEC0 +il2cpp_domain_get_assemblies (A) +GABypass init / UnityExplorer +3 +0x1C58 ++0x0B390700 +Component.GetComponent +UnityExplorer / NoClip +4 +0x1C60 ++0x0B3A2D20 +Transform.get_localScale +UnityExplorer inspector +5 +0x1C68 ++0x0B3A2CB0 +Transform.get_rotation +UnityExplorer inspector +6 +0x1C70 ++0x0018AD80 +il2cpp_object_get_class +UnityExplorer type query +7 +0x1C78 ++0x00007480 +il2cpp_class_get_method_from_name +UnityExplorer method lookup +8 +0x1C80 ++0x0B3A1AE0 +Transform.get_localPosition +UnityExplorer / NoClip +9 +0x1C88 ++0x0B3A1A70 +Transform.get_position +ESP / NoClip +10 +0x1C90 ++0x0B3A51D0 +Transform.set_localPosition +NoClip teleport +11 +0x1C98 ++0x0B398830 +GameObject.SetActive +UnityExplorer / NameChanger +12 +0x1CA0 ++0x0B3911F0 +GameObject.get_transform +ESP / NoClip +13 +0x1CA8 ++0x0B3A59D0 +Transform.set_rotation +FreeCam / NoClip +14 +0x1CB0 ++0x0B391D90 +GameObject.get_activeInHierarchy +UnityExplorer inspector +15 +0x1CB8 ++0x0B3B2410 +GameObject.get_tag +UnityExplorer inspector +16 +0x1CC0 ++0x0B3B2120 +GameObject.get_name +UnityExplorer inspector +17 +0x1CC8 ++0x0B3B40B0 +GameObject.get_layer +UnityExplorer inspector +18 +0x1CD0 ++0x0B397980 +GameObject.get_scene +UnityExplorer inspector +19 +0x1CD8 ++0x02F3DA80 +Game: skill/buff method A +SkillHack +20 +0x1CE0 ++0x00F27E10 +Game: skill/buff method B +SkillHack +21 +0x1CE8 ++0x0B329000 +Component.GetComponents +UnityExplorer component list +22 +0x1CF0 ++0x0B329D80 +Component.GetComponentsInChildren +UnityExplorer tree walk +23 +0x1CF8 ++0x03E9BB50 +Game: skill/ability slot method A +SkillHack +24 +0x1D00 ++0x0B383F60 +Object.get_name +UnityExplorer name display +25 +0x1D08 ++0x0B33CAB0 +Component.GetType (A) +UnityExplorer type display +26 +0x1D10 ++0x0B33CB00 +Component.GetType (B) +UnityExplorer type display +27 +0x1D18 ++0x039D1AA0 +Game: skill/ability slot method B +SkillHack +28 +0x1D20 ++0x026DE9F0 +Game: combat/hit method A +SkillHack / combat +29 +0x1D28 ++0x0478E860 +Game: UI show/hide toggle +NoClip / FpsUnlocker UI +30 +0x1D30 ++0x025E2D40 +Game: combat/hit method B +SkillHack / combat +31 +0x1D38 ++0x087C2CD0 +Game: movement/physics method A +NoClip CharacterController +32 +0x1D40 ++0x03419AF0 +Game: movement/physics method B +NoClip CharacterController +33 +0x1D48 ++0x0B322FB0 +SceneManagement.Scene.get_name +UnityExplorer scene display +34 +0x1D50 ++0x0B396A20 +SceneManager.GetActiveScene +UnityExplorer scene query +35 +0x1D58 ++0x0B397700 +CinemachineBrain.get_ActiveVirtualCamera +FreeCam hook +36 +0x1D60 ++0x03766810 +Game: entity/actor state method A +ESP / SkillHack +37 +0x1D68 ++0x0B3A2A60 +Transform.set_localScale +UnityExplorer inspector +38 +0x1D70 ++0x0B326660 +Rigidbody.get_velocity +NoClip / Vacuum +39 +0x1D78 ++0x0B3266B0 +Rigidbody.set_velocity +NoClip / Vacuum +40 +0x1D80 ++0x0B383200 +Object.Destroy +UnityExplorer +41 +0x1D88 ++0x0B3A1A10 +Transform.set_position +NoClip teleport / Vacuum +42 +0x1D90 ++0x0B3A2340 +Game: entity/actor state method B +ESP +43 +0x1D98 ++0x0B421800 +Input.GetAxis('Mouse X') +FreeCam look X +44 +0x1DA0 ++0x0B3A26D0 +Game: player state method A +ESP / SkillHack +45 +0x1DA8 ++0x0B3A1FB0 +Game: player state method B +ESP / SkillHack +46 +0x1DB0 ++0x0B32B030 +Game: player health/stat accessor +ESP health display +47 +0x1DB8 ++0x0B391240 +GameObject.SetActive (CinemachineBrain active flag) +FreeCam enable/disable +48 +0x1DC0 ++0x0B390440 +Camera.get_main +ESP worldToScreen / FreeCam +49 +0x1DC8 ++0x0B390F80 +GameObject.FindObjectOfType +Active scene object scan +50 +0x1DD0 ++0x0B3A19A0 +Transform.get_position (2nd ref) +ESP / NoClip +51 +0x1DD8 ++0x03F85430 +Game: skill/action method C +SkillHack +52 +0x1DE0 ++0x0B3A1D30 +Transform.set_rotation (2nd ref) +FreeCam / NoClip +53 +0x1DE8 ++0x0B3A1C90 +Camera.get_fieldOfView +FreeCam FOV control +54 +0x1DF0 ++0x00E92CF0 +Game: entity/actor state method C +ESP +55 +0x1E00 ++0x03DC14C0 +Game: skill/action method D +SkillHack +56 +0x1E08 ++0x03E0D2C0 +Game: skill/action method E +SkillHack +57 +0x1E10 ++0x03D9DF30 +Game: skill/action method F +SkillHack +58 +0x1E18 ++0x00E9E9F0 +Game: skill/action method G +SkillHack +59 +0x1E20 ++0x03EA53C0 +Game: skill/action method H +SkillHack +60 +0x1E28 ++0x0ACA0EC0 +TMPro.TextMeshProUGUI.set_text +Name changer UI label +61 +0x1E30 ++0x0B391D40 +UnityEngine.UI.Text.set_text +ON/OFF toggle labels / Name changer +62 +0x1E38 ++0x036AA8F0 +Game: skill/action method I +SkillHack +63 +0x1E40 ++0x03EC31C0 +Game: skill/action method J +SkillHack +64 +0x1E48 ++0x037F8CD0 +Game: entity/actor method D +ESP / combat +65 +0x1E50 ++0x036EA640 +Game: skill/action method K +SkillHack +66 +0x1E58 ++0x03EC30E0 +Game: skill/action method L +SkillHack +67 +0x1E60 ++0x037F2A40 +Game: entity/actor method E +ESP / combat +68 +0x1E68 ++0x037FD7E0 +Game: entity/actor method F +ESP / combat +69 +0x1E70 ++0x00D94C10 +il2cpp_domain_get +UnityExplorer domain probe +70 +0x1E78 ++0x00D94DA0 +il2cpp_assembly_get_image +UnityExplorer assembly walk +71 +0x1E80 ++0x00D93A60 +il2cpp_domain_get_assemblies (B) +Post-patch domain probe (main.cpp:67) +## 18.3 Functional Grouping +The 71 entries divide into four functional groups. Six entries (slots 2, 6, 7, 69, 70, 71) are IL2CPP runtime API functions — the low-level metadata accessors that the cheat uses to walk the IL2CPP type system for the UnityExplorer inspector. Their offsets are clustered near the start of GameAssembly.dll (+0x0007480, +0x0018AD80, +0x0018CEC0, +0x00D93A60, +0x00D94C10, +0x00D94DA0), consistent with early-loaded IL2CPP initialization code. +Thirty-four entries are UnityEngine managed API methods — Transform, GameObject, Component, Camera, Rigidbody, SceneManager, and Object — that provide the cheat with Unity scene graph access, world-space position manipulation, and object lifecycle control. These are used across all active modules: ESP calls position/camera methods every frame, NoClip writes to Transform.set_position and Rigidbody.set_velocity, FreeCam uses Camera.get_fieldOfView and CinemachineBrain.get_ActiveVirtualCamera, and the UnityExplorer inspector uses the full component introspection set. +Twenty-six entries are game-specific methods at offsets deep into GameAssembly.dll (+0x02F3DA80 and above), most concentrated in the 0x03xxxxxx–0x0Bxxxxxx range. Twelve of these are identifiable SkillHack targets (slots 19–20, 23, 27–28, 30, 51, 55–59, 62–66) — the methods responsible for skill cooldown, buff application, and action validation that SkillHack intercepts or spoofs. The remaining game-specific entries cover combat hit methods, movement/physics controllers, entity state accessors, and player stat readers used by the ESP and combat modules. +Five entries cover additional UI and camera libraries: Cinemachine (slot 35, CinemachineBrain), TextMeshPro (slot 60, TextMeshProUGUI.set_text), and legacy Unity UI (slot 61, UnityEngine.UI.Text.set_text). These are used exclusively by the Name Changer module and the FreeCam camera management code. +## 18.4 Version Sensitivity +All 71 IL2CPP offsets are hard-coded at compile time as fixed displacements from the GameAssembly.dll base. There is no runtime method name lookup, no FNV hash scan, and no fallback if an offset is wrong — if the game updates and shifts any of these methods, the corresponding cheat feature silently malfunctions (calling into an arbitrary address). The SkillHack module uses a separate FNV-1a name-hash lookup path (documented in Section 8) as a secondary resolution mechanism for its core hook target, but the 26 game-specific GABypass entries have no such fallback. This architecture implies the binary is built and tested against a specific pinned game version; the version-selector system documented in Section 15 may exist partly to accommodate minor offsets shifts across game build variants, but the offsets themselves are not adjusted per variant. +# 19. JSON Config Schema and Save/Load System +This chapter resolves the config-schema investigation. The binary does not implement a standalone .json config file. All cheeto settings persistence is handled through ImGui’s built-in .ini settings mechanism, augmented with per-module custom settings handlers registered at runtime. +## 19.1 IAT — File I/O Functions (Complete Resolution) +The PE import table was fully parsed this session, resolving every previously unidentified IAT slot relevant to file I/O and config: +IAT[0xB1268] = GetCurrentThreadId (stack cookie check at 0xAC709, NOT file I/O) +IAT[0xB1278] = VirtualFree +IAT[0xB1288] = VirtualProtect +IAT[0xB1178] = GetConsoleWindow (used in Settings tab Toggle Console) +IAT[0xB1628] = ShowWindow (used in Settings tab Toggle Console) +IAT[0xB1858] = fread (file read, called ONLY from 0x12121) +IAT[0xB1868] = fwrite (called from 0xEA1B, 0x170D6, 0x3033B, 0x3076D) +IAT[0xB1870] = fclose (called from 0xEAB0, 0x1212F, 0x121A9, 0x170DF etc.) +IAT[0xB1888] = _wfopen (wide-char file open, called ONLY from 0x11F93) +IAT[0xB1890] = fseek (called from 0x120BC, 0x120E7) +IAT[0xB1898] = ftell (called from 0x120A0, 0x120CD) +## 19.2 No Standalone JSON Config File +Exhaustive scanning of the binary confirmed no .json filename string exists anywhere in rdata or .data. The config system is the standard ImGui .ini persistence layer. All module settings are serialized through ImGui’s settings-handler API, not a JSON library. The nlohmann::json_abi_v3_12_0 library present in the binary is used exclusively for the i18n translation table, not for config I/O. +## 19.3 Config File: imgui.ini +The config filename “imgui.ini” (RVA 0x3ABB60) is set at RVA 0x1117A into ImGuiIO+0x20 (the IniFilename field) during ImGuiIO initialization. The log filename “imgui_log.txt” (RVA 0x3ABB70) is set into ImGuiIO+0x28 at the same site. Both are written relative to the process working directory at runtime. +## 19.4 Save/Load Trigger and Execution Path +Load path (on startup): RVA 0x30661 calls the file-read helper at 0x12050, which executes ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell again (0x120CD) → malloc → fread (0x12121) → fclose (0x1212F). The buffer is passed to 0x30840 (ParseIniSettingsFromMemory), which walks the handler list at [ImGuiContext+0x2920] calling each registered handler’s ReadLine callback. +Save path (periodic): The render loop checks [ImGuiContext+0x2900] (dirty flag, byte) and [ImGuiContext+0x2904] (float countdown timer). When both conditions are met, RVA 0x30A90 (SaveIniSettingsToDisk) builds the path from [ImGuiContext+0x2910] (custom IniFilename) or falls back to [.data+0x1BEC]. It calls each handler’s WriteAll callback, then passes the buffer to 0x11EA0 (_wfopen wrapper with “wt” mode at RVA 0x1803AD594), fwrite (0x3076D), and fclose (0x30776). The manual save trigger at RVA 0x17072 sets [ImGuiContext+0x2900]=1 and [ImGuiContext+0x2904]=0 to force an immediate write. +## 19.5 i18n Translation Table (Clarification) +The blob starting at RVA 0x3B10E8 is the compile-time JSON localization table, not the config schema. It is a single JSON object mapping English UI label strings to Chinese (zh_cn) equivalents. At startup (RVA 0x2164), a std::string constructor copies this blob (length 0xEED bytes) into [.data+0x1EB8]. The i18n loader at RVA 0x9D660 selects either “en” or “zh_cn” values based on the language toggle flag. The nlohmann runtime type-error strings (object, array, null, string, number, parse_error etc.) at 0x3B3010–0x3B30D8 confirm nlohmann v3.12.0 is statically linked. +The “enabled” string at RVA 0x3B0B28 is one of these UI labels; it is used to display the module on/off state in the GUI and is not a JSON config key. +## 19.6 Module Settings Handler Architecture +Each module registers a settings handler at [ImGuiContext+0x2920] (a dynamically-grown array of 0x48-byte handler structs). The handler struct layout (from RVA 0x30904): ++0x00 TypeName (const char*) — section identifier in .ini file ++0x08 TypeHash (u32) — CRC32 of TypeName (computed at 0x3079C–0x30803) ++0x18 ReadOpenFn — called when section header encountered ++0x38 WriteAllFn — called during save to emit key=value lines +The 11 registered module classes identified from RTTI at .data+0x0590–0x0E60 are: ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule. +## 19.7 ModuleManager Lifecycle +ModuleManager::Init (RVA 0x9ACA4) iterates the module registry at [.data+0x23B8], calls vtable[+0x10] to obtain each module instance, then vtable[+0x08] to initialize it. Each initialized module is logged as “Module {} initialized” (string at RVA 0x3B0C48). Completion is logged as “ModuleManager initialization complete” (RVA 0x3B0C60). The per-frame dispatch methods are vtable[+0x18] (Update, iterated at 0x9AE80) and vtable[+0x30] (RenderOverlay, iterated at 0x9AEF0). Both iterate the same module list checking [module+0x28] (enabled flag) before calling the virtual. +## 19.8 Settings Tab Behavior +Settings::RenderOverlay (RVA 0x9A4F0–0x9AB98, source E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp) handles: language toggle via 0x9D660 (reads [.data+0x1EB8] i18n blob, selects “en” or “zh_cn” values); theme color initialization via 0x98650 (parses hex color strings e.g. “00FF41FF” from rdata into [.data+0x1C00+0xD9C..] float RGBA fields); console window toggle via GetConsoleWindow (IAT[0xB1178]) and ShowWindow (IAT[0xB1628]). There are no Save/Load buttons; settings are persisted automatically by the ImGui .ini mechanism on each render frame that detects a dirty flag. +# 20. FPSModule +FPSModule implements two independent features controlled by the “FPS Monitor” tab in the GUI: an in-game FPS counter overlay and a separate FPS cap unlocker. The RTTI decorated name is .?AVFPSModule@@ (RVA 0x3C5CF8). The module name string “FPS Monitor” resides at RVA 0x3AFA88; “Show FPS Overlay” at 0x3AFA98; the overlay prefix string “FPS: ” at 0x3AFAAC. +## 20.1 Registration and Vtable +The registrar constructor references the name string at RVA 0x1B71 and calls the module registry at 0x9B2C0. Two vtable blocks are emitted. The lambda vtable (for the registrar’s std::function wrapper) lives at 0x3B0E00; the module instance vtable is at 0x3B0E38. The singleton object is heap-allocated and its pointer cached at [.data+0x22E0] (VA 0x1803C72E0). +Instance vtable (0x3B0E38): +[+0x00] 0x9B660 dtor +[+0x08] 0x9B660 dtor (scalar deleting) +[+0x10] 0x9B650 Initialize -> jmp 0x90060 +[+0x18] 0x9B640 GetSingleton -> returns [.data+0x05D0] +[+0x20] 0x9B620 dtor with size 0x10 +[+0x28] 0x9B630 GetSelf -> lea rax,[rcx+8]; ret +[+0x38] 0x9B720 vtable setter (returns ptr to 0x3B0E70) +[+0x48] 0x9B710 Update -> jmp 0x81300 +## 20.2 Initialize (RVA 0x814C0) +Guarded by a once_flag at [.data+0x2310]. On first call it allocates the module object (0xD8 bytes via 0xAC86A), stores the vtable pointer from 0x3AFA38 into [.data+0x22E0], copies the name string “FPS Monitor” into [.data+0x22E8], sets enabled = 0x0 at [.data+0x2308], then overwrites the vtable slot with the render-function pointer from 0x3AFAC0. If already initialized the singleton pointer is returned early from [.data+0x22E0]. +## 20.3 RenderOverlay — Panel (RVA 0x85660; inner ImGui branch at 0x856F0) +The panel render function is called by ModuleManager::RenderOverlay. It renders two ImGui checkboxes inside the “FPS Monitor” collapsing header. The first checkbox (“FPS Monitor”, bound to [module+0x28]) toggles the FPS counter overlay; on state change it sets [ImGuiContext+0x2900]=1 (dirty flag) and resets the ini-save timer. The second checkbox (“Show FPS Overlay”, RVA 0x3AFA98) is bound to [module+0x28] via 0x85320 (Checkbox with state-ptr helper) and controls display of the overlay window. After both checkboxes, the function calls ImGui::EndDisabled via [ImGuiContext+0x27F0] WORD counter decrement. +## 20.4 RenderOverlay — FPS Counter Overlay (RVA 0x858D0) +When the FPS overlay is enabled ([module+0x28] != 0), this function draws a frameless ImGui window labelled “##Foreground” (RVA 0x3ABF10) pinned to the top-left of the viewport. It calls [.data+0x1D38] (GetDeltaTime via ImGuiContext) with rcx=0, computes xmm6 = 1.0 / deltaTime (i.e. current FPS), builds the display string “FPS: ” + integer FPS value (via 0x7F5C0), then selects a text color from three XMMWORD constants based on two hard-coded thresholds: +fps >= 60 -> color constant at 0x1803B3530 (green) +30 <= fps < 60 -> color constant at 0x1803B3540 (yellow) +fps < 30 -> color constant at 0x1803B3510 (red) +The colored FPS string is then submitted to the ImGui drawlist via 0x51580 (AddText with explicit color). The overlay window uses ImGui foreground drawlist accessed through [ImGuiContext+0x15D8]+0x40. +## 20.5 Singleton State Layout +FPSModule singleton base address: [.data+0x22E0] (VA 0x1803C72E0). Object size: 0xD8 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3AFAC0 after init) ++0x08 std::string name = "FPS Monitor" ([.data+0x22E8]..[.data+0x2307]) ++0x28 BYTE enabled (0 = disabled; written at [.data+0x2308]) ++0x30 BYTE show_fps_overlay (checkbox state for "Show FPS Overlay") ++0x60 XMMWORD (overlay window position/size, zeroed on init) +# 21. PreventScreenshot +PreventScreenshot prevents the game window from being captured by screen-recording tools. RTTI: .?AVPreventScreenshot@@ (RVA 0x3C5DA8). GUI label: “Prevent Screenshot” (RVA 0x3B00B8). The module uses the Windows API SetWindowDisplayAffinity (string at .data RVA 0x3C34A6, imported dynamically from user32.dll at RVA 0x3AEC70) with a Windows 10 build check before applying the affinity flag. +## 21.1 Registration and Vtable +Singleton pointer cached at [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. Once_flag at [.data+0x2390]. Two boolean state fields: [.data+0x2380] = enabled (BYTE, 0 on init), [.data+0x2388] = second toggle flag (BYTE, 0 on init). +## 21.2 Initialize (RVA 0x8AD70) +Guarded by a once_flag at [.data+0x2390]. On first call: constructs the std::string name “Prevent Screenshot” at [.data+0x2360], stores base vtable ptr 0x3AFA38 at [.data+0x2358], overwrites with second vtable ptr from 0x3B0110, zeroes both bool fields at [.data+0x2380] and [.data+0x2388]. +## 21.3 RenderOverlay (RVA 0x8AE60) +Calls GetInstance (0x8AD70) to obtain the module pointer. Renders a single ImGui checkbox “Prevent Screenshot” via 0x9D7D0 (toggle-checkbox helper) with state pointer [module+0x28] (enabled bool). The result is passed to 0x61FE0 (ImGui::Checkbox state commit), then ImGui::EndDisabled is called via the [ImGuiContext+0x27F0] WORD counter path (with an assertion for “Calling EndDisabled() too many times!” at 0x3AC160 if the counter is already zero). +## 21.4 Update — SetWindowDisplayAffinity Dispatch (RVA 0x8AFC0) +Called per-frame by ModuleManager::Update. The logic is: +1. Call GetInstance (0x8AD70) -> rbp = module object ptr +2. If [rbp+0x30] already set: skip (module not yet enabled) +3. If [rbp+0x28] (enabled) set: walk the hook/window list at [.data+0x24D0] +4. For each node [rbx+0x10]: call 0x8B220 (OS-version-checked affinity setter) +5. Call 0x81B00 (build HWND list), then 0x869A0 (apply affinity to all HWNDs) +## 21.5 OS Version Check and SetWindowDisplayAffinity (RVA 0x8B220) +This function loads ntdll.dll (via IAT[0x1800B1290]), resolves “RtlGetVersion” (IAT[0x1800B1088]), and fills a 0x11C-byte OSVERSIONINFOEXW struct on the stack. The OS build number (OSVERSIONINFOEXW.dwBuildNumber) is then cached at [.data+0x24FC] after being memcpy’d into [.data+0x24F0]. On subsequent calls, the cached value is used directly. +The affinity call at 0x8B48F reads [rbp+0x28] (enabled bool) and compares the cached build number against 0x4A61 (decimal 19041, Windows 10 Build 19041 = version 20H1). Two code paths result: +build < 19041: affinity arg = (enabled ? 1 : 0) (WDA_MONITOR = 1) +build >= 19041: affinity arg = (enabled ? 0x11 : 0) (WDA_EXCLUDEFROMCAPTURE = 0x11) +The resolved SetWindowDisplayAffinity function pointer is called via IAT[0x1800B1460]. On pre-20H1 builds, WDA_MONITOR (0x1) is used, which prevents the window from appearing in screen captures taken via the PrintScreen key but not via capture APIs. On 20H1 and later, WDA_EXCLUDEFROMCAPTURE (0x11) is used, which prevents capture by all recording tools including OBS and the Windows Game Bar. The “SetWindowDisplayAffinity” string stored at .data RVA 0x3C34A6 is used as the GetProcAddress argument for the dynamic resolve. +## 21.6 Singleton State Layout +PreventScreenshot singleton base: [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3B0110 after init) ++0x08 std::string name = "Prevent Screenshot" ([.data+0x2360]..[.data+0x237F]) ++0x28 BYTE enabled (checkbox state; drives affinity arg) ++0x30 BYTE state_dirty (set=1 when affinity has been applied; guards re-apply) ++0x38 BYTE second_flag ([.data+0x2388]; purpose unclear, zeroed on init) +The HWND target list at [.data+0x24D0] is a doubly-linked list of window handles to which the affinity is applied. The list is populated by 0x81B00 (enumerate Unity windows) and walked by the Update loop. The count of registered HWNDs is tracked at [.data+0x24D8]. +# 22. ESPModule Render and Update Implementation +Chapter 9 established ESPModule’s state layout and color-table defaults. This chapter documents the two remaining vtable slots not covered there: RenderOverlay (the ImGui control panel) and Update (the per-frame world-space entity label loop), both of which were only identified during the current analysis pass. +## 22.1 RenderOverlay (RVA 0x83FA0) +RenderOverlay is a large, monolithic function spanning roughly 0x83FA0–0x8499E. It draws the “ESP Features” collapsing header and all subordinate controls using the same once-lock + ImGui state machine pattern documented in FPSModule (Chapter 20). The function uses rsi throughout as the ESPModule singleton pointer (base VA 0x1803C6F70). +The function opens a CollapsingHeader titled “ESP Features” (string RVA 0x3AF838) via helper 0x9D7D0 with its state bound to [.data+0x27B0]. If collapsed, execution jumps directly to the epilogue. When expanded, the first control rendered is an “ON / OFF” checkbox (string RVA 0x3AF848) via helper 0x85320; its bool is bound to [rsi+0x28] (enabled). If enabled is false, the remainder of the panel still renders but ImGui’s BeginDisabled path dims and suppresses all interaction. +The “Display Types” sub-header (string RVA 0x3AF858) is rendered via 0x6EC20, which is a lightweight CollapsingHeader wrapper that returns false immediately when ImGui’s locked-input flag ([ImGuiContext+0x106]) is set. When expanded, it presents four entity visibility checkboxes, each bound via 0x61FE0 (ImGui::Checkbox commit helper): +“Show Monsters” (RVA 0x3AF868) → [rsi+0x34] show_monsters +“Show NPC” (RVA 0x3AF878) → [rsi+0x35] show_npc +“Show Friendly” (RVA 0x3AF888) → [rsi+0x36] show_friendly +“Show Puzzles” (RVA 0x3AF898) → [rsi+0x37] show_puzzles +“Show All” (RVA 0x3AF8A8) → [rsi+0x38] show_all +After the Show All checkbox, a Separator is emitted via 0x70630 (which also adjusts the cursor Y position). A second sub-header, “Display Info” (RVA 0x3AF8B8), follows the same 0x6EC20 pattern. When expanded, it reveals the per-label visibility checkboxes: +“Show Distance” (RVA 0x3AF8C8) → [rsi+0x39] show_distance +“Show Name” (RVA 0x3AF8D8) → [rsi+0x3A] show_name +“Show Type” (RVA 0x3AF8E8) → [rsi+0x3C] show_type +A second Separator call via 0x70630 closes the Display Info block. The function epilogue at 0x84984–0x8499E restores the ImGui cursor Y, pops the saved XMM registers, and returns. +## 22.2 Update / DrawOverlay (RVA 0x84A00) +Update is the per-frame entity rendering loop. It is guarded at entry (0x8499F) by a two-instruction stub that tests [rcx+0x28] (enabled) and returns immediately if clear, so the entire loop is skipped when the module is disabled. The main body at 0x84A00 proceeds as follows. +Initialization: the function calls the GetEntityManager cached pointer ([.data+0x1D28], xor ecx, ecx) and GetEntityList ([.data+0x1D30]), both resolved by GABypass. It also calls GetScreenResolution ([.data+0x1D18]) into a local {float2, int} struct, and GetCameraPosition ([.data+0x1D00]) to build a world-origin vector. If the entity count at [rax+0x20] is zero, execution jumps to the epilogue at 0x852AB. +Per-entity loop (0x84B30–0x852A5): for each entity pointer in the array, the function calls GetEntityType ([.data+0x1D20], xor edx edx) and dispatches on the returned type code. The dispatch also loads the per-type color XMMWORD directly from the ESPModule object at a type-dependent offset, and selects the corresponding visibility-flag byte: +type 0x08 → color [rdi+0x70] GREEN (0.00, 1.00, 0.00) flag: show_friendly [rdi+0x36] +type 0x10 / 0x4010 → color [rdi+0x40] RED (1.00, 0.00, 0.00) flag: show_monsters [rdi+0x34] +type 0x20 → color [rdi+0x50] ORANGE (1.00, 0.65, 0.00) flag: show_puzzles [rdi+0x37] +type 0x100 → color [rdi+0x80] BLUE (0.00, 0.00, 1.00) flag: show_npc [rdi+0x35] +default → color [rdi+0xB0] WHITE (1.00, 1.00, 1.00) flag: show_all [rdi+0x38] +Visibility gating: for named types the check is (show_all OR type_flag) != 0; for the default case only show_all is tested. If the entity fails the gate, execution jumps to the loop increment at 0x85289. +Screen-space projection: GetScreenPosition ([.data+0x1CF8]) is called with the entity world position and camera origin to produce a {float2, float} screen-coord struct. The resulting screen-space depth is compared against the module’s max_draw_distance field ([rdi+0x30], default 300); entities beyond that distance are culled at 0x84C6B. +Label assembly: a temporary std::string is built on the stack (0x84CB0). If show_distance ([rdi+0x39]) is set, the metric distance is formatted as an integer via 0x7F5C0 and prepended with the distance marker string “m” (RVA 0x3AF8F4). If show_name ([rdi+0x3A]) is set, GetEntityName ([.data+0x1CE0]) is called and the result is appended; if show_type ([rdi+0x3C]) is set, the entity type code is looked up against a six-entry table at RVA 0x3AF908 / 0x3AF920 mapping type values to name string pairs: +0xFFFFFFFF → “All” +0x00000001 → “Invalid” +0x00000008 → “Character” +0x00000010 → “Enemy” +0x00000020 → “Interactive” +0x00000040 → “Projectile” +If multiple label fields are enabled, segments are joined by “ | ” (RVA 0x3AF900). The assembled label string is then submitted to the ImGui foreground draw list via 0x49820, which positions the text at the projected screen coordinate with a small pixel offset (loaded from RVA 0x3B3224), using the type-selected RGBA color. The foreground draw list is accessed through the “##Foreground” window (RVA 0x3ABF10) as documented in FPSModule. The font for the label is pushed/popped around the call via 0x28C00 and 0x28D70 (BeginFontScope / EndFontScope wrappers). +Loop increment: rbx (entity index) is incremented at 0x85289, r15 advances by 8 bytes through the entity pointer array, and the loop repeats from 0x84B30 until rbx reaches the entity count. On exit the stack cookie is verified and the function returns. +## 22.3 ESPModule Singleton State Layout (Complete) +The following table merges the fields identified in Chapter 9 with the RenderOverlay and Update findings above. Base address: [.data+0x1F70] (VA 0x1803C6F70). All booleans are BYTE; all color slots are XMMWORD (16-byte RGBA float4). +Offset +.data addr +Type +Field / Init Value ++0x00 +[.data+0x1F70] +QWORD +vtable ptr (0x3AFA38 before init; 0x3AF9E0 after) ++0x08 +[.data+0x1F78] +std::string +name = 'ESPModule' (RVA 0x3AF828) ++0x28 +[.data+0x1F98] +BYTE +enabled = 0 ++0x30 +[.data+0x1FA0] +DWORD +max_draw_distance = 300 (0x12C) ++0x34 +[.data+0x1FA4] +BYTE +show_monsters = 1 ++0x35 +[.data+0x1FA5] +BYTE +show_npc = 1 ++0x36 +[.data+0x1FA6] +BYTE +show_friendly = 1 ++0x37 +[.data+0x1FA7] +BYTE +show_puzzles = 1 ++0x38 +[.data+0x1FA8] +BYTE +show_all = 0 ++0x39 +[.data+0x1FA9] +BYTE +show_distance = 1 ++0x3A +[.data+0x1FAA] +BYTE +show_name = 1 ++0x3B +[.data+0x1FAB] +BYTE +reserved = 0 ++0x3C +[.data+0x1FAC] +BYTE +show_type = 0 ++0x40 +[.data+0x1FB0] +XMMWORD +color_enemy RED (1.00, 0.00, 0.00, 1.00) ++0x50 +[.data+0x1FC0] +XMMWORD +color_interactive ORANGE (1.00, 0.65, 0.00, 1.00) ++0x60 +[.data+0x1FD0] +XMMWORD +color_slot2 YELLOW (1.00, 1.00, 0.00, 1.00) ++0x70 +[.data+0x1FE0] +XMMWORD +color_friendly GREEN (0.00, 1.00, 0.00, 1.00) ++0x80 +[.data+0x1FF0] +XMMWORD +color_npc BLUE (0.00, 0.00, 1.00, 1.00) ++0x90 +[.data+0x2000] +XMMWORD +color_slot5 CYAN (0.00, 1.00, 1.00, 1.00) ++0xA0 +[.data+0x2010] +XMMWORD +color_slot6 PURPLE (0.58, 0.00, 0.83, 1.00) ++0xB0 +[.data+0x2020] +XMMWORD +color_default WHITE (1.00, 1.00, 1.00, 1.00) ++0xC0 +[.data+0x2030] +XMMWORD +color_slot8 PINK (1.00, 0.08, 0.58, 1.00) ++0xD0 +[.data+0x2040] +XMMWORD +color_slot9 LPINK (1.00, 0.75, 0.80, 1.00) +Color slots 2, 5, 6, 8, and 9 are not assigned to any type code in the Update dispatch and are therefore spare palette entries; they are exposed in the ImGui color-picker widgets but have no current runtime effect on the overlay. +# 23. DamageHack — Ghost Feature Analysis +The i18n table (RVA 0x3B1484) contains four keys with no corresponding RTTI class, vtable, registrar lambda, registered singleton, or callable code anywhere in the binary: “Damagehack Toggle”, “Damage Multiplier”, “Multiplier Value”, and “Random Damage Type”. This chapter documents what can be determined from the available evidence and establishes what is definitively absent. +## 23.1 i18n Evidence +The four DamageHack keys appear as a contiguous block in the JSON i18n blob immediately after the “Version: ” key and immediately before “This is free, if you spend money, then you have been deceived”. Each key carries English and Simplified Chinese translations: +“Damagehack Toggle” en / zh_cn: 伤害修改 (Damage Modification) +“Damage Multiplier” en / zh_cn: 伤害倍数 (Damage Multiplier) +“Multiplier Value” en / zh_cn: 倍数値 (Multiplier Value) +“Random Damage Type” en / zh_cn: 随机伤害类型 (Random Damage Type) +The Chinese translations are idiomatic and consistent with the translations for implemented features in the same blob, indicating they were written at the same time as the rest of the localisation table. The four keys fit the pattern of a planned ImGui panel: one boolean toggle, one float multiplier, a numeric input for the multiplier value, and an enum selector for damage type randomization. +## 23.2 What Is Absent +A complete binary search for any string containing “Damage”, “damage”, “DamageHack”, or “damagehack” outside the JSON blob returns zero results. The RTTI scan of the .data section (RVA 0x3C5000–0x3C8000) identifies exactly 11 cheat-module class names — ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule — and no DamageHack entry. Similarly, the registrar-lambda RTTI list contains no DamageHack entry. There is no singleton pointer, no once_flag guard, no vtable, and no callable RenderOverlay or Update function anywhere in the image. +## 23.3 Interpretation +DamageHack was planned but never implemented in this build. The i18n keys were added to the localisation file during feature planning or alongside a partial implementation that was subsequently stripped, but no code corresponding to those keys was ever compiled into the binary. This is consistent with the developer shipping the localisation blob as a whole-file asset while selectively excluding unfinished module source files from the build. +The intended design, inferred from the four i18n keys, would have been: a boolean master toggle (“Damagehack Toggle”) gating an intercepted damage-calculation call, a float multiplier applied to the outgoing damage value (“Damage Multiplier” / “Multiplier Value”), and an enum-driven randomisation mode for the damage type field (“Random Damage Type”). The implementation would most likely have operated as an IL2CPP function hook resolved via GABypass, consistent with how SkillHack intercepts cooldown and cost values. +From a detection standpoint, the ghost i18n keys are a useful indicator: any version of this cheat that activates DamageHack controls would be a different build from the one analysed here. The presence of these keys in an extracted string dump of a suspect binary is therefore a build-version discriminator, not evidence of active functionality. +# 25. Sidebar / Main Panel Render (RVA 0x7F8F0) +The top-level overlay panel is rendered by the function at RVA 0x7F8F0 (VA 0x18007F8F0). This function draws the outer “Sidebar” ImGui window that contains all module tab buttons and the About page. It is called from the ModuleManager render loop on every Present() frame and is responsible for the entire visible cheat UI chrome. +## 25.1 Function Signature and Layout +Entry point: RVA 0x7F8F0, approximately 0x146E bytes (tail-calls into ImGui epilogue at 0x180023E20 via jmp at 0x180080D5E). The function allocates a 0x380-byte stack frame, saves xmm6–xmm8, and takes a single rcx argument (ModuleManager / global context pointer). Key address references: +Window title: "Sidebar" (RVA 0x3AF2C8) — used as module lookup key (CRC32 via 0x180011DF0, registry lookup via 0x18003D1A0 and 0x18001D2B0); ImGui::Begin is not called from within 0x7F8F0 itself +Banner string: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) +Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) +Active tab idx: [.data+0x1F68] (VA 0x1803C6F68; written on click, read by jump table at 0x80B52) +## 25.2 Tab Navigation and Rendering +The sidebar renders six tab buttons. Each label is looked up from the i18n table via 0x18009D660 (the same translation dispatcher used by all modules). The six tabs, their label RVAs, and the jump-table case bodies dispatched on selection are: +Tab 0: "About" (RVA 0x3AF2D0) — sidebar header (banner + disclaimer) + About body sub-function (0x80E80) +Tab 1: "Player" (RVA 0x3AF2DC) — NoClip, SkillHack (movement/skill controls) +Tab 2: "ESP" (RVA 0x3AF2E8) — ESPModule overlay features +Tab 3: "World" (RVA 0x3AF2F0) — Vacuum (world/item interaction) +Tab 4: "Visual" (RVA 0x3AF2FC) — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +Tab 5: "Settings" (RVA 0x3ADFD8) — Theme/preset selection via 0x18009A4F0 (language, color theme) +The banner string (RVA 0x3AF258) and anti-scam disclaimer (RVA 0x3AF288) are rendered as a Sidebar-level header before the tab bar. Each of the six tab buttons is rendered by calling 0x80D80 (click-state handler, returns bool); if a tab is clicked its index (0–5) is written to [.data+0x1F68] (VA 0x1803C6F68). After all tab buttons are rendered, a jump table at RVA 0x80B52 reads [.data+0x1F68], bounds-checks against 5, and dispatches to the corresponding case via [0x180000000 + rax*4 + 0x80D64]. Case 0 calls sub-function 0x80E80 (About body: game title, version, author). Cases 1–4 call module-getter helpers that return the relevant singleton pointer, then invoke vtable[0x28] (RenderOverlay) for each. Case 5 delegates to 0x18009A4F0 (Settings/Theme renderer). +## 25.3 Author and Version Display +The About tab body is rendered by sub-function 0x80E80. It displays game context via the format string “%s Game: Endfield CTB3” (RVA 0x3AF350), the version label “Version: ” (RVA 0x3AF368) with value “1.0.0” (RVA 0x3AF374), and the author label “Author: ” (RVA 0x3AF380) with value “gktwo” (RVA 0x3AF38C). These are direct string literals, not i18n-dispatched keys. +## 25.4 Key Address Summary +RVA 0x7F8F0 Sidebar::RenderMainPanel (this chapter) +RVA 0x3AF258 Banner string +RVA 0x3AF288 Anti-scam disclaimer +RVA 0x3AF2C8 "Sidebar" window title +.data+0x1F68 Active tab index (VA 0x1803C6F68; written per-click, dispatched at jump table 0x80B52) +# 26. Language Selector (Sidebar Unconditional Panel) +The sidebar function (0x7F8F0) renders a language-selection sub-panel unconditionally on every frame, before the jump-table dispatch for tab bodies. The panel appears at VA range 0x180080770–0x180080B50 and is part of the sidebar’s Settings section rather than any individual tab body. +## 26.1 String Inventory +RVA 0x3AF310 "English" — first Combo item (index 0) +RVA 0x3AF318 "简体中文" — second Combo item (index 1) +RVA 0x3AF328 " Language" — tab label (5-space indent, 0xD chars) +RVA 0x3AF338 "##Language" — ImGui::Combo widget ID +## 26.2 Execution Flow +The language selector logic follows this sequence: +0x180080895 call 0x18009D660 — locale context init +0x1800808DD lea rsi,[...] # 0x1803AF310 — "English" item ptr +0x1800808E3 lea rbx,[...] # 0x1803AF318 — "简体中文" item ptr +0x1800809A1 lea rdx,[...] # 0x1803AF328 — tab label " Language" +0x1800809C6 call 0x18009D7D0 — BeginTab (render label) +0x180080A03 call 0x180064220 — ImGui::Combo (language dropdown) +al = 1 if selection changed, 0 otherwise +if English selected: +0x180080A2F mov DWORD PTR [0x1803C77B0], r12d — store 0 (language index = English) +if 简体中文 selected: +0x180080A5D mov DWORD PTR [0x1803C77B0], 0x1 — store 1 (language index = ZH-CN) +0x180080A6E call 0x18002A530 — i18n content refresh (reload translations) +0x180080A73 dec DWORD PTR [g_Config+0x2764] — decrement content ref-count +0x180080A80 mov rax,[g_Config+0x15D8] — get active config preset ptr +0x180080A87 mov BYTE PTR [rax+0x103], 0x1 — set dirty flag for config save +0x180080B0B lea rcx,[...] # 0x1803ADFC8 "Content" — module key +0x180080B12 call 0x180011DF0 — CRC32 lookup on "Content" module +0x180080B33 call 0x18003D1A0 — registry lookup +0x180080B4D call 0x18001D2B0 — module notify/update +## 26.3 Language Index State +VA 0x1803C77B0 language_index (DWORD) +0 = English +1 = 简体中文 (Simplified Chinese) +On language change, three things happen: the i18n content is refreshed via 0x18002A530, a config-preset dirty bit is set at [g_Config+0x15D8+0x103], and the “Content” module is notified via the standard CRC32/registry/notify triple (0x180011DF0, 0x18003D1A0, 0x18001D2B0). Two languages are supported in this build: English (default) and Simplified Chinese. +# 27. FreeCam Key Binding Display Panel (RVA 0x87A70–0x88606) +The documented FreeCam::Update function (RVA 0x871A0, see Ch.12.3) is 0x14C6 bytes long and includes a key-binding display section beginning at approximately 0x87A70 that was not previously described. This section renders four float-value sliders and eleven key-binding label rows using ImGui. +## 27.1 Float Sliders +Four consecutive DragFloat/SliderFloat controls appear before the key-binding rows, all using the ImGui slider variant at 0x180065570: +RVA 0x3AFCB0 "Free Camera" — sub-panel BeginTab label +RVA 0x3AF848 "ON / OFF" — toggle checkbox +RVA 0x3AFCC0 "Move Speed" — DragFloat, fmt "%.3f" (0x3ADFB0) +RVA 0x3AFCD0 "Look Sensitivity" — DragFloat, fmt "%.3f" +RVA 0x3AFCE8 "Roll Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFCF8 "FOV Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFD04 "FOV" — DragFloat, fmt "%.1f" (0x3ADFEC) +## 27.2 Key Binding Label Rows +Eleven key-binding rows follow. Each row: (1) calls 0x18000FCB0 (MakeString) to format the label via 0x18005FB60 (sprintf-style, substituting the key name), (2) calls 0x18009D7D0 to render the resulting string as a tab-style label. Unbound keys display “NONE” (RVA 0x3AF820). +RVA 0x3AFD08 "Forward Key: %s" — VA 0x180087A87 +RVA 0x3AFD18 "Backward Key: %s" — VA 0x180087B1A (approx) +RVA 0x3AFD30 "Left Key: %s" +RVA 0x3AFD40 "Right Key: %s" +RVA 0x3AFD50 "Up Key: %s" +RVA 0x3AFD60 "Down Key: %s" +RVA 0x3AFD70 "IncFOV Key: %s" +RVA 0x3AFD80 "DecFOV Key: %s" +RVA 0x3AFD90 "LeftRoll Key: %s" +RVA 0x3AFDA8 "RightRoll Key: %s" +RVA 0x3AFDC0 "ResetRoll Key: %s" +RVA 0x3AF820 "NONE" — displayed for any unbound key +## 27.3 Dispatch Pattern +Each key row uses the same three-call sequence: MakeString (0x18000FCB0) to build the “Key Name: %s” format string, 0x18005FB60 to sprintf the current key name into it, and 0x18009D7D0 to render the result. The key name state block is at [rip+...] # 0x1803C6E98 (the “Pu;” RTTI sentinel in .data indicates the key-binding state array). This panel is visually shown as a collapsible key-rebinding display inside the FreeCam tab when enabled. +# 28. Settings Tab — Theme Selector and Console Toggle (RVA 0x9A4F0) +The Settings tab body function at RVA 0x18009A4F0 (source: SettingsTAB.cpp, RVA 0x3B0B30) renders a theme selector and a console toggle. It is called from sidebar case 5 (0x80D25). The function ends at approximately RVA 0x9AB31. +## 28.1 Theme Selector +A “Theme” combo-box (“Theme” at RVA 0x3B0AD4, rendered via ImGui::Combo at 0x180064220) presents four themes. Selecting a theme calls the corresponding palette-applicator function, which writes RRGGBBAA hex color strings from .rdata into the active ImGui color table. +Theme name strings: +RVA 0x3B0AF8 "Default" — applicator: RVA 0x941F0 (restores ImGui defaults) +RVA 0x3B06D0 "Evangelion Unit 01" — applicator: RVA 0x94890 +RVA 0x3B0AE0 "Evangelion Unit 02" — applicator: RVA 0x96770 +RVA 0x3B0B10 "Matrix" — applicator: RVA 0x98650 +## 28.2 Palette Color Tables +Each non-default theme applicator reads RRGGBBAA hex strings from .rdata and applies them to ImGui style slots. The colors below are listed in the order each applicator writes them (11 colors for Evangelion themes, 10 for Matrix): +Evangelion Unit 01 (RVA 0x94890): +0x3B06F8 #FFFFFFFF 0x3B06E8 #7857A7FF 0x3B0718 #19171CFF +0x3B0708 #2A282EFF 0x3B0738 #2A282EE6 0x3B0728 #4DE6A5FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B0778 #A38CCF80 +0x3B0768 #7857A780 0x3B0798 #4A4552FF +Evangelion Unit 02 (RVA 0x96770): +0x3B06F8 #FFFFFFFF 0x3B0898 #D9293BFF 0x3B0888 #1E1E1EFF +0x3B08B8 #3A3A3AFF 0x3B08A8 #3A3A3AE6 0x3B08D8 #F7B302FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B08C8 #F7465880 +0x3B08F8 #D9293B80 0x3B0798 #4A4552FF +Matrix (RVA 0x98650): +0x3B09B8 #00FF41FF 0x3B09A8 #00AA2CFF 0x3B09D8 #000000FF +0x3B09C8 #0A0A0AFF 0x3B09F8 #0A0A0AE6 0x3B09E8 #004400FF +0x3B0758 #00000000 0x3B0A18 #00440040 0x3B0A08 #00881EFF +0x3B0A38 #00FF4180 +## 28.2.1 Per-Slot Color Applicator Helper (RVA 0x94190) +Each individual color push in the three non-default theme applicators (0x94890, 0x96770, 0x98650) is performed by a shared helper at RVA 0x94190. This function reads an RRGGBBAA hex string from .rdata using __stdio_common_vsscanf (IAT[0xB1880]), converts it to a packed RGBA value, then calls ImGui::PushStyleColor (via 0x180010840) with the target style-slot index and the parsed colour. It is called 159 times across the four writer functions (52 times from 0x94890 alone, corresponding to the full 52-slot Default palette). +## 28.3 Console Toggle +After the theme selector, the function renders a “Toggle Console” checkbox (RVA 0x3B0B00) using CheckboxToggle (0x180085320). The console state is read and displayed via two branches: +RVA 0x3B0B00 "Toggle Console" — checkbox label +if console enabled: display format "Console {}" (RVA 0x3B0B78) +using IAT AllocConsole (0x1800B1178) / GetStdHandle (0x1800B1628) +if console disabled: display "enabled" (RVA 0x3B0B28) +or "Disabled" (RVA 0x3B0B18) +## 28.4 Key Address Summary +RVA 0x9A4F0 SettingsTab::Render (this chapter) +RVA 0x941F0 Default palette applicator +RVA 0x94890 Evangelion Unit 01 palette applicator +RVA 0x96770 Evangelion Unit 02 palette applicator +RVA 0x98650 Matrix palette applicator +RVA 0x3B0AD4 "Theme" combo label +RVA 0x3B0B30 E:\git\Endfield_Cheeto\...\SettingsTAB.cpp +# 29. Win32/D3D11 Overlay Window Initialisation (RVA 0x827A0–0x8375C) +The overlay window subsystem is a single large function at 0x827A0 (called from the startup function 0xA9190 at 0xA9585) with two sub-functions: FindGameWindow (0x835D0) and GetOverlayRect (0x836A0). It creates the transparent layered Win32 window, initialises a D3D11 device and swap chain, runs the Win32 message loop, and keeps the overlay aligned to the game window. Ch. 7 documents the WndProc at 0x826A0 (the window procedure registered by this subsystem); Ch. 15.5 documents the Present hook call site at 0x82F00 which lies inside the message loop body. +## 29.1 DPI Awareness Initialisation (0x827FF–0x82923) +The function opens with a TLS-guarded once_flag block before performing DPI setup. Two DPI APIs are tried in priority order. First, LoadLibraryA(‘user32.dll’) is called (via IAT[0xB10E0]) and GetProcAddress is used to locate SetThreadDpiAwarenessContext; if found, it is called with context value 0xFFFFFFFFFFFFFFFC (DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2). If that fails, LoadLibraryA(‘shcore.dll’) and GetProcAddress resolve SetProcessDpiAwareness, which is then called with value 2 (PROCESS_PER_MONITOR_DPI_AWARE). If both dynamic lookups fail, the fallback is SetProcessDPIAware (IAT[0xB15A0]), a legacy API that sets system-DPI awareness. The guard at [.data+0x3C7440] / [.data+0x3C7448] ensures each path runs at most once. +## 29.2 Game Window Location and Window Class Registration (0x82924–0x82A28) +EnumWindows (IAT[0xB14A0]) is called with FindGameWindow (0x835D0) as the callback to locate the Unity game window. A WNDCLASSEX structure is then populated: CreateSolidBrush(0x7F00) (IAT[0xB1018]) sets the background brush to an opaque olive colour used only as a placeholder; LoadCursorW (IAT[0xB15C8]) provides the standard arrow cursor; two LoadIconW calls (IAT[0xB14E8]) load the small and large application icons. RegisterClassExW (IAT[0xB1638]) registers the class. GetSystemMetrics (IAT[0xB14E0]) is called twice to retrieve the full screen width (SM_CXSCREEN) and height (SM_CYSCREEN) for the initial window geometry. +## 29.3 Overlay Window and D3D11 Device Creation (0x82A29–0x82BFF) +CreateWindowExW (IAT[0xB1650]) creates the overlay window with WS_EX_LAYERED | WS_EX_TRANSPARENT style flags so it passes mouse input through to the game beneath it. SetLayeredWindowAttributes (IAT[0xB15E0]) sets the colour key and alpha. DwmExtendFrameIntoClientArea (IAT[0xB1918]) extends the DWM glass frame into the entire client area, which together with the layered attributes produces a fully transparent background. D3D11CreateDeviceAndSwapChain (IAT[0xB1908]) is called twice: the first call at 0x82B24 attempts D3D_FEATURE_LEVEL_11_0 with DXGI_FORMAT_R8G8B8A8_UNORM; on failure the second call at 0x82B7E retries with a DXGI_FORMAT_B8G8R8A8_UNORM swap chain as a fallback. After a successful device create, the compiled shader objects from Ch. 5 are bound. The helper 0x825B0 (called at 0x82B8C; documented in Ch. 7 as D3D11::Reinit) sets up the ImGui D3D11 backend. ShowWindow (IAT[0xB1628]) and UpdateWindow (IAT[0xB14D8]) make the window visible. CreateMutexA (IAT[0xB1720]) at 0x82C0D creates a named mutex to prevent duplicate overlay instances. +## 29.4 Initialisation Log and Message Loop (0x82C01–0x8352F) +Before entering the loop, the string ‘Initialized’ (RVA 0x3AF610) is logged at 0x82F5F from source file E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp. The main loop uses the standard Win32 pattern: PeekMessageW (IAT[0xB14D0]) / TranslateMessage (IAT[0xB14C8]) / DispatchMessageW (IAT[0xB14C0]). Each iteration calls FindWindowA(‘UnityWndClass’, NULL) (IAT[0xB14A8] called at 0x8301F) to verify the game process is still running; if the window disappears the loop exits. IsWindow (IAT[0xB1468]) validates the game HWND, GetWindowThreadProcessId (IAT[0xB1498]) retrieves its thread, and GetWindowRect (IAT[0xB1488]) reads its current bounds. SetWindowPos (IAT[0xB1588]) repositions the overlay to match the game window on every frame. GetForegroundWindow (IAT[0xB15F0]) and three GetClassNameA calls (IAT[0xB1490]) detect whether the game is the active foreground window and adjust the overlay visibility state via two SetWindowLongW calls (IAT[0xB15B0]). SwitchToThread (IAT[0xB1148]) at 0x8348A yields the CPU when the game is not in focus. On loop exit, DestroyWindow (IAT[0xB1570]) and UnregisterClassW (IAT[0xB1640]) clean up the overlay window and class. +## 29.5 FindGameWindow Callback (RVA 0x835D0) +This function is passed as the lpEnumFunc callback to EnumWindows. For each top-level window it calls GetWindowThreadProcessId (IAT[0xB1498]) and GetClassNameA (IAT[0xB1490]), then compares the class name against the literal string ‘UnityWndClass’ (RVA 0x3AF658) using the internal string-compare helper at 0xACA12. On a match it calls SetForegroundWindow (IAT[0xB1518]) to bring the game to the front, records the HWND, and then calls GetOverlayRect (0x836A0) to capture the initial window geometry. A second GetWindowThreadProcessId and AttachThreadInput call at 0x8368E synchronise the overlay thread’s input queue with the game thread. +## 29.6 GetOverlayRect (RVA 0x836A0) +Called by FindGameWindow and on every frame to compute the overlay rectangle. IsWindowVisible (IAT[0xB1480]) and IsIconic (IAT[0xB1510]) first check that the game window is visible and not minimised. DwmGetWindowAttribute (IAT[0xB1920]) with DWMWA_EXTENDED_FRAME_BOUNDS retrieves the DWM-adjusted window bounds (which exclude the invisible resize borders). GetClientRect (IAT[0xB15A8]) provides the inner client area. Two GetWindowLongPtrW calls (IAT[0xB1470]) read GWL_STYLE and GWL_EXSTYLE to account for window border widths. The function returns the final overlay RECT which SetWindowPos uses to position the overlay exactly over the game viewport. +## 29.7 Key Address Table +RVA 0x827A0 WinInit top-level entry (called from 0xA9585) +RVA 0x827FF DPI init block TLS-guarded; tries SetThreadDpiAwarenessContext then SetProcessDpiAwareness +RVA 0x82924 EnumWindows find game HWND via FindGameWindow callback +RVA 0x8298B RegisterClassExW overlay window class registration +RVA 0x82A29 CreateWindowExW WS_EX_LAYERED overlay window +RVA 0x82A60 DwmExtendFrameIntoClientArea full transparent client area +RVA 0x82B24 D3D11CreateDeviceAndSwapChain primary attempt (DXGI_FORMAT_R8G8B8A8_UNORM) +RVA 0x82B7E D3D11CreateDeviceAndSwapChain fallback (DXGI_FORMAT_B8G8R8A8_UNORM) +RVA 0x82C0D CreateMutexA single-instance guard mutex +RVA 0x82F5F ‘Initialized’ log source: UI.cpp; emitted after device creation succeeds +RVA 0x82F00 Present hook site documented in Ch. 15.5 +RVA 0x8348A SwitchToThread yields when game is not in foreground +RVA 0x835D0 FindGameWindow EnumWindows callback; locates ‘UnityWndClass’ HWND +RVA 0x836A0 GetOverlayRect DwmGetWindowAttribute + GetClientRect; returns overlay RECT +RVA 0x826A0 WndProc documented in Ch. 7 +# 24. Final Analysis Summary +EF-Cheeto.dll (internal name, distributed as unityexplorer.dll) is a fully-featured Unity game cheat module for an IL2CPP-based game. The complete analysis across twenty-five chapters reveals the following architecture: +Infrastructure Layer: D3D11 Present hook for overlay rendering, Win32 WndProc subclass for hotkeys, Toolhelp32 thread enumeration for safe code patching, MSVC-standard stack cookie security (no active anti-debug), D3DCompile for ImGui shaders, and _wfopen-based config persistence using nlohmann/json serialization. +Hook Engine: Custom hook manager with FNV-1a hash table, trampoline allocation via VirtualAlloc, thread-safe patching via Suspend/Resume, and a 71-entry IL2CPP function pointer bypass table (GABypass). +Cheat Modules (11 registered + 1 ghost): NoClip (CharacterController bypass), SkillHack (cooldown/cost IL2CPP hooks), FreeCam (CinemachineBrain camera override), FpsUnlocker (targetFrameRate), FPSModule (FPS counter overlay; see Ch. 20), SetDither (render setting), PlayerProfile (UI text injection), Vacuum (monster item pull), ESPModule (entity overlay, 10-color table; see Ch. 22), DamageHack (ghost — i18n only, no code; see Ch. 23), PreventScreenshot (registered; SetWindowDisplayAffinity). +Configuration: 172-field g_Config struct at .data+0x1F70, per-version config writers for multiple game versions, auto-save timer at [state+0x2904], ImGui layout persistence via standard ini format. +The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows, targeting IL2CPP Unity games. All twenty-five chapters together constitute a complete static reconstruction of the binary with no significant undocumented regions remaining. diff --git a/IDA/project/docs/input/files/ef_cheeto_feed_2_header.md b/IDA/project/docs/input/files/ef_cheeto_feed_2_header.md new file mode 100644 index 0000000..e09e8a1 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_feed_2_header.md @@ -0,0 +1,2103 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 2/3 +# This part: Reconstruction header with all structs, RVAs, string table, IL2CPP table. +# Feed with Parts 1 and 3 for complete reconstruction context. + +================================================================================ +RECONSTRUCTION HEADER (ef_cheeto_reconstruction.h) +Compiles: g++ -std=c++17 -fsyntax-only +2,092 lines covering 538 RVAs, 97 .data addresses, 189 strings, 75 IAT entries +================================================================================ + +// ============================================================================ +// EF-Cheeto (unityexplorer.dll) — Reconstruction Headers +// Derived from: EF-Cheeto_Vol12_Final_Analysis.docx (complete binary audit) +// Target: x86-64 Windows DLL, MSVC build, GameAssembly.dll (Endfield) +// Base VA: 0x180000000 | .data base: 0x1803C5000 (RVA 0x3C5000) +// ============================================================================ + +#pragma once +#include +#include + +// ============================================================================ +// SECTION 1 — PRIMITIVE TYPEDEFS +// ============================================================================ + +using u8 = uint8_t; +using u16 = uint16_t; +using u32 = uint32_t; +using u64 = uint64_t; +using i32 = int32_t; +using f32 = float; +using f64 = double; +using BOOL = int; // IL2CPP managed bool return (al register) + +// ============================================================================ +// SECTION 2 — GLOBAL .DATA LAYOUT (abridged — key singletons) +// ============================================================================ +// All offsets are RVA from binary base 0x180000000. +// VA = 0x180000000 + RVA. +// .data region starts at RVA 0x3C5000 (VA 0x1803C5000). +// References below use shorthand [.data+N] meaning VA 0x1803C5000 + N. +// +// Key global pointers: +// [.data+0x00D8] g_D3DState ptr (D3D11 device/swap chain block) +// [.data+0x00E0] active_preset_name (std::string — "Preset0".."Preset3") +// [.data+0x00EC] active_preset_index (DWORD — 0-3) +// [.data+0x00F0] gameassembly_base (cached GetModuleHandleW result) +// [.data+0x1E88] hook_spinlock (DWORD — 0=free, 1=held) +// [.data+0x1E90] hook_allocator_ptr (IAllocator for hook_array, capacity 0x80) +// [.data+0x23B8] ModuleManager.registrars_begin +// [.data+0x23C0] ModuleManager.registrars_end +// [.data+0x23C8] ModuleManager.registrars_cap +// [.data+0x2398] ModuleManager object ptr +// [.data+0x23A8] ModuleManager secondary ptr +// [.data+0x23D0] ModuleManager once_flag (std::once_flag) + +// ============================================================================ +// SECTION 3 — g_Config (global config object) +// ============================================================================ +// g_Config is a large global object stored in .data. +// Fields below are offsets FROM the g_Config object base (not from .data base). +// g_Config does not have a single documented base address — it IS .data in +// the relevant regions. Use field VA = 0x1803C5000 + offset where offset +// matches the [.data+N] values from the doc. +// +// PANEL / UI scroll state (used by all module Render() panel-open sequences) +struct GConfigPanelFields { + // offset from g_Config (which sits at .data) + // [g_Config+0x0058] scroll_base (float) — horizontal scroll base offset + // [g_Config+0x00D8] d3d_state_ptr (void*) — D3D11 state block + // [g_Config+0x0150] panel_width (float) — rendered panel content width + // [g_Config+0x0194] scroll_accum (float) — accumulated horizontal scroll + // [g_Config+0x0198] scroll_total (float) — total scroll range + // [g_Config+0x0E0C] scroll_step (float) — per-frame scroll delta + // [g_Config+0x15D8] panel_ptr (void*) — pointer to active ImGui panel struct + // [g_Config+0x1BEC] imgui_ini_fallback (void*) — fallback .ini path ptr + // [g_Config+0x1C00] scroll_region_root (void*) — root of scroll region config + // [g_Config+0x1F68] active_tab_idx (DWORD) — written by binding state array +}; + +// Panel-open sequence (all modules — addss path): +// rax = *panel_ptr; +// rax->field_0x103 = 1; +// xmm0 = scroll_step + rax->scroll_accum + rax->scroll_base + rax->scroll_total; +// rax->panel_width = xmm0; +// Panel-close sequence (subss path): same but scroll_accum -= scroll_step. + +// HOOK SLOTS [g_Config+0x1E40..0x1E68] (SkillHack IL2CPP hook target pointers) +// [g_Config+0x1E40] hook5_target — ApplySkillCost() (void fn) +// [g_Config+0x1E48] hook6_target — (dispatcher target) +// [g_Config+0x1E50] hook3_target — GetCooldownPercent() (float fn) +// [g_Config+0x1E58] hook4_target — IsSkillAvailable() (BOOL fn) +// [g_Config+0x1E60] hook1_target — skill check A (BOOL fn) +// [g_Config+0x1E68] hook2_target — skill check B (BOOL fn) + +// OVERLAY FLAGS (written by UnityExplorer when window is active) +// [g_Config+0x1F78] overlay_flags (DWORD) — |= 1 when UE window open +// [g_Config+0x1F90] overlay_scale (float) — set to 300.0f when UE open + +// ============================================================================ +// SECTION 4 — IL2CPP FUNCTION POINTER TABLE +// ============================================================================ +// GABypass::Patch (RVA 0xA9120) resolves 71 function pointers from +// GameAssembly.dll at DLL attach and writes them to .data slots. +// Format: slot_rva = .data offset from g_base 0x1803C5000 +// Access: fn_ptr = *(void**)(gameassembly_base + il2cpp_offset) +// +// Key: ptr = *(void**)(.data + slot_rva) +// call as: ((RetType(*)(Args...))(ptr))(args...); + +struct IL2CPP_Table { + // Slot .data-offset | IL2CPP offset | Resolved name + void* GameObject_GetComponentByIndex; // 0x1C48 +0x09DC0120 + void* il2cpp_domain_get_assemblies_A; // 0x1C50 +0x0018CEC0 + void* Component_GetComponent_Transform; // 0x1C58 +0x0B390700 + void* Transform_get_localScale; // 0x1C60 +0x0B3A2D20 + void* Transform_get_rotation; // 0x1C68 +0x0B3A2CB0 + void* il2cpp_object_get_class; // 0x1C70 +0x0018AD80 + void* il2cpp_class_get_method_from_name;// 0x1C78 +0x00007480 + void* Transform_get_localPosition; // 0x1C80 +0x0B3A1AE0 + void* Transform_get_position; // 0x1C88 +0x0B3A1A70 [also 0x1DD0] + void* Transform_set_localPosition; // 0x1C90 +0x0B3A51D0 + void* GameObject_SetActive; // 0x1C98 +0x0B398830 [also 0x1DB8] + void* GameObject_get_transform; // 0x1CA0 +0x0B3911F0 + void* Transform_set_rotation; // 0x1CA8 +0x0B3A59D0 [also 0x1DE0] + void* GameObject_get_activeInHierarchy; // 0x1CB0 +0x0B391D90 + void* GameObject_get_tag; // 0x1CB8 +0x0B3B2410 + void* GameObject_get_name; // 0x1CC0 +0x0B3B2120 + void* GameObject_get_layer; // 0x1CC8 +0x0B3B40B0 + void* GameObject_get_scene; // 0x1CD0 +0x0B397980 + void* Game_SkillBuff_A; // 0x1CD8 +0x02F3DA80 (SkillHack) + void* GetEntityName; // 0x1CE0 +0x00F27E10 (ESP label) + void* Component_GetComponents; // 0x1CE8 +0x0B329000 + void* Component_GetComponentsInChildren;// 0x1CF0 +0x0B329D80 + void* Game_SkillSlot_A; // 0x1CF8 +0x03E9BB50 (SkillHack) + void* Object_get_name; // 0x1D00 +0x0B383F60 + void* Component_GetType_A; // 0x1D08 +0x0B33CAB0 + void* Component_GetType_B; // 0x1D10 +0x0B33CB00 + void* Game_SkillSlot_B; // 0x1D18 +0x039D1AA0 (SkillHack) + void* Game_Combat_HitA; // 0x1D20 +0x026DE9F0 + void* GetEntityManager; // 0x1D28 +0x0478E860 (NoClip/FpsUnlocker) + void* Game_Combat_HitB; // 0x1D30 +0x025E2D40 + void* Game_Movement_PhysA; // 0x1D38 +0x087C2CD0 (NoClip CharCtrl) + void* Game_Movement_PhysB; // 0x1D40 +0x03419AF0 (NoClip CharCtrl) + void* Application_set_targetFrameRate; // 0x1D48 +0x0B322FB0 (FpsUnlocker) + void* SceneManager_GetActiveScene; // 0x1D50 +0x0B396A20 + void* CinemachineBrain_GetActiveVCam; // 0x1D58 +0x0B397700 (FreeCam) + void* Game_EntityState_A; // 0x1D60 +0x03766810 (ESP/SkillHack) + void* Transform_set_localScale; // 0x1D68 +0x0B3A2A60 + void* Rigidbody_get_velocity; // 0x1D70 +0x0B326660 (NoClip/Vacuum) + void* Rigidbody_set_velocity; // 0x1D78 +0x0B3266B0 (NoClip/Vacuum) + void* Object_Destroy; // 0x1D80 +0x0B383200 + void* Transform_set_position; // 0x1D88 +0x0B3A1A10 (NoClip/Vacuum) + void* Game_EntityState_B; // 0x1D90 +0x0B3A2340 (ESP) + void* Input_GetAxis_MouseX; // 0x1D98 +0x0B421800 (FreeCam look X) + void* Game_PlayerState_A; // 0x1DA0 +0x0B3A26D0 (ESP/SkillHack) + void* Game_PlayerState_B; // 0x1DA8 +0x0B3A1FB0 (ESP/SkillHack) + void* Game_PlayerHealthStat; // 0x1DB0 +0x0B32B030 (ESP health) + void* Camera_get_main; // 0x1DC0 +0x0B390440 (ESP/FreeCam) + void* GameObject_FindObjectOfType; // 0x1DC8 +0x0B390F80 + void* Game_SkillAction_C; // 0x1DD8 +0x03F85430 (SkillHack) + void* GetDeltaTime; // 0x1D38 +0x087C2CD0 (also FPS overlay) + void* Camera_get_fieldOfView; // 0x1DE8 +0x0B3A1C90 (FreeCam FOV) + void* Game_EntityState_C; // 0x1DF0 +0x00E92CF0 (ESP) + void* Rigidbody_AddForce; // 0x1E00 +0x03DC14C0 (Vacuum) + void* CharCtrl_set_enabled; // 0x1E08 +0x03E0D2C0 (NoClip) + void* Game_SkillAction_F; // 0x1E10 +0x03D9DF30 (SkillHack) + void* Game_SkillAction_G; // 0x1E18 +0x00E9E9F0 (SkillHack) + void* GetCharacterController; // 0x1E20 +0x03EA53C0 (NoClip) + void* TMPro_set_text; // 0x1E28 +0x0ACA0EC0 (PlayerProfile/NameChanger) + void* UnityUI_Text_set_text; // 0x1E30 +0x0B391D40 (ON/OFF labels) + void* Game_SkillAction_I; // 0x1E38 +0x036AA8F0 (SkillHack) + void* Game_SkillAction_J; // 0x1E40 +0x03EC31C0 (SkillHack hook5 target) + void* Game_EntityActor_D; // 0x1E48 +0x037F8CD0 (ESP/combat, hook6 target) + void* Game_SkillAction_K; // 0x1E50 +0x036EA640 (hook3/cooldown target) + void* Game_SkillAction_L; // 0x1E58 +0x03EC30E0 (hook4/avail target) + void* Game_EntityActor_E; // 0x1E60 +0x037F2A40 (hook1 target) + void* Game_EntityActor_F; // 0x1E68 +0x037FD7E0 (hook2 target) + void* il2cpp_domain_get; // 0x1E70 +0x00D94C10 + void* il2cpp_assembly_get_image; // 0x1E78 +0x00D94DA0 + void* il2cpp_domain_get_assemblies_B; // 0x1E80 +0x00D93A60 +}; + +// ============================================================================ +// SECTION 5 — BASE CLASS +// ============================================================================ + +struct BaseModule { + void* vtable; // [+0x00] vtable ptr + // std::string name at [+0x08] (SSO string, 24 bytes total: ptr+len+cap) + char name_sso[24]; // [+0x08] SSO buffer + // std::string tab_name at [+0x20] + char tab_name_sso[24]; // [+0x20] secondary name / tab label (SSO) + u8 enabled; // [+0x28] ON/OFF flag (BYTE) + u8 _pad[7]; // [+0x29..+0x2F] + // module-specific fields follow at [+0x30] +}; + +// BaseModule vtable layout (from factory stubs RVA 0x9B660–0x9B7A0): +// [0] +0x00 copy-ctor / factory() — placement-new ctor, writes vtable, returns this +// [1] +0x08 copy-ctor / factory() — same as [0] +// [2] +0x10 Init() / RegisterTab() — jmp stub → actual RegisterTab fn +// [3] +0x18 Render() — per-frame UI + game-state dispatch +// [4] +0x20 ~BaseModule() — dtor: frees name string, optional delete +// [5] +0x28 getNamePtr() — returns &this->name_string (+0x08) +// [6] +0x30 onHotkey() — pure virtual (sentinel value = 1) +// [7] +0x38 getLinkedModuleFactory() — returns paired module factory ptr + +// ============================================================================ +// SECTION 6 — MODULE STATE STRUCTS +// ============================================================================ + +// --- NoClip --- +// Singleton base: [.data+0x27B0] (referenced by RegisterTab / Render calls) +// Object size: ~0x38 bytes +struct NoClipModule : BaseModule { + // [+0x28] u8 enabled (ON/OFF checkbox) + i32 move_speed; // [+0x30] DragInt range [1, 10], default unknown +}; +// NoClip function table: +// RegisterTab 0x081300 — one-time init +// Render 0x0813D0 — ImGui panel (checkbox + Move Speed slider) +// Update 0x089B50 — per-frame CharacterController toggle +// Update stub 0x089B00 — tab destructor/cleanup wrapper +// Update stub2 0x089B40 — tab #2 setup (lea rdx, panel_callback → jmp 0x89060) + +// --- FreeCam --- +// Singleton base: [.data+0x2200] (0xD8 bytes, zeroed by RegisterMainTab) +struct FreeCamModule : BaseModule { + // [+0x28] u8 enabled + f32 move_speed; // [+0x30] SliderFloat max=500.0f default=30.0f + f32 roll_speed; // [+0x34] SliderFloat max=100.0f + f32 fov_speed; // [+0x38] (Look Sensitivity slider) + u8 _pad2[0x28]; // [+0x3C..+0x63] + void* active_cam_ptr; // [+0x68] cached active camera GameObject* + void* override_cam_ptr; // [+0x70] override camera ptr (cleared on disable) + u8 _pad3[0x40]; // [+0x78..+0xB7] + u8 cam_override_active; // [+0xB8] + // Key bindings written at RegisterMainTab to [.data+0x2230..0x225E]: + // [+0x2230] movdqa block1 = 0x1803B34F0 (WASD + misc keys) + // [+0x2240] movdqa block2 = 0x1803B35C0 + // [+0x2250] 0x3F800000 = 1.0f (FOV multiplier default) + // [+0x2254] 0x44415357 = 'WASD' key code mask + // [+0x2258] 0x6D6BA220 = additional keybind + // [+0x225C] 0x2725 = two-byte keybind + // [+0x225E] 0x60 = backtick key code + // Accumulator floats [+0x2260..0x22A8] pitch/yaw/roll/FOV — zeroed on init +}; +// FreeCam function table: +// RegisterFpsTab 0x0814C0 — registers FPS Monitor overlay tab +// RegisterMainTab 0x081590 — zeroes 0xD8 state, writes key defaults +// FpsUpdate stub 0x087150 — FPS overlay destructor wrapper +// Update 0x0871A0 — per-frame camera override (WASD+mouse) + +// --- FpsUnlocker --- +// Singleton base: [.data+0x21E8] +// Object size: 0x38 bytes +struct FpsUnlockerModule : BaseModule { + // [+0x28] u8 enabled + i32 fps_target; // [+0x30] DragInt max=500, min=30, default=300 +}; +// FpsUnlocker function table: +// RegisterTab 0x081730 — registers tab, writes fps_target default = 300 +// Render 0x085B90 — ImGui panel + Application.set_targetFrameRate call +// Update stub 0x085B40 — destructor wrapper, size 0x38 + +// --- SetDither --- +// Singleton base: referenced from registrar at RVA 0x001C41 +// Object size: 0x38 bytes (shared stub with SkillHack) +struct SetDitherModule : BaseModule { + // [+0x28] u8 enabled (unused — no per-frame write) +}; +// SetDither function table: +// RegisterTab/Render 0x081810 — registers tab only; no ImGui panel body +// Update stub 0x083DC0 — shared no-op: frees name string, optional delete + +// --- PlayerProfile --- +// Singleton base: referenced from registrar at RVA 0x001E20 +// Object size: 0x78 bytes +struct PlayerProfileModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + // [+0x30] std::string uid_str (wstring buffer for UID display text) + char uid_str_sso[24]; // [+0x30] + u8 _pad4[8]; // [+0x48..+0x4F] + // [+0x50] std::string name_str (wstring buffer for ManagerName text) + char name_str_sso[24]; // [+0x50] + u8 _pad5[8]; // [+0x68..+0x6F] + u8 name_changer_enabled; // [+0x70] +}; +// PlayerProfile function table: +// RegisterTab/Render 0x0818E0 — zeroes uid_str, name_str; stores IL2CPP fn ptrs +// Update 0x08A4F0 — per-frame UI path walk + SetText on TMP labels +// Update stub 0x08A4A0 — dtor: frees [+0x50],[+0x30],[+0x08], delete(0x78) +// UI paths used: +// UID: "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (RVA 0x3AFED0, len 0x2F) +// Name: "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (RVA 0x3AFFD0, len 0x8D) + +// --- Vacuum --- +// Singleton base: [.data+0x05D0] fn-ptr slot; obj referenced from registrar 0x001FC0 +// Object size: 0x38 bytes +struct VacuumModule : BaseModule { + // [+0x28] u8 vacuum_on ('Vacuum' main checkbox) + u8 _pad3[7]; + u8 monster_on; // [+0x30] 'Monster' sub-checkbox +}; +// Vacuum function table: +// RegisterTab 0x081A20 — stores update fn ptr 0x1803B0680 → 0x085B40 stub +// Render 0x093CA0 — 'Vacuum' + 'Monster' checkboxes +// PhysicsLoop 0x093F10 — per-frame Rigidbody.AddForce attraction +// Update stub 0x085B40 — shared destructor wrapper (frees [+0x08], delete 0x38) +// Attraction constant: *(float*)0x1803B32B4 + +// --- SkillHack --- +// Singleton base: referenced from registrar at RVA 0x001D50 +// Object size: ~0x38 bytes +struct SkillHackModule : BaseModule { + // [+0x28] u8 enabled — read by all 6 hook callbacks + // No per-frame Update; all work done by IL2CPP hook callbacks +}; +// SkillHack function table: +// Render 0x08D1F0 — hook installer only (installs 6 hooks, tail-jmps to 0x8D8A0) +// RenderPanel 0x08D240 — actual ImGui panel ('Free Skill' + ON/OFF toggle) +// Update stub 0x083DC0 — shared no-op (same as SetDither) +// Dispatcher 0x08D4B0 — BOOL callback: returns 1 when enabled +// CooldownBypass 0x08D500 — float callback: returns 100.0f when enabled +// AvailBypass 0x08D640 — BOOL callback: returns 1 when enabled +// CostBypass 0x08D780 — void callback: early-return (skip cost deduction) + +// --- ESPModule --- +// Singleton base: [.data+0x1F70] VA 0x1803C6F70 +// Object size: 0x100 bytes (12 RGBA color slots × 16 bytes = 0xC0, starts at +0x40) +struct ESPModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + i32 max_draw_distance; // [+0x30] default 300 (0x12C) + u8 show_monsters; // [+0x34] default 1 + u8 show_npc; // [+0x35] default 1 + u8 show_friendly; // [+0x36] default 1 + u8 show_puzzles; // [+0x37] default 1 + u8 show_all; // [+0x38] default 0 + u8 show_distance; // [+0x39] default 1 + u8 show_name; // [+0x3A] default 1 + u8 show_type; // [+0x3B] default 0 (reserved, unused) + u8 _reserved; // [+0x3C] + u8 _pad4[3]; // [+0x3D..+0x3F] + float color[12][4]; // [+0x40] 12 × RGBA float4, 16-byte aligned + // Color slot defaults (RGBA): + // [0] +0x40 enemy RED (1.0, 0.0, 0.0, 1.0) + // [1] +0x50 interactive ORANGE (1.0, 0.65, 0.0, 1.0) + // [2] +0x60 slot2 YELLOW (1.0, 1.0, 0.0, 1.0) + // [3] +0x70 friendly GREEN (0.0, 1.0, 0.0, 1.0) + // [4] +0x80 npc BLUE (0.0, 0.0, 1.0, 1.0) + // [5] +0x90 slot5 CYAN (0.0, 1.0, 1.0, 1.0) + // [6] +0xA0 slot6 PURPLE (0.58, 0.0, 0.83, 1.0) + // [7] +0xB0 default WHITE (1.0, 1.0, 1.0, 1.0) + // [8] +0xC0 slot8 PINK (1.0, 0.08, 0.58, 1.0) + // [9] +0xD0 slot9 LPINK (1.0, 0.75, 0.80, 1.0) + // [10] +0xE0 slot10 BLACK (0.0, 0.0, 0.0, 1.0) + // [11] +0xF0 slot11 GRAY (0.502, 0.502, 0.502, 1.0) +}; +// ESPModule function table: +// Singleton init 0x083E00 — lazy init via MSVC thread-safe static +// RenderOverlay 0x083FA0 — ImGui 'ESP Features' panel (large, 0x83FA0–0x8499E) +// Update 0x085C00 — per-frame world-space entity label loop (approx) +// Entity type dispatch in Update (byte code → color slot): +// 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle, default=slot7(white) + +// --- FPSModule (FpsOverlay) --- +// Singleton base: [.data+0x22E0] VA 0x1803C72E0 +// Object size: 0xD8 bytes +struct FPSModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + u8 show_fps_overlay; // [+0x30] 'Show FPS Overlay' checkbox + u8 _pad4[0x2F]; // [+0x31..+0x5F] + float overlay_pos[4]; // [+0x60] XMMWORD (position/size, zeroed on init) +}; +// FPSModule function table: +// RegisterTab 0x081810 — shared with SetDither registrar +// Render [via FpsOverlay chain] + +// --- PreventScreenshot --- +// Singleton base: [.data+0x2358] VA 0x1803C7358 +// Object size: 0x48 bytes +struct PreventScreenshotModule : BaseModule { + // [+0x28] u8 enabled — drives SetWindowDisplayAffinity arg + u8 _pad3[7]; + u8 state_dirty; // [+0x30] 1 = affinity applied, guard re-apply + u8 _pad4[7]; + u8 second_flag; // [+0x38] purpose unclear, zeroed on init +}; + +// ============================================================================ +// SECTION 7 — HOOK MANAGER +// ============================================================================ + +// Singleton: [.data+0x2470] VA 0x1803C7470 +// Object size: 0x90 bytes +struct HookManager { + void* hook_array; // [+0x00] flat array of HookEntry (0x38 bytes each) + u32 hook_capacity; // [+0x08] allocated slot count (initial 0x80) + u32 hook_count; // [+0x0C] active hook count + void* hash_buckets; // [+0x10] hash table bucket array (linked list heads) + u32 bucket_count; // [+0x18] power of 2, initial 8 + u32 bucket_mask; // [+0x1C] = bucket_count * 2 - 1 + void* free_list_head; // [+0x20] freed/recycled slot free list head + u8 _pad[4]; // [+0x28..+0x2B] + f32 load_factor; // [+0x28] hash load factor threshold (1.0f = 0x3F800000) + u8 initialized; // [+0x30] 0 after init (prevents double-init) + // Global spinlock: [.data+0x1E88] (DWORD, separate from struct) +}; + +// Each hook entry in hook_array is 0x38 bytes: +struct HookEntry { + u64 target_va; // [+0x00] VA of hooked IL2CPP function + u64 callback_va; // [+0x08] VA of replacement/detour function + u64 trampoline_va; // [+0x10] VirtualAlloc'd trampoline (orig bytes + JMP back) + u32 orig_bytes_0_3; // [+0x18] saved original bytes 0-3 + u16 orig_bytes_4_5; // [+0x1C] saved original bytes 4-5 + u8 orig_byte_6; // [+0x1E] saved original byte 6 + u8 flags; // [+0x20] bit0=has_far_jmp, bit1=enabled, bit2=suspended + u32 flags2; // [+0x24] lower nibble: hook type (0=near JMP, 1=far) + u64 hash_next; // [+0x28] next ptr in hash bucket chain + // [+0x30..+0x37] additional chain/bookkeeping fields +}; + +// HookManager API (all acquire spinlock at [.data+0x1E88]): +// CreateHook RVA 0x0A9CC8 — install new hook (FNV-1a hash lookup, trampoline alloc) +// RemoveHook RVA 0x0A9FA0 — remove and free hook +// EnableHook RVA 0x0AA140 — enable suspended hook +// GetHookInfo RVA 0x0AA2C0 — query hook by target VA +// Spinlock acq RVA 0x0A9C88 — acquire [.data+0x1E88] +// Spinlock rel inline — mov [.data+0x1E88], 0 + +// ============================================================================ +// SECTION 8 — MODULE MANAGER +// ============================================================================ + +// Singleton: [.data+0x2398] +// Registrar array: [.data+0x23B8]..[.data+0x23C0] (stride 0x60 bytes/slot) +struct ModuleManager { + u8 _pad[0x18]; // [+0x00..+0x17] + u8 initialized; // [+0x18] double-init guard + u8 _pad2[7]; // [+0x19..+0x1F] + // [+0x20..+0x57] registrar list (vector — 0x60-byte stride) +}; + +// ModuleManager API: +// AddRegistrar RVA 0x09B2C0 — push registrar slot (name str + factory fn) +// Grow helper RVA 0x09B3C0 — expand registrar vector +// Init RVA 0x09AC10 — called once from startup (RVA 0xA9190) +// Dispatch loops (each wraps vtable call in __try/__except via CxxFrameHandler4): +// Update loop RVA 0x09AE80 — calls vtable[+0x18] on each module +// Render loop RVA 0x09AEF0 — calls vtable[+0x20] on each module +// Hotkey loop RVA 0x09AF60 — calls vtable[+0x28] on each module +// Exception handlers (log + resume, do not propagate): +// Update catch RVA 0x0AEBC0 — logs "[ERROR] Failed to update module ''" +// Render catch RVA 0x0AEC50 — logs "[ERROR] Failed to render overlay for module ''" +// Hotkey catch RVA 0x0AECE0 — logs "[ERROR] Failed to process hotkeys for module ''" + +// Registration order (DLL init lambdas, before ModuleManager::Init): +// 1. SetDither (RVA 0x001C41) vtable 0x3B0D58 +// 2. FreeCam FPS (RVA 0x001C80) vtable 0x3B0E70 +// 3. SkillHack (RVA 0x001D50) vtable 0x3B0EE0 +// 4. PlayerProfile (RVA 0x001E20) vtable 0x3B0D90 +// 5. NoClip (RVA 0x001EF0) vtable 0x3B0DC8 +// 6. Vacuum (RVA 0x001FC0) vtable 0x3B0E38 +// 7. UnityExplorer (RVA 0x002090) vtable 0x3B0D28 +// 8. FpsUnlocker (RVA 0x001B80) vtable 0x3B0E00 +// 9. FreeCam main (RVA 0x001AB0) vtable 0x3B0E70 +// 10. ESPModule (RVA 0x001980) + +// ============================================================================ +// SECTION 9 — KEY FUNCTION RVA REFERENCE +// ============================================================================ +// All RVAs relative to binary base 0x180000000. +// Add 0x180000000 to get VA; add file raw offset base for file seek. + +namespace RVA { + // Startup / init + constexpr u32 DllMain_entry = 0x0AC840; // CRT DllMain thunk + constexpr u32 Startup_sequence = 0x0A9190; // main init: GABypass + ModMgr + constexpr u32 GABypass_Patch = 0x0A9120; // writes 71 IL2CPP fn ptrs + constexpr u32 ModuleManager_Init = 0x09AC10; + + // D3D11 / overlay + constexpr u32 D3D11_Hook_Install = 0x0827A0; // hooks IDXGISwapChain::Present + constexpr u32 D3D11_Present_Hook = 0x082820; // Present detour entry + constexpr u32 D3D11_CreateBuffers = 0x0551F0; // post-shader vertex/index buffer init + constexpr u32 ImGui_EndFrame = 0x001C2D0; // D3D11/ImGui EndFrame boundary + + // ImGui wrappers (cheat-side) + constexpr u32 ImGui_Toggle = 0x070820; // TabManager::BeginTab + constexpr u32 CheckboxToggle = 0x085320; // flip enabled flag + constexpr u32 ImGui_DragInt = 0x066750; // move_speed DragInt + constexpr u32 ImGui_SliderFloat = 0x065570; // move_speed SliderFloat (max 500) + constexpr u32 ImGui_InputText_ws = 0x08AC20; // InputText wstring wrapper + + // Config I/O + constexpr u32 ConfigSerialize = 0x012050; // serialize config to string + constexpr u32 BuildFilePath = 0x030A90; // build config file path + constexpr u32 ConfigFileIO = 0x011EA0; // UTF-8→wide fopen helper + constexpr u32 ConfigWrite = 0x0170D6; // fwrite config to file (approx) + + // Hook manager + constexpr u32 HookMgr_singleton = 0x081B00; // thread-safe static accessor + constexpr u32 HookMgr_CreateHook = 0x0A9CC8; + constexpr u32 HookMgr_RemoveHook = 0x0A9FA0; + constexpr u32 HookMgr_EnableHook = 0x0AA140; + constexpr u32 HookMgr_Spinlock = 0x0A9C88; + constexpr u32 Trampoline_Alloc = 0x0AA478; // GetSystemInfo+VirtualQuery sub + + // IL2CPP infrastructure + constexpr u32 IL2CPP_FindByPath = 0x09BCB0; // resolve Unity path to object + constexpr u32 WideToString = 0x00EB10; // UTF-8 → wstring + constexpr u32 BaseModule_Dtor = 0x00FA60; // shared dtor + + // ModuleManager dispatch + constexpr u32 ModMgr_UpdateLoop = 0x09AE80; + constexpr u32 ModMgr_RenderLoop = 0x09AEF0; + constexpr u32 ModMgr_HotkeyLoop = 0x09AF60; + constexpr u32 ModMgr_AddRegistrar = 0x09B2C0; + + // Theme / config preset writers (Ch.17 / Ch.28) + constexpr u32 Theme_Writer_Preset0 = 0x094890; // writes 52 color slots + constexpr u32 Theme_Writer_Preset1 = 0x096770; + constexpr u32 Theme_Writer_Preset2 = 0x098650; + constexpr u32 ColorApplicator = 0x094190; // shared helper: hex→RGBA×159 calls + + // Settings / NameChanger (Ch.19) + constexpr u32 Settings_RenderOverlay = 0x09A4F0; // Settings panel render + constexpr u32 Settings_end = 0x09AB98; // (end of Settings body) + + // UnityExplorer (Ch.16) + constexpr u32 UE_RegisterTab = 0x090060; + constexpr u32 UE_Render = 0x090250; + constexpr u32 UE_RefreshScenes = 0x090D40; +} + +// ============================================================================ +// SECTION 10 — CONFIG PRESET NAMES & STRINGS +// ============================================================================ +// Preset name string: [.data+0x00E0] (std::string, set during Settings load) +// Preset index: [.data+0x00EC] (DWORD, 0-3) +// Config file path: built by BuildFilePath (RVA 0x030A90) from [.data+0x0050]+0x50 +// Config strings (RVA): +// "Preset0" 0x3B0680 +// "Preset1" 0x3B0688 +// "Preset2" 0x3B0690 +// "Preset3" 0x3B0698 +// "EF-Cheeto.dll" 0x3B0358 (used by GABypass file scan) +// "gatmp.tmp" 0x3B0338 (temp file for bypass) +// "testyip" 0x3B0328 (test bypass marker) +// Source path embedded: "E:\git\Endfield_Cheeto\libraries\pipeline\..." + +// ============================================================================ +// SECTION 11 — KNOWN GAME API SIGNATURES (inferred from call sites) +// ============================================================================ +// These are IL2CPP managed method signatures inferred from cheat call sites. +// Calling convention: __fastcall (RCX=this/arg0, RDX=arg1, R8=arg2, etc.) +// Return in RAX (ptr/int) or XMM0 (float). + +// Transform methods +using fn_get_position = void*(*)(void* transform); // returns vec3* +using fn_set_position = void (*)(void* transform, void* vec3); +using fn_get_rotation = void*(*)(void* transform); // returns Quaternion* +using fn_set_rotation = void (*)(void* transform, void* quaternion); +using fn_get_localPos = void*(*)(void* transform); +using fn_set_localPos = void (*)(void* transform, void* vec3); +using fn_get_localScale= void*(*)(void* transform); +using fn_set_localScale= void (*)(void* transform, void* vec3); + +// GameObject methods +using fn_get_transform = void*(*)(void* gameObject); +using fn_SetActive = void (*)(void* gameObject, bool active); +using fn_get_name_go = void*(*)(void* gameObject); // returns System.String* + +// Rigidbody methods +using fn_AddForce = void (*)(void* rigidbody, void* vec3, int forceMode); +using fn_get_velocity = void*(*)(void* rigidbody); +using fn_set_velocity = void (*)(void* rigidbody, void* vec3); + +// Application +using fn_setTargetFPS = void (*)(int targetFrameRate); + +// TMPro / UI +using fn_set_text = void (*)(void* textComponent, int zero, void* wstring_ptr); + +// CharacterController +using fn_setEnabled = void (*)(void* ctrl, bool enabled, int zero); + +// Camera +using fn_Camera_main = void*(*)(void* zero); // Camera.get_main +using fn_get_fov = float(*)(void* camera); + +// SkillHack hook callbacks (return types match hooked method signatures): +using fn_BOOL_bypass = BOOL (*)(void); // Dispatcher / AvailBypass +using fn_float_bypass = float(*)(void); // CooldownBypass → returns 100.0f +using fn_void_bypass = void (*)(void); // CostBypass → early return + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 12 — IL2CPP TABLE ACCESSOR MACROS +// ============================================================================ +// Usage: CALL_IL2CPP(slot_name, RetType, arg0, ...) +// All slots live at fixed .data offsets from binary base 0x1803C5000. +// At runtime: ptr = *(void**)([.data + slot_offset]) +// +// Direct call helpers — use after GABypass has patched the table: + +#define IL2CPP_BASE_VA ((uintptr_t)0x1803C5000) +#define IL2CPP_SLOT(off) (*(void**)(IL2CPP_BASE_VA + (off))) + +// Transform +#define IL2_Transform_get_position(t) ((fn_get_position) IL2CPP_SLOT(0x1C88))(t) +#define IL2_Transform_set_position(t,v) ((fn_set_position) IL2CPP_SLOT(0x1D88))(t,v) +#define IL2_Transform_get_localPos(t) ((fn_get_localPos) IL2CPP_SLOT(0x1C80))(t) +#define IL2_Transform_set_localPos(t,v) ((fn_set_localPos)IL2CPP_SLOT(0x1C90))(t,v) +#define IL2_Transform_get_rotation(t) ((fn_get_rotation)IL2CPP_SLOT(0x1C68))(t) +#define IL2_Transform_set_rotation(t,q) ((fn_set_rotation)IL2CPP_SLOT(0x1CA8))(t,q) +#define IL2_Transform_get_localScale(t) ((fn_get_localScale)IL2CPP_SLOT(0x1C60))(t) +#define IL2_Transform_set_localScale(t,v) ((fn_set_localScale)IL2CPP_SLOT(0x1D68))(t,v) + +// GameObject +#define IL2_GO_get_transform(go) ((fn_get_transform)IL2CPP_SLOT(0x1CA0))(go) +#define IL2_GO_SetActive(go,a) ((fn_SetActive) IL2CPP_SLOT(0x1C98))(go,a) +#define IL2_GO_get_name(go) ((fn_get_name_go) IL2CPP_SLOT(0x1CC0))(go) + +// Rigidbody +#define IL2_RB_AddForce(rb,v,fm) ((fn_AddForce) IL2CPP_SLOT(0x1E00))(rb,v,fm) +#define IL2_RB_get_velocity(rb) ((fn_get_velocity) IL2CPP_SLOT(0x1D70))(rb) +#define IL2_RB_set_velocity(rb,v) ((fn_set_velocity) IL2CPP_SLOT(0x1D78))(rb,v) + +// Application +#define IL2_App_setTargetFPS(fps) ((fn_setTargetFPS) IL2CPP_SLOT(0x1D48))(fps) + +// Camera +#define IL2_Camera_main() ((fn_Camera_main) IL2CPP_SLOT(0x1DC0))(nullptr) +#define IL2_Camera_get_fov(cam) ((fn_get_fov) IL2CPP_SLOT(0x1DE8))(cam) + +// UI +#define IL2_TMPro_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E28))(comp,0,ws) +#define IL2_UI_Text_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E30))(comp,0,ws) + +// CharacterController +#define IL2_CharCtrl_setEnabled(c,en) ((fn_setEnabled) IL2CPP_SLOT(0x1E08))(c,en,0) + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 13 — STARTUP / LOADER CHAIN +// ============================================================================ +// DLL entry and initialization sequence (Ch.11 / Ch.29) + +namespace RVA { + // Entry point chain + constexpr u32 DllMain_entry_real = 0x01000; // CRT DllMain (spawns loader thread) + constexpr u32 LoaderThread = 0x05000; // main init thread: IL2CPP + window + hooks + constexpr u32 Startup_main = 0x0A9190; // step-by-step startup (steps 1-11) + constexpr u32 ModMgr_RegisterAll = 0x09AE00; // 11 modules registered via stubs + constexpr u32 ModMgr_MainLoop = 0x082000; // Present hook + ImGui render loop (0x82000-0x82300) + constexpr u32 D3D11Init_Shaders = 0x054DC0; // D3DCompile vertex+pixel shader (x2: 0x54DC0, 0x551E8) + constexpr u32 D3D11Init_Setup = 0x082500; // ImGui Win32+D3D11 backend init, WndProc subclass + + // Startup step addresses (from Ch.11.4): + // 1 0x0A91CE AllocConsole — 'il2cpp Game Console' + // 2 0x0A9267 SetConsoleCP(0xFDE9) — UTF-8 + // 3 0x0A92F7 FindWindowA(NULL,'UnityWndClass') — poll until game window present + // 4 0x0A93CC HookInstallerWrapper(EnumProcessModules) — module scanner install + // 5 0x0A93E6 Log 'Initializing..' (source: main.cpp:53) + // 6 0x0A942F Call [g_Config+0x1E80] — IL2CPP domain resolver + // 7 0x0A945A Log 'IL2CPP Domain Found: ' (if domain non-null) + // 8 0x0A94C4 Log 'IL2CPP Thread Attached Successfully: ' + // 9 0x0A9506 Error: Log 'Failed to Attach IL2CPP Thread!' + // 10 0x0A9545 Error: Log 'IL2CPP Domain Not Found!' + // 11 0x0A959F Success: Log 'Initialized' → then launch overlay window thread (0x827A0) + + // D3D11 overlay window subsystem (Ch.29) + constexpr u32 OverlayWindowInit = 0x0827A0; // create layered window + D3D11 device (0x827A0-0x8375C) + constexpr u32 FindGameWindow = 0x0835D0; // EnumWindows callback — locate Unity window + constexpr u32 GetOverlayRect = 0x0836A0; // compute overlay rect from game window bounds + constexpr u32 D3D11_Setup_sub = 0x0825B0; // D3D11::Reinit — recreate RT + ImGui D3D11 backend + constexpr u32 WndProc = 0x0826A0; // Win32 WndProc (HWND,UINT,WPARAM,LPARAM)→LRESULT + constexpr u32 ImGui_Win32_Handler = 0x057720; // ImGui_ImplWin32_WndProcHandler — all kb/mouse + constexpr u32 PresentHook_callsite = 0x082F00; // IDXGISwapChain::Present hook call site (inside msg loop) + constexpr u32 RenderFrame = 0x082FC0; // ImGui NewFrame + per-module Render dispatch + constexpr u32 ImGui_Begin_wrapper = 0x0937D0; // ImGui::Begin wrapper (Unity Explorer Window title) + constexpr u32 ImGui_Selectable = 0x0708D0; // ImGui::Selectable (preset selector, Ch.17) + + // Thread suspension for hook install (Ch.3) + constexpr u32 CollectProcessThreads = 0x0A96B0; // Toolhelp32 snapshot → thread ID array (0xA96B0-0xA9A1C) + constexpr u32 SuspendOrResumeThreads= 0x0A9A20; // OpenThread + Suspend/Resume all (0xA9A20-0xA9A98) + constexpr u32 PatchCode = 0x0A9A9C; // VirtualProtect + write hook bytes (0xA9A9C-0xA9BC3) + + // Hook manager detailed RVAs (Ch.8) + constexpr u32 HookMgr_Install = 0x0A9CC8; // alloc trampoline + FNV hash (= CreateHook) + constexpr u32 HookMgr_Remove = 0x0A9E8C; // remove + restore original bytes + constexpr u32 HookMgr_Enable_fn = 0x0A9A9C; // toggle enabled bit + patch + constexpr u32 HookMgr_AllocTramp = 0x0A960C; // allocate trampoline slot near target VA + constexpr u32 HookMgr_FreeSlot = 0x0AA684; // free trampoline + compact hook array + constexpr u32 HookInstaller_Wrapper = 0x08BAF0; // wrapper called at 0xA93CC during startup + + // Module scanner (Ch.11.2) + constexpr u32 ModulePathScanner = 0x08B650; // scan loaded modules for testyip/gatmp/EF-Cheeto + constexpr u32 ModPathScanner_EF = 0x08B937; // wcsstr branch: search for 'EF-Cheeto.dll' + + // String helpers + constexpr u32 UTF8ToWide = 0x08B4E0; // MultiByteToWideChar CP_UTF8(0xFDE9) wrapper + constexpr u32 WideStr_wcsstr = 0x0AB6A0; // custom wcsstr — returns iterator, -1 if not found + constexpr u32 WideStr_Dtor = 0x0AB758; // wstring destructor (used in path scanner) + + // Module-specific helpers + constexpr u32 NoClip_RegisterTab = 0x00FCB0; // one-time NoClip tab init + constexpr u32 FreeCam_RegisterTab = 0x00F7D0; // one-time FreeCam tab init + constexpr u32 ManagerName_Init = 0x00FFF0; // zero std::string fields for ModuleManager name + constexpr u32 NoClip_EntityIter = 0x089DC0; // entity iterator inner loop (NoClip::Update) + constexpr u32 SetDither_Render = 0x08C490; // SetDither::Render — graphics dither toggle + constexpr u32 SkillHack_PatchFloat = 0x08E220; // installs FloatReturn hook on [g_Config+0x1E50] + constexpr u32 SkillHack_PatchBool = 0x08EBC0; // installs BoolTrue hook on [g_Config+0x1E58] + constexpr u32 SkillHack_PatchVoid = 0x08F560; // installs VoidReturn hook on [g_Config+0x1E40] + constexpr u32 SkillHack_Trampoline = 0x08FF00; // common trampoline dispatcher (calls original fn) + constexpr u32 UE_GuardReturn = 0x0901D8; // early return after once_flag sealed (UE::RegisterTab) + constexpr u32 UE_AutoRefresh = 0x093B10; // auto-refresh timer check for scene list + constexpr u32 UE_Memset_block = 0x0AC86A; // memset 0xD8 bytes at [.data+0x2200] (FreeCam init) + constexpr u32 PreventSS_Init = 0x08AD70; // once_flag guarded PreventScreenshot init + constexpr u32 PreventSS_Render = 0x08AE60; // ImGui single checkbox 'Prevent Screenshot' + constexpr u32 PreventSS_Update = 0x08AFC0; // SetWindowDisplayAffinity dispatch (per-frame) + constexpr u32 PreventSS_OsCheck = 0x08B220; // Win10 build check + affinity setter + constexpr u32 TabMgr_BeginTab_full = 0x09D7D0; // full BeginTab with state+title resolution + constexpr u32 GABypass_Init = 0x09D1E0; // 71 IL2CPP stub patch sequence + constexpr u32 Std_once_flag_Execute = 0x0AFF60; // MSVC _Execute_once (once_flag) + constexpr u32 Sidebar_Settings = 0x080770; // sidebar settings section (0x80770-0x80B50) + // ImGui_EndFrame alias: see RVA::ImGui_EndFrame (0x001C2D0) defined in Section 9 +} + +// ============================================================================ +// SECTION 14 — D3D11 OVERLAY WINDOW INIT (Ch.29 summary) +// ============================================================================ +// OverlayWindowInit (RVA 0x827A0) sequence: +// +// 29.1 DPI setup (0x827FF-0x82923): +// Try SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) +// Fallback: SetProcessDpiAwareness(2) +// Final fallback: SetProcessDPIAware() +// Guard: [.data+0x3C7440] / [.data+0x3C7448] +// +// 29.2 Game window location + class registration (0x82924-0x82A28): +// EnumWindows(FindGameWindow@0x835D0) → locate Unity game HWND +// WNDCLASSEX: CreateSolidBrush(0x7F00), LoadCursorW, LoadIconW×2 +// RegisterClassExW +// GetSystemMetrics(SM_CXSCREEN/SM_CYSCREEN) +// +// 29.3 Overlay window + D3D11 device (0x82A29-0x82BFF): +// CreateWindowExW(WS_EX_LAYERED|WS_EX_TRANSPARENT) +// SetLayeredWindowAttributes +// DwmExtendFrameIntoClientArea (full glass) +// D3D11CreateDeviceAndSwapChain — attempt 1: DXGI_FORMAT_R8G8B8A8_UNORM +// on failure: attempt 2: DXGI_FORMAT_B8G8R8A8_UNORM +// D3D11::Reinit (0x825B0) — set up ImGui D3D11 backend +// ShowWindow / UpdateWindow +// CreateMutexA — prevent duplicate instances +// +// 29.4 Message loop (0x82C01-0x8352F): +// Log 'Initialized' (source: UI.cpp, RVA 0x3AF610) +// Loop: PeekMessageW / TranslateMessage / DispatchMessageW +// Each iter: FindWindowA('UnityWndClass',NULL) — exit if game gone +// IsWindow, GetWindowThreadProcessId, GetWindowRect +// SetWindowPos to track game window + +// WndProc (RVA 0x826A0) — pseudocode: +// LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// if (g_ImGuiCtx) { +// LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// if (r) return 1; +// } +// switch (msg) { +// case WM_DESTROY: PostQuitMessage(0); return 0; +// case WM_SIZE: +// if (g_pSwapChain && wParam != SIZE_MINIMIZED) { +// if (g_pRenderTargetView) { g_pRenderTargetView->Release(); g_pRenderTargetView=NULL; } +// g_pSwapChain->ResizeBuffers(0,LOWORD(lParam),HIWORD(lParam),DXGI_FORMAT_UNKNOWN,0); +// D3D11_Setup_sub(); // 0x825B0 — recreate RT + shaders +// } +// return 0; +// case WM_SYSCOMMAND: +// if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +// break; +// default: +// return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// } +// return 0; +// } + +// ============================================================================ +// SECTION 15 — MODULE PATH SCANNER (Ch.11.2) +// ============================================================================ +// ModulePathScanner (RVA 0x8B650): +// Args: HANDLE process, void** module_array, DWORD count +// For each module path: +// UTF8ToWide(path) → wpath +// wcsstr(wpath, L"testyip") → if found: found_count++ +// wcsstr(wpath, L"gatmp.tmp") → if found: found_count++ +// if not found: ModPathScanner_EF (0x8B937): +// wcsstr(wpath, L"EF-Cheeto.dll") → if found: found_count++ +// Returns found_count +// +// Injection identity strings (.data): +// L"testyip" [.data+0x0318] alternate temp-file loader name +// L"gatmp.tmp" [.data+0x0338] primary temp-file loader name +// L"EF-Cheeto.dll" [.data+0x0358] published DLL name (fallback) + +// ============================================================================ +// SECTION 16 — THREAD SUSPENSION SUBSYSTEM (Ch.3) +// ============================================================================ +// CollectProcessThreads (RVA 0xA96B0): +// CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,0) → hSnapshot +// THREADENTRY32 te32; te32.dwSize = sizeof(THREADENTRY32); +// Thread32First(hSnapshot, &te32) +// while Thread32Next: if te32.th32OwnerProcessID==GetCurrentProcessId() +// AND te32.th32ThreadID != calling_thread: append to array +// +// SuspendOrResumeThreads (RVA 0xA9A20): +// For each collected thread ID: +// hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// if suspend: SuspendThread(hThread) +// if resume: ResumeThread(hThread) +// CloseHandle(hThread) +// +// PatchCode (RVA 0xA9A9C): +// VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &oldProt) +// memcpy(target, patch_bytes, size) +// VirtualProtect(target, size, oldProt, &oldProt) +// FlushInstructionCache(GetCurrentProcess(), target, size) + +// ============================================================================ +// SECTION 17 — PREVENT SCREENSHOT MODULE (Ch.21 supplement) +// ============================================================================ +// PreventScreenshot::Initialize (RVA 0x8AD70): +// Guarded by once_flag at [.data+0x2390] +// Allocates module object (0x48 bytes) +// Sets vtable: 0x3AFA38 → 0x3B0110 after init +// Zeroes: enabled, state_dirty, second_flag +// +// PreventScreenshot::Update (RVA 0x8AFC0): +// 1. Call GetInstance (0x8AD70) +// 2. Check enabled [module+0x28] +// 3. If enabled && !state_dirty: call OsCheck (0x8B220) +// 4. Build HWND list at [.data+0x24D0] +// 5. For each HWND node [rbx+0x10]: call OsCheck affinity setter +// 6. Call HookMgr_singleton (0x81B00) to update hook state +// +// PreventScreenshot::OsCheck (RVA 0x8B220): +// Checks Windows 10 build version +// Calls SetWindowDisplayAffinity(hwnd, WDA_MONITOR) via IAT[0xB1460] +// On disable: SetWindowDisplayAffinity(hwnd, WDA_NONE) + +// ============================================================================ +// SECTION 18 — COMPLETE FUNCTION INDEX (all 91 named functions) +// ============================================================================ +// Cross-reference: function name → RVA (use RVA:: namespace above for most) +// This table captures every named entry from the doc cross-reference (Ch.24/25). + +// Name RVA Chapter +// DllMain 0x001000 Entry +// LoaderThread 0x005000 Ch.11 +// FreeCam::RegisterTab 0x00F7D0 Ch.12.3 +// FreeCam::RegisterFpsTab 0x0814C0 Ch.12.3 +// NoClip::RegisterTab 0x00FCB0 Ch.12.2 +// ManagerName::Init 0x00FFF0 Ch.15 +// ImGui::EndFrame 0x01C2D0 Ch.15 +// ConfigSerialize 0x012050 Ch.6 +// ConfigFileIO (UTF8→wide fopen) 0x011EA0 Ch.6 +// BuildFilePath 0x030A90 Ch.6 +// D3D11Init_Shaders A 0x054DC0 Ch.5 +// D3D11Init_Shaders B 0x0551E8 Ch.5 +// D3D11::CreateBuffers 0x0551F0 Ch.5 +// ImGui_ImplWin32_WndProcHandler 0x057720 Ch.7 +// ImGui::Toggle (TabMgr) 0x070820 Ch.12 +// ImGui::Selectable 0x0708D0 Ch.17 +// TabMgr::BeginTabFull 0x09D7D0 Ch.12 +// Sidebar_Settings entry 0x080770 Ch.25 +// D3D11::Setup (ImGui backend init) 0x082500 Ch.29 +// D3D11::Reinit 0x0825B0 Ch.7/29 +// WndProc 0x0826A0 Ch.7 +// OverlayWindowInit 0x0827A0 Ch.29 +// FindGameWindow 0x0835D0 Ch.29 +// GetOverlayRect 0x0836A0 Ch.29 +// PresentHook callsite 0x082F00 Ch.15.5 +// RenderFrame 0x082FC0 Ch.15 +// HookMgr_singleton 0x081B00 Ch.8 +// ESPModule singleton init 0x083E00 Ch.9 +// ESPModule::RenderOverlay 0x083FA0 Ch.22 +// SetDither::Render 0x08C490 Ch.12.5 +// CheckboxToggle 0x085320 Ch.12 +// ImGui::SliderFloat 0x065570 Ch.12.3 +// ImGui::DragInt 0x066750 Ch.12.2 +// NoClip::Render 0x0813D0 Ch.12.2 +// NoClip::Update 0x089B50 Ch.12.2 +// NoClip::EntityIterator 0x089DC0 Ch.12.2 +// FreeCam::Update 0x0871A0 Ch.12.3 +// FpsUnlocker::Render 0x085B90 Ch.12.4 +// PlayerProfile::Update 0x08A4F0 Ch.12.6 +// Vacuum::Render 0x093CA0 Ch.12.7 +// Vacuum::PhysicsLoop 0x093F10 Ch.12.7 +// Vacuum::EntityIterator 0x094000 Ch.12.7 +// SkillHack::Render (hook install) 0x08D1F0 Ch.12.8 +// SkillHack::RenderPanel 0x08D240 Ch.12.8 +// SkillHack::Dispatcher 0x08D4B0 Ch.10 +// SkillHack::CooldownBypass 0x08D500 Ch.10 +// SkillHack::AvailBypass 0x08D640 Ch.10 +// SkillHack::CostBypass 0x08D780 Ch.10 +// SkillHack::PatchFloat 0x08E220 Ch.10 +// SkillHack::PatchBool 0x08EBC0 Ch.10 +// SkillHack::PatchVoid 0x08F560 Ch.10 +// SkillHack::TrampolineDispatch 0x08FF00 Ch.10 +// PreventScreenshot::Initialize 0x08AD70 Ch.21 +// PreventScreenshot::Render 0x08AE60 Ch.21 +// PreventScreenshot::Update 0x08AFC0 Ch.21 +// PreventScreenshot::OsCheck 0x08B220 Ch.21 +// UTF8ToWide 0x08B4E0 Ch.11 +// ModulePathScanner 0x08B650 Ch.11.2 +// ModulePathScanner::EFSearch 0x08B937 Ch.11.2 +// HookInstallerWrapper 0x08BAF0 Ch.11.3 +// ImGui::InputText_ws 0x08AC20 Ch.12.6 +// HookInstaller inner 0x08BAF0 Ch.11.3 +// ColorApplicator 0x094190 Ch.28.2.1 +// Theme_Writer_Preset0 0x094890 Ch.17/28 +// Theme_Writer_Preset1 0x096770 Ch.17/28 +// Theme_Writer_Preset2 0x098650 Ch.17/28 +// Settings::RenderOverlay 0x09A4F0 Ch.19.8 +// UnityExplorer::RegisterTab 0x090060 Ch.16 +// UnityExplorer::Render 0x090250 Ch.16 +// UnityExplorer::RefreshScenes 0x090D40 Ch.16 +// UnityExplorer::GuardReturn 0x0901D8 Ch.16 +// UnityExplorer::AutoRefresh 0x093B10 Ch.16 +// ImGui::Begin wrapper 0x0937D0 Ch.16 +// ModuleManager::AddRegistrar 0x09B2C0 Ch.15 +// ModuleManager::Grow 0x09B3C0 Ch.15 +// ModuleManager::Init 0x09AC10 Ch.15 +// ModuleManager::UpdateLoop 0x09AE80 Ch.15 +// ModuleManager::RenderLoop 0x09AEF0 Ch.15 +// ModuleManager::HotkeyLoop 0x09AF60 Ch.15 +// ModuleManager::RegisterAll 0x09AE00 Ch.15 +// DispatchLoop_UpdateCatch 0x0AEBC0 Ch.15.4.1 +// DispatchLoop_RenderCatch 0x0AEC50 Ch.15.4.1 +// DispatchLoop_HotkeyCatch 0x0AECE0 Ch.15.4.1 +// IL2CPP_FindByPath 0x09BCB0 Ch.16/19 +// GABypass::Init 0x09D1E0 Ch.18 +// CollectProcessThreads 0x0A96B0 Ch.3 +// SuspendOrResumeThreads 0x0A9A20 Ch.3 +// PatchCode 0x0A9A9C Ch.3 +// Startup_main 0x0A9190 Ch.11.4 +// HookMgr_AllocTrampoline 0x0A960C Ch.8 +// HookMgr_CreateHook 0x0A9CC8 Ch.8 +// HookMgr_RemoveHook 0x0A9FA0 Ch.8 +// HookMgr_EnableHook 0x0AA140 Ch.8 +// HookMgr_FreeSlot 0x0AA684 Ch.8 +// HookMgr_Spinlock 0x0A9C88 Ch.8 +// WideStr::wcsstr 0x0AB6A0 Ch.11 +// WideStr::Dtor 0x0AB758 Ch.11 +// Memset_block 0x0AC86A (alloc+memset 0xD8 bytes) +// BaseModule::Dtor 0x00FA60 Ch.12 +// WideToString 0x00EB10 Ch.11 +// PreventScreenshot::SetAffinity 0x08B490 Ch.21 (SetWindowDisplayAffinity call site) +// Vacuum::Render (alt addr) 0x093C90 Ch.12.7 (one-byte offset alias for 0x93CA0) + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 19 — CONFIG I/O FUNCTIONS (Ch.6 complete) +// ============================================================================ + +namespace RVA { + // Config I/O + constexpr u32 ReadConfig = 0x0302D2; // fread JSON config on startup → populate g_Config + constexpr u32 ReadConfig_end = 0x030348; // ReadConfig range end + constexpr u32 SaveConfig = 0x030620; // fwrite g_Config state to JSON file (0x30620-0x307A0) + constexpr u32 SaveConfig_end = 0x0307A0; + constexpr u32 ImGuiSaveIni = 0x017078; // fwrite ImGui window layout to .ini (0x17078-0x172CA) + constexpr u32 ImGuiSaveIni_end = 0x0172CA; + constexpr u32 ConsoleDebugWrite = 0x00EA1B; // fwrite to stdout/console (debug output, size=1) + + // SaveConfig (RVA 0x30620) pseudocode: + // Check state->enabled_flag [rbx+0x2900] + // Load state->file_path ptr [rbx+0x50] + // Call BuildFilePath (0x30A90) + // Call OpenConfigFile(path, "wt") → FILE* fp + // Serialize via ConfigSerialize (0x12050) → string + // fwrite(string, 1, len, fp); fclose(fp) + // Auto-save timer: xmm0=[rbx+0x2904], timer -= delta; on expire: re-save + // + // Config field written by language selector: + // [g_Config+0x2764] content ref-count (DWORD, decremented on lang change) + constexpr u32 LangSelector_refcount_off = 0x2764; // g_Config+0x2764 = content ref-count +} + +// ============================================================================ +// SECTION 20 — LOG / PRINT / CRC32 / REGISTRY (Ch.15 / Ch.26 helpers) +// ============================================================================ + +namespace RVA { + constexpr u32 Log_Print = 0x00FDA0; // shared logging helper (called by all 3 dispatch catchers) + constexpr u32 ImGui_PushStyleColor = 0x010840; // ImGui::PushStyleColor — theme system (159 calls) + constexpr u32 CRC32_Lookup = 0x011DF0; // CRC32 of module key string (e.g. "Sidebar", "Content") + constexpr u32 Module_RegistryLookup = 0x03D1A0; // registry lookup by CRC32 hash → module ptr + constexpr u32 Module_Notify = 0x01D2B0; // module notify/update (called after lang change) + constexpr u32 ImGui_Epilogue = 0x023E20; // ImGui epilogue tail-call target (Sidebar tail-jmps here) + constexpr u32 I18n_Refresh = 0x02A530; // i18n content refresh — reload translations on lang change + constexpr u32 Locale_ContextInit = 0x09D660; // locale context init — selects "en" or "zh_cn" based on flag + constexpr u32 Label_Formatter = 0x05FB60; // sprintf-style: build "Key Name: %s" label strings + constexpr u32 ImGui_Combo = 0x064220; // ImGui::Combo (language dropdown, 2-item list) + constexpr u32 FPS_StringBuild = 0x07F5C0; // build "FPS: NNN" string for FPS overlay +} + +// i18n language flag: [.data+0x3C77B0] (VA 0x1803C77B0) +// 0 = English (RVA 0x3AF310) +// 1 = 简体中文 (RVA 0x3AF318) +// Language tab label: " Language" (RVA 0x3AF328, 5-space indent) +// Combo widget ID: "##Language" (RVA 0x3AF338) + +// ============================================================================ +// SECTION 21 — SIDEBAR / MAIN PANEL (Ch.25 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 Sidebar_Render = 0x07F8F0; // top-level overlay panel (0x7F8F0, ~0x146E bytes) + // Sidebar_Render calls: + // CRC32_Lookup(0x11DF0) on "Sidebar" key (RVA 0x3AF2C8) + // Module_RegistryLookup(0x3D1A0) + // Module_Notify(0x1D2B0) + // Language selector sub-panel (0x80770-0x80B50) unconditionally + // Jump-table dispatch for all tab bodies + // Tail-jmp to ImGui_Epilogue (0x23E20) at 0x80D5E + // Stack frame: 0x380 bytes; saves xmm6–xmm8; single rcx arg (ModuleManager ptr) + // + // Key strings: + // Banner: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) + // Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) + // Window key: "Sidebar" (RVA 0x3AF2C8) — ImGui::Begin not called inside 0x7F8F0 itself + // Active tab index written to [.data+0x1F68] on click, read by jump table + + constexpr u32 Lang_Selector_start = 0x080770; // language selector sub-panel start (unconditional) + constexpr u32 Lang_Selector_end = 0x080B50; // language selector sub-panel end +} + +// Language selector execution flow (Ch.26.2): +// 0x80895 call Locale_ContextInit(0x9D660) +// 0x808DD lea rsi, "English" (RVA 0x3AF310) +// 0x808E3 lea rbx, "简体中文" (RVA 0x3AF318) +// 0x809A1 lea rdx, " Language" (RVA 0x3AF328) +// 0x809C6 call TabMgr::BeginTab(0x9D7D0) +// 0x80A03 call ImGui::Combo(0x64220) → al=1 if changed +// 0x80A2F if English: mov [.data+0x3C77B0], 0 +// 0x80A5D if ZH-CN: mov [.data+0x3C77B0], 1 +// 0x80A6E call I18n_Refresh(0x2A530) +// 0x80A73 dec [g_Config+0x2764] (content ref-count) +// 0x80A80 rax = [g_Config+0x15D8] (active config preset ptr) +// 0x80A87 [rax+0x103] = 1 (dirty flag → triggers config save) +// 0x80B0B lea rcx, "Content" (RVA 0x3ADFC8) +// 0x80B12 call CRC32_Lookup(0x11DF0) +// 0x80B33 call Module_RegistryLookup(0x3D1A0) +// 0x80B4D call Module_Notify(0x1D2B0) + +// ============================================================================ +// SECTION 22 — ESPMODULE COMPLETE FUNCTION TABLE (Ch.22) +// ============================================================================ + +namespace RVA { + constexpr u32 ESPModule_Init = 0x083E00; // lazy singleton init (thread-safe static) + constexpr u32 ESPModule_Render = 0x083F60; // Ch.22 §22.1 — "ESP Features" collapsing header + constexpr u32 ESPModule_DrawOverlay = 0x083000; // Ch.22 §22.2 — world-space entity label overlay + constexpr u32 ESPModule_Update = 0x084A00; // per-frame entity label draw loop start + constexpr u32 ESPModule_Update_loop = 0x0852A5; // entity label loop body +} +// ESPModule::RenderOverlay (0x83FA0–0x8499E): large monolithic ImGui panel +// ESPModule::Update entity type dispatch: 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle + +// ============================================================================ +// SECTION 23 — FPSMODULE COMPLETE (Ch.20) +// ============================================================================ + +namespace RVA { + constexpr u32 FPSModule_Initialize = 0x0814C0; // once_flag guarded init (once_flag at [.data+0x2310]) + constexpr u32 FPSModule_RenderPanel = 0x085660; // panel render (two checkboxes: FPS Monitor + Show FPS Overlay) + constexpr u32 FPSModule_RenderPanel_branch = 0x0856F0; // inner ImGui branch of panel render + constexpr u32 FPSModule_RenderOverlay = 0x085700; // FPS counter overlay start + constexpr u32 FPSModule_RenderOverlay_end = 0x085900; // FPS counter overlay end + constexpr u32 FPSModule_RenderOverlay_counter = 0x0858D0; // "##Foreground" frameless window (FPS display) +} +// FPSModule::Initialize (0x814C0): +// Guarded by once_flag at [.data+0x2310] +// Alloc 0xD8 bytes (via 0xAC86A), store ptr at [.data+0x22E0] +// vtable: 0x3AFA38 → 0x3AFAC0 after init +// name: "FPS Monitor" (RVA 0x3AFA88) at [.data+0x22E8] +// enabled = 0 at [.data+0x2308] +// +// FPSModule overlay color thresholds (RVA of XMMWORD constants): +// fps >= 60: 0x1803B3530 (green) +// 30 <= fps < 60: 0x1803B3540 (yellow) +// fps < 30: 0x1803B3510 (red) +// FPS display string built by FPS_StringBuild (0x7F5C0): "FPS: " + integer + +// ============================================================================ +// SECTION 24 — SETDITHER COMPLETE (Ch.12.5.1) +// ============================================================================ + +namespace RVA { + constexpr u32 SetDither_RenderOverlay = 0x08C4A0; // SetDither::RenderOverlay — distinct from RegisterTab + // SetDither::RenderOverlay is invoked by the tab-callback pointer chain + // (not directly from RegisterTab at 0x81810) + // Implements the graphics dither toggle panel body +} + +// ============================================================================ +// SECTION 25 — FREECAM KEY BINDING DISPLAY (Ch.27.3) +// ============================================================================ +// Key display sub-panel inside FreeCam tab (when enabled): +// Each row uses: MakeString(0xFCB0) → Label_Formatter(0x5FB60) → TabMgr::BeginTab(0x9D7D0) +// Key binding state array: [rip + ...] # 0x1803C6E98 ("Pu;" RTTI sentinel in .data) +// Key label format strings (RVAs): +// "Forward Key: %s" 0x3AFD08 VA 0x180087A87 +// "Backward Key: %s" 0x3AFD18 VA 0x180087B1A (approx) +// "Left Key: %s" 0x3AFD30 +// "Right Key: %s" 0x3AFD40 +// "Up Key: %s" 0x3AFD50 +// "Down Key: %s" 0x3AFD60 +// "IncFOV Key: %s" 0x3AFD70 +// "DecFOV Key: %s" 0x3AFD80 +// "LeftRoll Key: %s" 0x3AFD90 +// "RightRoll Key: %s" 0x3AFDA8 +// "ResetRoll Key: %s" 0x3AFDC0 +// "NONE" 0x3AF820 — displayed for any unbound key + +namespace RVA { + constexpr u32 FreeCam_KeyDisplay = 0x087A87; // FreeCam key binding display panel start +} + +// ============================================================================ +// SECTION 26 — SKILLHACK INTERNALS (Ch.10 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 SkillHack_FNV_hash = 0x08D555; // FNV-1a 64-bit hash (unrolled, 8-byte XOR/MUL loop) + // FNV constants: prime=0x100000001B3, offset=0xCBF29CE484222325 + constexpr u32 SkillHack_HashMiss = 0x08D770; // hash miss fallback: xor al,al → ret 0 + constexpr u32 SkillHack_CallOrig = 0x08D891; // call-original trampoline: call r8 (original fn) + constexpr u32 SkillHack_SkipRet = 0x08D894; // skip-to-ret jmp target (cost bypass early exit) + constexpr u32 Vacuum_Monster_subss = 0x093EAC; // Vacuum::Render Monster sub-checkbox subss sequence +} + +// ============================================================================ +// SECTION 27 — CRT SECURITY FUNCTIONS (Ch.4) +// ============================================================================ + +namespace RVA { + constexpr u32 CRT_SecurityInit = 0x0AC580; // __security_check_cookie + SEH init (0xAC580-0xAC6CA) + constexpr u32 CRT_SecurityInit_end = 0x0AC6CA; + constexpr u32 CRT_SecurityCookie = 0x0AC6CC; // __security_check_cookie verifier (0xAC6CC-0xAC77B) + constexpr u32 CRT_SecurityCookie_end= 0x0AC77B; +} +// CRT_SecurityInit pseudocode (called at DllMain + first-chance exception dispatch): +// call IsProcessorFeaturePresent(0x17) → if supported: int 29h (fast fail) +// call __security_check_cookie helper (sub_0x1800AC574) +// RtlCaptureContext / RtlLookupFunctionEntry / RtlVirtualUnwind +// Build EXCEPTION_RECORD: code=0x40000015 (STATUS_FATAL_APP_EXIT), flags=NONCONTINUABLE +// call IsDebuggerPresent → save eax +// call SetUnhandledExceptionFilter(NULL) +// call UnhandledExceptionFilter(&record) +// if !result && !debugger: call TerminateProcess(handle, code) [via int 29h at 0xAC628] + +// ============================================================================ +// SECTION 28 — THREAD ENUMERATION DETAIL (Ch.3 call-site map) +// ============================================================================ +// All CollectProcessThreads (0xA96B0) internal call sites: +// 0xA9701 TH32CS_SNAPTHREAD = 4 (lea ecx,[rbx+4]) +// 0xA970B CreateToolhelp32Snapshot(4, pid) +// 0xA971E sizeof(THREADENTRY32) = 28 = 0x1C +// 0xA972F Thread32First(hSnapshot, &te32) +// [loop body] +// 0xA9740 check te32.th32OwnerProcessID offset (0x10) +// 0xA974B GetCurrentProcessId() +// 0xA9751 cmp te32.th32OwnerProcessID, eax +// 0xA9757 GetCurrentThreadId() +// 0xA975D cmp te32.th32ThreadID, eax +// 0xA9761 je skip (exclude caller thread) +// 0xA9763 get vector data ptr +// 0xA9778 VirtualAlloc/HeapReAlloc if vector full +// 0xA97CA store thread ID: [rdx+rcx*4] = eax +// 0xA97CD inc [rdi+0xC] (vector count++) +// 0xA97DD Thread32Next(hSnapshot, &te32) +// 0xA97E3 test eax,eax → jne loop +// 0xA97EB GetLastError → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0xA9815 CloseHandle(hSnapshot) +// +// SuspendOrResumeThreads (0xA9A20) call sites: +// 0xA9849 OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// 0xA9861 SuspendThread(hThread) +// 0xA9964 ResumeThread(hThread) [×37 total resume calls] +// 0xA988B GetThreadContext(hThread, &ctx) +// 0xA993C CreateToolhelp32Snapshot (secondary snapshot) +// +// PatchCode (0xA9A9C) call sites: +// 0xA9AFC VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &old) +// 0xA9B6C VirtualProtect(target, size, old, &old) (restore) +// 0xA9B72 GetCurrentProcess() +// 0xA9B81 FlushInstructionCache(hProc, target, size) + +// ============================================================================ +// SECTION 29 — IAT CALL SITE MAP (Ch.2 complete) +// ============================================================================ +// All Win32 IAT entries with RVAs and call sites: +// SuspendThread IAT 0xB1050 call site 0xA9861 +// ResumeThread IAT 0xB1058 call site 0xA9964 (×37) +// GetThreadContext IAT 0xB1068 call site 0xA988B +// FlushInstructionCache IAT 0xB1070 call site 0xA9B81 +// SetThreadContext IAT 0xB1078 call site 0xA993C +// GetProcAddress IAT 0xB1088 call sites 0x55F7E, 0x55F92 (×7) +// LoadLibraryA IAT 0xB10E0 call sites 0x55F57, 0x585AE (×4) +// AllocConsole IAT 0xB1108 +// GetConsoleMode IAT 0xB1120 +// SetConsoleMode IAT 0xB1128 +// SetConsoleTitleA IAT 0xB12A0 +// GetCurrentProcess IAT 0xB1270 call site 0xA9B72 +// VirtualFree IAT 0xB1278 call sites 0x81D5B, 0xAA6E1 +// VirtualProtect IAT 0xB1288 call sites 0xA9AFC, 0xA9B6C +// VirtualAlloc IAT 0xB11A0 call sites 0xAA566, 0xAA607 +// IsDebuggerPresent IAT 0xB11E8 call site 0xAC67B +// IsProcessorFeaturePresent IAT 0xB11F0 call site 0xAC5A2 +// TerminateProcess IAT 0xB11F8 call site 0xAC628 (via int 29h) +// SetUnhandledExceptionFilter IAT 0xB1200 call site 0xAC698 +// UnhandledExceptionFilter IAT 0xB1208 call site 0xAC6A3 +// RtlVirtualUnwind IAT 0xB1210 +// RtlLookupFunctionEntry IAT 0xB1218 +// RtlCaptureContext IAT 0xB1220 +// OpenThread IAT 0xB11D0 call site 0xA9849 (×38) +// Thread32Next IAT 0xB11A8 call site 0xA97DD +// Thread32First IAT 0xB11B0 call site 0xA972F +// CreateToolhelp32Snapshot IAT 0xB1160 call site 0xA970B +// SetWindowDisplayAffinity IAT 0xB1460 call site 0x8B48F +// FindWindowA IAT 0xB14A8 call site 0x8301F +// EnumWindows IAT 0xB14A0 +// GetWindowRect IAT 0xB1488 +// GetWindowThreadProcessId IAT 0xB1498 +// IsWindow IAT 0xB1468 +// GetSystemMetrics IAT 0xB14E0 +// LoadIconW IAT 0xB14E8 +// GetAsyncKeyState IAT 0xB???? call site 0x8301A +// ShowWindow IAT 0xB1628 +// UpdateWindow IAT 0xB14D8 +// RegisterClassExW IAT 0xB1638 +// CreateWindowExW IAT 0xB1650 +// SetLayeredWindowAttributes IAT 0xB15E0 +// SetProcessDPIAware IAT 0xB15A0 +// LoadCursorW IAT 0xB15C8 +// PeekMessageW IAT 0xB14D0 +// TranslateMessage IAT 0xB14C8 +// DispatchMessageW IAT 0xB14C0 +// PostQuitMessage IAT 0xB???? (WndProc WM_DESTROY) +// SetWindowPos IAT 0xB???? (overlay alignment) +// CreateSolidBrush IAT 0xB1018 +// CreateMutexA IAT 0xB1720 +// DwmExtendFrameIntoClientArea IAT 0xB1918 +// D3D11CreateDeviceAndSwapChain IAT 0xB1908 +// D3DCompile IAT 0xB1000 call sites 0x54E77, 0x55069 +// _wfopen IAT 0xB1888 call site 0x11F93 +// fwrite IAT 0xB1868 call sites 0xEA1B, 0x170D6, 0x3033B, 0x3076D +// fread IAT 0xB1870 (via 0x11EA0 helper) +// fclose IAT 0xB1878 call sites 0x170DF, 0x30776 + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 30 — REMAINING CALL-SITE ADDRESSES (final gap closure) +// ============================================================================ +// These are internal addresses referenced in the doc that complete coverage. +// They are instruction-level addresses, not function entry points. + +namespace RVA { + // Config I/O range markers + constexpr u32 OpenConfigFile_end = 0x012043; // OpenConfigFile range end (0x11EA0–0x12043) + constexpr u32 ImGuiSaveIni_caller = 0x0170B9; // caller VA of ImGuiSaveIni (fopen 'wt' for .ini) + constexpr u32 SaveConfig_iniwrite = 0x030750; // SaveConfig: write ImGui ini section call site + + // FpsUnlocker alt address (function table ref) + constexpr u32 FpsUnlocker_Render_alt = 0x085B80; // FpsUnlocker::Render alt ref addr (one-byte offset) + + // FreeCam key display + constexpr u32 FreeCam_BackwardKey = 0x087B1A; // "Backward Key: %s" display address (approx) + + // ModuleManager::DispatchRegistrarInit call site + constexpr u32 DispatchRegInit_callsite = 0x083348; // called at 0x83348 — init ImGui panel layout after first Present + + // ModulePathScanner skip-on-failure + constexpr u32 ModPathScanner_skip = 0x08BA41; // je target: skip module on GetModuleFileNameW failure + + // CollectProcessThreads instruction-level addresses (within 0xA96B0 body) + // 0xA96E7 xor ebx,ebx — thread count = 0 + // 0xA96F8 init empty vector — mov [rcx],rbx; mov [rcx+8],rbx + // 0xA9711 mov r14,rax — hSnapshot = CreateToolhelp32Snapshot result + // 0xA9714 cmp rax,-1 — INVALID_HANDLE_VALUE check + // 0xA9725 lea rdx,[rsp+0x30] — THREADENTRY32 buffer ptr + // 0xA972A mov [rsp+0x30],r12d — te32.dwSize = 28 + // 0xA9751 cmp [rsp+0x3C],eax — te32.th32OwnerProcessID == GetCurrentProcessId + // 0xA9755 jne skip — skip threads from other processes + // (All within CollectProcessThreads body at 0xA96B0; see Section 28 for full map) +} + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 19 — SIDEBAR / MAIN PANEL (Ch.25) +// ============================================================================ +// Top-level overlay panel function: RVA 0x7F8F0 (~0x146E bytes) +// Called every Present() frame from ModuleManager render loop. +// Stack frame: 0x380 bytes; saves xmm6-xmm8; single rcx arg (global ctx ptr) +// +// Key strings: +// "Sidebar" RVA 0x3AF2C8 — window lookup key (CRC32 0x11DF0, reg 0x3D1A0/0x1D2B0) +// "EF - Cheeto Press F12 to show panel" RVA 0x3AF258 +// "This is free, if you spend money, then you have been deceived" RVA 0x3AF288 +// Active tab index: [.data+0x1F68] VA 0x1803C6F68 (written on click, read at 0x80B52) +// +// Six tabs (jump-table dispatch at 0x80B52, case bodies): +// Tab 0 "About" RVA 0x3AF2D0 — banner + disclaimer + About sub-fn (0x80E80) +// Tab 1 "Player" RVA 0x3AF2DC — NoClip, SkillHack +// Tab 2 "ESP" RVA 0x3AF2E8 — ESPModule overlay +// Tab 3 "World" RVA 0x3AF2F0 — Vacuum +// Tab 4 "Visual" RVA 0x3AF2FC — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +// Tab 5 "Settings" RVA 0x3ADFD8 — Settings::RenderOverlay (case 5 at 0x80D25) +// +// i18n label dispatcher: 0x9D660 (translates label string per language toggle) +// Sidebar function tail-calls into ImGui epilogue at 0x23E20 via jmp at 0x80D5E + +namespace RVA { + constexpr u32 Sidebar_Main = 0x07F8F0; // top-level sidebar render + constexpr u32 Sidebar_About = 0x080E80; // About tab sub-function + constexpr u32 Sidebar_JumpTable = 0x080B52; // tab jump table (reads [.data+0x1F68]) + constexpr u32 Sidebar_Case5 = 0x080D25; // Settings tab case entry + constexpr u32 i18n_Dispatcher = 0x09D660; // translation dispatcher (en/zh_cn) + // ImGui_Combo = 0x064220 (already defined in Section 9 RVA namespace) + // ImGui_Epilogue = 0x023E20 (already defined in Section 9 RVA namespace) + constexpr u32 CRC32_fn = 0x011DF0; // CRC32 hash (window key) + constexpr u32 Registry_lookup = 0x03D1A0; // registry lookup by CRC32 + constexpr u32 Registry_lookup2 = 0x01D2B0; // secondary registry lookup +} + +// ============================================================================ +// SECTION 20 — FREECAM KEY BINDING DISPLAY PANEL (Ch.27) +// ============================================================================ +// Sub-section of FreeCam::Update (RVA 0x871A0), begins at ~0x87A70, ends 0x88606 +// (FreeCam::Update is 0x14C6 bytes total) +// +// Float sliders (ImGui variant 0x65570): +// "Free Camera" RVA 0x3AFCB0 — sub-panel BeginTab label +// "ON / OFF" RVA 0x3AF848 — toggle checkbox +// "Move Speed" RVA 0x3AFCC0 — DragFloat fmt "%.3f" (0x3ADFB0) +// "Look Sensitivity" RVA 0x3AFCD0 — DragFloat fmt "%.3f" +// "Roll Speed" RVA 0x3AFCE8 — DragFloat fmt "%.3f" +// "FOV Speed" RVA 0x3AFCF8 — DragFloat fmt "%.3f" +// "FOV" RVA 0x3AFD04 — DragFloat fmt "%.1f" (0x3ADFEC) +// +// Key binding rows (11 total) — each row: +// MakeString(0xFCB0) → sprintf(0x5FB60, "Key: %s", key_name) → TabLabel(0x9D7D0) +// "NONE" RVA 0x3AF820 — displayed for unbound keys +// Key-binding state array: [rip+...] 0x1803C6E98 +// Rows: +// "Forward Key: %s" RVA 0x3AFD08 (VA 0x180087A87) +// "Backward Key: %s" RVA 0x3AFD18 +// "Left Key: %s" RVA 0x3AFD30 +// "Right Key: %s" RVA 0x3AFD40 +// "Up Key: %s" RVA 0x3AFD50 +// "Down Key: %s" RVA 0x3AFD60 +// "IncFOV Key: %s" RVA 0x3AFD70 +// "DecFOV Key: %s" RVA 0x3AFD80 +// "LeftRoll Key: %s" RVA 0x3AFD90 +// "RightRoll Key: %s" RVA 0x3AFDA8 +// "ResetRoll Key: %s" RVA 0x3AFDC0 + +namespace RVA { + constexpr u32 FreeCam_KeyBindPanel = 0x087A70; // key binding display section start + constexpr u32 FreeCam_KeyBind_end = 0x088606; // end of FreeCam::Update + constexpr u32 Sprintf_label = 0x05FB60; // sprintf-style label formatter +} + +// ============================================================================ +// SECTION 21 — SETTINGS TAB (Ch.28) +// ============================================================================ +// Settings::RenderOverlay RVA 0x9A4F0 (source: SettingsTAB.cpp RVA 0x3B0B30) +// Called from sidebar case 5 (0x80D25). Ends at ~0x9AB31. +// +// 28.1 Theme selector: +// ImGui::Combo("Theme", ...) via 0x64220 +// Four themes → four applicator functions: +// "Default" RVA 0x3B0AF8 → applicator 0x941F0 (restores ImGui defaults) +// "Evangelion Unit 01" RVA 0x3B06D0 → applicator 0x94890 (52 color writes) +// "Evangelion Unit 02" RVA 0x3B0AE0 → applicator 0x96770 +// "Matrix" RVA 0x3B0B10 → applicator 0x98650 +// Each non-default applicator uses per-slot helper RVA 0x94190 (159 calls total): +// reads RRGGBBAA hex string → __stdio_common_vsscanf → ImGui::PushStyleColor (0x10840) +// +// Evangelion Unit 01 colors (RVA 0x94890, in write order): +// #FFFFFFFF #7857A7FF #19171CFF #2A282EFF #2A282EE6 #4DE6A5FF +// #00000000 #4A455240 #A38CCF80 #7857A780 #4A4552FF +// +// Evangelion Unit 02 colors (RVA 0x96770): +// #FFFFFFFF #D9293BFF #1E1E1EFF #3A3A3AFF #3A3A3AE6 #F7B302FF +// #00000000 #4A455240 #F7465880 #D9293B80 #4A4552FF +// +// Matrix colors (RVA 0x98650): +// #00FF41FF #00AA2CFF #000000FF #0A0A0AFF #0A0A0AE6 #004400FF +// #00000000 #00440040 #00881EFF #00FF4180 +// +// 28.3 Console toggle: +// CheckboxToggle(0x85320) with label "Toggle Console" (RVA 0x3B0B00) +// Enabled branch: AllocConsole (IAT 0xB1178) / GetStdHandle → display "Console {}" +// Disabled branch: FreeConsole + +namespace RVA { + constexpr u32 Theme_Default = 0x0941F0; // restores ImGui default palette + constexpr u32 StyleColor_push = 0x010840; // ImGui::PushStyleColor wrapper + // Settings_end 0x09AB31 — see also RVA::Settings_end 0x09AB98 in Section 9 +} + +// ============================================================================ +// SECTION 22 — CONFIG / IMGUI .INI SYSTEM (Ch.19) +// ============================================================================ +// ImGui .ini filename: "imgui.ini" RVA 0x3ABB60 +// Set at RVA 0x1117A into ImGuiIO+0x20 (IniFilename field) +// +// Config save/load: +// Load path (startup): RVA 0x30661 → ConfigSerialize (0x12050) +// → ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell → fread → fclose +// Manual save trigger: RVA 0x17072 +// Sets [ImGuiContext+0x2900]=1, [ImGuiContext+0x2904]=0 → forces immediate write +// fwrite calls: 0x3076D (config body), also 0x170D6 +// fclose: 0x30776 +// +// Module settings handler struct (ImGuiContext+0x2920 array, 0x48 bytes each): +// +0x00 TypeName (const char*) — .ini section name +// +0x08 TypeHash (u32) — CRC32 of TypeName (computed 0x3079C–0x30803) +// +0x18 ReadOpenFn — called on section header encounter +// +0x38 WriteAllFn — called during save to emit key=value lines +// 11 registered modules (RTTI .data+0x0590–0x0E60): +// ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule +// +// i18n blob: RVA 0x3B10E8 (0xEED bytes, nlohmann JSON, en→zh_cn map) +// Copied to [.data+0x1EB8] at startup RVA 0x2164 +// Loader: RVA 0x9D660 — selects en or zh_cn based on language flag +// nlohmann version: v3.12.0 (statically linked; error strings at 0x3B3010–0x3B30D8) + +namespace RVA { + constexpr u32 ImGuiIni_set = 0x01117A; // IniFilename = "imgui.ini" write + constexpr u32 Config_save_trigger = 0x017072; // manual save: set ImGuiCtx+0x2900 + constexpr u32 Config_load_entry = 0x030661; // config file load entry + constexpr u32 Config_ftell = 0x0120A0; // ftell in config read + constexpr u32 Config_fseek_A = 0x0120BC; // fseek in config read + constexpr u32 Config_fseek_B = 0x0120E7; // fseek in config read + constexpr u32 Config_fwrite = 0x03076D; // config body fwrite + constexpr u32 Config_fclose = 0x030776; // config fclose + constexpr u32 ImGui_handler_CRC = 0x03079C; // CRC32 of TypeName (start) + constexpr u32 ImGui_handler_CRC_end = 0x030803; // CRC32 of TypeName (end) + constexpr u32 i18n_blob_rva = 0x3B10E8; // JSON localization blob (.rdata) + constexpr u32 i18n_loader = 0x09D660; // translation dispatcher + constexpr u32 i18n_copy_site = 0x02164; // startup: copies blob to [.data+0x1EB8] + constexpr u32 Registrar_name_str = 0x01B71; // registrar constructor name string RVA ref +} + +// ============================================================================ +// SECTION 23 — UNITY EXPLORER MODULE (Ch.16 supplement) +// ============================================================================ +// UE draw body: RVA 0x0902E0 (per-frame inspector UI, called from UE::Render 0x90250) +// Window title: "Unity Explorer Window" RVA 0x3B02E0 (via ImGui::Begin wrapper 0x937D0) +// +// Scene panel (pseudocode): +// if (scene_list empty) { +// ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +// } else { +// ImGui::Text("Select Scene:"); +// ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +// if (changed) LoadScene(selected_scene_idx); +// } +// // When scene panel active: g_Config->overlay_flags |= 1; overlay_scale = 300.0f +// // ([g_Config+0x1F78], [g_Config+0x1F90]) +// +// Auto-refresh (RVA 0x090250): +// if (enabled && auto_refresh) { +// now = GetTime(); // 0x93B10 +// if ((now - last_refresh_time) * SCALE >= refresh_interval) +// RefreshScenes(this); last_refresh_time = now; +// } +// +// Scene list storage: vector at [this+0x58]..[this+0x60] +// GameObject list: vector at [this+0x40]..[this+0x48] +// Search filter: [this+?] char[0x100] buffer "##SearchFilter" +// +// Inspector panel (when object selected via 'Ins' button): +// 'Active' checkbox → GameObject.SetActive via IL2CPP +// Transform: Position, LocalPosition, Rotation, Scale (float3 inputs) +// 'Components' section via IL2CPP GetComponents(UnityEngine.Component) +// Per component: "%s.%s" (namespace.classname) +// Failure strings: "Unknown Component", "Unable to get GameObject class information." +// +// Key strings (Ch.16.4): +// "No scenes available. Click 'Refresh Scenes' to load." +// "Select Scene:" "No GameObjects found in this scene." "DontDestroyOnLoad" +// "No GameObject selected." "Active" "Components" "All Components:" + +namespace RVA { + constexpr u32 UE_DrawBody = 0x0902E0; // main per-frame inspector draw + constexpr u32 UE_AutoRefresh_fn = 0x093B10; // auto-refresh timer check +} + +// ============================================================================ +// SECTION 24 — ADDITIONAL IAT ENTRIES (referenced in doc but not in Ch.2 table) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw offset 0xAF600) +// These slots appear in inline code references throughout the doc: + +// IAT[0xB1148] SwitchToThread — spinlock backoff (if backoff<32: SwitchToThread else Sleep(1)) +// IAT[0xB1168] GetModuleFileNameExW — module path scanner, get full path of each module +// IAT[0xB1178] AllocConsole — Settings console toggle enable branch +// IAT[0xB1290] GetModuleHandleW — GABypass: GetModuleHandleW(L"GameAssembly.dll") +// also: PreventScreenshot::OsCheck loads ntdll for RtlGetVersion + +// ============================================================================ +// SECTION 25 — MODULEMANGER INIT VARIANT ADDRESS (Ch.19.7) +// ============================================================================ +// Two RVAs for ModuleManager::Init appear in the doc: +// RVA 0x09AC10 — from Ch.15 (primary reference) +// RVA 0x09ACA4 — from Ch.19.7 (alternate call site / body continuation) +// Both refer to the same function; 0x9AC10 is entry, 0x9ACA4 is within body. +// Body action (Ch.19.7): +// Iterates module registry [.data+0x23B8], calls vtable[+0x10] → module instance, +// then vtable[+0x18] (Render dispatch) per registered module. +// Source: ModuleManager.cpp lines 34 and 52 (assert strings in binary). + +// Vacuum::RegisterTab stub at RVA 0x9B650 resolves via jmp to +// UnityExplorerModule::RegisterTab at RVA 0x090060. +// (Vacuum and UE share a registrar stub due to module ordering in init sequence) + +// GABypass::Patch call site in startup: RVA 0x0A942A +// Called exactly once from LoaderThread, immediately after 'Initializing..' log (0xA93E6) +// and before any module Update()/Render() calls. + +// ============================================================================ +// SECTION 26 — COMPLETE ADDRESS COVERAGE INDEX +// ============================================================================ +// All 282 unique cheat-range addresses extracted from the doc, organized by subsystem. +// Addresses not in RVA:: namespace appear inline below with descriptions. + +// -- Config / i18n / .ini system -- +// 0x01B71 registrar constructor name string ref +// 0x02164 i18n blob copy to [.data+0x1EB8] at startup +// 0x1117A ImGuiIO.IniFilename = "imgui.ini" write site +// 0x17072 manual config save trigger (sets ImGuiCtx+0x2900=1) +// 0x30661 config file load entry (calls ConfigSerialize 0x12050) +// 0x30904 ImGui handler struct layout base (from CRC32 compute chain) + +// -- Sidebar / UI -- +// 0x80B52 sidebar tab jump table (reads active_tab_idx [.data+0x1F68]) + +// -- D3D11 overlay window (detailed call sites Ch.29) -- +// 0x8298B EnumWindows → FindGameWindow, end of DPI section +// 0x82A60 DwmExtendFrameIntoClientArea call site +// 0x82B24 D3D11CreateDeviceAndSwapChain attempt 1 (R8G8B8A8) +// 0x82B7E D3D11CreateDeviceAndSwapChain attempt 2 (B8G8R8A8 fallback) +// 0x82C0D CreateMutexA — duplicate-instance guard +// 0x82F5F Log "Initialized" (source UI.cpp, before message loop) +// 0x83386 DispatchRegistrarInit once_flag — install registrar hooks +// 0x8348A SwitchToThread yield site (game out of focus) + +// -- FreeCam -- +// 0x87A70 FreeCam key binding display panel start (inside FreeCam::Update) +// 0x88606 FreeCam::Update end + +// -- UnityExplorer -- +// 0x902E0 UE main draw body (scene panel + GO inspector) + +// -- Settings / Theme -- +// 0x941F0 Default theme applicator (restores ImGui defaults) +// 0x9AB31 Settings::RenderOverlay approximate end + +// -- ModuleManager -- +// 0x9ACA4 ModuleManager::Init body (alt addr, iterates registry vtable[+0x10]/[+0x18]) +// 0x9B650 Vacuum/UE RegisterTab shared stub (resolves to UE::RegisterTab 0x90060) + +// -- Startup -- +// 0xA942A GABypass::Patch call site in LoaderThread (after 'Initializing..' log) + +// -- IAT slots (additional, not in main IAT table) -- +// 0xB1148 SwitchToThread +// 0xB1168 GetModuleFileNameExW +// 0xB1178 AllocConsole +// 0xB1290 GetModuleHandleW (GameAssembly + ntdll RtlGetVersion) + +// ============================================================================ +// SECTION 27 — COMPLETE .RDATA STRING TABLE +// ============================================================================ +// All 189 .rdata string RVAs from the document, grouped by subsystem. +// Format: RVA — "string content" — usage + +// --- ImGui / config filenames --- +// 0x3ABB60 "imgui.ini" ImGuiIO+0x20 IniFilename (written at RVA 0x1117A) +// 0x3ABB70 "imgui_log.txt" ImGuiIO+0x28 LogFilename (written at same site) +// 0x3ABF10 "##Foreground" FPS overlay frameless window label +// 0x3AC160 "Calling EndDisabled() too many times!" ImGui assert string + +// --- D3D11 shaders (HLSL source, compiled at runtime) --- +// 0x3AE660 Vertex shader HLSL source length=0x2DD (733 bytes) +// entry="main" target="vs_4_0" +// cbuffer vertexBuffer:b0 { float4x4 ProjectionMatrix } +// VS_INPUT{float2 pos:POSITION, float4 col:COLOR0, float2 uv:TEXCOORD0} +// PS_INPUT main: output.pos = mul(ProjectionMatrix, float4(pos.xy,0,1)) +// 0x3AE940 Pixel shader HLSL source length=0x191 (401 bytes) +// entry="main" target="ps_4_0" +// sampler sampler0; Texture2D texture0; +// float4 main: return input.col * texture0.Sample(sampler0, input.uv) + +// --- PreventScreenshot --- +// 0x3AEC70 dynamic import string for SetWindowDisplayAffinity (from user32.dll, RVA 0x3C34A6) +// 0x3B00B8 module name "PreventScreenshot" (registrar) + +// --- About page (Tab 0, sub-fn 0x80E80) --- +// 0x3AF350 "%s Game: Endfield CTB3" format string +// 0x3AF368 "Version: " label +// 0x3AF374 "1.0.0" version value +// 0x3AF380 "Author: " label +// 0x3AF38C "gktwo" author value +// (All direct string literals, not i18n-dispatched) + +// --- Window class detection --- +// 0x3AF658 "UnityWndClass" FindWindowA arg / string-compare (0xACA12) + +// --- ESP module (ESPModule::RenderOverlay RVA 0x83FA0) --- +// 0x3AF828 "ESPModule" module name +// 0x3AF838 "ESP Features" CollapsingHeader title → state [.data+0x27B0] +// 0x3AF848 "ON / OFF" checkbox label → [module+0x28] +// 0x3AF858 "Display Types" CollapsingHeader sub-header (via 0x6EC20) +// 0x3AF868 "Show Monsters" checkbox → [rsi+0x34] show_monsters +// 0x3AF878 "Show NPC" checkbox → [rsi+0x35] show_npc +// 0x3AF888 "Show Friendly" checkbox → [rsi+0x36] show_friendly +// 0x3AF898 "Show Puzzles" checkbox → [rsi+0x37] show_puzzles +// 0x3AF8A8 "Show All" checkbox → [rsi+0x38] show_all +// 0x3AF8B8 "Display Info" CollapsingHeader sub-header +// 0x3AF8C8 "Show Distance" checkbox → [rsi+0x39] show_distance +// 0x3AF8D8 "Show Name" checkbox → [rsi+0x3A] show_name +// 0x3AF8E8 "Show Type" checkbox → [rsi+0x3C] show_type +// 0x3AF8F4 (entity label separator string, used in Update DrawOverlay) +// 0x3AF900 (entity label buffer string) +// 0x3AF908 entity type dispatch table start (type→name pairs) +// 0x3AF920 entity type dispatch table continued (0xFFFFFFFF sentinel) +// 0x3AF9E0 vtable ptr value (0x3AF9E0 = post-init vtable for ESPModule) + +// --- FPS overlay (FPSModule) --- +// 0x3AFA98 FPSModule vtable block start +// 0x3AFAAC "FPS: " prefix for FPS display string (via 0x7F5C0) +// Color thresholds for FPS display (XMMWORD constants, already in .rdata): +// fps >= 60: color at 0x1803B3530 (green 0.0, 1.0, 0.0, 1.0) +// 30<=fps<60: color at 0x1803B3540 (yellow 1.0, 1.0, 0.0, 1.0) +// fps < 30: color at 0x1803B3510 (red 1.0, 0.0, 0.0, 1.0) + +// --- FreeCam --- +// 0x3AF820 "NONE" unbound key display in key binding rows + +// --- PlayerProfile UI paths --- +// 0x3AFED0 "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (len 0x2F) +// 0x3AFFD0 "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (len 0x8D) + +// --- FreeCam key binding panel (Ch.27) --- +// 0x3AFCB0 "Free Camera" +// 0x3AFCC0 "Move Speed" +// 0x3AFCD0 "Look Sensitivity" +// 0x3AFCE8 "Roll Speed" +// 0x3AFCF8 "FOV Speed" +// 0x3AFD04 "FOV" +// 0x3AFD08 "Forward Key: %s" +// 0x3AFD18 "Backward Key: %s" +// 0x3AFD30 "Left Key: %s" +// 0x3AFD40 "Right Key: %s" +// 0x3AFD50 "Up Key: %s" +// 0x3AFD60 "Down Key: %s" +// 0x3AFD70 "IncFOV Key: %s" +// 0x3AFD80 "DecFOV Key: %s" +// 0x3AFD90 "LeftRoll Key: %s" +// 0x3AFDA8 "RightRoll Key: %s" +// 0x3AFDC0 "ResetRoll Key: %s" + +// --- UE module string table (Ch.16.4) --- +// 0x3B02D0 "Unity Explorer" tab label / ImGui::Begin title +// 0x3B02E0 "Unity Explorer Window" ImGui window title +// 0x3B02F8 "Search Filter:" label above search input +// 0x3B0308 "##SearchFilter" ImGui InputText widget ID +// 0x3B0318 "Inspector" inspector sub-panel label +// 0x3B0328 "GameObjectHierarchy" hierarchy sub-panel label +// 0x3B0340 "No scenes loaded. Click Refresh..." +// 0x3B0390 "Scene: " scene prefix label +// 0x3B0398 "No GameObjects found in this scene." +// 0x3B03C0 "DontDestroyOnLoad" special DDOL scene label +// 0x3B03D8 "DontDestroyOnLoad (Not Found)" +// 0x3B03F8 "Refresh" button label +// 0x3B0400 "Auto Refresh" checkbox label +// 0x3B0410 "Interval (s)" refresh interval slider +// 0x3B0420 "Scenes found: %d" +// 0x3B0438 "No scenes available. Click 'Refresh Scenes' to load." +// 0x3B0470 "Select Scene:" +// 0x3B0480 "Select Scene" combo default text +// 0x3B0490 "##SceneCombo" ImGui Combo widget ID +// 0x3B04A0 "]: " object list entry separator +// 0x3B04A8 "Ins##" inspect button label prefix +// 0x3B04B8 "No GameObject selected." +// 0x3B04D0 "Click 'Ins' button..." inspector hint +// 0x3B0508 "Active" active checkbox label +// 0x3B0510 "Transform" section header +// 0x3B0520 "Position" +// 0x3B0530 "Local Position" +// 0x3B0540 "Rotation" +// 0x3B054C "Scale" +// 0x3B0558 "No Transform component found." +// 0x3B0578 "Components" section header +// 0x3B0588 "GameObject Class: %s.%s" +// 0x3B05A0 "All Components:" +// 0x3B05B0 "UnityEngine.Component, UnityEngine.CoreModule" (GetComponents type arg) +// 0x3B05E0 "%s.%s" component name format +// 0x3B05E8 "Unknown Component" +// 0x3B0600 "No components found or failed to get components." +// 0x3B0638 "Unable to get GameObject class information." +// 0x3B0D28 "UnityExplorerModule" module name (registrar) +// UE auto-refresh state: bool at [.data+0x2640], float at [.data+0x2644] + +// --- Settings tab (Ch.28) --- +// 0x3B0AD4 "Theme" combo label +// 0x3B0AF8 "Default" theme name +// 0x3B06D0 "Evangelion Unit 01" theme name +// 0x3B0AE0 "Evangelion Unit 02" theme name +// 0x3B0B10 "Matrix" theme name +// 0x3B0B00 "Toggle Console" checkbox label +// 0x3B0B18 (Settings key address for enabled state) +// 0x3B0B28 "enabled" UI label for module on/off state (not JSON key) +// 0x3B0B78 "Console {}" console enabled display format +// 0x3B0B30 SettingsTAB.cpp source file path string + +// Theme color string RVAs (Evangelion Unit 01): +// 0x3B06E8 0x3B06F8 0x3B0708 0x3B0718 0x3B0728 0x3B0738 +// 0x3B0748 0x3B0758 0x3B0768 0x3B0778 0x3B0798 +// Theme color string RVAs (Evangelion Unit 02): +// 0x3B0888 0x3B0898 0x3B08A8 0x3B08B8 0x3B08C8 0x3B08D8 0x3B08F8 +// Theme color string RVAs (Matrix): +// 0x3B09A8 0x3B09B8 0x3B09C8 0x3B09D8 0x3B09E8 0x3B09F8 +// 0x3B0A08 0x3B0A18 0x3B0A38 + +// --- ModuleManager log strings (Ch.15.7) --- +// 0x3B0B88 "[WARNING] ModuleManager already initialized" +// 0x3B0BC0 ModuleManager.cpp assert source file path +// 0x3B0C08 "Initializing ModuleManager" +// 0x3B0C28 "Failed to initialize module {}" +// 0x3B0C48 "Module {} initialized" +// 0x3B0C60 "ModuleManager initialization complete" +// 0x3B0C90 "[ERROR] Failed to update module " +// 0x3B0CB8 "[ERROR] Failed to render overlay for module " +// 0x3B0CE8 "[ERROR] Failed to process hotkeys for module " + +// --- Config file mode strings --- +// 0x3AD590 "rb" Config READ - binary read mode +// 0x3AD594 "wt" Config WRITE - text write mode (ImGui ini) + +// --- DamageHack ghost keys (Ch.23) --- +// 0x3B1484 i18n table — four keys with no RTTI class (ghost/unimplemented feature) + +// --- Locale --- +// 0x3B2020 "en" locale string passed to string-construct at 0x9D890 + +// --- Startup / project identity --- +// 0x3B3148 "E:\git\Endfield_Cheeto\user\main.cpp" (confirms project name) + +// --- ESP color constant addresses in .data (ESP Update type dispatch) --- +// 0x3B3224 drawlist color source (XMMWORD, type-selected RGBA) +// 0x3B3308 100.0f constant (SkillHack CooldownBypass return value) +// ESP color table .rdata bases (correspond to ESPModule::color[] slots): +// 0x3B3500 color[10] BLACK (0.0,0.0,0.0,1.0) +// 0x3B3510 color[0] RED (1.0,0.0,0.0,1.0) also FPS<30 threshold +// 0x3B3520 color[1] ORANGE (1.0,0.647,0.0,1.0) +// 0x3B3530 color[3] GREEN (0.0,1.0,0.0,1.0) also FPS>=60 threshold +// 0x3B3540 color[2] YELLOW (1.0,1.0,0.0,1.0) also FPS 30-60 threshold +// 0x3B3550 color[11] GRAY (0.502,0.502,0.502,1.0) +// 0x3B3560 color[8] PINK (1.0,0.078,0.576,1.0) +// 0x3B3570 color[9] LPINK (1.0,0.753,0.796,1.0) +// 0x3B3580 color[6] PURPLE (0.58,0.0,0.827,1.0) +// 0x3B3590 color[4] BLUE (0.0,0.0,1.0,1.0) +// 0x3B35A0 color[5] CYAN (0.0,1.0,1.0,1.0) +// 0x3B35B0 color[7] WHITE (1.0,1.0,1.0,1.0) + +// --- Preset/config JSON keys (Ch.17/19) --- +// 0x3B06F8 "Default" preset name (also used as JSON key, via 0x3B0AF8) + +// --- FPS Overlay / PreventScreenshot extra --- +// 0x3B0198 "FPSMonitor" / FPS module registrar tab label (inside main cheat overlay) + +// ============================================================================ +// SECTION 28 — COMPLETE IAT TABLE (all 75 entries) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw 0xAF600). Format: IAT[RVA] = function (DLL) + +// Previously documented entries (Sections 9/24) plus newly added: +// 0xB1148 SwitchToThread KERNEL32 spinlock backoff (if backoff<32) +// 0xB1168 GetModuleFileNameExW PSAPI module path scanner full-path retrieval +// 0xB1178 AllocConsole KERNEL32 Settings console toggle enable +// 0xB1268 GetCurrentThreadId KERNEL32 stack cookie check (RVA 0xAC709) +// 0xB1290 GetModuleHandleW KERNEL32 GABypass: L"GameAssembly.dll"; OsCheck: ntdll +// 0xB1470 GetWindowLongPtrW USER32 overlay: read GWL_STYLE, GWL_EXSTYLE +// 0xB1480 IsWindowVisible USER32 overlay: check game window visible +// 0xB1490 GetClassNameA USER32 overlay: detect foreground window class (×3) +// 0xB1510 IsIconic USER32 overlay: check not minimized +// 0xB1518 SetForegroundWindow USER32 overlay: bring game to front on match +// 0xB1570 DestroyWindow USER32 overlay: cleanup on loop exit +// 0xB1588 SetWindowPos USER32 overlay: reposition to match game window +// 0xB15A8 GetClientRect USER32 overlay: get inner client area +// 0xB15B0 SetWindowLongW USER32 overlay: update window style ×2 +// 0xB15F0 GetForegroundWindow USER32 overlay: check active foreground window +// 0xB1640 UnregisterClassW USER32 overlay: cleanup window class on exit +// 0xB1858 fread CRT config file read (called ONLY from 0x12121) +// 0xB1880 __stdio_common_vsscanf CRT theme color parser (RRGGBBAA hex→RGBA) +// 0xB1890 _wfopen CRT config file open (called ONLY from 0x11F93) +// 0xB1898 fseek CRT config seek (from 0x120BC, 0x120E7) +// 0xB1920 DwmGetWindowAttribute DWMAPI overlay: DWMWA_EXTENDED_FRAME_BOUNDS rect + +// ============================================================================ +// SECTION 29 — IMGUI HELPER RVAs (inline functions used throughout modules) +// ============================================================================ +// ImGui wrapper functions used by module Render() bodies (not in main RVA namespace) + +namespace RVA { + constexpr u32 ImGui_CollapsingHeader = 0x06EC20; // lightweight wrapper; checks ImGuiCtx+0x106 locked flag + constexpr u32 ImGui_Checkbox_commit = 0x061FE0; // checkbox state commit helper + constexpr u32 ImGui_Separator_cursor = 0x070630; // Separator + cursor Y adjust + constexpr u32 ImGui_AddText_colored = 0x051580; // drawlist AddText with explicit color + constexpr u32 FPS_string_builder = 0x07F5C0; // "FPS: " + int → display string + constexpr u32 Str_compare_helper = 0x0ACA12; // internal string compare (wchar/char) + constexpr u32 ImGui_EndDisabled_path = 0x0ACA1F; // EndDisabled via ImGuiCtx+0x27F0 decrement +} + +// ImGuiContext field offsets referenced in cheat code: +// [ImGuiContext+0x106] locked_input_flag (BYTE) — CollapsingHeader disabled check +// [ImGuiContext+0x15D8] foreground_drawlist — FPS overlay drawlist ptr (+0x40 = draw cmds) +// [ImGuiContext+0x27F0] EndDisabled_counter (WORD) — decremented on EndDisabled call +// [ImGuiContext+0x2900] save_to_disk_flag (set=1 by manual save trigger 0x17072) +// [ImGuiContext+0x2904] save_timer (set=0 by manual save trigger) +// [ImGuiContext+0x2910] custom IniFilename (ptr; config save path source) +// [ImGuiContext+0x2920] settings_handlers (dynamically-grown array of 0x48-byte structs) + +// ============================================================================ +// SECTION 30 — D3D11 SHADER SOURCE (Ch.5) +// ============================================================================ +// Both shaders are stored as raw HLSL text in .rdata and compiled at runtime +// via D3DCompile (IAT[0xB1000]) during D3D11Init (RVA 0x54DC0/0x551E8). + +// Vertex shader (RVA 0x3AE660, 733 bytes, "main"/"vs_4_0"): +static const char* VS_HLSL_SOURCE_RVA = "0x3AE660"; // marker only — see comment +// cbuffer vertexBuffer : register(b0) { float4x4 ProjectionMatrix; }; +// struct VS_INPUT { float2 pos:POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// PS_INPUT main(VS_INPUT input) { +// PS_INPUT output; +// output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +// output.col = input.col; output.uv = input.uv; +// return output; } + +// Pixel shader (RVA 0x3AE940, 401 bytes, "main"/"ps_4_0"): +static const char* PS_HLSL_SOURCE_RVA = "0x3AE940"; // marker only — see comment +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// sampler sampler0; Texture2D texture0; +// float4 main(PS_INPUT input) : SV_Target { +// return input.col * texture0.Sample(sampler0, input.uv); } + +// Shader init sequence (RVA 0x54DC0): +// load g_D3DState from [g_Config+0xD8] → R14 +// check already-init: cmp (*r14), null; je skip +// call 0x551F0 (create vertex/index buffers) +// D3DCompile(0x3AE660, 0x2DD, NULL,NULL,NULL, "main","vs_4_0",0,0,...) → vertex blob +// D3DCompile(0x3AE940, 0x191, NULL,NULL,NULL, "main","ps_4_0",0,0,...) → pixel blob + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 31 — COMPLETE .DATA ADDRESS MAP (SUPPLEMENTAL) +// ============================================================================ +// All 97 .data offsets documented across all chapters, with absolute VAs and +// semantic descriptions. Base: .data = 0x1803C5000 (RVA 0x3C5000) + +// --- Module dispatch fn ptr state blocks (vtable[+0x18] accessor targets) --- +// Each module's vtable[+0x18] stub returns the module's .data state block. +// At offset [+0x00] of that block is the actual Render/Update fn ptr written +// by RegisterTab. The ModuleManager dispatch loop calls stub → gets this ptr → calls it. +// +// [.data+0x0530] FpsOverlay state block → fn ptr (overlay render) +// [.data+0x0580] PlayerProfile state block → fn ptr +// [.data+0x0630] SetDither state block → fn ptr (no-op stub 0x83DC0) +// [.data+0x06D0] NoClip state block → fn ptr +// [.data+0x0770] SkillHack state block → fn ptr (hook installer) +// [.data+0x07D0] FreeCam state block → fn ptr + +// --- RTTI / module name strings (.data) --- +// [.data+0x0590]–[.data+0x0E60] 11 module RTTI class descriptors +// (ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule) + +// --- Panel state init config block (.data, written by DispatchRegistrarInit) --- +// [.data+0x1F08] panel_config_src_A (16 bytes) — source for movups xmm0 +// [.data+0x1F18] panel_config_src_B (16 bytes) — source for movups xmm1 +// [.data+0x1F28] panel_config_dst_A (16 bytes) — dest: initial panel state copy +// [.data+0x1F38] panel_config_dst_B (16 bytes) — dest: initial panel state copy + +// --- ESPModule singleton — absolute .data field addresses --- +// Base: [.data+0x1F70] VA 0x1803C6F70 +// +// [.data+0x1F70] QWORD vtable ptr (pre-init: 0x3AFA38; post-init: 0x3AF9E0) +// [.data+0x1F78] STRING name = "ESPModule" (SSO std::string, RVA 0x3AF828) +// [.data+0x1F98] BYTE enabled = 0 +// [.data+0x1FA0] DWORD max_draw_distance = 300 (0x12C) +// [.data+0x1FA4] BYTE show_monsters = 1 +// [.data+0x1FA5] BYTE show_npc = 1 +// [.data+0x1FA6] BYTE show_friendly = 1 +// [.data+0x1FA7] BYTE show_puzzles = 1 +// [.data+0x1FA8] BYTE show_all = 0 +// [.data+0x1FA9] BYTE show_distance = 1 +// [.data+0x1FAA] BYTE show_name = 1 +// [.data+0x1FAB] BYTE reserved = 0 +// [.data+0x1FAC] BYTE show_type = 0 +// [.data+0x1FB0] XMMWD color[0] RED (1.00, 0.00, 0.00, 1.00) — Enemies +// [.data+0x1FC0] XMMWD color[1] ORANGE (1.00, 0.65, 0.00, 1.00) — Interactive/NPC +// [.data+0x1FD0] XMMWD color[2] YELLOW (1.00, 1.00, 0.00, 1.00) — spare +// [.data+0x1FE0] XMMWD color[3] GREEN (0.00, 1.00, 0.00, 1.00) — Friendly +// [.data+0x1FF0] XMMWD color[4] BLUE (0.00, 0.00, 1.00, 1.00) — NPC/spare +// [.data+0x2000] XMMWD color[5] CYAN (0.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2010] XMMWD color[6] PURPLE (0.58, 0.00, 0.83, 1.00) — spare +// [.data+0x2020] XMMWD color[7] WHITE (1.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2030] XMMWD color[8] PINK (1.00, 0.08, 0.58, 1.00) — spare +// [.data+0x2040] XMMWD color[9] LPINK (1.00, 0.75, 0.80, 1.00) — spare +// (color[10] BLACK and color[11] GRAY not stored separately; loaded from .rdata at runtime) +// Note: Color slots 2,5,6,8,9 are spare palette entries with no current entity type mapping. +// Slots 0,1,3,4 map to Enemies/Interactive/Friendly/NPC respectively. + +// --- FPSModule singleton --- +// [.data+0x22E0] QWORD FPSModule singleton ptr VA 0x1803C72E0 +// [.data+0x22E8] STRING name = "FPS Monitor" (SSO std::string) +// [.data+0x2308] BYTE enabled = 0 +// [.data+0x2310] QWORD once_flag (std::once_flag, guards Initialize RVA 0x814C0) + +// --- PreventScreenshot singleton --- +// [.data+0x2358] QWORD PreventScreenshot singleton ptr VA 0x1803C7358 +// [.data+0x2360] STRING name = "Prevent Screenshot" (SSO std::string) +// [.data+0x2380] BYTE enabled = 0 +// [.data+0x2388] BYTE second_toggle_flag = 0 +// [.data+0x2390] QWORD once_flag (guards Initialize RVA 0x8AD70) +// [.data+0x24D0] QWORD hook/window list head (linked list; nodes have HWND at [+0x10]) +// [.data+0x24F0] DWORD cached OSVERSIONINFOEXW.dwBuildNumber (from memcpy of RtlGetVersion) +// [.data+0x24FC] DWORD cached OS build number (same value, second copy for comparison) + +// --- UnityExplorer module --- +// [.data+0x260C] QWORD once_flag (guards RegisterTab RVA 0x90060) +// [.data+0x2610] QWORD update_fn_ptr = 0x083DC0 (shared no-op stub) +// [.data+0x2618] STRING tab_string = "Unity Explorer" (std::string) +// [.data+0x2638] BYTE enabled = 0 +// [.data+0x2640] BOOL auto_refresh = 0 +// [.data+0x2644] float refresh_interval = 3.0f (0x40400000) +// [.data+0x2648] QWORD* scene_list_begin = NULL +// [.data+0x2650] QWORD* scene_list_end = NULL +// [.data+0x2660] QWORD* scene_list_cap = NULL +// [.data+0x2670] DWORD selected_scene_idx = 0 +// [.data+0x2680] DWORD selected_obj_idx = 0 +// [.data+0x2684] char[0x100] search_filter = "" (zero-filled) +// [.data+0x2784] BOOL inspector_active = 0 +// [.data+0x2788] QWORD inspected_obj_ptr = 0 +// [.data+0x2790] STRING inspected_obj_name = "" (std::string) + +// ============================================================================ +// SECTION 32 — MAGIC CONSTANTS AND IEEE 754 VALUES +// ============================================================================ + +// --- IEEE 754 float constants --- +static_assert(sizeof(float) == 4, "float must be 32-bit"); + +// 0x41F00000 = 30.0f — FreeCam Move Speed default +// 0x3DCCCCCD = 0.1f — FreeCam Move Speed / Roll Speed / FOV Speed step +// 0x42C80000 = 100.0f — FreeCam Roll Speed max; SkillHack CooldownBypass return value +// 0x43FA0000 = 500.0f — FreeCam Move Speed max +// 0x40400000 = 3.0f — UnityExplorer auto-refresh interval default +// 0x3F800000 = 1.0f — HookManager load factor threshold; FreeCam FOV multiplier default +// 0x42960000 = 75.0f — FreeCam Look Sensitivity default +// 0x44415357 = (reinterpret: packed 'WASD' ASCII) — FreeCam default key binding word + +// --- FreeCam default key binding block --- +// Written to [.data+0x2230..0x225E] by FreeCam::RegisterMainTab: +// [+0x2230..0x223F] = [0x1803B34F0] (key config block 1, 16 bytes) +// [+0x2240..0x224F] = [0x1803B35C0] (key config block 2, 16 bytes) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier) +// [+0x2254] = 0x44415357 ('WASD' key mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind word) +// [+0x225E] = 0x60 (backtick key — FreeCam toggle) + +// --- Security cookie --- +// Stack canary magic value (lower 48 bits): 0x2B992DDFA232 +// Full XOR combination of: GetSystemTimeAsFileTime, GetCurrentThreadId, +// GetCurrentProcessId, QueryPerformanceCounter (see Ch.4 / Section 4) +// Checked at RVA 0x0AC6CC by __security_check_cookie (CRT standard) + +// --- Windows version constants --- +// 0x4A61 = 19041 decimal — Windows 10 Build 19041 (20H1) +// Used in PreventScreenshot::OsCheck to select WDA_MONITOR vs WDA_EXCLUDEFROMCAPTURE: +// build < 19041: SetWindowDisplayAffinity(..., 1) // WDA_MONITOR +// build >= 19041: SetWindowDisplayAffinity(..., 0x11) // WDA_EXCLUDEFROMCAPTURE + +// --- Hash constants --- +// FNV-1a 64-bit (used in HookManager hash table): +// Offset basis: 0xCBF29CE484222325ULL +// Prime: 0x00000100000001B3ULL +// (See Section 8 / Ch.8.7 for unrolled implementation at RVA 0x8D555) + +// --- CP_UTF8 --- +// 0xFDE9 = 65001 = CP_UTF8 +// Used in: MultiByteToWideChar calls in OpenConfigFile (0x11EA0), +// SetConsoleOutputCP (startup), UTF8ToWide helper (0x8B4E0) + +// --- Module object sizes --- +// BaseModule object size: 0x30 bytes (used by operator delete in NoOpUpdateStub) +// FPSModule object size: 0xD8 bytes (zeroed by memset 0xAC86A in Initialize) +// PreventScreenshot object size: 0x48 bytes (from vtable dtor stub size arg) +// UnityExplorer state block size: 0x190 bytes (zero-filled in RegisterTab) +// FreeCam state block size: 0xD8 bytes (zeroed in RegisterMainTab) +// HookEntry size: 0x38 bytes (stride in hook_array) +// HookManager singleton size: 0x90 bytes +// ModuleManager registrar stride: 0x60 bytes per slot +// ImGui settings handler size: 0x48 bytes per handler struct +// THREADENTRY32 size: 28 (sizeof: written as r12d = [rbx+0x1C]) +// OSVERSIONINFOEXW size: 0x11C bytes (stack-allocated in OsCheck) + +// --- HookManager array constants --- +// Initial hook array capacity: 0x80 slots +// Shrink threshold: count <= capacity/2 AND count > 0x20 +// Load factor threshold: 1.0f (0x3F800000) — triggers hash table rehash + +// --- SkillHack callback return constants --- +// 0x42C80000 = 100.0f returned by Callback_CooldownBypass (RVA 0x8D500) +// stored at .rdata RVA 0x3B3308 +// Note: prior summary incorrectly stated 0.0; doc confirms 100.0f + +// ============================================================================ +// SECTION 33 — IAT SUPPLEMENTAL ENTRIES (Ch.19 / final resolution) +// ============================================================================ +// Additional IAT entries resolved in Ch.19 not previously in header: +// IAT[0xB1278] VirtualFree KERNEL32 hook manager cleanup +// IAT[0xB1288] VirtualProtect KERNEL32 hook patcher (Ch.8.6) +// IAT[0xB1628] ShowWindow USER32 Settings console toggle visibility +// IAT[0xB1868] fwrite CRT config body (0xEA1B, 0x170D6, 0x3033B, 0x3076D) +// IAT[0xB1870] fclose CRT (0xEAB0, 0x1212F, 0x121A9, 0x170DF) + +// ============================================================================ +// END SUPPLEMENTAL SECTIONS +// ============================================================================ + +// ============================================================================ +// SECTION 34 — FINAL FIVE .DATA ADDRESSES +// ============================================================================ + +// [.data+0x2180] QWORD SetDither update fn ptr = 0x1803B01B0 → 0x83DC0 (no-op stub) +// Written by SetDither::RegisterTab (RVA 0x181810) + +// [.data+0x2307] BYTE End of FPSModule name std::string SSO buffer +// Name "FPS Monitor" occupies [.data+0x22E8]..[.data+0x2307] +// (19 chars + null = 20 bytes; SSO inline storage) + +// [.data+0x237F] BYTE End of PreventScreenshot name std::string SSO buffer +// Name "Prevent Screenshot" occupies [.data+0x2360]..[.data+0x237F] +// +0x28 field = enabled BYTE (checkbox state; drives affinity arg) + +// [.data+0x245C] BYTE g_showPanel — overlay panel visibility flag +// 0 = hidden, 1 = visible +// Toggled by VK_F12 (0x7B) poll at RVA 0x8301A (GetAsyncKeyState) +// Banner shown when hidden: "EF - Cheeto ... Press F12" (RVA 0x3AF258) + +// [.data+0x24D8] QWORD PreventScreenshot HWND list count / tracked window count +// Companion to [.data+0x24D0] (linked list head) +// Used in Update affinity application loop (RVA 0x8AFC0) + diff --git a/IDA/project/docs/input/files/ef_cheeto_feed_3a_hexdumps.txt b/IDA/project/docs/input/files/ef_cheeto_feed_3a_hexdumps.txt new file mode 100644 index 0000000..15acf1a --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_feed_3a_hexdumps.txt @@ -0,0 +1,1761 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 3A/3 +# This part: Named function hex dumps (actual machine code bytes) +# 33 key functions, all annotated with RVA and function name. +# Use with Parts 1, 2, and 3B. + +# EF-Cheeto.dll — Named Function Hex Dumps +# All addresses are RVAs (add 0x180000000 for VA) +# Generated from .text section (raw offset 0x400) + +======================================================================== +FUNCTION: DllMain +RVA: 0x01000–0x02000 Size: 4096 bytes +180001000 48 8D 0D 89 ED 0A 00 E9 D8 AB 0A 00 CC CC CC CC H............... +180001010 48 89 5C 24 08 48 89 74 24 10 48 89 7C 24 18 4C H.\$.H.t$.H.|$.L +180001020 89 64 24 20 55 41 56 41 57 48 8D AC 24 70 FA FF .d$ UAVAWH..$p.. +180001030 FF 48 81 EC 90 06 00 00 C6 44 24 40 02 48 8D 05 .H.......D$@.H.. +180001040 54 E6 3A 00 48 89 44 24 48 C6 44 24 50 04 48 8D T.:.H.D$H.D$P.H. +180001050 05 4B E6 3A 00 48 89 44 24 58 C6 44 24 60 05 48 .K.:.H.D$X.D$`.H +180001060 8D 05 42 E6 3A 00 48 89 44 24 68 C6 44 24 70 06 ..B.:.H.D$h.D$p. +180001070 48 8D 05 39 E6 3A 00 48 89 44 24 78 C6 45 80 08 H..9.:.H.D$x.E.. +180001080 48 8D 05 31 E6 3A 00 48 89 45 88 C6 45 90 09 48 H..1.:.H.E..E..H +180001090 8D 05 2E E6 3A 00 48 89 45 98 C6 45 A0 0C 48 8D ....:.H.E..E..H. +1800010A0 05 23 E6 3A 00 48 89 45 A8 C6 45 B0 0D 48 8D 05 .#.:.H.E..E..H.. +1800010B0 1C E6 3A 00 48 89 45 B8 C6 45 C0 10 48 8D 05 15 ..:.H.E..E..H... +1800010C0 E6 3A 00 48 89 45 C8 C6 45 D0 11 48 8D 05 0E E6 .:.H.E..E..H.... +1800010D0 3A 00 48 89 45 D8 C6 45 E0 12 48 8D 05 07 E6 3A :.H.E..E..H....: +1800010E0 00 48 89 45 E8 C6 45 F0 13 48 8D 05 FC E5 3A 00 .H.E..E..H....:. +1800010F0 48 89 45 F8 C6 45 00 14 48 8D 05 F9 E5 3A 00 48 H.E..E..H....:.H +180001100 89 45 08 C6 45 10 1B 48 8D 05 F6 E5 3A 00 48 89 .E..E..H....:.H. +180001110 45 18 C6 45 20 20 48 8D 05 EB E5 3A 00 48 89 45 E..E H....:.H.E +180001120 28 C6 45 30 21 48 8D 05 E4 E5 3A 00 48 89 45 38 (.E0!H....:.H.E8 +180001130 C6 45 40 22 48 8D 05 DD E5 3A 00 48 89 45 48 C6 .E@"H....:.H.EH. +180001140 45 50 23 48 8D 05 D6 E5 3A 00 48 89 45 58 C6 45 EP#H....:.H.EX.E +180001150 60 24 48 8D 05 CB E5 3A 00 48 89 45 68 C6 45 70 `$H....:.H.Eh.Ep +180001160 25 48 8D 05 C4 E5 3A 00 48 89 45 78 C6 85 80 00 %H....:.H.Ex.... +180001170 00 00 26 48 8D 05 BA E5 3A 00 48 89 85 88 00 00 ..&H....:.H..... +180001180 00 C6 85 90 00 00 00 27 48 8D 05 A9 E5 3A 00 48 .......'H....:.H +180001190 89 85 98 00 00 00 C6 85 A0 00 00 00 28 48 8D 05 ............(H.. +1800011A0 9C E5 3A 00 48 89 85 A8 00 00 00 C6 85 B0 00 00 ..:.H........... +1800011B0 00 2D 48 8D 05 8F E5 3A 00 48 89 85 B8 00 00 00 .-H....:.H...... +1800011C0 C6 85 C0 00 00 00 2E 48 8D 05 7E E5 3A 00 48 89 .......H..~.:.H. +1800011D0 85 C8 00 00 00 C6 85 D0 00 00 00 2C 48 8D 05 6D ...........,H..m +1800011E0 E5 3A 00 48 89 85 D8 00 00 00 C6 85 E0 00 00 00 .:.H............ +1800011F0 30 48 8D 05 EC 03 0D 00 48 89 85 E8 00 00 00 C6 0H......H....... +180001200 85 F0 00 00 00 31 48 8D 05 27 B1 3A 00 48 89 85 .....1H..'.:.H.. +180001210 F8 00 00 00 C6 85 00 01 00 00 32 48 8D 05 16 B1 ..........2H.... +180001220 3A 00 48 89 85 08 01 00 00 C6 85 10 01 00 00 33 :.H............3 +180001230 48 8D 05 05 B1 3A 00 48 89 85 18 01 00 00 C6 85 H....:.H........ +180001240 20 01 00 00 34 48 8D 05 F4 B0 3A 00 48 89 85 28 ...4H....:.H..( +180001250 01 00 00 C6 85 30 01 00 00 35 48 8D 05 E3 B0 3A .....0...5H....: +180001260 00 48 89 85 38 01 00 00 C6 85 40 01 00 00 36 48 .H..8.....@...6H +180001270 8D 05 D2 B0 3A 00 48 89 85 48 01 00 00 C6 85 50 ....:.H..H.....P +180001280 01 00 00 37 48 8D 05 C1 B0 3A 00 48 89 85 58 01 ...7H....:.H..X. +180001290 00 00 C6 85 60 01 00 00 38 48 8D 05 B0 B0 3A 00 ....`...8H....:. +1800012A0 48 89 85 68 01 00 00 C6 85 70 01 00 00 39 48 8D H..h.....p...9H. +1800012B0 05 9F B0 3A 00 48 89 85 78 01 00 00 C6 85 80 01 ...:.H..x....... +1800012C0 00 00 41 48 8D 05 8E B0 3A 00 48 89 85 88 01 00 ..AH....:.H..... +1800012D0 00 C6 85 90 01 00 00 42 48 8D 05 7D B0 3A 00 48 .......BH..}.:.H +1800012E0 89 85 98 01 00 00 C6 85 A0 01 00 00 43 48 8D 05 ............CH.. +1800012F0 6C B0 3A 00 48 89 85 A8 01 00 00 C6 85 B0 01 00 l.:.H........... +180001300 00 44 48 8D 05 5B B0 3A 00 48 89 85 B8 01 00 00 .DH..[.:.H...... +180001310 C6 85 C0 01 00 00 45 48 8D 05 4A B0 3A 00 48 89 ......EH..J.:.H. +180001320 85 C8 01 00 00 C6 85 D0 01 00 00 46 48 8D 05 39 ...........FH..9 +180001330 B0 3A 00 48 89 85 D8 01 00 00 C6 85 E0 01 00 00 .:.H............ +180001340 47 48 8D 05 28 B0 3A 00 48 89 85 E8 01 00 00 C6 GH..(.:.H....... +180001350 85 F0 01 00 00 48 48 8D 05 17 B0 3A 00 48 89 85 .....HH....:.H.. +180001360 F8 01 00 00 C6 85 00 02 00 00 49 48 8D 05 06 B0 ..........IH.... +180001370 3A 00 48 89 85 08 02 00 00 C6 85 10 02 00 00 4A :.H............J +180001380 48 8D 05 F5 AF 3A 00 48 89 85 18 02 00 00 C6 85 H....:.H........ +180001390 20 02 00 00 4B 48 8D 05 E4 AF 3A 00 48 89 85 28 ...KH....:.H..( +1800013A0 02 00 00 C6 85 30 02 00 00 4C 48 8D 05 D3 AF 3A .....0...LH....: +1800013B0 00 48 89 85 38 02 00 00 C6 85 40 02 00 00 4D 48 .H..8.....@...MH +1800013C0 8D 05 C2 AF 3A 00 48 89 85 48 02 00 00 C6 85 50 ....:.H..H.....P +1800013D0 02 00 00 4E 48 8D 05 B1 AF 3A 00 48 89 85 58 02 ...NH....:.H..X. +1800013E0 00 00 C6 85 60 02 00 00 4F 48 8D 05 A0 AF 3A 00 ....`...OH....:. +1800013F0 48 89 85 68 02 00 00 C6 85 70 02 00 00 50 48 8D H..h.....p...PH. +180001400 05 8F AF 3A 00 48 89 85 78 02 00 00 C6 85 80 02 ...:.H..x....... +180001410 00 00 51 48 8D 05 7E AF 3A 00 48 89 85 88 02 00 ..QH..~.:.H..... +180001420 00 C6 85 90 02 00 00 52 48 8D 05 6D AF 3A 00 48 .......RH..m.:.H +180001430 89 85 98 02 00 00 C6 85 A0 02 00 00 53 48 8D 05 ............SH.. +180001440 5C AF 3A 00 48 89 85 A8 02 00 00 C6 85 B0 02 00 \.:.H........... +180001450 00 54 48 8D 05 4B AF 3A 00 48 89 85 B8 02 00 00 .TH..K.:.H...... +180001460 C6 85 C0 02 00 00 55 48 8D 05 3A AF 3A 00 48 89 ......UH..:.:.H. +180001470 85 C8 02 00 00 C6 85 D0 02 00 00 56 48 8D 05 29 ...........VH..) +180001480 AF 3A 00 48 89 85 D8 02 00 00 C6 85 E0 02 00 00 .:.H............ +180001490 57 48 8D 05 18 AF 3A 00 48 89 85 E8 02 00 00 C6 WH....:.H....... +1800014A0 85 F0 02 00 00 58 48 8D 05 07 AF 3A 00 48 89 85 .....XH....:.H.. +1800014B0 F8 02 00 00 C6 85 00 03 00 00 59 48 8D 05 F6 AE ..........YH.... +1800014C0 3A 00 48 89 85 08 03 00 00 C6 85 10 03 00 00 5A :.H............Z +1800014D0 48 8D 05 E5 AE 3A 00 48 89 85 18 03 00 00 C6 85 H....:.H........ +1800014E0 20 03 00 00 5B 48 8D 05 6C E2 3A 00 48 89 85 28 ...[H..l.:.H..( +1800014F0 03 00 00 C6 85 30 03 00 00 5C 48 89 85 38 03 00 .....0...\H..8.. +180001500 00 C6 85 40 03 00 00 60 48 8D 05 51 E2 3A 00 48 ...@...`H..Q.:.H +180001510 89 85 48 03 00 00 C6 85 50 03 00 00 61 48 8D 05 ..H.....P...aH.. +180001520 44 E2 3A 00 48 89 85 58 03 00 00 C6 85 60 03 00 D.:.H..X.....`.. +180001530 00 62 48 8D 05 37 E2 3A 00 48 89 85 68 03 00 00 .bH..7.:.H..h... +180001540 C6 85 70 03 00 00 63 48 8D 05 2A E2 3A 00 48 89 ..p...cH..*.:.H. +180001550 85 78 03 00 00 C6 85 80 03 00 00 64 48 8D 05 1D .x.........dH... +180001560 E2 3A 00 48 89 85 88 03 00 00 C6 85 90 03 00 00 .:.H............ +180001570 65 48 8D 05 10 E2 3A 00 48 89 85 98 03 00 00 C6 eH....:.H....... +180001580 85 A0 03 00 00 66 48 8D 05 03 E2 3A 00 48 89 85 .....fH....:.H.. +180001590 A8 03 00 00 C6 85 B0 03 00 00 67 48 8D 05 F6 E1 ..........gH.... +1800015A0 3A 00 48 89 85 B8 03 00 00 C6 85 C0 03 00 00 68 :.H............h +1800015B0 48 8D 05 E9 E1 3A 00 48 89 85 C8 03 00 00 C6 85 H....:.H........ +1800015C0 D0 03 00 00 69 48 8D 05 DC E1 3A 00 48 89 85 D8 ....iH....:.H... +1800015D0 03 00 00 C6 85 E0 03 00 00 6A 48 8D 05 CF E1 3A .........jH....: +1800015E0 00 48 89 85 E8 03 00 00 C6 85 F0 03 00 00 6B 48 .H............kH +1800015F0 8D 05 C6 E1 3A 00 48 89 85 F8 03 00 00 C6 85 00 ....:.H......... +180001600 04 00 00 6C 48 8D 05 B5 E1 3A 00 48 89 85 08 04 ...lH....:.H.... +180001610 00 00 C6 85 10 04 00 00 6D 48 8D 05 B0 E1 3A 00 ........mH....:. +180001620 48 89 85 18 04 00 00 C6 85 20 04 00 00 6E 48 8D H........ ...nH. +180001630 05 AB E1 3A 00 48 89 85 28 04 00 00 C6 85 30 04 ...:.H..(.....0. +180001640 00 00 6F 48 8D 05 9E E1 3A 00 48 89 85 38 04 00 ..oH....:.H..8.. +180001650 00 C6 85 40 04 00 00 70 48 8D 05 61 AD 3A 00 48 ...@...pH..a.:.H +180001660 89 85 48 04 00 00 C6 85 50 04 00 00 71 48 8D 05 ..H.....P...qH.. +180001670 50 AD 3A 00 48 89 85 58 04 00 00 C6 85 60 04 00 P.:.H..X.....`.. +180001680 00 72 48 8D 05 3F AD 3A 00 48 89 85 68 04 00 00 .rH..?.:.H..h... +180001690 C6 85 70 04 00 00 73 48 8D 05 2E AD 3A 00 48 89 ..p...sH....:.H. +1800016A0 85 78 04 00 00 C6 85 80 04 00 00 74 48 8D 05 1D .x.........tH... +1800016B0 AD 3A 00 48 89 85 88 04 00 00 C6 85 90 04 00 00 .:.H............ +1800016C0 75 48 8D 05 0C AD 3A 00 48 89 85 98 04 00 00 C6 uH....:.H....... +1800016D0 85 A0 04 00 00 76 48 8D 05 FB AC 3A 00 48 89 85 .....vH....:.H.. +1800016E0 A8 04 00 00 C6 85 B0 04 00 00 77 48 8D 05 EA AC ..........wH.... +1800016F0 3A 00 48 89 85 B8 04 00 00 C6 85 C0 04 00 00 78 :.H............x +180001700 48 8D 05 D9 AC 3A 00 48 89 85 C8 04 00 00 C6 85 H....:.H........ +180001710 D0 04 00 00 79 48 8D 05 C8 AC 3A 00 48 89 85 D8 ....yH....:.H... +180001720 04 00 00 C6 85 E0 04 00 00 7A 48 8D 05 B7 AC 3A .........zH....: +180001730 00 48 89 85 E8 04 00 00 C6 85 F0 04 00 00 7B 48 .H............{H +180001740 8D 05 A6 AC 3A 00 48 89 85 F8 04 00 00 C6 85 00 ....:.H......... +180001750 05 00 00 A0 48 8D 05 95 E0 3A 00 48 89 85 08 05 ....H....:.H.... +180001760 00 00 C6 85 10 05 00 00 A1 48 8D 05 88 E0 3A 00 .........H....:. +180001770 48 89 85 18 05 00 00 C6 85 20 05 00 00 A2 48 8D H........ ....H. +180001780 05 7B E0 3A 00 48 89 85 28 05 00 00 C6 85 30 05 .{.:.H..(.....0. +180001790 00 00 A3 48 8D 05 6E E0 3A 00 48 89 85 38 05 00 ...H..n.:.H..8.. +1800017A0 00 C6 85 40 05 00 00 A4 48 8D 05 61 E0 3A 00 48 ...@....H..a.:.H +1800017B0 89 85 48 05 00 00 C6 85 50 05 00 00 A5 48 8D 05 ..H.....P....H.. +1800017C0 54 E0 3A 00 48 89 85 58 05 00 00 B9 30 00 00 00 T.:.H..X....0... +1800017D0 E8 1B 9F 0A 00 48 8B F0 48 89 00 48 89 40 08 48 .....H..H..H.@.H +1800017E0 89 40 10 66 C7 40 18 01 01 48 89 05 A8 56 3C 00 .@.f.@...H...V<. +1800017F0 48 8D 5C 24 40 49 BC 55 55 55 55 55 55 55 05 4C H.\$@I.UUUUUUU.L +180001800 8D 35 92 56 3C 00 45 33 FF 0F 1F 80 00 00 00 00 .5.V<.E3........ +180001810 4C 8B CB 4C 8B C6 48 8D 95 78 05 00 00 E8 9E 20 L..L..H..x..... +180001820 08 00 0F 10 00 0F 11 44 24 20 F2 0F 10 40 10 F2 .......D$ ...@.. +180001830 0F 11 85 70 05 00 00 80 BD 70 05 00 00 00 75 60 ...p.....p....u` +180001840 4C 39 25 59 56 3C 00 0F 84 93 00 00 00 48 8B 3D L9%YV<.......H.= +180001850 44 56 3C 00 4C 89 74 24 30 4C 89 7C 24 38 B9 30 DV<.L.t$0L.|$8.0 +180001860 00 00 00 E8 88 9E 0A 00 90 0F 10 03 0F 11 40 20 ..............@ +180001870 48 89 38 48 89 78 08 48 89 78 10 66 C7 40 18 00 H.8H.x.H.x.f.@.. +180001880 00 4C 89 7C 24 38 0F 10 44 24 20 0F 29 44 24 20 .L.|$8..D$ .)D$ +180001890 4C 8B C0 48 8D 54 24 20 49 8B CE E8 90 22 08 00 L..H.T$ I....".. +1800018A0 48 83 C3 10 48 8D 85 60 05 00 00 48 3B D8 0F 85 H...H..`...H;... +1800018B0 5C FF FF FF 48 8D 0D A5 E5 0A 00 4C 8D 9C 24 90 \...H......L..$. +1800018C0 06 00 00 49 8B 5B 20 49 8B 73 28 49 8B 7B 30 4D ...I.[ I.s(I.{0M +1800018D0 8B 63 38 49 8B E3 41 5F 41 5E 5D E9 04 A3 0A 00 .c8I..A_A^]..... +1800018E0 E8 7B 1E 08 00 90 CC CC CC CC CC CC CC CC CC CC .{.............. +1800018F0 48 83 EC 28 B9 18 00 00 00 E8 F2 9D 0A 00 48 8D H..(..........H. +180001900 0D DB E5 0A 00 48 89 00 48 89 40 08 48 89 05 BD .....H..H.@.H... +180001910 5B 3C 00 48 83 C4 28 E9 C8 A2 0A 00 CC CC CC CC [<.H..(......... +180001920 48 8D 0D 19 E6 0A 00 E9 B8 A2 0A 00 CC CC CC CC H............... +180001930 48 8D 0D 19 E6 0A 00 E9 A8 A2 0A 00 CC CC CC CC H............... +180001940 48 81 EC 88 00 00 00 8B 0D 8F 51 3C 00 65 48 8B H.........Q<.eH. +180001950 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001960 0C 02 39 0D 68 5A 3C 00 7E 2D 48 8D 0D 5F 5A 3C ..9.hZ<.~-H.._Z< +180001970 00 E8 9A 9E 0A 00 83 3D 53 5A 3C 00 FF 75 18 48 .......=SZ<..u.H +180001980 8D 0D 0A E6 0A 00 E8 59 A2 0A 00 48 8D 0D 3E 5A .......Y...H..>Z +180001990 3C 00 E8 0D 9E 0A 00 48 8D 44 24 40 48 89 84 24 <......H.D$@H..$ +1800019A0 90 00 00 00 48 8D 05 FD F4 3A 00 48 89 44 24 40 ....H....:.H.D$@ +1800019B0 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +1800019C0 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 0B 00 00 $ .W....L$0A.... +1800019D0 00 48 8D 15 40 F3 3A 00 48 8D 4C 24 20 E8 CE E2 .H..@.:.H.L$ ... +1800019E0 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +1800019F0 C4 59 3C 00 E8 C7 98 09 00 90 48 8D 4C 24 20 E8 .Y<.......H.L$ . +180001A00 5C E0 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC \...H........... +180001A10 48 81 EC 88 00 00 00 8B 0D BF 50 3C 00 65 48 8B H.........P<.eH. +180001A20 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001A30 0C 02 39 0D 98 59 3C 00 7E 2D 48 8D 0D 8F 59 3C ..9..Y<.~-H...Y< +180001A40 00 E8 CA 9D 0A 00 83 3D 83 59 3C 00 FF 75 18 48 .......=.Y<..u.H +180001A50 8D 0D 3A E5 0A 00 E8 89 A1 0A 00 48 8D 0D 6E 59 ..:........H..nY +180001A60 3C 00 E8 3D 9D 0A 00 48 8D 44 24 40 48 89 84 24 <..=...H.D$@H..$ +180001A70 90 00 00 00 48 8D 05 9D F4 3A 00 48 89 44 24 40 ....H....:.H.D$@ +180001A80 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +180001A90 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 09 00 00 $ .W....L$0A.... +180001AA0 00 48 8D 15 80 DD 3A 00 48 8D 4C 24 20 E8 FE E1 .H....:.H.L$ ... +180001AB0 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +180001AC0 F4 58 3C 00 E8 F7 97 09 00 90 48 8D 4C 24 20 E8 .X<.......H.L$ . +180001AD0 8C DF 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC ....H........... +180001AE0 48 81 EC 88 00 00 00 8B 0D EF 4F 3C 00 65 48 8B H.........O<.eH. +180001AF0 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001B00 0C 02 39 0D C8 58 3C 00 7E 2D 48 8D 0D BF 58 3C ..9..X<.~-H...X< +180001B10 00 E8 FA 9C 0A 00 83 3D B3 58 3C 00 FF 75 18 48 .......=.X<..u.H +180001B20 8D 0D 6A E4 0A 00 E8 B9 A0 0A 00 48 8D 0D 9E 58 ..j........H...X +180001B30 3C 00 E8 6D 9C 0A 00 48 8D 44 24 40 48 89 84 24 <..m...H.D$@H..$ +180001B40 90 00 00 00 48 8D 05 05 F4 3A 00 48 89 44 24 40 ....H....:.H.D$@ +180001B50 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +180001B60 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 09 00 00 $ .W....L$0A.... +180001B70 00 48 8D 15 C8 F1 3A 00 48 8D 4C 24 20 E8 2E E1 .H....:.H.L$ ... +180001B80 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +180001B90 24 58 3C 00 E8 27 97 09 00 90 48 8D 4C 24 20 E8 $X<..'....H.L$ . +180001BA0 BC DE 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC ....H........... +180001BB0 48 81 EC 88 00 00 00 8B 0D 1F 4F 3C 00 65 48 8B H.........O<.eH. +180001BC0 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001BD0 0C 02 39 0D F8 57 3C 00 7E 2D 48 8D 0D EF 57 3C ..9..W<.~-H...W< +180001BE0 00 E8 2A 9C 0A 00 83 3D E3 57 3C 00 FF 75 18 48 ..*....=.W<..u.H +180001BF0 8D 0D 9A E3 0A 00 E8 E9 9F 0A 00 48 8D 0D CE 57 ...........H...W +180001C00 3C 00 E8 9D 9B 0A 00 48 8D 44 24 40 48 89 84 24 <......H.D$@H..$ +180001C10 90 00 00 00 48 8D 05 E5 F1 3A 00 48 89 44 24 40 ....H....:.H.D$@ +180001C20 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +180001C30 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 09 00 00 $ .W....L$0A.... +180001C40 00 48 8D 15 40 E5 3A 00 48 8D 4C 24 20 E8 5E E0 .H..@.:.H.L$ .^. +180001C50 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +180001C60 54 57 3C 00 E8 57 96 09 00 90 48 8D 4C 24 20 E8 TW<..W....H.L$ . +180001C70 EC DD 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC ....H........... +180001C80 48 81 EC 88 00 00 00 8B 0D 4F 4E 3C 00 65 48 8B H........ON<.eH. +180001C90 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001CA0 0C 02 39 0D 28 57 3C 00 7E 2D 48 8D 0D 1F 57 3C ..9.(W<.~-H...W< +180001CB0 00 E8 5A 9B 0A 00 83 3D 13 57 3C 00 FF 75 18 48 ..Z....=.W<..u.H +180001CC0 8D 0D CA E2 0A 00 E8 19 9F 0A 00 48 8D 0D FE 56 ...........H...V +180001CD0 3C 00 E8 CD 9A 0A 00 48 8D 44 24 40 48 89 84 24 <......H.D$@H..$ +180001CE0 90 00 00 00 48 8D 05 6D F0 3A 00 48 89 44 24 40 ....H..m.:.H.D$@ +180001CF0 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +180001D00 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 07 00 00 $ .W....L$0A.... +180001D10 00 48 8D 15 90 DF 3A 00 48 8D 4C 24 20 E8 8E DF .H....:.H.L$ ... +180001D20 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +180001D30 84 56 3C 00 E8 87 95 09 00 90 48 8D 4C 24 20 E8 .V<.......H.L$ . +180001D40 1C DD 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC ....H........... +180001D50 48 81 EC 88 00 00 00 8B 0D 7F 4D 3C 00 65 48 8B H.........M<.eH. +180001D60 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001D70 0C 02 39 0D 58 56 3C 00 7E 2D 48 8D 0D 4F 56 3C ..9.XV<.~-H..OV< +180001D80 00 E8 8A 9A 0A 00 83 3D 43 56 3C 00 FF 75 18 48 .......=CV<..u.H +180001D90 8D 0D FA E1 0A 00 E8 49 9E 0A 00 48 8D 0D 2E 56 .......I...H...V +180001DA0 3C 00 E8 FD 99 0A 00 48 8D 44 24 40 48 89 84 24 <......H.D$@H..$ +180001DB0 90 00 00 00 48 8D 05 B5 F0 3A 00 48 89 44 24 40 ....H....:.H.D$@ +180001DC0 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +180001DD0 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 09 00 00 $ .W....L$0A.... +180001DE0 00 48 8D 15 18 E4 3A 00 48 8D 4C 24 20 E8 BE DE .H....:.H.L$ ... +180001DF0 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +180001E00 B4 55 3C 00 E8 B7 94 09 00 90 48 8D 4C 24 20 E8 .U<.......H.L$ . +180001E10 4C DC 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC L...H........... +180001E20 48 81 EC 88 00 00 00 8B 0D AF 4C 3C 00 65 48 8B H.........L<.eH. +180001E30 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001E40 0C 02 39 0D 88 55 3C 00 7E 2D 48 8D 0D 7F 55 3C ..9..U<.~-H...U< +180001E50 00 E8 BA 99 0A 00 83 3D 73 55 3C 00 FF 75 18 48 .......=sU<..u.H +180001E60 8D 0D 2A E1 0A 00 E8 79 9D 0A 00 48 8D 0D 5E 55 ..*....y...H..^U +180001E70 3C 00 E8 2D 99 0A 00 48 8D 44 24 40 48 89 84 24 <..-...H.D$@H..$ +180001E80 90 00 00 00 48 8D 05 55 F0 3A 00 48 89 44 24 40 ....H..U.:.H.D$@ +180001E90 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +180001EA0 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 0D 00 00 $ .W....L$0A.... +180001EB0 00 48 8D 15 08 E0 3A 00 48 8D 4C 24 20 E8 EE DD .H....:.H.L$ ... +180001EC0 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +180001ED0 E4 54 3C 00 E8 E7 93 09 00 90 48 8D 4C 24 20 E8 .T<.......H.L$ . +180001EE0 7C DB 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC |...H........... +180001EF0 48 81 EC 88 00 00 00 8B 0D DF 4B 3C 00 65 48 8B H.........K<.eH. +180001F00 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001F10 0C 02 39 0D B8 54 3C 00 7E 2D 48 8D 0D AF 54 3C ..9..T<.~-H...T< +180001F20 00 E8 EA 98 0A 00 83 3D A3 54 3C 00 FF 75 18 48 .......=.T<..u.H +180001F30 8D 0D 5A E0 0A 00 E8 A9 9C 0A 00 48 8D 0D 8E 54 ..Z........H...T +180001F40 3C 00 E8 5D 98 0A 00 48 8D 44 24 40 48 89 84 24 <..]...H.D$@H..$ +180001F50 90 00 00 00 48 8D 05 35 EE 3A 00 48 89 44 24 40 ....H..5.:.H.D$@ +180001F60 48 8D 44 24 40 48 89 44 24 78 0F 57 C0 0F 11 44 H.D$@H.D$x.W...D +180001F70 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 06 00 00 $ .W....L$0A.... +180001F80 00 48 8D 15 D8 DE 3A 00 48 8D 4C 24 20 E8 1E DD .H....:.H.L$ ... +180001F90 00 00 90 4C 8D 44 24 40 48 8D 54 24 20 48 8D 0D ...L.D$@H.T$ H.. +180001FA0 14 54 3C 00 E8 17 93 09 00 90 48 8D 4C 24 20 E8 .T<.......H.L$ . +180001FB0 AC DA 00 00 48 81 C4 88 00 00 00 C3 CC CC CC CC ....H........... +180001FC0 48 81 EC 88 00 00 00 8B 0D 0F 4B 3C 00 65 48 8B H.........K<.eH. +180001FD0 04 25 58 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B .%X........H.... +180001FE0 0C 02 39 0D E8 53 3C 00 7E 2D 48 8D 0D DF 53 3C ..9..S<.~-H...S< +180001FF0 00 E8 1A 98 0A 00 83 3D D3 53 3C 00 FF 75 18 48 .......=.S<..u.H + +======================================================================== +FUNCTION: LoaderThread +RVA: 0x05000–0x06000 Size: 4096 bytes +180005000 8D 4D 00 48 89 4D B0 48 8D 4D 20 48 89 4D B8 48 .M.H.M.H.M H.M.H +180005010 8D 4D 40 48 89 4D C0 48 8D 4D 3C 48 89 4D C8 48 .M@H.M.H.MH... +180005B50 10 6D 0A 00 4C 8B 7C 24 48 48 8B C7 48 8B 74 24 .m..L.|$HH..H.t$ +180005B60 40 48 8B 5C 24 50 48 8B 7C 24 58 48 83 C4 30 41 @H.\$PH.|$XH..0A +180005B70 5E C3 4C 8B CA 48 89 5C 24 28 48 8B D3 4C 89 74 ^.L..H.\$(H..L.t +180005B80 24 20 E8 99 26 00 00 48 8B 5C 24 50 48 8B 7C 24 $ ..&..H.\$PH.|$ +180005B90 58 48 83 C4 30 41 5E C3 E8 33 8C 00 00 CC CC CC XH..0A^..3...... +180005BA0 48 89 5C 24 08 57 48 83 EC 60 48 8B D9 0F B6 09 H.\$.WH..`H..... +180005BB0 80 F9 7D 0F 84 C0 00 00 00 80 F9 3A 0F 84 B7 00 ..}........:.... +180005BC0 00 00 8D 41 D0 3C 09 0F 87 1F 01 00 00 33 C0 80 ...A.<.......3.. +180005BD0 F9 30 75 0C 48 FF C3 EB 3E 0F 1F 80 00 00 00 00 .0u.H...>....... +180005BE0 3D CC CC CC 0C 0F 87 F4 00 00 00 8D 0C 80 0F BE =............... +180005BF0 03 48 FF C3 8D 04 48 83 C0 D0 48 3B DA 74 0D 0F .H....H...H;.t.. +180005C00 B6 0B 80 F9 30 7C 05 80 F9 39 7E D4 3D FF FF FF ....0|...9~.=... +180005C10 7F 0F 87 C8 00 00 00 48 3B DA 0F 84 CC 00 00 00 .......H;....... +180005C20 0F B6 0B 80 F9 7D 74 09 80 F9 3A 0F 85 BB 00 00 .....}t...:..... +180005C30 00 49 8B 38 48 8B 4F 08 48 83 79 18 00 0F 8F 8F .I.8H.O.H.y..... +180005C40 00 00 00 48 C7 41 18 FF FF FF FF 48 8D 4C 24 20 ...H.A.....H.L$ +180005C50 48 8B 57 10 44 8B C0 E8 E4 D9 FF FF 0F 10 44 24 H.W.D.........D$ +180005C60 20 48 8D 4C 24 40 F2 0F 10 4C 24 30 0F 29 44 24 H.L$@...L$0.)D$ +180005C70 40 F2 0F 11 4C 24 50 EB 41 49 8B 38 48 8B 4F 08 @...L$P.AI.8H.O. +180005C80 4C 8B 41 18 4D 85 C0 78 70 49 8D 40 01 48 89 41 L.A.M..xpI.@.H.A +180005C90 18 48 8D 4C 24 40 48 8B 57 10 E8 A1 D9 FF FF 0F .H.L$@H.W....... +180005CA0 10 44 24 40 48 8D 4C 24 20 F2 0F 10 4C 24 50 0F .D$@H.L$ ...L$P. +180005CB0 29 44 24 20 F2 0F 11 4C 24 30 E8 51 2F 00 00 48 )D$ ...L$0.Q/..H +180005CC0 8B 0F 89 01 48 8B C3 48 8B 5C 24 70 48 83 C4 60 ....H..H.\$pH..` +180005CD0 5F C3 48 8D 0D 17 B8 0C 00 E8 12 85 00 00 CC 48 _.H............H +180005CE0 8D 0D BA B5 0C 00 E8 05 85 00 00 CC 48 8D 0D 1D ............H... +180005CF0 B5 0C 00 E8 F8 84 00 00 CC 48 8D 0D 68 B5 0C 00 .........H..h... +180005D00 E8 EB 84 00 00 CC CC CC CC CC CC CC CC CC CC CC ................ +180005D10 48 89 5C 24 08 57 48 83 EC 60 44 0F B6 09 48 8B H.\$.WH..`D...H. +180005D20 D9 41 80 F9 7D 0F 84 EB 00 00 00 41 80 F9 3A 0F .A..}......A..:. +180005D30 84 E1 00 00 00 41 8D 41 D0 3C 09 0F 87 4F 01 00 .....A.A.<...O.. +180005D40 00 33 C9 41 80 F9 30 75 07 48 FF C3 EB 39 66 90 .3.A..0u.H...9f. +180005D50 81 F9 CC CC CC 0C 0F 87 27 01 00 00 0F BE 03 8D ........'....... +180005D60 0C 89 48 FF C3 8D 49 E8 8D 0C 48 48 3B DA 74 0B ..H...I...HH;.t. +180005D70 0F B6 03 3C 30 7C 04 3C 39 7E D5 81 F9 FF FF FF ...<0|.<9~...... +180005D80 7F 0F 87 FC 00 00 00 48 3B DA 0F 84 00 01 00 00 .......H;....... +180005D90 0F B6 03 3C 7D 74 08 3C 3A 0F 85 F1 00 00 00 49 ...<}t.<:......I +180005DA0 8B 38 0F B6 57 18 8D 42 FF 3C 05 0F 86 B8 00 00 .8..W..B.<...... +180005DB0 00 80 FA 0A 0F 84 AF 00 00 00 48 8B 47 08 48 83 ..........H.G.H. +180005DC0 78 18 00 0F 8F AD 00 00 00 48 C7 40 18 FF FF FF x........H.@.... +180005DD0 FF 48 8B 57 10 44 8B C1 48 8D 4C 24 20 E8 5E D8 .H.W.D..H.L$ .^. +180005DE0 FF FF 0F 10 44 24 20 48 8D 4C 24 40 F2 0F 10 4C ....D$ H.L$@...L +180005DF0 24 30 0F 29 44 24 40 F2 0F 11 4C 24 50 E8 4E 2F $0.)D$@...L$P.N/ +180005E00 00 00 48 8B 0F 89 41 04 48 8B C3 48 8B 5C 24 70 ..H...A.H..H.\$p +180005E10 48 83 C4 60 5F C3 49 8B 38 0F B6 4F 18 8D 41 FF H..`_.I.8..O..A. +180005E20 3C 05 76 45 80 F9 0A 74 40 48 8B 4F 08 4C 8B 41 <.vE...t@H.O.L.A +180005E30 18 4D 85 C0 78 67 49 8D 40 01 48 89 41 18 48 8D .M..xgI.@.H.A.H. +180005E40 4C 24 40 48 8B 57 10 E8 F4 D7 FF FF 0F 10 44 24 L$@H.W........D$ +180005E50 40 48 8D 4C 24 20 F2 0F 10 4C 24 50 0F 29 44 24 @H.L$ ...L$P.)D$ +180005E60 20 F2 0F 11 4C 24 30 EB 94 48 8D 0D 78 B7 0C 00 ...L$0..H..x... +180005E70 E8 7B 83 00 00 CC 48 8D 0D 73 B6 0C 00 E8 6E 83 .{....H..s....n. +180005E80 00 00 CC 48 8D 0D 16 B4 0C 00 E8 61 83 00 00 CC ...H.......a.... +180005E90 48 8D 0D 79 B3 0C 00 E8 54 83 00 00 CC 48 8D 0D H..y....T....H.. +180005EA0 C4 B3 0C 00 E8 47 83 00 00 CC CC CC CC CC CC CC .....G.......... +180005EB0 40 55 53 56 57 41 54 41 56 41 57 48 8D 6C 24 90 @USVWATAVAWH.l$. +180005EC0 48 81 EC 70 01 00 00 48 8B 05 72 F1 3B 00 48 33 H..p...H..r.;.H3 +180005ED0 C4 48 89 45 60 4D 8B F1 48 8B DA 4C 8B E1 44 88 .H.E`M..H..L..D. +180005EE0 45 C8 33 FF 41 0F B6 41 08 3C 63 75 3D 41 80 F8 E.3.A..A...ot...xt.H.|$0 + +======================================================================== +FUNCTION: WndProc +RVA: 0x826A0–0x827A0 Size: 256 bytes +1800826A0 48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 H.\$.H.l$.H.t$.W +1800826B0 48 83 EC 30 48 8B 05 45 45 34 00 49 8B F1 49 8B H..0H..EE4.I..I. +1800826C0 F8 8B DA 48 8B E9 48 85 C0 74 1D 48 83 C0 30 48 ...H..H..t.H..0H +1800826D0 89 44 24 20 E8 47 50 FD FF 48 85 C0 74 0A B8 01 .D$ .GP..H..t... +1800826E0 00 00 00 E9 9B 00 00 00 83 FB 02 0F 84 88 00 00 ................ +1800826F0 00 83 FB 05 74 2B 81 FB 12 01 00 00 75 10 48 8B ....t+......u.H. +180082700 C7 25 F0 FF 00 00 48 3D 00 F1 00 00 74 73 4C 8B .%....H=....tsL. +180082710 CE 4C 8B C7 8B D3 48 8B CD FF 15 21 EE 02 00 EB .L....H....!.... +180082720 62 48 83 3D 0F 45 34 00 00 74 56 48 83 FF 01 74 bH.=.E4..tVH...t +180082730 50 48 8B 0D E8 44 34 00 33 DB 48 85 C9 74 0D 48 PH...D4.3.H..t.H +180082740 8B 01 FF 50 10 48 89 1D D4 44 34 00 48 8B 0D DD ...P.H...D4.H... +180082750 44 34 00 48 8B C6 48 C1 E8 10 33 D2 44 0F B7 C8 D4.H..H...3.D... +180082760 44 0F B7 C6 48 8B 01 89 5C 24 28 89 5C 24 20 FF D...H...\$(.\$ . +180082770 50 68 E8 39 FE FF FF EB 08 33 C9 FF 15 6F ED 02 Ph.9.....3...o.. +180082780 00 33 C0 48 8B 5C 24 40 48 8B 6C 24 48 48 8B 74 .3.H.\$@H.l$HH.t +180082790 24 50 48 83 C4 30 5F C3 CC CC CC CC CC CC CC CC $PH..0_......... + +======================================================================== +FUNCTION: OverlayWindowInit +RVA: 0x827A0–0x8301A Size: 2170 bytes +1800827A0 48 8B C4 48 89 58 08 48 89 70 10 48 89 78 18 55 H..H.X.H.p.H.x.U +1800827B0 41 54 41 55 41 56 41 57 48 8D A8 F8 FC FF FF 48 ATAUAVAWH......H +1800827C0 81 EC E0 03 00 00 0F 29 70 C8 48 8B 05 6F 28 34 .......)p.H..o(4 +1800827D0 00 48 33 C4 48 89 85 C0 02 00 00 48 8B 05 1E 44 .H3.H......H...D +1800827E0 34 00 48 85 C0 74 10 48 8B 88 D0 00 00 00 48 85 4.H..t.H......H. +1800827F0 C9 74 04 C6 41 30 01 41 BF 04 00 00 00 33 D2 B9 .t..A0.A.....3.. +180082800 0A 00 00 00 E8 37 5C FD FF 8B 3D CD 42 34 00 85 .....7\...=.B4.. +180082810 C0 74 75 65 48 8B 04 25 58 00 00 00 48 8B 0C F8 .tueH..%X...H... +180082820 41 8B 04 0F 39 05 16 4C 34 00 7E 35 48 8D 0D 0D A...9..L4.~5H... +180082830 4C 34 00 E8 D8 8F 02 00 83 3D 01 4C 34 00 FF 75 L4.......=.L4..u +180082840 20 48 8D 0D 28 C4 32 00 FF 15 92 E8 02 00 48 89 H..(.2.......H. +180082850 05 FB 4B 34 00 48 8D 0D E4 4B 34 00 E8 43 8F 02 ..K4.H...K4..C.. +180082860 00 48 8D 15 18 C4 32 00 48 8B 0D E1 4B 34 00 FF .H....2.H...K4.. +180082870 15 13 E8 02 00 48 85 C0 74 0E 48 C7 C1 FC FF FF .....H..t.H..... +180082880 FF FF D0 E9 89 00 00 00 BA 03 00 00 00 B9 06 00 ................ +180082890 00 00 E8 A9 5B FD FF 85 C0 74 70 65 48 8B 04 25 ....[....tpeH..% +1800828A0 58 00 00 00 48 8B 0C F8 41 8B 04 0F 39 05 96 4B X...H...A...9..K +1800828B0 34 00 7E 35 48 8D 0D 8D 4B 34 00 E8 50 8F 02 00 4.~5H...K4..P... +1800828C0 83 3D 81 4B 34 00 FF 75 20 48 8D 0D D0 C3 32 00 .=.K4..u H....2. +1800828D0 FF 15 0A E8 02 00 48 89 05 53 4B 34 00 48 8D 0D ......H..SK4.H.. +1800828E0 64 4B 34 00 E8 BB 8E 02 00 48 8D 15 C0 C3 32 00 dK4......H....2. +1800828F0 48 8B 0D 39 4B 34 00 FF 15 8B E7 02 00 48 85 C0 H..9K4.......H.. +180082900 74 09 B9 02 00 00 00 FF D0 EB 06 FF 15 8F EC 02 t............... +180082910 00 48 83 3D FF 42 34 00 00 75 0F 33 D2 48 8D 0D .H.=.B4..u.3.H.. +180082920 AC 0C 00 00 FF 15 76 EB 02 00 45 33 E4 4C 89 A5 ......v...E3.L.. +180082930 A0 00 00 00 C7 85 90 00 00 00 50 00 00 00 33 C9 ..........P...3. +180082940 FF 15 D2 E6 02 00 48 89 85 C0 00 00 00 BA 00 7F ......H......... +180082950 00 00 33 C9 FF 15 6E EC 02 00 48 89 85 B8 00 00 ..3...n...H..... +180082960 00 BA 00 7F 00 00 33 C9 FF 15 7A EB 02 00 48 89 ......3...z...H. +180082970 85 B0 00 00 00 BA 00 7F 00 00 33 C9 FF 15 66 EB ..........3...f. +180082980 02 00 48 89 85 D8 00 00 00 33 C9 FF 15 FF E8 02 ..H......3...... +180082990 00 48 89 85 A8 00 00 00 48 8D 05 01 FD FF FF 48 .H......H......H +1800829A0 89 85 98 00 00 00 48 8D 35 3B CC 32 00 48 89 B5 ......H.5;.2.H.. +1800829B0 D0 00 00 00 4C 89 A5 C8 00 00 00 C7 85 94 00 00 ....L........... +1800829C0 00 03 00 00 00 48 8D 8D 90 00 00 00 FF 15 66 EC .....H........f. +1800829D0 02 00 B9 01 00 00 00 FF 15 03 EB 02 00 8B D8 33 ...............3 +1800829E0 C9 FF 15 F9 EA 02 00 4C 89 64 24 58 48 8B 8D A8 .......L.d$XH... +1800829F0 00 00 00 48 89 4C 24 50 4C 89 64 24 48 4C 89 64 ...H.L$PL.d$HL.d +180082A00 24 40 89 5C 24 38 89 44 24 30 44 89 64 24 28 44 $@.\$8.D$0D.d$(D +180082A10 89 64 24 20 41 B9 00 00 00 80 4C 8B C6 48 8B 95 .d$ A.....L..H.. +180082A20 D0 00 00 00 B9 28 00 00 08 FF 15 21 EC 02 00 4C .....(.....!...L +180082A30 8B F0 41 B9 02 00 00 00 41 B0 FF 33 D2 48 8B C8 ..A.....A..3.H.. +180082A40 FF 15 9A EB 02 00 66 0F 6F 05 62 09 33 00 F3 0F ......f.o.b.3... +180082A50 7F 85 08 01 00 00 48 8D 95 08 01 00 00 49 8B CE ......H......I.. +180082A60 FF 15 B2 EE 02 00 4C 89 65 14 48 C7 45 28 02 00 ......L.e.H.E(.. +180082A70 00 00 48 C7 45 40 02 00 00 00 4C 89 65 00 C7 45 ..H.E@....L.e..E +180082A80 10 1C 00 00 00 C7 45 08 3C 00 00 00 C7 45 0C 01 ......E.<....E.. +180082A90 00 00 00 C7 45 24 20 00 00 00 4C 89 75 30 48 C7 ....E$ ...L.u0H. +180082AA0 45 1C 01 00 00 00 48 C7 45 38 01 00 00 00 C7 85 E.....H.E8...... +180082AB0 18 01 00 00 00 B0 00 00 C7 85 1C 01 00 00 00 A0 ................ +180082AC0 00 00 48 8D 1D 5F 41 34 00 48 89 5C 24 58 48 8D ..H.._A4.H.\$XH. +180082AD0 85 E0 00 00 00 48 89 44 24 50 48 8D 35 57 41 34 .....H.D$PH.5WA4 +180082AE0 00 48 89 74 24 48 4C 8D 25 43 41 34 00 4C 89 64 .H.t$HL.%CA4.L.d +180082AF0 24 40 48 8D 45 00 48 89 44 24 38 C7 44 24 30 07 $@H.E.H.D$8.D$0. +180082B00 00 00 00 C7 44 24 28 02 00 00 00 48 8D 85 18 01 ....D$(....H.... +180082B10 00 00 48 89 44 24 20 45 33 C9 45 33 C0 BA 01 00 ..H.D$ E3.E3.... +180082B20 00 00 33 C9 FF 15 DE ED 02 00 3D 04 00 7A 88 75 ..3.......=..z.u +180082B30 53 48 89 5C 24 58 48 8D 85 E0 00 00 00 48 89 44 SH.\$XH......H.D +180082B40 24 50 48 89 74 24 48 4C 89 64 24 40 48 8D 45 00 $PH.t$HL.d$@H.E. +180082B50 48 89 44 24 38 C7 44 24 30 07 00 00 00 C7 44 24 H.D$8.D$0.....D$ +180082B60 28 02 00 00 00 48 8D 85 18 01 00 00 48 89 44 24 (....H......H.D$ +180082B70 20 45 33 C9 45 33 C0 BA 05 00 00 00 33 C9 FF 15 E3.E3......3... +180082B80 84 ED 02 00 85 C0 0F 85 EC 09 00 00 E8 1F FA FF ................ +180082B90 FF 48 89 BD 28 01 00 00 65 48 8B 0C 25 58 00 00 .H..(...eH..%X.. +180082BA0 00 4C 8B 2C F9 43 8B 04 2F 39 05 F9 4B 34 00 7E .L.,.C../9..K4.~ +180082BB0 2D 48 8D 0D F0 4B 34 00 E8 53 8C 02 00 83 3D E4 -H...K4..S....=. +180082BC0 4B 34 00 FF 75 18 48 8D 0D D3 D4 02 00 E8 12 90 K4..u.H......... +180082BD0 02 00 48 8D 0D CF 4B 34 00 E8 C6 8B 02 00 48 8D ..H...K4......H. +180082BE0 0D B3 47 34 00 E8 26 80 01 00 BA 0A 00 00 00 49 ..G4..&........I +180082BF0 8B CE FF 15 30 EA 02 00 49 8B CE FF 15 D7 E8 02 ....0...I....... +180082C00 00 48 8B 3D F8 3F 34 00 B9 B0 2C 00 00 FF 15 0D .H.=.?4...,..... +180082C10 EB 02 00 4C 8B C8 4C 8B 05 E3 3F 34 00 4D 85 C0 ...L..L...?4.M.. +180082C20 74 5D 45 8B 50 04 49 0F BF 90 1C 2B 00 00 49 8D t]E.P.I....+..I. +180082C30 80 20 2B 00 00 48 8D 04 D0 44 39 10 74 36 8D 4A . +..H...D9.t6.J +180082C40 01 B8 AB AA AA 2A F7 E9 8B C2 C1 E8 1F 03 D0 8D .....*.......... +180082C50 04 52 03 C0 2B C8 66 41 89 88 1C 2B 00 00 48 0F .R..+.fA...+..H. +180082C60 BF C1 48 05 64 05 00 00 49 8D 04 C0 44 89 10 33 ..H.d...I...D..3 +180082C70 C9 89 48 04 66 FF 40 04 41 FF 80 14 2B 00 00 4C ..H.f.@.A...+..L +180082C80 89 8D 18 01 00 00 48 8D 44 24 60 48 89 85 E0 00 ......H.D$`H.... +180082C90 00 00 4C 89 8D E8 00 00 00 4D 85 C9 74 0E 33 D2 ..L......M..t.3. +180082CA0 49 8B C9 E8 A8 23 F9 FF 33 DB EB 04 33 DB 8B C3 I....#..3...3... +180082CB0 48 89 05 49 3F 34 00 E8 A4 3B F9 FF 48 85 FF 74 H..I?4...;..H..t +180082CC0 09 48 89 3D 38 3F 34 00 EB 07 48 8B 3D 2F 3F 34 .H.=8?4...H.=/?4 +180082CD0 00 83 4F 30 21 33 C9 E8 14 33 FC FF 0F 57 F6 0F ..O0!3...3...W.. +180082CE0 11 75 30 0F 11 75 50 0F 11 75 60 0F 11 75 70 C7 .u0..uP..u`..up. +180082CF0 45 5C FF FF 7F 7F C7 45 6C 00 00 80 3F C7 45 70 E\.....El...?.Ep +180082D00 00 00 80 3F 66 89 5D 3A C6 45 34 00 4C 8B 67 68 ...?f.]:.E4.L.gh +180082D10 B9 48 1B 32 00 E8 76 61 F9 FF 4C 8B F8 48 8D 05 .H.2..va..L..H.. +180082D20 DC 82 0A 00 48 89 05 AD 41 34 00 49 8D B7 48 1B ....H...A4.I..H. +180082D30 32 00 48 89 35 A7 41 34 00 4C 89 3D A8 41 34 00 2.H.5.A4.L.=.A4. +180082D40 4C 89 3D A9 41 34 00 48 8D 1D C2 82 0A 00 48 8B L.=.A4.H......H. +180082D50 CB E8 BA FD FC FF 48 3B C3 74 1E 0F 1F 44 00 00 ......H;.t...D.. +180082D60 48 39 35 89 41 34 00 77 10 48 8B D8 48 8B C8 E8 H95.A4.w.H..H... +180082D70 9C FD FC FF 48 3B C3 75 E7 0F 28 45 30 0F 29 45 ....H;.u..(E0.)E +180082D80 A0 0F 28 4D 50 0F 28 55 60 0F 28 5D 70 C6 45 A4 ..(MP.(U`.(]p.E. +180082D90 01 0F 29 75 00 0F 29 75 10 0F 29 75 20 0F 28 45 ..)u..)u..)u .(E +180082DA0 A0 0F 29 45 30 0F 29 75 40 0F 29 4D 50 0F 29 55 ..)E0.)u@.)MP.)U +180082DB0 60 0F 29 5D 70 0F 29 B5 80 00 00 00 4C 89 7D 28 `.)]p.).....L.}( +180082DC0 C7 45 30 48 1B 32 00 C7 45 3C 00 00 70 41 48 8D .E0H.2..E<..pAH. +180082DD0 05 5B B8 32 00 48 89 45 40 48 8D 55 00 49 8B CC .[.2.H.E@H.U.I.. +180082DE0 E8 BB 89 FC FF 48 89 47 70 0F 57 F6 0F 11 75 30 .....H.Gp.W...u0 +180082DF0 0F 11 75 50 0F 11 75 60 0F 11 75 70 C7 45 5C FF ..uP..u`..up.E\. +180082E00 FF 7F 7F C7 45 6C 00 00 80 3F C7 45 70 00 00 80 ....El...?.Ep... +180082E10 3F 45 33 E4 66 44 89 65 3A 66 C7 45 34 00 01 C6 ?E3.fD.e:f.E4... +180082E20 45 36 01 4C 8B 7F 68 B9 78 B2 08 00 E8 5F 60 F9 E6.L..h.x...._`. +180082E30 FF 48 8B F0 48 8D 05 15 5B 05 00 48 89 05 96 40 .H..H...[..H...@ +180082E40 34 00 48 8D BE 78 B2 08 00 48 89 3D 90 40 34 00 4.H..x...H.=.@4. +180082E50 48 89 35 91 40 34 00 48 89 35 92 40 34 00 48 8D H.5.@4.H.5.@4.H. +180082E60 1D FB 5A 05 00 48 8B CB E8 A3 FC FC FF 48 3B C3 ..Z..H.......H;. +180082E70 74 19 48 39 3D 77 40 34 00 77 10 48 8B D8 48 8B t.H9=w@4.w.H..H. +180082E80 C8 E8 8A FC FC FF 48 3B C3 75 E7 0F 28 45 30 0F ......H;.u..(E0. +180082E90 29 45 A0 0F 28 4D 50 0F 28 55 60 0F 28 5D 70 C6 )E..(MP.(U`.(]p. +180082EA0 45 A4 01 0F 29 75 00 0F 29 75 10 0F 29 75 20 0F E...)u..)u..)u . +180082EB0 28 45 A0 0F 29 45 30 0F 29 75 40 0F 29 4D 50 0F (E..)E0.)u@.)MP. +180082EC0 29 55 60 0F 29 5D 70 0F 29 B5 80 00 00 00 48 89 )U`.)]p.).....H. +180082ED0 75 28 C7 45 30 78 B2 08 00 C7 45 3C 00 00 70 41 u(.E0x....E<..pA +180082EE0 48 8D 05 91 C7 32 00 48 89 45 40 48 8D 55 00 49 H....2.H.E@H.U.I +180082EF0 8B CF E8 A9 88 FC FF 48 8B 05 02 3D 34 00 4C 89 .......H...=4.L. +180082F00 60 50 8B 0D E4 21 34 00 85 C9 74 24 83 E9 01 74 `P...!4...t$...t +180082F10 18 83 E9 01 74 0C 83 F9 01 75 15 E8 30 57 01 00 ....t....u..0W.. +180082F20 EB 13 E8 49 38 01 00 EB 0C E8 62 19 01 00 EB 05 ...I8.....b..... +180082F30 E8 BB 12 01 00 49 8B CE E8 F3 2D FD FF E8 EE 23 .....I....-....# +180082F40 FD FF 32 DB 0F 57 C0 0F 11 85 E8 00 00 00 0F 57 ..2..W.........W +180082F50 C9 F3 0F 7F 8D F8 00 00 00 41 B8 0B 00 00 00 48 .........A.....H +180082F60 8D 15 AA C6 32 00 48 8D 8D E8 00 00 00 E8 3E CD ....2.H.......>. +180082F70 F8 FF 90 E8 D8 B4 F8 FF 48 8D 8D E8 00 00 00 48 ........H......H +180082F80 89 4C 24 20 41 BF 01 00 00 00 45 8B CF 41 B8 F8 .L$ A.....E..A.. +180082F90 00 00 00 48 8D 15 86 C6 32 00 48 8B C8 E8 3E AF ...H....2.H...>. +180082FA0 FF FF 90 48 8D 8D E8 00 00 00 E8 B1 CA F8 FF 48 ...H...........H +180082FB0 8B BD 28 01 00 00 65 48 8B 34 25 58 00 00 00 90 ..(...eH.4%X.... +180082FC0 44 89 7C 24 20 45 33 C9 45 33 C0 33 D2 48 8D 4D D.|$ E3.E3.3.H.M +180082FD0 00 FF 15 F9 E4 02 00 85 C0 74 3F 0F 1F 44 00 00 .........t?..D.. +180082FE0 48 8D 4D 00 FF 15 DE E4 02 00 48 8D 4D 00 FF 15 H.M.......H.M... +180082FF0 CC E4 02 00 0F B6 DB 83 7D 08 12 41 0F 44 DF 44 ........}..A.D.D +180083000 89 7C 24 20 45 33 C9 45 33 C0 33 D2 48 8D 4D 00 .|$ E3.E3.3.H.M. +180083010 FF 15 BA E4 02 00 85 C0 75 C6 ........u. + +======================================================================== +FUNCTION: ModuleManager_RenderFrame +RVA: 0x82FC0–0x8301A Size: 90 bytes +180082FC0 44 89 7C 24 20 45 33 C9 45 33 C0 33 D2 48 8D 4D D.|$ E3.E3.3.H.M +180082FD0 00 FF 15 F9 E4 02 00 85 C0 74 3F 0F 1F 44 00 00 .........t?..D.. +180082FE0 48 8D 4D 00 FF 15 DE E4 02 00 48 8D 4D 00 FF 15 H.M.......H.M... +180082FF0 CC E4 02 00 0F B6 DB 83 7D 08 12 41 0F 44 DF 44 ........}..A.D.D +180083000 89 7C 24 20 45 33 C9 45 33 C0 33 D2 48 8D 4D 00 .|$ E3.E3.3.H.M. +180083010 FF 15 BA E4 02 00 85 C0 75 C6 ........u. + +======================================================================== +FUNCTION: ESPModule_Init +RVA: 0x83E00–0x83FA0 Size: 416 bytes +180083E00 40 53 48 83 EC 40 48 8D 1D 63 31 34 00 0F 57 C0 @SH..@H..c14..W. +180083E10 0F 11 44 24 20 0F 57 C9 F3 0F 7F 4C 24 30 41 B8 ..D$ .W....L$0A. +180083E20 09 00 00 00 48 8D 15 FD B9 32 00 48 8D 4C 24 20 ....H....2.H.L$ +180083E30 E8 7B BE F8 FF 90 48 8D 05 FB BB 32 00 48 89 05 .{....H....2.H.. +180083E40 2C 31 34 00 48 8D 54 24 20 48 8D 0D 28 31 34 00 ,14.H.T$ H..(14. +180083E50 E8 7B B9 F8 FF C6 05 3C 31 34 00 00 48 8D 4C 24 .{.....<14..H.L$ +180083E60 20 E8 FA BB F8 FF 48 8D 05 73 BB 32 00 48 89 05 .....H..s.2.H.. +180083E70 FC 30 34 00 66 0F 6F 05 94 F6 32 00 0F 29 05 2D .04.f.o...2..).- +180083E80 31 34 00 66 0F 6F 0D 95 F6 32 00 0F 29 0D 2E 31 14.f.o...2..)..1 +180083E90 34 00 66 0F 6F 05 A6 F6 32 00 0F 29 05 2F 31 34 4.f.o...2..)./14 +180083EA0 00 66 0F 6F 0D 87 F6 32 00 0F 29 0D 30 31 34 00 .f.o...2..).014. +180083EB0 66 0F 6F 05 D8 F6 32 00 0F 29 05 31 31 34 00 66 f.o...2..).114.f +180083EC0 0F 6F 0D D9 F6 32 00 0F 29 0D 32 31 34 00 66 0F .o...2..).214.f. +180083ED0 6F 05 AA F6 32 00 0F 29 05 33 31 34 00 66 0F 6F o...2..).314.f.o +180083EE0 0D CB F6 32 00 0F 29 0D 34 31 34 00 66 0F 6F 05 ...2..).414.f.o. +180083EF0 6C F6 32 00 0F 29 05 35 31 34 00 66 0F 6F 0D 6D l.2..).514.f.o.m +180083F00 F6 32 00 0F 29 0D 36 31 34 00 66 0F 6F 05 EE F5 .2..).614.f.o... +180083F10 32 00 0F 29 05 37 31 34 00 66 0F 6F 0D 2F F6 32 2..).714.f.o./.2 +180083F20 00 0F 29 0D 38 31 34 00 C7 05 72 30 34 00 01 01 ..).814...r04... +180083F30 01 01 C7 05 6C 30 34 00 00 01 01 00 C6 05 69 30 ....l04.......i0 +180083F40 34 00 00 C7 05 53 30 34 00 2C 01 00 00 48 8B C3 4....S04.,...H.. +180083F50 48 83 C4 40 5B C3 CC CC CC CC CC CC CC CC CC CC H..@[........... +180083F60 48 89 5C 24 08 57 48 83 EC 20 48 8B F9 8B DA 48 H.\$.WH.. H....H +180083F70 83 C1 08 E8 E8 BA F8 FF F6 C3 01 74 0D BA 00 01 ...........t.... +180083F80 00 00 48 8B CF E8 CE 77 02 00 48 8B 5C 24 30 48 ..H....w..H.\$0H +180083F90 8B C7 48 83 C4 20 5F C3 CC CC CC CC CC CC CC CC ..H.. _......... + +======================================================================== +FUNCTION: ESPModule_RenderOverlay +RVA: 0x83FA0–0x849A0 Size: 2560 bytes +180083FA0 48 8B C4 48 89 58 08 48 89 70 18 48 89 78 20 55 H..H.X.H.p.H.x U +180083FB0 41 56 41 57 48 8D 68 A1 48 81 EC B0 00 00 00 0F AVAWH.h.H....... +180083FC0 29 70 D8 48 8B F1 8B 15 10 2B 34 00 65 48 8B 04 )p.H.....+4.eH.. +180083FD0 25 58 00 00 00 41 BF 04 00 00 00 48 8B 3C D0 45 %X...A.....H.<.E +180083FE0 33 F6 42 8B 04 3F 39 05 C0 37 34 00 7E 4A 48 8D 3.B..?9..74.~JH. +180083FF0 0D B7 37 34 00 E8 16 78 02 00 83 3D AB 37 34 00 ..74...x...=.74. +180084000 FF 75 35 44 89 35 A6 37 34 00 33 D2 48 8D 0D A5 .u5D.5.74.3.H... +180084010 37 34 00 E8 78 46 02 00 90 E8 42 96 01 00 90 48 74..xF....B....H +180084020 8D 0D 0A C1 02 00 E8 B9 7B 02 00 90 48 8D 0D 79 ........{...H..y +180084030 37 34 00 E8 6C 77 02 00 0F 57 C0 0F 11 45 B7 0F 74..lw...W...E.. +180084040 57 C9 F3 0F 7F 4D C7 41 B8 0C 00 00 00 48 8D 15 W....M.A.....H.. +180084050 E4 B7 32 00 48 8D 4D B7 E8 53 BC F8 FF 90 4C 8D ..2.H.M..S....L. +180084060 45 B7 48 8D 55 D7 48 8D 0D 43 37 34 00 E8 5E 97 E.H.U.H..C74..^. +180084070 01 00 90 48 83 78 18 0F 76 03 48 8B 00 33 D2 48 ...H.x..v.H..3.H +180084080 8B C8 E8 99 C7 FE FF 0F B6 D8 48 8D 4D D7 E8 CD ..........H.M... +180084090 B9 F8 FF 90 48 8D 4D B7 E8 C3 B9 F8 FF 84 DB 0F ....H.M......... +1800840A0 84 28 09 00 00 48 8B 0D 54 2B 34 00 48 8B 81 D8 .(...H..T+4.H... +1800840B0 15 00 00 C6 80 03 01 00 00 01 48 8B 81 D8 15 00 ..........H..... +1800840C0 00 F3 0F 10 81 0C 0E 00 00 F3 0F 58 80 94 01 00 ...........X.... +1800840D0 00 F3 0F 11 80 94 01 00 00 F3 0F 58 40 58 F3 0F ...........X@X.. +1800840E0 58 80 98 01 00 00 F3 0F 11 80 50 01 00 00 42 8B X.........P...B. +1800840F0 04 3F 39 05 B4 36 34 00 7E 4A 48 8D 0D AB 36 34 .?9..64.~JH...64 +180084100 00 E8 0A 77 02 00 83 3D 9F 36 34 00 FF 75 35 44 ...w...=.64..u5D +180084110 89 35 9A 36 34 00 33 D2 48 8D 0D 99 36 34 00 E8 .5.64.3.H...64.. +180084120 6C 45 02 00 90 E8 36 95 01 00 90 48 8D 0D FE BF lE....6....H.... +180084130 02 00 E8 AD 7A 02 00 90 48 8D 0D 6D 36 34 00 E8 ....z...H..m64.. +180084140 60 76 02 00 0F 57 C0 0F 11 45 B7 0F 57 C9 F3 0F `v...W...E..W... +180084150 7F 4D C7 41 B8 08 00 00 00 48 8D 15 E8 B6 32 00 .M.A.....H....2. +180084160 48 8D 4D B7 E8 47 BB F8 FF 90 4C 8D 45 B7 48 8D H.M..G....L.E.H. +180084170 55 D7 48 8D 0D 37 36 34 00 E8 52 96 01 00 90 48 U.H..764..R....H +180084180 83 78 18 0F 76 03 48 8B 00 48 8D 56 28 48 8B C8 .x..v.H..H.V(H.. +180084190 E8 8B 11 00 00 90 48 8D 4D D7 E8 C1 B8 F8 FF 90 ......H.M....... +1800841A0 48 8D 4D B7 E8 B7 B8 F8 FF 80 7E 28 00 0F 84 D1 H.M.......~(.... +1800841B0 07 00 00 48 8B 0D 46 2A 34 00 48 8B 81 D8 15 00 ...H..F*4.H..... +1800841C0 00 C6 80 03 01 00 00 01 48 8B 81 D8 15 00 00 F3 ........H....... +1800841D0 0F 10 35 91 F1 32 00 80 B8 06 01 00 00 00 75 14 ..5..2........u. +1800841E0 48 C7 45 6F 00 00 00 00 0F 28 CE 48 8D 4D 6F E8 H.Eo.....(.H.Mo. +1800841F0 0C 4A FA FF 42 8B 04 3F 39 05 AE 35 34 00 7E 4A .J..B..?9..54.~J +180084200 48 8D 0D A5 35 34 00 E8 04 76 02 00 83 3D 99 35 H...54...v...=.5 +180084210 34 00 FF 75 35 44 89 35 94 35 34 00 33 D2 48 8D 4..u5D.5.54.3.H. +180084220 0D 93 35 34 00 E8 66 44 02 00 90 E8 30 94 01 00 ..54..fD....0... +180084230 90 48 8D 0D F8 BE 02 00 E8 A7 79 02 00 90 48 8D .H........y...H. +180084240 0D 67 35 34 00 E8 5A 75 02 00 0F 57 C0 0F 11 45 .g54..Zu...W...E +180084250 B7 0F 57 C9 F3 0F 7F 4D C7 41 B8 0D 00 00 00 48 ..W....M.A.....H +180084260 8D 15 F2 B5 32 00 48 8D 4D B7 E8 41 BA F8 FF 90 ....2.H.M..A.... +180084270 4C 8D 45 B7 48 8D 55 F7 48 8D 0D 31 35 34 00 E8 L.E.H.U.H..154.. +180084280 4C 95 01 00 90 48 83 78 18 0F 76 03 48 8B 00 48 L....H.x..v.H..H +180084290 8B C8 E8 89 A9 FE FF 0F B6 D8 48 8D 4D F7 E8 BD ..........H.M... +1800842A0 B7 F8 FF 90 48 8D 4D B7 E8 B3 B7 F8 FF 84 DB 0F ....H.M......... +1800842B0 84 CD 03 00 00 42 8B 04 3F 39 05 ED 34 34 00 7E .....B..?9..44.~ +1800842C0 4A 48 8D 0D E4 34 34 00 E8 43 75 02 00 83 3D D8 JH...44..Cu...=. +1800842D0 34 34 00 FF 75 35 44 89 35 D3 34 34 00 33 D2 48 44..u5D.5.44.3.H +1800842E0 8D 0D D2 34 34 00 E8 A5 43 02 00 90 E8 6F 93 01 ...44...C....o.. +1800842F0 00 90 48 8D 0D 37 BE 02 00 E8 E6 78 02 00 90 48 ..H..7.....x...H +180084300 8D 0D A6 34 34 00 E8 99 74 02 00 0F 57 C0 0F 11 ...44...t...W... +180084310 45 B7 0F 57 C9 F3 0F 7F 4D C7 41 B8 0D 00 00 00 E..W....M.A..... +180084320 48 8D 15 41 B5 32 00 48 8D 4D B7 E8 80 B9 F8 FF H..A.2.H.M...... +180084330 90 4C 8D 45 B7 48 8D 55 F7 48 8D 0D 70 34 34 00 .L.E.H.U.H..p44. +180084340 E8 8B 94 01 00 90 48 83 78 18 0F 76 03 48 8B 00 ......H.x..v.H.. +180084350 48 8D 56 34 48 8B C8 E8 84 DC FD FF 90 48 8D 4D H.V4H........H.M +180084360 F7 E8 FA B6 F8 FF 90 48 8D 4D B7 E8 F0 B6 F8 FF .......H.M...... +180084370 0F 28 CE 0F 57 C0 E8 F5 49 FA FF 42 8B 04 3F 39 .(..W...I..B..?9 +180084380 05 27 34 34 00 7E 4A 48 8D 0D 1E 34 34 00 E8 7D .'44.~JH...44..} +180084390 74 02 00 83 3D 12 34 34 00 FF 75 35 44 89 35 0D t...=.44..u5D.5. +1800843A0 34 34 00 33 D2 48 8D 0D 0C 34 34 00 E8 DF 42 02 44.3.H...44...B. +1800843B0 00 90 E8 A9 92 01 00 90 48 8D 0D 71 BD 02 00 E8 ........H..q.... +1800843C0 20 78 02 00 90 48 8D 0D E0 33 34 00 E8 D3 73 02 x...H...34...s. +1800843D0 00 0F 57 C0 0F 11 45 B7 0F 57 C9 F3 0F 7F 4D C7 ..W...E..W....M. +1800843E0 41 B8 08 00 00 00 48 8D 15 8B B4 32 00 48 8D 4D A.....H....2.H.M +1800843F0 B7 E8 BA B8 F8 FF 90 4C 8D 45 B7 48 8D 55 F7 48 .......L.E.H.U.H +180084400 8D 0D AA 33 34 00 E8 C5 93 01 00 90 48 83 78 18 ...34.......H.x. +180084410 0F 76 03 48 8B 00 48 8D 56 35 48 8B C8 E8 BE DB .v.H..H.V5H..... +180084420 FD FF 90 48 8D 4D F7 E8 34 B6 F8 FF 90 48 8D 4D ...H.M..4....H.M +180084430 B7 E8 2A B6 F8 FF 0F 28 CE 0F 57 C0 E8 2F 49 FA ..*....(..W../I. +180084440 FF 42 8B 04 3F 39 05 61 33 34 00 7E 4A 48 8D 0D .B..?9.a34.~JH.. +180084450 58 33 34 00 E8 B7 73 02 00 83 3D 4C 33 34 00 FF X34...s...=L34.. +180084460 75 35 44 89 35 47 33 34 00 33 D2 48 8D 0D 46 33 u5D.5G34.3.H..F3 +180084470 34 00 E8 19 42 02 00 90 E8 E3 91 01 00 90 48 8D 4...B.........H. +180084480 0D AB BC 02 00 E8 5A 77 02 00 90 48 8D 0D 1A 33 ......Zw...H...3 +180084490 34 00 E8 0D 73 02 00 0F 57 C0 0F 11 45 B7 0F 57 4...s...W...E..W +1800844A0 C9 F3 0F 7F 4D C7 41 B8 0D 00 00 00 48 8D 15 D5 ....M.A.....H... +1800844B0 B3 32 00 48 8D 4D B7 E8 F4 B7 F8 FF 90 4C 8D 45 .2.H.M.......L.E +1800844C0 B7 48 8D 55 F7 48 8D 0D E4 32 34 00 E8 FF 92 01 .H.U.H...24..... +1800844D0 00 90 48 83 78 18 0F 76 03 48 8B 00 48 8D 56 36 ..H.x..v.H..H.V6 +1800844E0 48 8B C8 E8 F8 DA FD FF 90 48 8D 4D F7 E8 6E B5 H........H.M..n. +1800844F0 F8 FF 90 48 8D 4D B7 E8 64 B5 F8 FF 42 8B 04 3F ...H.M..d...B..? +180084500 39 05 A6 32 34 00 7E 4A 48 8D 0D 9D 32 34 00 E8 9..24.~JH...24.. +180084510 FC 72 02 00 83 3D 91 32 34 00 FF 75 35 44 89 35 .r...=.24..u5D.5 +180084520 8C 32 34 00 33 D2 48 8D 0D 8B 32 34 00 E8 5E 41 .24.3.H...24..^A +180084530 02 00 90 E8 28 91 01 00 90 48 8D 0D F0 BB 02 00 ....(....H...... +180084540 E8 9F 76 02 00 90 48 8D 0D 5F 32 34 00 E8 52 72 ..v...H.._24..Rr +180084550 02 00 0F 57 C0 0F 11 45 B7 0F 57 C9 F3 0F 7F 4D ...W...E..W....M +180084560 C7 41 B8 0C 00 00 00 48 8D 15 2A B3 32 00 48 8D .A.....H..*.2.H. +180084570 4D B7 E8 39 B7 F8 FF 90 4C 8D 45 B7 48 8D 55 F7 M..9....L.E.H.U. +180084580 48 8D 0D 29 32 34 00 E8 44 92 01 00 90 48 83 78 H..)24..D....H.x +180084590 18 0F 76 03 48 8B 00 48 8D 56 37 48 8B C8 E8 3D ..v.H..H.V7H...= +1800845A0 DA FD FF 90 48 8D 4D F7 E8 B3 B4 F8 FF 90 48 8D ....H.M.......H. +1800845B0 4D B7 E8 A9 B4 F8 FF 0F 28 CE 0F 57 C0 E8 AE 47 M.......(..W...G +1800845C0 FA FF 42 8B 04 3F 39 05 E0 31 34 00 7E 4A 48 8D ..B..?9..14.~JH. +1800845D0 0D D7 31 34 00 E8 36 72 02 00 83 3D CB 31 34 00 ..14..6r...=.14. +1800845E0 FF 75 35 44 89 35 C6 31 34 00 33 D2 48 8D 0D C5 .u5D.5.14.3.H... +1800845F0 31 34 00 E8 98 40 02 00 90 E8 62 90 01 00 90 48 14...@....b....H +180084600 8D 0D 2A BB 02 00 E8 D9 75 02 00 90 48 8D 0D 99 ..*.....u...H... +180084610 31 34 00 E8 8C 71 02 00 0F 57 C0 0F 11 45 B7 0F 14...q...W...E.. +180084620 57 C9 F3 0F 7F 4D C7 41 B8 08 00 00 00 48 8D 15 W....M.A.....H.. +180084630 74 B2 32 00 48 8D 4D B7 E8 73 B6 F8 FF 90 4C 8D t.2.H.M..s....L. +180084640 45 B7 48 8D 55 F7 48 8D 0D 63 31 34 00 E8 7E 91 E.H.U.H..c14..~. +180084650 01 00 90 48 83 78 18 0F 76 03 48 8B 00 48 8D 56 ...H.x..v.H..H.V +180084660 38 48 8B C8 E8 77 D9 FD FF 90 48 8D 4D F7 E8 ED 8H...w....H.M... +180084670 B3 F8 FF 90 48 8D 4D B7 E8 E3 B3 F8 FF E8 AE BF ....H.M......... +180084680 FE FF 42 8B 04 3F 39 05 20 31 34 00 7E 4A 48 8D ..B..?9. 14.~JH. +180084690 0D 17 31 34 00 E8 76 71 02 00 83 3D 0B 31 34 00 ..14..vq...=.14. +1800846A0 FF 75 35 44 89 35 06 31 34 00 33 D2 48 8D 0D 05 .u5D.5.14.3.H... +1800846B0 31 34 00 E8 D8 3F 02 00 90 E8 A2 8F 01 00 90 48 14...?.........H +1800846C0 8D 0D 6A BA 02 00 E8 19 75 02 00 90 48 8D 0D D9 ..j.....u...H... +1800846D0 30 34 00 E8 CC 70 02 00 0F 57 C0 0F 11 45 B7 0F 04...p...W...E.. +1800846E0 57 C9 F3 0F 7F 4D C7 41 B8 0C 00 00 00 48 8D 15 W....M.A.....H.. +1800846F0 C4 B1 32 00 48 8D 4D B7 E8 B3 B5 F8 FF 90 4C 8D ..2.H.M.......L. +180084700 45 B7 48 8D 55 F7 48 8D 0D A3 30 34 00 E8 BE 90 E.H.U.H...04.... +180084710 01 00 90 48 83 78 18 0F 76 03 48 8B 00 48 8B C8 ...H.x..v.H..H.. +180084720 E8 FB A4 FE FF 0F B6 D8 48 8D 4D F7 E8 2F B3 F8 ........H.M../.. +180084730 FF 90 48 8D 4D B7 E8 25 B3 F8 FF 84 DB 0F 84 41 ..H.M..%.......A +180084740 02 00 00 42 8B 04 3F 39 05 5F 30 34 00 7E 4A 48 ...B..?9._04.~JH +180084750 8D 0D 56 30 34 00 E8 B5 70 02 00 83 3D 4A 30 34 ..V04...p...=J04 +180084760 00 FF 75 35 44 89 35 45 30 34 00 33 D2 48 8D 0D ..u5D.5E04.3.H.. +180084770 44 30 34 00 E8 17 3F 02 00 90 E8 E1 8E 01 00 90 D04...?......... +180084780 48 8D 0D A9 B9 02 00 E8 58 74 02 00 90 48 8D 0D H.......Xt...H.. +180084790 18 30 34 00 E8 0B 70 02 00 0F 57 C0 0F 11 45 B7 .04...p...W...E. +1800847A0 0F 57 C9 F3 0F 7F 4D C7 41 B8 0D 00 00 00 48 8D .W....M.A.....H. +1800847B0 15 13 B1 32 00 48 8D 4D B7 E8 F2 B4 F8 FF 90 4C ...2.H.M.......L +1800847C0 8D 45 B7 48 8D 55 17 48 8D 0D E2 2F 34 00 E8 FD .E.H.U.H.../4... +1800847D0 8F 01 00 90 48 83 78 18 0F 76 03 48 8B 00 48 8D ....H.x..v.H..H. +1800847E0 56 39 48 8B C8 E8 F6 D7 FD FF 90 48 8D 4D 17 E8 V9H........H.M.. +1800847F0 6C B2 F8 FF 90 48 8D 4D B7 E8 62 B2 F8 FF 0F 28 l....H.M..b....( +180084800 CE 0F 57 C0 E8 67 45 FA FF 42 8B 04 3F 39 05 99 ..W..gE..B..?9.. +180084810 2F 34 00 7E 4A 48 8D 0D 90 2F 34 00 E8 EF 6F 02 /4.~JH.../4...o. +180084820 00 83 3D 84 2F 34 00 FF 75 35 44 89 35 7F 2F 34 ..=./4..u5D.5./4 +180084830 00 33 D2 48 8D 0D 7E 2F 34 00 E8 51 3E 02 00 90 .3.H..~/4..Q>... +180084840 E8 1B 8E 01 00 90 48 8D 0D E3 B8 02 00 E8 92 73 ......H........s +180084850 02 00 90 48 8D 0D 52 2F 34 00 E8 45 6F 02 00 0F ...H..R/4..Eo... +180084860 57 C0 0F 11 45 B7 0F 57 C9 F3 0F 7F 4D C7 41 B8 W...E..W....M.A. +180084870 09 00 00 00 48 8D 15 5D B0 32 00 48 8D 4D B7 E8 ....H..].2.H.M.. +180084880 2C B4 F8 FF 90 4C 8D 45 B7 48 8D 55 17 48 8D 0D ,....L.E.H.U.H.. +180084890 1C 2F 34 00 E8 37 8F 01 00 90 48 83 78 18 0F 76 ./4..7....H.x..v +1800848A0 03 48 8B 00 48 8D 56 3A 48 8B C8 E8 30 D7 FD FF .H..H.V:H...0... +1800848B0 90 48 8D 4D 17 E8 A6 B1 F8 FF 90 48 8D 4D B7 E8 .H.M.......H.M.. +1800848C0 9C B1 F8 FF 42 8B 04 3F 39 05 DE 2E 34 00 7E 4A ....B..?9...4.~J +1800848D0 48 8D 0D D5 2E 34 00 E8 34 6F 02 00 83 3D C9 2E H....4..4o...=.. +1800848E0 34 00 FF 75 35 44 89 35 C4 2E 34 00 33 D2 48 8D 4..u5D.5..4.3.H. +1800848F0 0D C3 2E 34 00 E8 96 3D 02 00 90 E8 60 8D 01 00 ...4...=....`... +180084900 90 48 8D 0D 28 B8 02 00 E8 D7 72 02 00 90 48 8D .H..(.....r...H. +180084910 0D 97 2E 34 00 E8 8A 6E 02 00 0F 57 C0 0F 11 45 ...4...n...W...E +180084920 B7 0F 57 C9 F3 0F 7F 4D C7 41 B8 09 00 00 00 48 ..W....M.A.....H +180084930 8D 15 B2 AF 32 00 48 8D 4D B7 E8 71 B3 F8 FF 90 ....2.H.M..q.... +180084940 4C 8D 45 B7 48 8D 55 17 48 8D 0D 61 2E 34 00 E8 L.E.H.U.H..a.4.. +180084950 7C 8E 01 00 90 48 83 78 18 0F 76 03 48 8B 00 48 |....H.x..v.H..H +180084960 8D 56 3C 48 8B C8 E8 75 D6 FD FF 90 48 8D 4D 17 .V..7.u8... +180084BC0 00 00 0F 10 47 40 0F 11 44 24 74 80 7F 38 00 75 ....G@..D$t..8.u +180084BD0 24 80 7F 34 00 75 1E E9 AD 06 00 00 0F 10 47 70 $..4.u........Gp +180084BE0 0F 11 44 24 74 80 7F 38 00 75 0A 80 7F 36 00 0F ..D$t..8.u...6.. +180084BF0 84 94 06 00 00 C6 44 24 70 01 48 8B 05 07 21 34 ......D$p.H...!4 +180084C00 00 33 C9 FF D0 44 8B E8 48 8B 15 01 21 34 00 33 .3...D..H...!4.3 +180084C10 C9 FF D2 44 8B E0 4C 8B 0D DB 20 34 00 45 33 C0 ...D..L... 4.E3. +180084C20 49 8B D7 48 8D 4D 60 41 FF D1 F2 0F 10 30 44 8B I..H.M`A.....0D. +180084C30 70 08 4C 8B 0D C7 20 34 00 F2 0F 11 75 C0 44 89 p.L... 4....u.D. +180084C40 75 C8 F2 44 0F 11 6D D0 8B 44 24 60 89 45 D8 45 u..D..m..D$`.E.E +180084C50 33 C0 48 8D 55 C0 48 8D 4D D0 41 FF D1 0F 28 F8 3.H.U.H.M.A...(. +180084C60 66 0F 6E 4F 30 0F 5B C9 0F 2F F9 0F 87 18 06 00 f.nO0.[../...... +180084C70 00 48 8B 1D 70 20 34 00 48 8B 05 71 20 34 00 F2 .H..p 4.H..q 4.. +180084C80 0F 11 75 E0 44 89 75 E8 33 C9 FF D0 48 8B D0 45 ..u.D.u.3...H..E +180084C90 33 C9 4C 8D 45 E0 48 8D 4D 70 FF D3 F2 0F 10 00 3.L.E.H.Mp...... +180084CA0 F2 0F 11 45 F0 44 0F 2F 60 08 0F 87 D4 05 00 00 ...E.D./`....... +180084CB0 0F 57 C0 0F 11 85 C0 00 00 00 45 33 F6 4C 89 B5 .W........E3.L.. +180084CC0 D0 00 00 00 4C 89 B5 D8 00 00 00 45 33 C0 48 8D ....L......E3.H. +180084CD0 15 DB F6 04 00 48 8D 8D C0 00 00 00 E8 CF AF F8 .....H.......... +180084CE0 FF 90 44 38 77 39 0F 84 88 01 00 00 8B 15 EA 1D ..D8w9.......... +180084CF0 34 00 65 48 8B 04 25 58 00 00 00 B9 04 00 00 00 4.eH..%X........ +180084D00 48 8B 04 D0 8B 0C 01 39 0D 9F 2A 34 00 7E 4A 48 H......9..*4.~JH +180084D10 8D 0D 96 2A 34 00 E8 F5 6A 02 00 83 3D 8A 2A 34 ...*4...j...=.*4 +180084D20 00 FF 75 35 44 89 35 85 2A 34 00 33 D2 48 8D 0D ..u5D.5.*4.3.H.. +180084D30 84 2A 34 00 E8 57 39 02 00 90 E8 21 89 01 00 90 .*4..W9....!.... +180084D40 48 8D 0D E9 B3 02 00 E8 98 6E 02 00 90 48 8D 0D H........n...H.. +180084D50 58 2A 34 00 E8 4B 6A 02 00 0F 57 C0 0F 11 45 98 X*4..Kj...W...E. +180084D60 0F 57 C9 F3 0F 7F 4D A8 41 B8 01 00 00 00 48 8D .W....M.A.....H. +180084D70 15 7F AB 32 00 48 8D 4D 98 E8 32 AF F8 FF 90 4C ...2.H.M..2....L +180084D80 8D 45 98 48 8D 95 80 00 00 00 48 8D 0D 1F 2A 34 .E.H......H...*4 +180084D90 00 E8 3A 8A 01 00 48 8B D8 48 83 78 18 0F 76 03 ..:...H..H.x..v. +180084DA0 48 8B 18 F3 0F 2C D7 48 8D 4D 30 E8 10 A8 FF FF H....,.H.M0..... +180084DB0 90 49 C7 C0 FF FF FF FF 0F 1F 84 00 00 00 00 00 .I.............. +180084DC0 49 FF C0 42 80 3C 03 00 75 F6 48 8B D3 48 8D 4D I..B.<..u.H..H.M +180084DD0 30 E8 7A A9 F8 FF 0F 10 00 0F 11 85 A0 00 00 00 0.z............. +180084DE0 0F 10 48 10 0F 11 8D B0 00 00 00 C6 00 00 4C 89 ..H...........L. +180084DF0 70 10 48 C7 40 18 0F 00 00 00 48 8D 95 A0 00 00 p.H.@.....H..... +180084E00 00 66 48 0F 7E C1 66 0F 6F C1 66 0F 73 D8 08 66 .fH.~.f.o.f.s..f +180084E10 48 0F 7E C0 48 83 F8 0F 48 0F 47 D1 66 49 0F 7E H.~.H...H.G.fI.~ +180084E20 C8 48 8D 8D C0 00 00 00 E8 23 A9 F8 FF 48 8D 95 .H.......#...H.. +180084E30 C0 00 00 00 48 8D 4D 10 E8 93 A9 F8 FF 48 8D 4D ....H.M......H.M +180084E40 10 E8 1A AC F8 FF 90 48 8D 8D A0 00 00 00 E8 0D .......H........ +180084E50 AC F8 FF 90 48 8D 4D 30 E8 03 AC F8 FF 90 48 8D ....H.M0......H. +180084E60 8D 80 00 00 00 E8 F6 AB F8 FF 90 48 8D 4D 98 E8 ...........H.M.. +180084E70 EC AB F8 FF 80 7F 3A 00 0F 84 2E 01 00 00 0F 57 ......:........W +180084E80 C0 0F 11 85 A0 00 00 00 4C 89 B5 B0 00 00 00 4C ........L......L +180084E90 89 B5 B8 00 00 00 41 B8 07 00 00 00 48 8D 15 55 ......A.....H..U +180084EA0 AA 32 00 48 8D 8D A0 00 00 00 E8 01 AE F8 FF 90 .2.H............ +180084EB0 48 8B 05 29 1E 34 00 33 D2 49 8B CF FF D0 48 85 H..).4.3.I....H. +180084EC0 C0 74 76 48 8B D0 48 8D 4D 98 E8 A1 6B 01 00 48 .tvH..H.M...k..H +180084ED0 8B 95 B8 00 00 00 48 83 FA 0F 76 34 48 FF C2 48 ......H...v4H..H +180084EE0 8B 8D A0 00 00 00 48 8B C1 48 81 FA 00 10 00 00 ......H..H...... +180084EF0 72 19 48 83 C2 27 48 8B 49 F8 48 2B C1 48 83 E8 r.H..'H.I.H+.H.. +180084F00 08 48 83 F8 1F 0F 87 F8 03 00 00 E8 48 68 02 00 .H..........Hh.. +180084F10 0F 10 45 98 0F 11 85 A0 00 00 00 0F 10 4D A8 0F ..E..........M.. +180084F20 11 8D B0 00 00 00 F3 44 0F 7F 4D A8 C6 45 98 00 .......D..M..E.. +180084F30 48 8D 4D 98 E8 27 AB F8 FF 48 83 BD D0 00 00 00 H.M..'...H...... +180084F40 00 74 19 41 B8 03 00 00 00 48 8D 15 B0 A9 32 00 .t.A.....H....2. +180084F50 48 8D 8D C0 00 00 00 E8 F4 A7 F8 FF 48 8D 95 A0 H...........H... +180084F60 00 00 00 48 83 BD B8 00 00 00 0F 48 0F 47 95 A0 ...H.......H.G.. +180084F70 00 00 00 4C 8B 85 B0 00 00 00 48 8D 8D C0 00 00 ...L......H..... +180084F80 00 E8 CA A7 F8 FF 48 8D 95 C0 00 00 00 48 8D 4D ......H......H.M +180084F90 10 E8 3A A8 F8 FF 48 8D 4D 10 E8 C1 AA F8 FF 90 ..:...H.M....... +180084FA0 48 8D 8D A0 00 00 00 E8 B4 AA F8 FF 80 7F 3C 00 H.............<. +180084FB0 0F 84 DE 00 00 00 49 8B C6 48 8D 0D 40 B0 F7 FF ......I..H..@... +180084FC0 39 B4 81 08 F9 3A 00 74 15 48 FF C0 48 83 F8 06 9....:.t.H..H... +180084FD0 72 EE 48 8D 15 0B A6 32 00 4D 8B C6 EB 1E 48 03 r.H....2.M....H. +180084FE0 C0 0F 10 8C C1 20 F9 3A 00 66 0F 6F C1 66 0F 73 ..... .:.f.o.f.s +180084FF0 D8 08 66 49 0F 7E C0 66 48 0F 7E CA 0F 57 C0 0F ..fI.~.fH.~..W.. +180085000 11 85 A0 00 00 00 4C 89 B5 B0 00 00 00 4C 89 B5 ......L......L.. +180085010 B8 00 00 00 48 8D 8D A0 00 00 00 E8 90 AC F8 FF ....H........... +180085020 90 48 83 BD D0 00 00 00 00 74 19 41 B8 03 00 00 .H.......t.A.... +180085030 00 48 8D 15 C8 A8 32 00 48 8D 8D C0 00 00 00 E8 .H....2.H....... +180085040 0C A7 F8 FF 48 8D 95 A0 00 00 00 48 83 BD B8 00 ....H......H.... +180085050 00 00 0F 48 0F 47 95 A0 00 00 00 4C 8B 85 B0 00 ...H.G.....L.... +180085060 00 00 48 8D 8D C0 00 00 00 E8 E2 A6 F8 FF 48 8D ..H...........H. +180085070 95 C0 00 00 00 48 8D 4D 10 E8 52 A7 F8 FF 48 8D .....H.M..R...H. +180085080 4D 10 E8 D9 A9 F8 FF 90 48 8D 8D A0 00 00 00 E8 M.......H....... +180085090 CC A9 F8 FF 48 83 BD D0 00 00 00 00 0F 84 D6 01 ....H........... +1800850A0 00 00 F3 0F 10 45 F0 F3 0F 11 44 24 68 66 41 0F .....E....D$hfA. +1800850B0 6E CC 0F 5B C9 F3 0F 5C 4D F4 F3 0F 11 4C 24 6C n..[...\M....L$l +1800850C0 48 8B 1D 39 1B 34 00 48 8B 73 70 48 85 F6 74 07 H..9.4.H.spH..t. +1800850D0 F3 0F 10 76 1C EB 0B 41 0F 28 F0 48 8B B3 E0 12 ...v...A.(.H.... +1800850E0 00 00 48 8B 83 E0 12 00 00 48 89 45 00 F3 0F 10 ..H......H.E.... +1800850F0 83 F4 12 00 00 F3 0F 11 45 08 F3 0F 10 8B F0 12 ........E....... +180085100 00 00 F3 0F 11 4D 0C 48 8D 8B C8 20 00 00 48 8D .....M.H... ..H. +180085110 55 00 E8 19 8E FB FF 41 0F 2E F0 7A 0A 75 08 F3 U......A...z.u.. +180085120 0F 10 B3 F4 12 00 00 41 0F 28 D0 0F 28 CE 48 8B .......A.(..(.H. +180085130 CE E8 FA F8 F9 FF 48 8B 05 C3 1A 34 00 48 8B 88 ......H....4.H.. +180085140 D8 15 00 00 4C 8D 05 C5 6D 32 00 BA 01 00 00 00 ....L...m2...... +180085150 48 8B 49 40 E8 D7 3D F9 FF 4C 8B D0 4C 8D 85 C0 H.I@..=..L..L... +180085160 00 00 00 48 83 BD D8 00 00 00 0F 4C 0F 47 85 C0 ...H.......L.G.. +180085170 00 00 00 48 8D 4C 24 74 E8 E3 D2 F8 FF 8B F0 A9 ...H.L$t........ +180085180 00 00 00 FF 74 52 4D 85 C0 74 4D 41 80 38 00 74 ....tRM..tMA.8.t +180085190 47 41 0F 10 42 60 0F 11 44 24 70 49 8B 4A 38 44 GA..B`..D$pI.J8D +1800851A0 89 74 24 48 F3 44 0F 11 44 24 40 4C 89 74 24 38 .t$H.D..D$@L.t$8 +1800851B0 4C 89 44 24 30 48 8D 44 24 70 48 89 44 24 28 89 L.D$0H.D$pH.D$(. +1800851C0 74 24 20 4C 8D 4C 24 68 41 0F 28 D2 49 8B D2 48 t$ L.L$hA.(.I..H +1800851D0 8B 49 18 E8 A8 C3 FC FF 48 8B 1D 21 1A 34 00 48 .I......H..!.4.H +1800851E0 63 83 C8 20 00 00 85 C0 7F 0E 48 8D 0D EF 6F 32 c.. ......H...o2 +1800851F0 00 E8 3A 30 FA FF EB 26 48 03 C0 48 8B 8B D0 20 ..:0...&H..H... +180085200 00 00 F3 0F 10 54 C1 FC F3 0F 10 4C C1 F8 48 8B .....T.....L..H. +180085210 4C C1 F0 E8 18 F8 F9 FF FF 8B C8 20 00 00 48 8B L.......... ..H. +180085220 05 DB 19 34 00 48 8B 88 D8 15 00 00 4C 8D 05 DD ...4.H......L... +180085230 6C 32 00 BA 01 00 00 00 48 8B 49 40 E8 EF 3C F9 l2......H.I@..<. +180085240 FF 48 8B C8 41 8B C5 99 2B C2 D1 F8 66 0F 6E C0 .H..A...+...f.n. +180085250 0F 5B C0 F3 0F 11 45 88 C7 45 8C 00 00 00 00 F3 .[....E..E...... +180085260 44 0F 11 5C 24 20 44 8B CE 4C 8D 44 24 68 48 8D D..\$ D..L.D$hH. +180085270 55 88 E8 A9 45 FC FF 90 48 8D 8D C0 00 00 00 E8 U...E...H....... +180085280 DC A7 F8 FF 48 8B 5C 24 58 48 FF C3 48 89 5C 24 ....H.\$XH..H.\$ +180085290 58 4C 8B 7D 90 49 83 C7 08 4C 89 7D 90 48 63 44 XL.}.I...L.}.HcD +1800852A0 24 50 48 3B D8 0F 82 85 F8 FF FF 48 8B 8D E0 00 $PH;.......H.... + +======================================================================== +FUNCTION: FPSModule_RenderOverlay +RVA: 0x85700–0x85900 Size: 512 bytes +180085700 00 48 8D 15 80 A3 32 00 48 8D 4C 24 20 E8 9E A5 .H....2.H.L$ ... +180085710 F8 FF 90 4C 8D 44 24 20 48 8D 54 24 40 48 8D 0D ...L.D$ H.T$@H.. +180085720 8C 20 34 00 E8 A7 80 01 00 90 48 83 78 18 0F 76 . 4.......H.x..v +180085730 03 48 8B 00 33 D2 48 8B C8 E8 E2 B0 FE FF 0F B6 .H..3.H......... +180085740 D8 48 8D 4C 24 40 E8 15 A3 F8 FF 90 48 8D 4C 24 .H.L$@......H.L$ +180085750 20 E8 0A A3 F8 FF 84 DB 0F 84 57 01 00 00 48 8B .........W...H. +180085760 0D 9B 14 34 00 48 8B 81 D8 15 00 00 C6 80 03 01 ...4.H.......... +180085770 00 00 01 48 8B 81 D8 15 00 00 F3 0F 10 81 0C 0E ...H............ +180085780 00 00 F3 0F 58 80 94 01 00 00 F3 0F 11 80 94 01 ....X........... +180085790 00 00 F3 0F 58 40 58 F3 0F 58 80 98 01 00 00 F3 ....X@X..X...... +1800857A0 0F 11 80 50 01 00 00 42 8B 04 37 39 05 FB 1F 34 ...P...B..79...4 +1800857B0 00 7E 4D 48 8D 0D F2 1F 34 00 E8 51 60 02 00 83 .~MH....4..Q`... +1800857C0 3D E6 1F 34 00 FF 75 38 C7 05 DE 1F 34 00 00 00 =..4..u8....4... +1800857D0 00 00 33 D2 48 8D 0D DD 1F 34 00 E8 B0 2E 02 00 ..3.H....4...... +1800857E0 90 E8 7A 7E 01 00 90 48 8D 0D 42 A9 02 00 E8 F1 ..z~...H..B..... +1800857F0 63 02 00 90 48 8D 0D B1 1F 34 00 E8 A4 5F 02 00 c...H....4..._.. +180085800 0F 57 C0 0F 11 44 24 20 0F 57 C9 F3 0F 7F 4C 24 .W...D$ .W....L$ +180085810 30 41 B8 10 00 00 00 48 8D 15 7A A2 32 00 48 8D 0A.....H..z.2.H. +180085820 4C 24 20 E8 88 A4 F8 FF 90 4C 8D 44 24 20 48 8D L$ ......L.D$ H. +180085830 54 24 40 48 8D 0D 76 1F 34 00 E8 91 7F 01 00 90 T$@H..v.4....... +180085840 48 83 78 18 0F 76 03 48 8B 00 48 8D 56 28 48 8B H.x..v.H..H.V(H. +180085850 C8 E8 CA FA FF FF 90 48 8D 4C 24 40 E8 FF A1 F8 .......H.L$@.... +180085860 FF 90 48 8D 4C 24 20 E8 F4 A1 F8 FF 48 8B 0D 8D ..H.L$ .....H... +180085870 13 34 00 48 8B 81 D8 15 00 00 C6 80 03 01 00 00 .4.H............ +180085880 01 48 8B 81 D8 15 00 00 F3 0F 10 80 94 01 00 00 .H.............. +180085890 F3 0F 5C 81 0C 0E 00 00 F3 0F 11 80 94 01 00 00 ..\............. +1800858A0 F3 0F 58 40 58 F3 0F 58 80 98 01 00 00 F3 0F 11 ..X@X..X........ +1800858B0 80 50 01 00 00 48 8B 5C 24 70 48 8B 74 24 78 48 .P...H.\$pH.t$xH +1800858C0 8B BC 24 80 00 00 00 48 83 C4 60 41 5E C3 CC CC ..$....H..`A^... +1800858D0 48 8B C4 48 89 58 10 48 89 78 18 55 48 8D 68 A1 H..H.X.H.x.UH.h. +1800858E0 48 81 EC F0 00 00 00 0F 29 70 E8 33 FF 40 38 79 H.......)p.3.@8y +1800858F0 28 0F 84 26 02 00 00 48 8B 05 3A 14 34 00 33 C9 (..&...H..:.4.3. + +======================================================================== +FUNCTION: PreventScreenshot_Init +RVA: 0x8AD70–0x8AE60 Size: 240 bytes +18008AD70 48 83 EC 48 8B 0D 62 BD 33 00 65 48 8B 04 25 58 H..H..b.3.eH..%X +18008AD80 00 00 00 BA 04 00 00 00 48 8B 04 C8 8B 0C 02 39 ........H......9 +18008AD90 0D FB C5 33 00 0F 8E A7 00 00 00 48 8D 0D EE C5 ...3.......H.... +18008ADA0 33 00 E8 69 0A 02 00 83 3D E2 C5 33 00 FF 0F 85 3..i....=..3.... +18008ADB0 8E 00 00 00 0F 57 C0 0F 11 44 24 20 0F 57 C9 F3 .....W...D$ .W.. +18008ADC0 0F 7F 4C 24 30 41 B8 12 00 00 00 48 8D 15 E6 52 ..L$0A.....H...R +18008ADD0 32 00 48 8D 4C 24 20 E8 D4 4E F8 FF 90 48 8D 05 2.H.L$ ..N...H.. +18008ADE0 54 4C 32 00 48 89 05 6D C5 33 00 48 8D 54 24 20 TL2.H..m.3.H.T$ +18008ADF0 48 8D 0D 69 C5 33 00 E8 D4 49 F8 FF C6 05 7D C5 H..i.3...I....}. +18008AE00 33 00 00 48 8D 4C 24 20 E8 53 4C F8 FF 48 8D 05 3..H.L$ .SL..H.. +18008AE10 FC 52 32 00 48 89 05 3D C5 33 00 C6 05 5E C5 33 .R2.H..=.3...^.3 +18008AE20 00 00 C6 05 5F C5 33 00 00 48 8D 0D A0 50 02 00 ...._.3..H...P.. +18008AE30 E8 AF 0D 02 00 90 48 8D 0D 53 C5 33 00 E8 62 09 ......H..S.3..b. +18008AE40 02 00 48 8D 05 0F C5 33 00 48 83 C4 48 C3 CC CC ..H....3.H..H... +18008AE50 48 8D 15 69 01 00 00 E9 A4 B1 FF FF CC CC CC CC H..i............ + +======================================================================== +FUNCTION: PreventScreenshot_OsCheck +RVA: 0x8B220–0x8B490 Size: 624 bytes +18008B220 48 89 5C 24 10 57 48 81 EC 70 02 00 00 48 8B 05 H.\$.WH..p...H.. +18008B230 0C 9E 33 00 48 33 C4 48 89 84 24 60 02 00 00 48 ..3.H3.H..$`...H +18008B240 8B F9 8B 0D 94 B8 33 00 65 48 8B 04 25 58 00 00 ......3.eH..%X.. +18008B250 00 BA 04 00 00 00 48 8B 04 C8 8B 0C 02 39 0D 7D ......H......9.} +18008B260 C2 33 00 0F 8E FB 01 00 00 48 8D 0D 70 C2 33 00 .3.......H..p.3. +18008B270 E8 9B 05 02 00 83 3D 64 C2 33 00 FF 0F 85 E2 01 ......=d.3...... +18008B280 00 00 48 8D 0D 47 4E 32 00 FF 15 01 60 02 00 48 ..H..GN2....`..H +18008B290 85 C0 0F 84 BC 00 00 00 48 8D 15 49 4E 32 00 48 ........H..IN2.H +18008B2A0 8B C8 FF 15 E0 5D 02 00 48 8B D8 48 85 C0 0F 84 .....]..H..H.... +18008B2B0 A0 00 00 00 33 D2 41 B8 18 01 00 00 48 8D 8C 24 ....3.A.....H..$ +18008B2C0 44 01 00 00 E8 A1 15 02 00 C7 84 24 40 01 00 00 D..........$@... +18008B2D0 1C 01 00 00 48 8D 8C 24 40 01 00 00 FF D3 85 C0 ....H..$@....... +18008B2E0 75 72 48 8D 4C 24 20 48 8D 94 24 40 01 00 00 41 urH.L$ H..$@...A +18008B2F0 B8 02 00 00 00 41 8B C0 0F 1F 84 00 00 00 00 00 .....A.......... +18008B300 0F 10 02 0F 11 01 0F 10 4A 10 0F 11 49 10 0F 10 ........J...I... +18008B310 42 20 0F 11 41 20 0F 10 4A 30 0F 11 49 30 0F 10 B ..A ..J0..I0.. +18008B320 42 40 0F 11 41 40 0F 10 4A 50 0F 11 49 50 0F 10 B@..A@..JP..IP.. +18008B330 42 60 0F 11 41 60 48 8D 89 80 00 00 00 0F 10 4A B`..A`H........J +18008B340 70 0F 11 49 F0 48 8D 92 80 00 00 00 48 83 E8 01 p..I.H......H... +18008B350 75 AE EB 7E 33 D2 41 B8 1C 01 00 00 48 8D 8C 24 u..~3.A.....H..$ +18008B360 40 01 00 00 E8 01 15 02 00 48 8D 4C 24 20 48 8D @........H.L$ H. +18008B370 94 24 40 01 00 00 41 B8 02 00 00 00 41 8B C0 90 .$@...A.....A... +18008B380 0F 10 02 0F 11 01 0F 10 4A 10 0F 11 49 10 0F 10 ........J...I... +18008B390 42 20 0F 11 41 20 0F 10 4A 30 0F 11 49 30 0F 10 B ..A ..J0..I0.. +18008B3A0 42 40 0F 11 41 40 0F 10 4A 50 0F 11 49 50 0F 10 B@..A@..JP..IP.. +18008B3B0 42 60 0F 11 41 60 48 8D 89 80 00 00 00 0F 10 4A B`..A`H........J +18008B3C0 70 0F 11 49 F0 48 8D 92 80 00 00 00 48 83 E8 01 p..I.H......H... +18008B3D0 75 AE 0F 10 02 0F 11 01 48 8B 42 10 48 89 41 10 u.......H.B.H.A. +18008B3E0 8B 42 18 89 41 18 48 8D 0D 03 C1 33 00 48 8D 54 .B..A.H....3.H.T +18008B3F0 24 20 0F 10 02 0F 11 01 0F 10 4A 10 0F 11 49 10 $ ........J...I. +18008B400 0F 10 42 20 0F 11 41 20 0F 10 4A 30 0F 11 49 30 ..B ..A ..J0..I0 +18008B410 0F 10 42 40 0F 11 41 40 0F 10 4A 50 0F 11 49 50 ..B@..A@..JP..IP +18008B420 0F 10 42 60 0F 11 41 60 48 8D 89 80 00 00 00 0F ..B`..A`H....... +18008B430 10 4A 70 0F 11 49 F0 48 8D 92 80 00 00 00 49 83 .Jp..I.H......I. +18008B440 E8 01 75 AE 0F 10 02 0F 11 01 48 8B 42 10 48 89 ..u.......H.B.H. +18008B450 41 10 8B 42 18 89 41 18 48 8D 0D 81 C0 33 00 E8 A..B..A.H....3.. +18008B460 40 03 02 00 E8 07 F9 FF FF 44 0F B6 40 28 48 8B @........D..@(H. +18008B470 CF 81 3D 81 C0 33 00 61 4A 00 00 73 0A 33 D2 45 ..=..3.aJ..s.3.E +18008B480 84 C0 0F 95 C2 EB 08 41 F6 D8 1B D2 83 E2 11 FF .......A........ + +======================================================================== +FUNCTION: ModulePathScanner +RVA: 0x8B650–0x8BAF0 Size: 1184 bytes +18008B650 40 55 53 56 57 41 54 41 55 41 56 41 57 48 8D AC @USVWATAUAVAWH.. +18008B660 24 48 FE FF FF 48 81 EC B8 02 00 00 48 8B 05 CD $H...H......H... +18008B670 99 33 00 48 33 C4 48 89 85 A0 01 00 00 49 8B F1 .3.H3.H......I.. +18008B680 4C 89 4C 24 40 41 8B D8 4C 8B EA 48 8B F9 48 89 L.L$@A..L..H..H. +18008B690 4C 24 38 E8 68 64 FF FF 4C 8B D0 4C 8D 0D AE FF L$8.hd..L..L.... +18008B6A0 FF FF 4D 8B C1 49 C1 E8 08 41 0F B6 D0 41 0F B6 ..M..I...A...A.. +18008B6B0 C9 48 B8 25 23 22 84 E4 9C F2 CB 48 33 C8 49 B8 .H.%#".....H3.I. +18008B6C0 B3 01 00 00 00 01 00 00 49 0F AF C8 48 33 D1 49 ........I...H3.I +18008B6D0 0F AF D0 49 8B C1 48 C1 E8 10 0F B6 C8 48 33 D1 ...I..H......H3. +18008B6E0 49 0F AF D0 49 8B C1 48 C1 E8 18 0F B6 C8 48 33 I...I..H......H3 +18008B6F0 D1 49 0F AF D0 49 8B C1 48 C1 E8 20 0F B6 C8 48 .I...I..H.. ...H +18008B700 33 D1 49 0F AF D0 49 8B C1 48 C1 E8 28 0F B6 C8 3.I...I..H..(... +18008B710 48 33 D1 49 0F AF D0 49 8B C1 48 C1 E8 30 0F B6 H3.I...I..H..0.. +18008B720 C8 48 33 CA 49 0F AF C8 49 8B C1 48 C1 E8 38 48 .H3.I...I..H..8H +18008B730 33 C8 49 0F AF C8 49 23 4A 48 48 C1 E1 04 49 03 3.I...I#JHH...I. +18008B740 4A 30 48 8B 41 08 49 8B 52 20 48 3B C2 74 1A 48 J0H.A.I.R H;.t.H +18008B750 8B 09 4C 3B 48 10 74 13 48 3B C1 74 0C 48 8B 40 ..L;H.t.H;.t.H.@ +18008B760 08 4C 3B 48 10 75 F1 EB 02 33 C0 48 85 C0 48 0F .L;H.u...3.H..H. +18008B770 44 C2 48 3B C2 0F 84 49 03 00 00 4C 8B 50 18 4D D.H;...I...L.P.M +18008B780 85 D2 0F 84 3C 03 00 00 4C 8B CE 44 8B C3 49 8B ....<...L..D..I. +18008B790 D5 48 8B CF 41 FF D2 8B C8 89 44 24 30 85 C0 0F .H..A.....D$0... +18008B7A0 84 21 03 00 00 4D 85 ED 0F 84 18 03 00 00 48 85 .!...M........H. +18008B7B0 F6 0F 84 0F 03 00 00 8B 06 C1 E8 03 89 44 24 34 .............D$4 +18008B7C0 45 33 FF 45 33 F6 85 C0 0F 84 E6 02 00 00 89 4C E3.E3..........L +18008B7D0 24 30 4E 8D 24 F5 00 00 00 00 41 B9 04 01 00 00 $0N.$.....A..... +18008B7E0 4C 8D 45 90 4B 8B 14 2C 48 8B CF FF 15 77 59 02 L.E.K..,H....wY. +18008B7F0 00 85 C0 0F 84 48 02 00 00 0F 57 C0 0F 11 44 24 .....H....W...D$ +18008B800 68 48 C7 44 24 78 00 00 00 00 48 C7 45 80 00 00 hH.D$x....H.E... +18008B810 00 00 48 8D 45 90 49 C7 C0 FF FF FF FF 0F 1F 00 ..H.E.I......... +18008B820 49 FF C0 66 42 83 3C 40 00 75 F5 48 8D 55 90 48 I..fB.<@.u.H.U.H +18008B830 8D 4C 24 68 E8 D7 32 F8 FF 90 48 8D 15 F7 9A 33 .L$h..2...H....3 +18008B840 00 48 8D 4C 24 48 E8 95 FC FF FF 4C 8B 48 10 48 .H.L$H.....L.H.H +18008B850 83 78 18 07 76 03 48 8B 00 48 8D 74 24 68 48 83 .x..v.H..H.t$hH. +18008B860 7D 80 07 48 0F 47 74 24 68 48 8B 4C 24 78 4C 3B }..H.Gt$hH.L$xL; +18008B870 C9 77 2B 4D 85 C9 75 04 33 FF EB 29 48 8D 1C 4E .w+M..u.3..)H..N +18008B880 4C 8B C0 48 8B D3 48 8B CE E8 12 FE 01 00 48 8B L..H..H.......H. +18008B890 F8 48 3B C3 74 08 48 2B FE 48 D1 FF EB 07 48 C7 .H;.t.H+.H....H. +18008B8A0 C7 FF FF FF FF 48 8B 54 24 60 48 83 FA 07 76 37 .....H.T$`H...v7 +18008B8B0 48 8D 14 55 02 00 00 00 48 8B 4C 24 48 48 8B C1 H..U....H.L$HH.. +18008B8C0 48 81 FA 00 10 00 00 72 19 48 83 C2 27 48 8B 49 H......r.H..'H.I +18008B8D0 F8 48 2B C1 48 83 E8 08 48 83 F8 1F 0F 87 7F 01 .H+.H...H....... +18008B8E0 00 00 E8 71 FE 01 00 48 83 FF FF 74 4A 48 8B 55 ...q...H...tJH.U +18008B8F0 80 48 83 FA 07 0F 86 52 01 00 00 48 8D 14 55 02 .H.....R...H..U. +18008B900 00 00 00 48 8B 4C 24 68 48 81 FA 00 10 00 00 48 ...H.L$hH......H +18008B910 8B C1 72 19 48 83 C2 27 48 8B 49 F8 48 2B C1 48 ..r.H..'H.I.H+.H +18008B920 83 E8 08 48 83 F8 1F 0F 87 68 01 00 00 E8 26 FE ...H.....h....&. +18008B930 01 00 E9 16 01 00 00 48 8D 15 1A 9A 33 00 48 8D .......H....3.H. +18008B940 4C 24 48 E8 98 FB FF FF 4C 8B C0 4C 8B 48 10 48 L$H.....L..L.H.H +18008B950 83 78 18 07 76 03 4C 8B 00 48 8D 74 24 68 48 8B .x..v.L..H.t$hH. +18008B960 45 80 48 83 F8 07 48 0F 47 74 24 68 48 8B 4C 24 E.H...H.Gt$hH.L$ +18008B970 78 4C 3B C9 77 2C 4D 85 C9 75 04 33 FF EB 2A 48 xL;.w,M..u.3..*H +18008B980 8D 1C 4E 48 8B D3 48 8B CE E8 12 FD 01 00 48 8B ..NH..H.......H. +18008B990 F8 48 3B C3 48 8B 45 80 74 08 48 2B FE 48 D1 FF .H;.H.E.t.H+.H.. +18008B9A0 EB 07 48 C7 C7 FF FF FF FF 48 8B 54 24 60 48 83 ..H......H.T$`H. +18008B9B0 FA 07 76 3B 48 8D 14 55 02 00 00 00 48 8B 4C 24 ..v;H..U....H.L$ +18008B9C0 48 48 8B C1 48 81 FA 00 10 00 00 72 19 48 83 C2 HH..H......r.H.. +18008B9D0 27 48 8B 49 F8 48 2B C1 48 83 E8 08 48 83 F8 1F 'H.I.H+.H...H... +18008B9E0 0F 87 95 00 00 00 E8 6D FD 01 00 48 8B 45 80 48 .......m...H.E.H +18008B9F0 83 FF FF 74 13 48 83 F8 07 76 52 48 8D 14 45 02 ...t.H...vRH..E. +18008BA00 00 00 00 E9 FB FE FF FF 48 83 F8 07 76 33 48 8D ........H...v3H. +18008BA10 14 45 02 00 00 00 48 8B 4C 24 68 48 8B C1 48 81 .E....H.L$hH..H. +18008BA20 FA 00 10 00 00 72 15 48 83 C2 27 48 8B 49 F8 48 .....r.H..'H.I.H +18008BA30 2B C1 48 83 E8 08 48 83 F8 1F 77 59 E8 17 FD 01 +.H...H...wY.... +18008BA40 00 4B 8B 04 2C 4B 89 44 FD 00 41 FF C7 41 FF C6 .K..,K.D..A..A.. +18008BA50 44 3B 74 24 34 73 58 48 8B 7C 24 38 E9 71 FD FF D;t$4sXH.|$8.q.. +18008BA60 FF 48 C7 44 24 20 00 00 00 00 45 33 C9 45 33 C0 .H.D$ ....E3.E3. +18008BA70 33 D2 33 C9 FF 15 C6 5D 02 00 CC 48 C7 44 24 20 3.3....]...H.D$ +18008BA80 00 00 00 00 45 33 C9 45 33 C0 33 D2 33 C9 FF 15 ....E3.E3.3.3... +18008BA90 AC 5D 02 00 90 48 C7 44 24 20 00 00 00 00 45 33 .]...H.D$ ....E3 +18008BAA0 C9 45 33 C0 33 D2 33 C9 FF 15 92 5D 02 00 CC 48 .E3.3.3....]...H +18008BAB0 8B 74 24 40 42 8D 0C FD 00 00 00 00 89 0E 8B 44 .t$@B..........D +18008BAC0 24 30 EB 02 33 C0 48 8B 8D A0 01 00 00 48 33 CC $0..3.H......H3. +18008BAD0 E8 FB FB 01 00 48 81 C4 B8 02 00 00 41 5F 41 5E .....H......A_A^ +18008BAE0 41 5D 41 5C 5F 5E 5B 5D C3 CC CC CC CC CC CC CC A]A\_^[]........ + +======================================================================== +FUNCTION: SkillHack_Render_HookInstaller +RVA: 0x8D1F0–0x8D240 Size: 80 bytes +18008D1F0 48 83 EC 28 48 8B 0D 65 9C 33 00 48 8D 15 AE 02 H..(H..e.3.H.... +18008D200 00 00 E8 99 06 00 00 48 8B 0D 5A 9C 33 00 48 8D .......H..Z.3.H. +18008D210 15 9B 02 00 00 E8 86 06 00 00 E8 01 10 00 00 E8 ................ +18008D220 9C 19 00 00 E8 37 23 00 00 48 8B 0D 18 9C 33 00 .....7#..H....3. +18008D230 48 8D 15 79 02 00 00 48 83 C4 28 E9 60 06 00 00 H..y...H..(.`... + +======================================================================== +FUNCTION: SkillHack_Dispatcher +RVA: 0x8D4B0–0x8D500 Size: 80 bytes +18008D4B0 48 89 5C 24 08 57 48 83 EC 20 48 8B DA 48 8B F9 H.\$.WH.. H..H.. +18008D4C0 E8 3B 3E FF FF 80 78 28 00 74 0D B0 01 48 8B 5C .;>...x(.t...H.\ +18008D4D0 24 30 48 83 C4 20 5F C3 E8 23 46 FF FF 4C 8B CB $0H.. _..#F..L.. +18008D4E0 48 8D 15 C9 FF FF FF 4C 8B C7 48 8B C8 48 8B 5C H......L..H..H.\ +18008D4F0 24 30 48 83 C4 20 5F E9 04 2A 00 00 CC CC CC CC $0H.. _..*...... + +======================================================================== +FUNCTION: SkillHack_CooldownBypass +RVA: 0x8D500–0x8D550 Size: 80 bytes +18008D500 48 89 5C 24 18 57 48 83 EC 20 48 8B FA 48 8B D9 H.\$.WH.. H..H.. +18008D510 E8 EB 3D FF FF 80 78 28 00 74 13 F3 0F 10 05 E5 ..=...x(.t...... +18008D520 5D 32 00 48 8B 5C 24 40 48 83 C4 20 5F C3 E8 CD ]2.H.\$@H.. _... +18008D530 45 FF FF 4C 8B C0 4C 8D 1D C3 FF FF FF 49 BA B3 E..L..L......I.. +18008D540 01 00 00 00 01 00 00 45 0F B6 CB 48 B8 25 23 22 .......E...H.%#" + +======================================================================== +FUNCTION: SkillHack_SkillAvailable +RVA: 0x8D640–0x8D780 Size: 320 bytes +18008D640 48 89 5C 24 18 57 48 83 EC 20 48 8B FA 48 8B D9 H.\$.WH.. H..H.. +18008D650 E8 AB 3C FF FF 80 78 28 00 74 0D B0 01 48 8B 5C ..<...x(.t...H.\ +18008D660 24 40 48 83 C4 20 5F C3 E8 93 44 FF FF 4C 8B C8 $@H.. _...D..L.. +18008D670 4C 8D 1D C9 FF FF FF 49 BA B3 01 00 00 00 01 00 L......I........ +18008D680 00 45 0F B6 C3 48 B8 25 23 22 84 E4 9C F2 CB 49 .E...H.%#".....I +18008D690 8B CB 4C 33 C0 48 C1 E9 08 0F B6 D1 49 8B C3 48 ..L3.H......I..H +18008D6A0 C1 E8 10 0F B6 C8 49 8B C3 4D 0F AF C2 48 C1 E8 ......I..M...H.. +18008D6B0 18 4C 33 C2 49 8B 51 20 4D 0F AF C2 4C 33 C1 0F .L3.I.Q M...L3.. +18008D6C0 B6 C8 4D 0F AF C2 49 8B C3 4C 33 C1 48 C1 E8 20 ..M...I..L3.H.. +18008D6D0 0F B6 C8 49 8B C3 48 C1 E8 28 4D 0F AF C2 4C 33 ...I..H..(M...L3 +18008D6E0 C1 0F B6 C8 4D 0F AF C2 49 8B C3 4C 33 C1 48 C1 ....M...I..L3.H. +18008D6F0 E8 30 0F B6 C8 49 8B C3 48 C1 E8 38 4D 0F AF C2 .0...I..H..8M... +18008D700 49 33 C8 49 0F AF CA 48 33 C8 49 0F AF CA 49 23 I3.I...H3.I...I# +18008D710 49 48 48 C1 E1 04 49 03 49 30 48 8B 41 08 48 3B IHH...I.I0H.A.H; +18008D720 C2 74 1E 48 8B 09 4C 3B 58 10 74 17 0F 1F 40 00 .t.H..L;X.t...@. +18008D730 48 3B C1 74 0C 48 8B 40 08 4C 3B 58 10 75 F1 EB H;.t.H.@.L;X.u.. +18008D740 02 33 C0 48 85 C0 48 0F 44 C2 48 3B C2 74 1C 4C .3.H..H.D.H;.t.L +18008D750 8B 40 18 4D 85 C0 74 13 48 8B D7 48 8B CB 48 8B .@.M..t.H..H..H. +18008D760 5C 24 40 48 83 C4 20 5F 49 FF E0 48 8B 5C 24 40 \$@H.. _I..H.\$@ +18008D770 32 C0 48 83 C4 20 5F C3 CC CC CC CC CC CC CC CC 2.H.. _......... + +======================================================================== +FUNCTION: SkillHack_CostBypass +RVA: 0x8D780–0x8D8A0 Size: 288 bytes +18008D780 48 89 5C 24 18 57 48 83 EC 20 48 8B FA 48 8B D9 H.\$.WH.. H..H.. +18008D790 E8 6B 3B FF FF 80 78 28 00 0F 85 F5 00 00 00 E8 .k;...x(........ +18008D7A0 5C 43 FF FF 4C 8B C8 4C 8D 1D D2 FF FF FF 49 BA \C..L..L......I. +18008D7B0 B3 01 00 00 00 01 00 00 45 0F B6 C3 48 B8 25 23 ........E...H.%# +18008D7C0 22 84 E4 9C F2 CB 49 8B CB 4C 33 C0 48 C1 E9 08 ".....I..L3.H... +18008D7D0 0F B6 D1 49 8B C3 48 C1 E8 10 0F B6 C8 49 8B C3 ...I..H......I.. +18008D7E0 4D 0F AF C2 48 C1 E8 18 4C 33 C2 49 8B 51 20 4D M...H...L3.I.Q M +18008D7F0 0F AF C2 4C 33 C1 0F B6 C8 4D 0F AF C2 49 8B C3 ...L3....M...I.. +18008D800 4C 33 C1 48 C1 E8 20 0F B6 C8 49 8B C3 48 C1 E8 L3.H.. ...I..H.. +18008D810 28 4D 0F AF C2 4C 33 C1 0F B6 C8 4D 0F AF C2 49 (M...L3....M...I +18008D820 8B C3 4C 33 C1 48 C1 E8 30 0F B6 C8 49 8B C3 48 ..L3.H..0...I..H +18008D830 C1 E8 38 4D 0F AF C2 49 33 C8 49 0F AF CA 48 33 ..8M...I3.I...H3 +18008D840 C8 49 0F AF CA 49 23 49 48 48 C1 E1 04 49 03 49 .I...I#IHH...I.I +18008D850 30 48 8B 41 08 48 3B C2 74 1A 48 8B 09 4C 3B 58 0H.A.H;.t.H..L;X +18008D860 10 74 13 48 3B C1 74 0C 48 8B 40 08 4C 3B 58 10 .t.H;.t.H.@.L;X. +18008D870 75 F1 EB 02 33 C0 48 85 C0 48 0F 44 C2 48 3B C2 u...3.H..H.D.H;. +18008D880 74 12 4C 8B 40 18 4D 85 C0 74 09 48 8B D7 48 8B t.L.@.M..t.H..H. +18008D890 CB 41 FF D0 48 8B 5C 24 40 48 83 C4 20 5F C3 CC .A..H.\$@H.. _.. + +======================================================================== +FUNCTION: SkillHack_TrampolineDispatch +RVA: 0x8FF00–0x8FF80 Size: 128 bytes +18008FF00 48 89 5C 24 08 57 4D 8B D8 48 BF B3 01 00 00 00 H.\$.WM..H...... +18008FF10 01 00 00 4C 8B D2 44 0F B6 C2 48 B8 25 23 22 84 ...L..D...H.%#". +18008FF20 E4 9C F2 CB 49 8B D9 4C 33 C0 4C 8B C9 4C 0F AF ....I..L3.L..L.. +18008FF30 C7 48 8B C2 48 C1 E8 08 0F B6 D0 49 8B C2 48 C1 .H..H......I..H. +18008FF40 E8 10 4C 33 C2 49 8B 51 20 0F B6 C8 49 8B C2 48 ..L3.I.Q ...I..H +18008FF50 C1 E8 18 4C 0F AF C7 4C 33 C1 0F B6 C8 4C 0F AF ...L...L3....L.. +18008FF60 C7 49 8B C2 4C 33 C1 48 C1 E8 20 0F B6 C8 49 8B .I..L3.H.. ...I. +18008FF70 C2 48 C1 E8 28 4C 0F AF C7 4C 33 C1 0F B6 C8 4C .H..(L...L3....L + +======================================================================== +FUNCTION: FNV1a_hash +RVA: 0x8D555–0x8D640 Size: 235 bytes +18008D555 49 8B CB 4C 33 C8 48 C1 E9 08 4D 0F AF CA 0F B6 I..L3.H...M..... +18008D565 D1 49 8B C3 4C 33 CA 48 C1 E8 10 49 8B 50 20 4D .I..L3.H...I.P M +18008D575 0F AF CA 0F B6 C8 49 8B C3 4C 33 C9 48 C1 E8 18 ......I..L3.H... +18008D585 4D 0F AF CA 0F B6 C8 49 8B C3 4C 33 C9 48 C1 E8 M......I..L3.H.. +18008D595 20 4D 0F AF CA 0F B6 C8 49 8B C3 4C 33 C9 48 C1 M......I..L3.H. +18008D5A5 E8 28 4D 0F AF CA 0F B6 C8 49 8B C3 4C 33 C9 48 .(M......I..L3.H +18008D5B5 C1 E8 30 4D 0F AF CA 0F B6 C8 49 8B C3 4C 33 C9 ..0M......I..L3. +18008D5C5 48 C1 E8 38 49 8B 48 30 4D 0F AF CA 4C 33 C8 4D H..8I.H0M...L3.M +18008D5D5 0F AF CA 4D 23 48 48 4D 03 C9 4A 8B 44 C9 08 48 ...M#HHM..J.D..H +18008D5E5 3B C2 74 1B 4A 8B 0C C9 4C 3B 58 10 74 13 48 3B ;.t.J...L;X.t.H; +18008D5F5 C1 74 0C 48 8B 40 08 4C 3B 58 10 75 F1 EB 02 33 .t.H.@.L;X.u...3 +18008D605 C0 48 85 C0 48 0F 44 C2 48 3B C2 74 1C 4C 8B 40 .H..H.D.H;.t.L.@ +18008D615 18 4D 85 C0 74 13 48 8B D7 48 8B CB 48 8B 5C 24 .M..t.H..H..H.\$ +18008D625 40 48 83 C4 20 5F 49 FF E0 48 8B 5C 24 40 0F 57 @H.. _I..H.\$@.W +18008D635 C0 48 83 C4 20 5F C3 CC CC CC CC .H.. _..... + +======================================================================== +FUNCTION: ModuleManager_Init +RVA: 0x9AC10–0x9AE00 Size: 496 bytes +18009AC10 48 89 4C 24 08 53 56 57 41 56 41 57 48 83 EC 70 H.L$.SVWAVAWH..p +18009AC20 4C 8B F1 48 8D 41 18 48 89 44 24 38 80 38 00 74 L..H.A.H.D$8.8.t +18009AC30 2F 48 8D 15 50 5F 31 00 48 8B 0D 99 67 01 00 E8 /H..P_1.H...g... +18009AC40 5C 51 F7 FF 48 8D 15 65 46 FE FF 48 8B C8 48 83 \Q..H..eF..H..H. +18009AC50 C4 70 41 5F 41 5E 5F 5E 5B 48 FF 25 80 66 01 00 .pA_A^_^[H.%.f.. +18009AC60 0F 57 C0 0F 11 44 24 48 0F 57 C9 F3 0F 7F 4C 24 .W...D$H.W....L$ +18009AC70 58 41 B8 1A 00 00 00 48 8D 15 8A 5F 31 00 48 8D XA.....H..._1.H. +18009AC80 4C 24 48 E8 28 50 F7 FF 90 E8 C2 37 F7 FF 48 8D L$H.(P.....7..H. +18009AC90 4C 24 48 48 89 4C 24 20 41 B9 01 00 00 00 41 B8 L$HH.L$ A.....A. +18009ACA0 22 00 00 00 48 8D 15 15 5F 31 00 48 8B C8 E8 2D "...H..._1.H...- +18009ACB0 32 FE FF 90 48 8D 4C 24 48 E8 A2 4D F7 FF 49 8D 2...H.L$H..M..I. +18009ACC0 76 08 48 89 74 24 30 49 8B 06 48 3B 06 74 03 48 v.H.t$0I..H;.t.H +18009ACD0 89 06 8B 0D 04 BE 32 00 65 48 8B 04 25 58 00 00 ......2.eH..%X.. +18009ACE0 00 BA 04 00 00 00 48 8B 04 C8 8B 0C 02 39 0D DD ......H......9.. +18009ACF0 C6 32 00 7E 2D 48 8D 0D D4 C6 32 00 E8 0F 0B 01 .2.~-H....2..... +18009AD00 00 83 3D C8 C6 32 00 FF 75 18 48 8D 0D 7F 52 01 ..=..2..u.H...R. +18009AD10 00 E8 CE 0E 01 00 48 8D 0D B3 C6 32 00 E8 82 0A ......H....2.... +18009AD20 01 00 48 8B 1D 8F C6 32 00 4C 8B 3D 90 C6 32 00 ..H....2.L.=..2. +18009AD30 4C 89 BC 24 B8 00 00 00 48 89 9C 24 A8 00 00 00 L..$....H..$.... +18009AD40 49 3B DF 0F 84 C2 00 00 00 48 8B 4B 58 48 85 C9 I;.......H.KXH.. +18009AD50 75 06 FF 15 70 65 01 00 48 8B 01 FF 50 10 48 8B u...pe..H...P.H. +18009AD60 F8 48 89 84 24 B0 00 00 00 48 8B 16 49 3B 56 10 .H..$....H..I;V. +18009AD70 74 09 48 89 02 48 83 06 08 EB 10 4C 8D 84 24 B0 t.H..H.....L..$. +18009AD80 00 00 00 49 8B CE E8 45 03 00 00 48 8B 07 48 8B ...I...E...H..H. +18009AD90 CF FF 50 08 0F 57 C0 0F 11 44 24 48 0F 57 C9 F3 ..P..W...D$H.W.. +18009ADA0 0F 7F 4C 24 58 41 B8 15 00 00 00 48 8D 15 96 5E ..L$XA.....H...^ +18009ADB0 31 00 48 8D 4C 24 48 E8 F4 4E F7 FF 90 48 8D 47 1.H.L$H..N...H.G +18009ADC0 08 48 89 44 24 20 4C 8D 4C 24 48 E8 10 02 00 00 .H.D$ L.L$H..... +18009ADD0 90 48 8D 4C 24 48 E8 85 4C F7 FF 90 48 83 C3 60 .H.L$H..L...H..` +18009ADE0 E9 53 FF FF FF 4C 8B B4 24 A0 00 00 00 48 8B 9C .S...L..$....H.. +18009ADF0 24 A8 00 00 00 4C 8B BC 24 B8 00 00 00 48 8B 74 $....L..$....H.t + +======================================================================== +FUNCTION: ModuleManager_DispatchRender +RVA: 0x9AE80–0x9AEF0 Size: 112 bytes +18009AE80 48 89 5C 24 20 57 48 83 EC 30 80 79 18 00 74 46 H.\$ WH..0.y..tF +18009AE90 48 8B 19 48 8B 79 08 48 89 7C 24 50 48 89 5C 24 H..H.y.H.|$PH.\$ +18009AEA0 40 48 3B DF 74 30 48 8B 0B 48 89 4C 24 48 48 85 @H;.t0H..H.L$HH. +18009AEB0 C9 74 1D 80 79 28 00 74 17 48 8B 01 FF 50 18 90 .t..y(.t.H...P.. +18009AEC0 48 83 C3 08 EB D6 48 8B 5C 24 40 48 8B 7C 24 50 H.....H.\$@H.|$P +18009AED0 48 83 C3 08 EB C6 48 8B 5C 24 58 48 83 C4 30 5F H.....H.\$XH..0_ +18009AEE0 C3 CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC ................ + +======================================================================== +FUNCTION: ModuleManager_DispatchHotkeys +RVA: 0x9AEF0–0x9AF60 Size: 112 bytes +18009AEF0 48 89 5C 24 20 57 48 83 EC 30 80 79 18 00 74 46 H.\$ WH..0.y..tF +18009AF00 48 8B 19 48 8B 79 08 48 89 7C 24 50 48 89 5C 24 H..H.y.H.|$PH.\$ +18009AF10 40 48 3B DF 74 30 48 8B 0B 48 89 4C 24 48 48 85 @H;.t0H..H.L$HH. +18009AF20 C9 74 1D 80 79 28 00 74 17 48 8B 01 FF 50 30 90 .t..y(.t.H...P0. +18009AF30 48 83 C3 08 EB D6 48 8B 5C 24 40 48 8B 7C 24 50 H.....H.\$@H.|$P +18009AF40 48 83 C3 08 EB C6 48 8B 5C 24 58 48 83 C4 30 5F H.....H.\$XH..0_ +18009AF50 C3 CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC ................ + +======================================================================== +FUNCTION: ModuleManager_DispatchRegistrarInit +RVA: 0x9AF60–0x9B000 Size: 160 bytes +18009AF60 48 89 5C 24 20 57 48 83 EC 30 80 79 18 00 74 5C H.\$ WH..0.y..t\ +18009AF70 48 8B 19 48 8B 79 08 48 89 7C 24 50 48 89 5C 24 H..H.y.H.|$PH.\$ +18009AF80 40 48 3B DF 74 2A 48 8B 0B 48 89 4C 24 48 48 85 @H;.t*H..H.L$HH. +18009AF90 C9 74 17 48 8B 01 FF 50 38 90 48 83 C3 08 EB DC .t.H...P8.H..... +18009AFA0 48 8B 5C 24 40 48 8B 7C 24 50 48 83 C3 08 EB CC H.\$@H.|$PH..... +18009AFB0 0F 10 05 51 BF 32 00 0F 11 05 6A BF 32 00 0F 10 ...Q.2....j.2... +18009AFC0 0D 53 BF 32 00 0F 11 0D 6C BF 32 00 48 8B 5C 24 .S.2....l.2.H.\$ +18009AFD0 58 48 83 C4 30 5F C3 CC CC CC CC CC CC CC CC CC XH..0_.......... +18009AFE0 48 81 EC B8 00 00 00 48 8B 05 52 A0 32 00 48 33 H......H..R.2.H3 +18009AFF0 C4 48 89 84 24 A0 00 00 00 4C 89 4C 24 58 48 8B .H..$....L.L$XH. + +======================================================================== +FUNCTION: GABypass_Patch +RVA: 0x9D1E0–0x9D800 Size: 1568 bytes +18009D1E0 48 83 EC 58 48 83 3D 04 7F 32 00 00 74 67 0F 57 H..XH.=..2..tg.W +18009D1F0 C0 0F 11 44 24 30 0F 57 C9 F3 0F 7F 4C 24 40 41 ...D$0.W....L$@A +18009D200 B8 17 00 00 00 48 8D 15 7C 3D 31 00 48 8D 4C 24 .....H..|=1.H.L$ +18009D210 30 E8 9A 2A F7 FF 90 E8 34 12 F7 FF 48 8D 4C 24 0..*....4...H.L$ +18009D220 30 48 89 4C 24 20 41 B9 01 00 00 00 41 B8 14 00 0H.L$ A.....A... +18009D230 00 00 48 8D 15 67 3D 31 00 48 8B C8 E8 9F 0C FE ..H..g=1.H...... +18009D240 FF 90 48 8D 4C 24 30 E8 14 28 F7 FF 48 8B 15 9D ..H.L$0..(..H... +18009D250 7E 32 00 EB 10 48 8D 0D 04 2F 31 00 FF 15 2E 40 ~2...H.../1....@ +18009D260 01 00 48 8B D0 48 8D 8A 80 AD 18 00 48 89 0D FD ..H..H......H... +18009D270 99 32 00 48 8D 8A C0 CE 18 00 48 89 0D CF 99 32 .2.H......H....2 +18009D280 00 48 8D 8A 60 3A D9 00 48 89 0D F1 9B 32 00 48 .H..`:..H....2.H +18009D290 8D 8A 80 74 00 00 48 89 0D DB 99 32 00 48 8D 8A ...t..H....2.H.. +18009D2A0 10 4C D9 00 48 89 0D C5 9B 32 00 48 8D 8A A0 4D .L..H....2.H...M +18009D2B0 D9 00 48 89 0D BF 9B 32 00 48 8D 82 F0 9A 41 03 ..H....2.H....A. +18009D2C0 48 89 05 79 9A 32 00 48 8D 82 60 E8 78 04 48 89 H..y.2.H..`.x.H. +18009D2D0 05 53 9A 32 00 48 8D 82 30 54 F8 03 48 89 05 F5 .S.2.H..0T..H... +18009D2E0 9A 32 00 48 8D 82 F0 E9 E9 00 48 89 05 27 9B 32 .2.H......H..'.2 +18009D2F0 00 48 8D 82 40 2D 5E 02 48 89 05 31 9A 32 00 48 .H..@-^.H..1.2.H +18009D300 8D 8A 80 DA F3 02 48 89 0D CB 99 32 00 48 8D 82 ......H....2.H.. +18009D310 A0 1A 9D 03 48 89 05 FD 99 32 00 48 8D 82 10 7E ....H....2.H...~ +18009D320 F2 00 48 89 05 B7 99 32 00 48 8D 82 F0 E9 6D 02 ..H....2.H....m. +18009D330 48 89 05 E9 99 32 00 48 8D 82 50 BB E9 03 48 89 H....2.H..P...H. +18009D340 05 B3 99 32 00 48 8D 82 C0 53 EA 03 48 89 05 CD ...2.H...S..H... +18009D350 9A 32 00 48 89 0D 9E 9A 32 00 48 8D 82 C0 D2 E0 .2.H....2.H..... +18009D360 03 48 89 05 A0 9A 32 00 48 8D 82 30 DF D9 03 48 .H....2.H..0...H +18009D370 89 05 9A 9A 32 00 48 8D 82 C0 14 DC 03 48 89 05 ....2.H......H.. +18009D380 7C 9A 32 00 48 8D 82 40 2A 7F 03 48 89 05 CE 9A |.2.H..@*..H.... +18009D390 32 00 48 8D 82 E0 D7 7F 03 48 89 05 C8 9A 32 00 2.H......H....2. +18009D3A0 48 8D 82 40 A6 6E 03 48 89 05 A2 9A 32 00 48 8D H..@.n.H....2.H. +18009D3B0 82 E0 30 EC 03 48 89 05 9C 9A 32 00 48 8D 82 C0 ..0..H....2.H... +18009D3C0 31 EC 03 48 89 05 76 9A 32 00 48 8D 82 D0 8C 7F 1..H..v.2.H..... +18009D3D0 03 48 89 05 70 9A 32 00 48 8D 82 F0 A8 6A 03 48 .H..p.2.H....j.H +18009D3E0 89 05 52 9A 32 00 48 8D 82 C0 0E CA 0A 48 89 05 ..R.2.H......H.. +18009D3F0 34 9A 32 00 48 8D 82 B0 CA 33 0B 48 89 05 06 99 4.2.H....3.H.... +18009D400 32 00 48 8D 82 00 CB 33 0B 48 89 05 00 99 32 00 2.H....3.H....2. +18009D410 48 8D 82 80 9D 32 0B 48 89 05 D2 98 32 00 48 8D H....2.H....2.H. +18009D420 82 00 90 32 0B 48 89 05 BC 98 32 00 48 8D 82 B0 ...2.H....2.H... +18009D430 66 32 0B 48 89 05 3E 99 32 00 48 8D 82 60 66 32 f2.H..>.2.H..`f2 +18009D440 0B 48 89 05 28 99 32 00 48 8D 82 30 B0 32 0B 48 .H..(.2.H..0.2.H +18009D450 89 05 5A 99 32 00 48 8D 82 D0 2C 7C 08 48 89 05 ..Z.2.H...,|.H.. +18009D460 D4 98 32 00 48 8D 82 20 6A 39 0B 48 89 05 DE 98 ..2.H.. j9.H.... +18009D470 32 00 48 8D 82 00 77 39 0B 48 89 05 D8 98 32 00 2.H...w9.H....2. +18009D480 48 8D 82 30 88 39 0B 48 89 05 0A 98 32 00 48 8D H..0.9.H....2.H. +18009D490 82 80 0F 39 0B 48 89 05 2C 99 32 00 48 8D 82 F0 ...9.H..,.2.H... +18009D4A0 11 39 0B 48 89 05 F6 97 32 00 48 8D 82 40 12 39 .9.H....2.H..@.9 +18009D4B0 0B 48 89 05 00 99 32 00 48 8D 82 40 04 39 0B 48 .H....2.H..@.9.H +18009D4C0 89 05 FA 98 32 00 48 8D 82 90 1D 39 0B 48 89 05 ....2.H....9.H.. +18009D4D0 DC 97 32 00 48 8D 82 40 1D 39 0B 48 89 05 4E 99 ..2.H..@.9.H..N. +18009D4E0 32 00 48 8D 82 00 07 39 0B 48 89 05 68 97 32 00 2.H....9.H..h.2. +18009D4F0 48 8D 82 20 01 DC 09 48 89 05 4A 97 32 00 48 8D H.. ...H..J.2.H. +18009D500 82 B0 1F 3A 0B 48 89 05 9C 98 32 00 48 8D 82 40 ...:.H....2.H..@ +18009D510 23 3A 0B 48 89 05 76 98 32 00 48 8D 82 D0 26 3A #:.H..v.2.H...&: +18009D520 0B 48 89 05 78 98 32 00 48 8D 82 60 2A 3A 0B 48 .H..x.2.H..`*:.H +18009D530 89 05 32 98 32 00 48 8D 82 A0 19 3A 0B 48 89 05 ..2.2.H....:.H.. +18009D540 8C 98 32 00 48 8D 82 10 1A 3A 0B 48 89 05 36 98 ..2.H....:.H..6. +18009D550 32 00 48 8D 82 70 1A 3A 0B 48 89 05 28 97 32 00 2.H..p.:.H..(.2. +18009D560 48 8D 82 E0 1A 3A 0B 48 89 05 12 97 32 00 48 8D H....:.H....2.H. +18009D570 82 90 1C 3A 0B 48 89 05 6C 98 32 00 48 8D 82 30 ...:.H..l.2.H..0 +18009D580 1D 3A 0B 48 89 05 56 98 32 00 48 8D 82 D0 59 3A .:.H..V.2.H...Y: +18009D590 0B 48 89 05 10 97 32 00 48 8D 82 D0 51 3A 0B 48 .H....2.H...Q:.H +18009D5A0 89 05 EA 96 32 00 48 8D 82 B0 2C 3A 0B 48 89 05 ....2.H...,:.H.. +18009D5B0 B4 96 32 00 48 8D 82 20 2D 3A 0B 48 89 05 9E 96 ..2.H.. -:.H.... +18009D5C0 32 00 48 8D 82 10 68 76 03 48 89 05 90 97 32 00 2.H...hv.H....2. +18009D5D0 48 8D 82 00 18 42 0B 48 89 05 BA 97 32 00 48 8D H....B.H....2.H. +18009D5E0 82 F0 2C E9 00 48 89 05 04 98 32 00 48 8D 82 00 ..,..H....2.H... +18009D5F0 32 38 0B 48 89 05 86 97 32 00 48 8D 82 60 3F 38 28.H....2.H..`?8 +18009D600 0B 48 89 05 F8 96 32 00 48 8D 82 10 24 3B 0B 48 .H....2.H...$;.H +18009D610 89 05 A2 96 32 00 48 8D 82 B0 40 3B 0B 48 89 05 ....2.H...@;.H.. +18009D620 A4 96 32 00 48 8D 82 20 21 3B 0B 48 89 05 8E 96 ..2.H.. !;.H.... +18009D630 32 00 48 8D 82 B0 2F 32 0B 48 89 05 08 97 32 00 2.H.../2.H....2. +18009D640 48 8D 82 80 79 39 0B 48 89 05 82 96 32 00 48 83 H...y9.H....2.H. +18009D650 C4 58 C3 CC CC CC CC CC CC CC CC CC CC CC CC CC .X.............. +18009D660 48 89 5C 24 08 48 89 74 24 10 57 48 83 EC 50 48 H.\$.H.t$.WH..PH +18009D670 8B 05 CA 79 32 00 48 33 C4 48 89 44 24 40 0F 57 ...y2.H3.H.D$@.W +18009D680 C0 0F 11 44 24 20 0F 57 C9 F3 0F 7F 4C 24 30 48 ...D$ .W....L$0H +18009D690 8B 3D 32 98 32 00 48 8D 35 1B 98 32 00 48 83 3D .=2.2.H.5..2.H.= +18009D6A0 2B 98 32 00 0F 48 0F 47 35 0B 98 32 00 48 BB FF +.2..H.G5..2.H.. +18009D6B0 FF FF FF FF FF FF 7F 48 3B FB 0F 87 98 00 00 00 .......H;....... +18009D6C0 48 83 FF 0F 77 18 48 89 7C 24 30 48 C7 44 24 38 H...w.H.|$0H.D$8 +18009D6D0 0F 00 00 00 0F 10 06 0F 11 44 24 20 EB 43 48 8B .........D$ .CH. +18009D6E0 C7 48 83 C8 0F 48 3B C3 77 0F 48 8B D8 B9 16 00 .H...H;.w.H..... +18009D6F0 00 00 48 3B C1 48 0F 42 D9 48 8D 4B 01 E8 3E 25 ..H;.H.B.H.K..>% +18009D700 F7 FF 48 89 44 24 20 48 89 7C 24 30 48 89 5C 24 ..H.D$ H.|$0H.\$ +18009D710 38 4C 8D 47 01 48 8B D6 48 8B C8 E8 44 F1 00 00 8L.G.H..H...D... +18009D720 90 48 8D 54 24 20 E8 35 00 00 00 0F B6 D8 48 8D .H.T$ .5......H. +18009D730 4C 24 20 E8 28 23 F7 FF 0F B6 C3 48 8B 4C 24 40 L$ .(#.....H.L$@ +18009D740 48 33 CC E8 88 DF 00 00 48 8B 5C 24 60 48 8B 74 H3......H.\$`H.t +18009D750 24 68 48 83 C4 50 5F C3 E8 93 23 F7 FF CC CC CC $hH..P_...#..... +18009D760 48 81 EC 98 00 00 00 48 C7 44 24 78 00 00 00 00 H......H.D$x.... +18009D770 4C 8D 44 24 40 48 8D 4C 24 30 E8 51 04 00 00 0F L.D$@H.L$0.Q.... +18009D780 B6 15 32 A0 32 00 0F B6 08 88 0D 29 A0 32 00 88 ..2.2......).2.. +18009D790 10 48 8D 48 08 4C 8B 05 24 A0 32 00 48 8B 11 48 .H.H.L..$.2.H..H +18009D7A0 89 15 1A A0 32 00 4C 89 01 0F B6 10 E8 0F B5 00 ....2.L......... +18009D7B0 00 90 B0 01 EB 02 32 C0 48 81 C4 98 00 00 00 C3 ......2.H....... +18009D7C0 CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC ................ +18009D7D0 40 53 56 57 41 54 41 55 41 56 41 57 48 81 EC 70 @SVWATAUAVAWH..p +18009D7E0 01 00 00 48 8B 05 56 78 32 00 48 33 C4 48 89 84 ...H..Vx2.H3.H.. +18009D7F0 24 60 01 00 00 49 8B F8 48 8B DA 4C 8B F9 48 89 $`...I..H..L..H. + +======================================================================== +FUNCTION: Startup_main +RVA: 0xA9190–0xA9500 Size: 880 bytes +1800A9190 48 89 5C 24 08 48 89 74 24 10 48 89 7C 24 18 55 H.\$.H.t$.H.|$.U +1800A91A0 41 56 41 57 48 8B EC 48 83 EC 70 48 8B 05 8E BE AVAWH..H..pH.... +1800A91B0 31 00 48 33 C4 48 89 45 F0 E8 92 52 F6 FF 48 8B 1.H3.H.E...R..H. +1800A91C0 F8 80 B8 C0 00 00 00 00 0F 85 E3 00 00 00 FF 15 ................ +1800A91D0 34 7F 00 00 33 C9 FF 15 C4 86 00 00 48 8B D8 33 4...3.......H..3 +1800A91E0 C9 FF 15 B9 86 00 00 4C 8B CB 4C 8D 05 1F 60 30 .......L..L...`0 +1800A91F0 00 48 8D 15 1C 60 30 00 48 8B C8 FF 15 77 86 00 .H...`0.H....w.. +1800A9200 00 B9 01 00 00 00 FF 15 94 86 00 00 48 8B D8 B9 ............H... +1800A9210 01 00 00 00 FF 15 86 86 00 00 4C 8B CB 4C 8D 05 ..........L..L.. +1800A9220 F8 5F 30 00 48 8D 15 F5 5F 30 00 48 8B C8 FF 15 ._0.H..._0.H.... +1800A9230 44 86 00 00 B9 02 00 00 00 FF 15 61 86 00 00 48 D..........a...H +1800A9240 8B D8 B9 02 00 00 00 FF 15 53 86 00 00 4C 8B CB .........S...L.. +1800A9250 4C 8D 05 C5 5F 30 00 48 8D 15 C2 5F 30 00 48 8B L..._0.H..._0.H. +1800A9260 C8 FF 15 11 86 00 00 B9 E9 FD 00 00 FF 15 9E 7E ...............~ +1800A9270 00 00 B9 F5 FF FF FF FF 15 9B 7E 00 00 48 8B D8 ..........~..H.. +1800A9280 C7 45 E8 00 00 00 00 48 8D 55 E8 48 8B C8 FF 15 .E.....H.U.H.... +1800A9290 8C 7E 00 00 85 C0 74 12 8B 55 E8 83 CA 04 89 55 .~....t..U.....U +1800A92A0 E8 48 8B CB FF 15 7E 7E 00 00 C6 87 C0 00 00 00 .H....~~........ +1800A92B0 01 E8 9A 51 F6 FF 66 C7 00 01 01 C7 40 04 01 00 ...Q..f.....@... +1800A92C0 00 00 C6 40 03 01 48 8D 0D 13 9E 30 00 FF 15 CD ...@..H....0.... +1800A92D0 7F 00 00 FF 15 9F 7E 00 00 48 85 C0 74 17 0F B6 ......~..H..t... +1800A92E0 0D 05 BE 31 00 F6 D9 1B D2 83 E2 05 48 8B C8 FF ...1........H... +1800A92F0 15 33 83 00 00 33 D2 48 8D 0D 5A 63 30 00 FF 15 .3...3.H..Zc0... +1800A9300 74 81 00 00 48 85 C0 0F 85 B8 00 00 00 48 BF 00 t...H........H.. +1800A9310 00 4F 91 94 4E 00 00 48 BE DB 34 B6 D7 82 DE 1B .O..N..H..4..... +1800A9320 43 49 BF FE 35 65 C4 FF FF FF 7F 49 BE FF FF FF CI..5e.....I.... +1800A9330 FF FF FF FF 7F 48 8D 4D E8 E8 D2 A7 FE FF 48 8B .....H.M......H. +1800A9340 5D E8 49 3B DF 7F 09 48 81 C3 00 CA 9A 3B EB 03 ].I;...H.....;.. +1800A9350 49 8B DE 48 8D 4D E0 E8 B4 A7 FE FF 48 8B 45 E0 I..H.M......H.E. +1800A9360 48 3B D8 74 48 7C 46 48 8B CB 48 2B C8 48 3B CF H;.tH|FH..H+.H;. +1800A9370 74 10 7C 0E BA 00 5C 26 05 8B CA E8 2C 23 00 00 t.|...\&....,#.. +1800A9380 EB D1 48 8B C6 48 F7 E9 48 C1 FA 12 48 8B C2 48 ..H..H..H...H..H +1800A9390 C1 E8 3F 48 03 D0 48 69 C2 40 42 0F 00 48 3B C1 ..?H..Hi.@B..H;. +1800A93A0 7D 02 FF C2 8B CA E8 01 23 00 00 EB A6 33 D2 48 }.......#....3.H +1800A93B0 8D 0D A2 62 30 00 FF 15 BC 80 00 00 48 85 C0 0F ...b0.......H... +1800A93C0 84 70 FF FF FF 48 8B 0D A4 7D 00 00 E8 1F 27 FE .p...H...}....'. +1800A93D0 FF 0F 57 C0 0F 11 45 C0 0F 57 C9 F3 0F 7F 4D D0 ..W...E..W....M. +1800A93E0 41 B8 0E 00 00 00 48 8D 15 4B 9D 30 00 48 8D 4D A.....H..K.0.H.M +1800A93F0 C0 E8 BA 68 F6 FF 90 E8 54 50 F6 FF 48 8D 4D C0 ...h....TP..H.M. +1800A9400 48 89 4C 24 20 41 B9 01 00 00 00 41 B8 35 00 00 H.L$ A.....A.5.. +1800A9410 00 48 8D 15 30 9D 30 00 48 8B C8 E8 C0 4A FD FF .H..0.0.H....J.. +1800A9420 90 48 8D 4D C0 E8 36 66 F6 FF E8 B1 3D FF FF FF .H.M..6f....=... +1800A9430 15 4B DA 31 00 48 8B D8 0F 57 C0 0F 57 C9 48 8D .K.1.H...W..W.H. +1800A9440 4D C0 0F 11 45 C0 F3 0F 7F 4D D0 48 85 C0 0F 84 M...E....M.H.... +1800A9450 EB 00 00 00 41 B8 15 00 00 00 48 8D 15 97 9C 30 ....A.....H....0 +1800A9460 00 E8 4A 68 F6 FF 90 E8 E4 4F F6 FF 48 8D 4D C0 ..Jh.....O..H.M. +1800A9470 48 89 4C 24 20 41 B9 01 00 00 00 41 B8 42 00 00 H.L$ A.....A.B.. +1800A9480 00 48 8D 15 C0 9C 30 00 48 8B C8 E8 50 4A FD FF .H....0.H...PJ.. +1800A9490 90 48 8D 4D C0 E8 C6 65 F6 FF 48 8B 05 D7 D9 31 .H.M...e..H....1 +1800A94A0 00 48 8B CB FF D0 0F 57 C0 0F 57 C9 48 8D 4D C0 .H.....W..W.H.M. +1800A94B0 0F 11 45 C0 F3 0F 7F 4D D0 48 85 C0 74 42 41 B8 ..E....M.H..tBA. +1800A94C0 25 00 00 00 48 8D 15 45 9C 30 00 E8 E0 67 F6 FF %...H..E.0...g.. +1800A94D0 90 E8 7A 4F F6 FF 48 8D 4D C0 48 89 4C 24 20 41 ..zO..H.M.H.L$ A +1800A94E0 B9 01 00 00 00 41 B8 49 00 00 00 48 8D 15 56 9C .....A.I...H..V. +1800A94F0 30 00 48 8B C8 E8 E6 49 FD FF 90 E9 7C 00 00 00 0.H....I....|... + +======================================================================== +FUNCTION: CollectProcessThreads +RVA: 0xA9600–0xA9A20 Size: 1056 bytes +1800A9600 49 8B E3 41 5F 41 5E 5D C3 CC CC CC 48 83 EC 28 I..A_A^]....H..( +1800A9610 4C 8B 05 C9 E1 31 00 4D 85 C0 75 30 48 8B 0D 6D L....1.M..u0H..m +1800A9620 D8 31 00 33 D2 41 B8 00 07 00 00 C7 05 B3 E1 31 .1.3.A.........1 +1800A9630 00 20 00 00 00 FF 15 85 7B 00 00 48 89 05 9E E1 . ......{..H.... +1800A9640 31 00 4C 8B C0 48 85 C0 74 30 EB 47 8B 15 9A E1 1.L..H..t0.G.... +1800A9650 31 00 8B 05 90 E1 31 00 3B D0 72 3D 8D 0C 00 33 1.....1.;.r=...3 +1800A9660 D2 4C 6B C9 38 48 8B 0D 24 D8 31 00 FF 15 46 7B .Lk.8H..$.1...F{ +1800A9670 00 00 4C 8B C0 48 85 C0 75 04 33 C0 EB 2C 8B 05 ..L..H..u.3..,.. +1800A9680 64 E1 31 00 03 C0 4C 89 05 53 E1 31 00 89 05 55 d.1...L..S.1...U +1800A9690 E1 31 00 8B 15 53 E1 31 00 8B C2 48 6B C0 38 49 .1...S.1...Hk.8I +1800A96A0 03 C0 FF C2 89 15 42 E1 31 00 48 83 C4 28 C3 CC ......B.1.H..(.. +1800A96B0 48 8B C4 48 89 58 10 48 89 70 18 48 89 78 20 55 H..H.X.H.p.H.x U +1800A96C0 41 54 41 55 41 56 41 57 48 8D A8 A8 FB FF FF 48 ATAUAVAWH......H +1800A96D0 81 EC 30 05 00 00 48 8B 05 63 B9 31 00 48 33 C4 ..0...H..c.1.H3. +1800A96E0 48 89 85 20 04 00 00 33 DB 89 54 24 24 44 8B FA H.. ...3..T$$D.. +1800A96F0 48 89 4C 24 28 48 8B F9 48 89 19 48 89 59 08 33 H.L$(H..H..H.Y.3 +1800A9700 D2 8D 4B 04 44 89 44 24 20 8B F3 FF 15 4F 7A 00 ..K.D.D$ ....Oz. +1800A9710 00 4C 8B F0 48 83 F8 FF 0F 84 C8 02 00 00 44 8D .L..H.........D. +1800A9720 63 1C 48 8B C8 48 8D 54 24 30 44 89 64 24 30 FF c.H..H.T$0D.d$0. +1800A9730 15 7B 7A 00 00 85 C0 0F 84 D5 00 00 00 8D 73 01 .{z...........s. +1800A9740 83 7C 24 30 10 0F 82 85 00 00 00 FF 15 07 7A 00 .|$0..........z. +1800A9750 00 39 44 24 3C 75 79 FF 15 0B 7B 00 00 39 44 24 .9D$.1...H....1.3 +1800A9FAC D2 48 D1 E8 4C 6B C8 38 FF 15 FE 71 00 00 48 85 .H..Lk.8...q..H. +1800A9FBC C0 74 14 D1 2D 23 D8 31 00 48 89 05 14 D8 31 00 .t..-#.1.H....1. +1800A9FCC EB 05 BE 02 00 00 00 87 1D AF CE 31 00 48 8B 5C ...........1.H.\ +1800A9FDC 24 40 8B C6 48 8B 6C 24 48 48 8B 74 24 50 48 83 $@..H.l$HH.t$PH. +1800A9FEC C4 30 5F C3 .0_. + +======================================================================== +FUNCTION: SecurityExceptionInit +RVA: 0xAC580–0xAC6CC Size: 332 bytes +1800AC580 48 89 5C 24 08 55 48 8D AC 24 40 FB FF FF 48 81 H.\$.UH..$@...H. +1800AC590 EC C0 05 00 00 8B D9 B9 17 00 00 00 FF 15 4E 4C ..............NL +1800AC5A0 00 00 85 C0 74 04 8B CB CD 29 B9 03 00 00 00 E8 ....t....)...... +1800AC5B0 C0 FF FF FF 33 D2 48 8D 4D F0 41 B8 D0 04 00 00 ....3.H.M.A..... +1800AC5C0 E8 A5 02 00 00 48 8D 4D F0 FF 15 51 4C 00 00 48 .....H.M...QL..H +1800AC5D0 8B 9D E8 00 00 00 48 8D 95 D8 04 00 00 48 8B CB ......H......H.. +1800AC5E0 45 33 C0 FF 15 2F 4C 00 00 48 85 C0 74 3F 48 8B E3.../L..H..t?H. +1800AC5F0 95 D8 04 00 00 48 8D 8D E0 04 00 00 48 C7 44 24 .....H......H.D$ +1800AC600 38 00 00 00 00 4C 8B C8 48 89 4C 24 30 4C 8B C3 8....L..H.L$0L.. +1800AC610 48 8D 8D E8 04 00 00 48 89 4C 24 28 48 8D 4D F0 H......H.L$(H.M. +1800AC620 48 89 4C 24 20 33 C9 FF 15 E3 4B 00 00 48 8B 85 H.L$ 3....K..H.. +1800AC630 C8 04 00 00 48 8D 4C 24 50 48 89 85 E8 00 00 00 ....H.L$PH...... +1800AC640 33 D2 48 8D 85 C8 04 00 00 41 B8 98 00 00 00 48 3.H......A.....H +1800AC650 83 C0 08 48 89 85 88 00 00 00 E8 0B 02 00 00 48 ...H...........H +1800AC660 8B 85 C8 04 00 00 48 89 44 24 60 C7 44 24 50 15 ......H.D$`.D$P. +1800AC670 00 00 40 C7 44 24 54 01 00 00 00 FF 15 67 4B 00 ..@.D$T......gK. +1800AC680 00 8B D8 33 C9 48 8D 44 24 50 48 89 44 24 40 48 ...3.H.D$PH.D$@H +1800AC690 8D 45 F0 48 89 44 24 48 FF 15 62 4B 00 00 48 8D .E.H.D$H..bK..H. +1800AC6A0 4C 24 40 FF 15 5F 4B 00 00 85 C0 75 0D 83 FB 01 L$@.._K....u.... +1800AC6B0 74 08 8D 48 03 E8 BA FE FF FF 48 8B 9C 24 D0 05 t..H......H..$.. +1800AC6C0 00 00 48 81 C4 C0 05 00 00 5D C3 CC ..H......].. + +======================================================================== +FUNCTION: SecurityCheckCookie +RVA: 0xAC6CC–0xAC77C Size: 176 bytes +1800AC6CC 48 89 5C 24 18 55 48 8B EC 48 83 EC 30 48 8B 05 H.\$.UH..H..0H.. +1800AC6DC 60 89 31 00 48 BB 32 A2 DF 2D 99 2B 00 00 48 3B `.1.H.2..-.+..H; +1800AC6EC C3 75 77 48 8D 4D 10 48 C7 45 10 00 00 00 00 FF .uwH.M.H.E...... +1800AC6FC 15 DF 4A 00 00 48 8B 45 10 48 89 45 F0 FF 15 59 ..J..H.E.H.E...Y +1800AC70C 4B 00 00 8B C0 48 31 45 F0 FF 15 3D 4A 00 00 8B K....H1E...=J... +1800AC71C C0 48 8D 4D 18 48 31 45 F0 FF 15 D5 49 00 00 8B .H.M.H1E....I... +1800AC72C 45 18 48 8D 4D F0 48 C1 E0 20 48 33 45 18 48 33 E.H.M.H.. H3E.H3 +1800AC73C 45 F0 48 33 C1 48 B9 FF FF FF FF FF FF 00 00 48 E.H3.H.........H +1800AC74C 23 C1 48 B9 33 A2 DF 2D 99 2B 00 00 48 3B C3 48 #.H.3..-.+..H;.H +1800AC75C 0F 44 C1 48 89 05 DA 88 31 00 48 8B 5C 24 50 48 .D.H....1.H.\$PH +1800AC76C F7 D0 48 89 05 0B 89 31 00 48 83 C4 30 5D C3 CC ..H....1.H..0].. + diff --git a/IDA/project/docs/input/files/ef_cheeto_pe_headers.b64 b/IDA/project/docs/input/files/ef_cheeto_pe_headers.b64 new file mode 100644 index 0000000..76597cc --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_pe_headers.b64 @@ -0,0 +1,6 @@ +# EF-Cheeto PE headers (DOS+PE+COFF+Optional+SectionTable) +# Size: 1024 bytes +# ImageBase: 0x180000000 +# To decode: import base64; data = base64.b64decode(open(this).read().split('\n',5)[-1]) + +TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA+AAAAA4fug4AtAnNIbgBTM0hVGhpcyBwcm9ncmFtIGNhbm5vdCBiZSBydW4gaW4gRE9TIG1vZGUuDQ0KJAAAAAAAAADPDnkji28XcItvF3CLbxdwgheEcJ9vF3AM5hRxj28XcAzmE3GDbxdwDOYScZVvF3AM5hZxg28XcPLuFnGabxdwi28WcA5uF3Ae5h5xu28XcB7m6HCKbxdwHuYVcYpvF3BSaWNoi28XcAAAAAAAAAAAAAAAAAAAAABQRQAAZIYIABlnOWkAAAAAAAAAAPAAIiALAg4sAPIKAAD8MQAAAAAAxMEKAAAQAAAAAACAAQAAAAAQAAAAAgAABgAAAAAAAAAGAAAAAAAAAABQPQAABAAAAAAAAAIAYAEAABAAAAAAAAAQAAAAAAAAAAAQAAAAAAAAEAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAsITwAuAEAAAAwPQD4AAAAAIA8AGhtAAAAAAAAAAAAAABAPQBsCQAAcDc7ADgAAAAAAAAAAAAAAAAAAAAAAAAAADg7ACgAAAAwNjsAQAEAAAAAAAAAAAAAABALADAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAudGV4dAAAAKfxCgAAEAAAAPIKAAAEAAAAAAAAAAAAAAAAAAAgAABgLnJkYXRhAAC0NTEAABALAAA2MQAA9goAAAAAAAAAAAAAAAAAQAAAQC5kYXRhAAAA8CcAAABQPAAAFgAAACw8AAAAAAAAAAAAAAAAAEAAAMAucGRhdGEAAGhtAAAAgDwAAG4AAABCPAAAAAAAAAAAAAAAAABAAABALmRldG91cmPAIQAAAPA8AAAiAAAAsDwAAAAAAAAAAAAAAAAAQAAAQC5kZXRvdXJkGAAAAAAgPQAAAgAAANI8AAAAAAAAAAAAAAAAAEAAAMAucnNyYwAAAPgAAAAAMD0AAAIAAADUPAAAAAAAAAAAAAAAAABAAABALnJlbG9jAABsCQAAAEA9AAAKAAAA1jwAAAAAAAAAAAAAAAAAQAAAQgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA== diff --git a/IDA/project/docs/input/files/ef_cheeto_reconstruction_prompt.md b/IDA/project/docs/input/files/ef_cheeto_reconstruction_prompt.md new file mode 100644 index 0000000..53af924 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_reconstruction_prompt.md @@ -0,0 +1,122 @@ +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed diff --git a/IDA/project/docs/input/files/ef_cheeto_section__data.b64 b/IDA/project/docs/input/files/ef_cheeto_section__data.b64 new file mode 100644 index 0000000..a5d8399 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_section__data.b64 @@ -0,0 +1,9 @@ +# EF-Cheeto binary section: .data +# RVA: 0x3c5000 +# Size: 5,632 bytes +# Raw offset in original DLL: 0x3c2c00 +# To decode: import base64; data = base64.b64decode(open('ef_cheeto_section__data.b64').read().split('\n',5)[-1]) +# ImageBase: 0x180000000 +# VA = ImageBase + RVA + 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 diff --git a/IDA/project/docs/input/files/ef_cheeto_section__detourc.b64 b/IDA/project/docs/input/files/ef_cheeto_section__detourc.b64 new file mode 100644 index 0000000..5cb3b39 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_section__detourc.b64 @@ -0,0 +1,9 @@ +# EF-Cheeto binary section: .detourc +# RVA: 0x3cf000 +# Size: 8,704 bytes +# Raw offset in original DLL: 0x3cb000 +# To decode: import base64; data = base64.b64decode(open('ef_cheeto_section__detourc.b64').read().split('\n',5)[-1]) +# ImageBase: 0x180000000 +# VA = ImageBase + RVA + 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 diff --git a/IDA/project/docs/input/files/ef_cheeto_section__pdata.b64 b/IDA/project/docs/input/files/ef_cheeto_section__pdata.b64 new file mode 100644 index 0000000..6b113c6 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_section__pdata.b64 @@ -0,0 +1,9 @@ +# EF-Cheeto binary section: .pdata +# RVA: 0x3c8000 +# Size: 28,160 bytes +# Raw offset in original DLL: 0x3c4200 +# To decode: import base64; data = base64.b64decode(open('ef_cheeto_section__pdata.b64').read().split('\n',5)[-1]) +# ImageBase: 0x180000000 +# VA = ImageBase + RVA + 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 diff --git a/IDA/project/docs/input/files/ef_cheeto_section__rdata_cheat.b64 b/IDA/project/docs/input/files/ef_cheeto_section__rdata_cheat.b64 new file mode 100644 index 0000000..cfcd1ff --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_section__rdata_cheat.b64 @@ -0,0 +1,9 @@ +# EF-Cheeto binary section: .rdata_cheat +# RVA: 0x3A0000 +# Size: 81,920 bytes +# Raw offset in original DLL: 0x39e600 +# To decode: import base64; data = base64.b64decode(open('ef_cheeto_section__rdata_cheat.b64').read().split('\n',5)[-1]) +# ImageBase: 0x180000000 +# VA = ImageBase + RVA + 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 diff --git a/IDA/project/docs/input/files/ef_cheeto_section__rdata_iat.b64 b/IDA/project/docs/input/files/ef_cheeto_section__rdata_iat.b64 new file mode 100644 index 0000000..13a3a67 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_section__rdata_iat.b64 @@ -0,0 +1,9 @@ +# EF-Cheeto binary section: .rdata_iat +# RVA: 0xB1000 +# Size: 4,096 bytes +# Raw offset in original DLL: 0xaf600 +# To decode: import base64; data = base64.b64decode(open('ef_cheeto_section__rdata_iat.b64').read().split('\n',5)[-1]) +# ImageBase: 0x180000000 +# VA = ImageBase + RVA + +Vj48AAAAAAAAAAAAAAAAAPY0PAAAAAAABjU8AAAAAAAAAAAAAAAAAPY9PAAAAAAAKD48AAAAAAA8PjwAAAAAAA4+PAAAAAAAAAAAAAAAAACwLDwAAAAAAMAsPAAAAAAA0Cw8AAAAAADgLDwAAAAAAPQsPAAAAAAADC08AAAAAAAgLTwAAAAAADAtPAAAAAAAQi08AAAAAABQLTwAAAAAAGYtPAAAAAAAfC08AAAAAACKLTwAAAAAAJgtPAAAAAAApi08AAAAAAC8LTwAAAAAAMwtPAAAAAAA4C08AAAAAADyLTwAAAAAAAIuPAAAAAAAHi48AAAAAAAwLjwAAAAAAEYuPAAAAAAAYC48AAAAAABwLjwAAAAAAIYuPAAAAAAAli48AAAAAACoLjwAAAAAALouPAAAAAAAyC48AAAAAADmLjwAAAAAAAAvPAAAAAAACC88AAAAAAAYLzwAAAAAAC4vPAAAAAAASi88AAAAAABkLzwAAAAAAHwvPAAAAAAAkC88AAAAAACsLzwAAAAAAL4vPAAAAAAA4C88AAAAAACKLDwAAAAAAPovPAAAAAAACjA8AAAAAAAaMDwAAAAAACgwPAAAAAAANDA8AAAAAABCMDwAAAAAAFAwPAAAAAAAAkU8AAAAAADuRDwAAAAAANJEPAAAAAAAvkQ8AAAAAACgRDwAAAAAAIREPAAAAAAAcEQ8AAAAAABWRDwAAAAAAEJEPAAAAAAAJkQ8AAAAAAAKRDwAAAAAAPBDPAAAAAAA1kM8AAAAAADEQzwAAAAAALJDPAAAAAAAoEM8AAAAAACUQzwAAAAAAJosPAAAAAAAdiw8AAAAAABoLDwAAAAAAO4vPAAAAAAAViw8AAAAAABCLDwAAAAAABxFPAAAAAAAzC88AAAAAAAAAAAAAAAAAJA8PAAAAAAAajw8AAAAAAAyPDwAAAAAANw7PAAAAAAAxDs8AAAAAACuOzwAAAAAAFo7PAAAAAAA6jw8AAAAAABCPTwAAAAAAJg9PAAAAAAAvDw8AAAAAAAWOzwAAAAAANo6PAAAAAAAQDU8AAAAAABiNTwAAAAAAII1PAAAAAAAoDU8AAAAAADCNTwAAAAAAAI2PAAAAAAATjY8AAAAAACENjwAAAAAAKo2PAAAAAAAxjY8AAAAAADgNjwAAAAAAAA3PAAAAAAAHDc8AAAAAAA8NzwAAAAAAF43PAAAAAAAkjc8AAAAAACwNzwAAAAAANw3PAAAAAAAAjg8AAAAAAAcODwAAAAAAEI4PAAAAAAAbjg8AAAAAACcODwAAAAAAMI4PAAAAAAAAjk8AAAAAAA+OTwAAAAAAIA5PAAAAAAAojk8AAAAAADCOTwAAAAAAAA6PAAAAAAARDo8AAAAAACMOjwAAAAAAKw6PAAAAAAAuDo8AAAAAADGOjwAAAAAAAAAAAAAAAAA/js8AAAAAAAAAAAAAAAAACQ1PAAAAAAAAAAAAAAAAADANDwAAAAAAKQ0PAAAAAAAmDQ8AAAAAACENDwAAAAAANw0PAAAAAAAcjQ8AAAAAABiNDwAAAAAAFI0PAAAAAAANjQ8AAAAAAAoNDwAAAAAABQ0PAAAAAAAljA8AAAAAAC6MDwAAAAAAAA0PAAAAAAA7DM8AAAAAADcMzwAAAAAAMwzPAAAAAAAuDM8AAAAAACsMzwAAAAAAJozPAAAAAAAyjA8AAAAAADaMDwAAAAAAOYwPAAAAAAA9jA8AAAAAAACMTwAAAAAABgxPAAAAAAAKjE8AAAAAACoMDwAAAAAAIgzPAAAAAAAdjM8AAAAAABgMzwAAAAAAG4wPAAAAAAAUjM8AAAAAAA8MzwAAAAAADAzPAAAAAAAIDM8AAAAAAAYMzwAAAAAAIIwPAAAAAAACDM8AAAAAAD0MjwAAAAAAOAyPAAAAAAAPDE8AAAAAABSMTwAAAAAAGIxPAAAAAAAdDE8AAAAAACAMTwAAAAAAI4xPAAAAAAAnDE8AAAAAACwMTwAAAAAALwxPAAAAAAA2jE8AAAAAADmMTwAAAAAAPwxPAAAAAAAEDI8AAAAAAAiMjwAAAAAACwyPAAAAAAAPjI8AAAAAABQMjwAAAAAAF4yPAAAAAAAbDI8AAAAAAB+MjwAAAAAAJIyPAAAAAAApjI8AAAAAAC4MjwAAAAAAMoyPAAAAAAAAAAAAAAAAACgPzwAAAAAAII/PAAAAAAAYj88AAAAAABYPzwAAAAAAE4/PAAAAAAARD88AAAAAAA6PzwAAAAAACI/PAAAAAAAFj88AAAAAAAyRTwAAAAAAPw+PAAAAAAA5D48AAAAAADSPjwAAAAAALY/PAAAAAAAbD88AAAAAAAAAAAAAAAAALw+PAAAAAAAAAAAAAAAAABKQTwAAAAAAGJBPAAAAAAAPkE8AAAAAAAEQTwAAAAAAAAAAAAAAAAAZEA8AAAAAACCQTwAAAAAADxAPAAAAAAAIkA8AAAAAAAAAAAAAAAAAFRBPAAAAAAAbEE8AAAAAAAAAAAAAAAAAEZAPAAAAAAAWkA8AAAAAACMRTwAAAAAAH5FPAAAAAAAhEU8AAAAAAB2RTwAAAAAAFJFPAAAAAAAkkU8AAAAAABGRTwAAAAAADxFPAAAAAAAUEA8AAAAAABmRTwAAAAAAKJFPAAAAAAAbkU8AAAAAACaRTwAAAAAAF5FPAAAAAAAAAAAAAAAAACgQTwAAAAAALpBPAAAAAAA3EE8AAAAAACOQTwAAAAAADRBPAAAAAAA+EE8AAAAAAAUQjwAAAAAAFxCPAAAAAAAUEI8AAAAAABEQjwAAAAAADpCPAAAAAAA/D88AAAAAAAsQjwAAAAAAAAAAAAAAAAANEA8AAAAAAAqQDwAAAAAABhAPAAAAAAADkA8AAAAAAAMQTwAAAAAAOpAPAAAAAAAxkA8AAAAAACSQDwAAAAAAHhAPAAAAAAAgEA8AAAAAACaQDwAAAAAANBAPAAAAAAAAAAAAAAAAAC8QDwAAAAAAG5APAAAAAAAqkU8AAAAAAAqQTwAAAAAAAAAAAAAAAAAGEE8AAAAAAAAAAAAAAAAALRAPAAAAAAAAAAAAAAAAAAYLDwAAAAAAAAAAAAAAAAAeD48AAAAAACYPjwAAAAAAAAAAAAAAAAAYAcBgAEAAABgBwGAAQAAADDKCoABAAAAUMoKgAEAAABQygqAAQAAAAAAAAAAAAAAZMgKgAEAAAAAAAAAAAAAAJAhAIABAAAAABAAgAEAAAAQEACAAQAAAPAYAIABAAAAIBkAgAEAAAAwGQCAAQAAAEAZAIABAAAAEBoAgAEAAADgGgCAAQAAALAbAIABAAAAgBwAgAEAAABQHQCAAQAAACAeAIABAAAA8B4AgAEAAADAHwCAAQAAAJAgAIABAAAAYCEAgAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAABAQAAAQAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIQB4AC0AcwB5AHMALQBkAGUAZgBhAHUAbAB0AC0AbABvAGMAYQBsAGUAAAAAAAAAAAECAwQFBgcBAgMEBQYHBwACAwQFBgcHAgMEBQYHBgcAAQMEBQYHBwEDBAUGBwYHAAMEBQYHBgcDBAUGBwUGBwABAgQFBgcHAQIEBQYHBgcAAgQFBgcGBwIEBQYHBQYHAAEEBQYHBgcBBAUGBwUGBwAEBQYHBQYHBAUGBwQFBgcAAQIDBQYHBwECAwUGBwYHAAIDBQYHBgcCAwUGBwUGBwABAwUGBwYHAQMFBgcFBgcAAwUGBwUGBwMFBgcEBQYHAAECBQYHBgcBAgUGBwUGBwACBQYHBQYHAgUGBwQFBgcAAQUGBwUGBwEFBgcEBQYHAAUGBwQFBgcFBgcDBAUGBwABAgMEBgcHAQIDBAYHBgcAAgMEBgcGBwIDBAYHBQYHAAEDBAYHBgcBAwQGBwUGBwADBAYHBQYHAwQGBwQFBgcAAQIEBgcGBwECBAYHBQYHAAIEBgcFBgcCBAYHBAUGBwABBAYHBQYHAQQGBwQFBgcABAYHBAUGBwQGBwMEBQYHAAECAwYHBgcBAgMGBwUGBwACAwYHBQYHAgMGBwQFBgcAAQMGBwUGBwEDBgcEBQYHAAMGBwQFBgcDBgcDBAUGBwABAgYHBQYHAQIGBwQFBgcAAgYHBAUGBwIGBwMEBQYHAAEGBwQFBgcBBgcDBAUGBwAGBwMEBQYHBgcCAwQFBgcAAQIDBAUHBwECAwQFBwYHAAIDBAUHBgcCAwQFBwUGBwABAwQFBwYHAQMEBQcFBgcAAwQFBwUGBwMEBQcEBQYHAAECBAUHBgcBAgQFBwUGBwACBAUHBQYHAgQFBwQFBgcAAQQFBwUGBwEEBQcEBQYHAAQFBwQFBgcEBQcDBAUGBwABAgMFBwYHAQIDBQcFBgcAAgMFBwUGBwIDBQcEBQYHAAEDBQcFBgcBAwUHBAUGBwADBQcEBQYHAwUHAwQFBgcAAQIFBwUGBwECBQcEBQYHAAIFBwQFBgcCBQcDBAUGBwABBQcEBQYHAQUHAwQFBgcABQcDBAUGBwUHAgMEBQYHAAECAwQHBgcBAgMEBwUGBwACAwQHBQYHAgMEBwQFBgcAAQMEBwUGBwEDBAcEBQYHAAMEBwQFBgcDBAcDBAUGBwABAgQHBQYHAQIEBwQFBgcAAgQHBAUGBwIEBwMEBQYHAAEEBwQFBgcBBAcDBAUGBwAEBwMEBQYHBAcCAwQFBgcAAQIDBwUGBwECAwcEBQYHAAIDBwQFBgcCAwcDBAUGBwABAwcEBQYHAQMHAwQFBgcAAwcDBAUGBwMHAgMEBQYHAAECBwQFBgcBAgcDBAUGBwACBwMEBQYHAgcCAwQFBgcAAQcDBAUGBwEHAgMEBQYHAAcCAwQFBgcHAQIDBAUGBwABAgMEBQYHAQIDBAUGBgcAAgMEBQYGBwIDBAUGBQYHAAEDBAUGBgcBAwQFBgUGBwADBAUGBQYHAwQFBgQFBgcAAQIEBQYGBwECBAUGBQYHAAIEBQYFBgcCBAUGBAUGBwABBAUGBQYHAQQFBgQFBgcABAUGBAUGBwQFBgMEBQYHAAECAwUGBgcBAgMFBgUGBw== diff --git a/IDA/project/docs/input/files/ef_cheeto_section__reloc.b64 b/IDA/project/docs/input/files/ef_cheeto_section__reloc.b64 new file mode 100644 index 0000000..f58d9c8 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_section__reloc.b64 @@ -0,0 +1,9 @@ +# EF-Cheeto binary section: .reloc +# RVA: 0x3d4000 +# Size: 2,560 bytes +# Raw offset in original DLL: 0x3cd600 +# To decode: import base64; data = base64.b64decode(open('ef_cheeto_section__reloc.b64').read().split('\n',5)[-1]) +# ImageBase: 0x180000000 +# VA = ImageBase + RVA + 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 diff --git a/IDA/project/docs/input/files/ef_cheeto_text_chunk1of4.b64 b/IDA/project/docs/input/files/ef_cheeto_text_chunk1of4.b64 new file mode 100644 index 0000000..2a096d3 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_text_chunk1of4.b64 @@ -0,0 +1,7 @@ +# EF-Cheeto .text section — chunk 1/4 +# RVA range: 0x01000–0x2CF20 +# Size: 180,000 bytes / ~60,000 tokens +# ImageBase: 0x180000000 VA = 0x0180001000 +# To decode: import base64; data = base64.b64decode(open(this).read().split('\n',6)[-1]) + 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 diff --git a/IDA/project/docs/input/files/ef_cheeto_text_chunk2of4.b64 b/IDA/project/docs/input/files/ef_cheeto_text_chunk2of4.b64 new file mode 100644 index 0000000..aa2a772 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_text_chunk2of4.b64 @@ -0,0 +1,7 @@ +# EF-Cheeto .text section — chunk 2/4 +# RVA range: 0x2CF20–0x58E40 +# Size: 180,000 bytes / ~60,000 tokens +# ImageBase: 0x180000000 VA = 0x018002CF20 +# To decode: import base64; data = base64.b64decode(open(this).read().split('\n',6)[-1]) + +EoO/lBwAAP91CUAPttXrBUUywDLSi4tMFgAAhcl1HUWEyXQgi4O4IQAAiYPQIQAAx4PcIQAAAgAAAOsIO4u4IQAAdTiE0nQSi4O4IQAAiYPQIQAAiavcIQAAhcl0CDuLuCEAAHUWQIT2dQVFhMB0DIuDuCEAAImD1CEAAIuDTBYAAIXAdAg7g7ghAAB1JUWEyXUEhNJ0HIuDuCEAAImD2CEAAImH8CEAAMeH9CEAAM3MzD0z9kiLg8AhAABIhcB0EvdAFAAAAQB0CcaDtCEAAADrFoB7fwB0EIC7ECIAAAB1B0CIq7QhAADzDxCL9CEAAA8vznYXDyjBD1fJ8w9cQ0jzD1/I8w8Ri/QhAAAPLs56CHUGibPwIQAAi4P4IQAAhcB0HomD2CEAAImD1CEAAImD0CEAAIuD/CEAAImD3CEAAImz+CEAAOgDBAAAg7tgIgAA/0iLPYWbOQAPhT8BAABMi4/AIQAATYXJD4QvAQAASIO/mCMAAAAPhSEBAABB90EUAAABAA+FEwEAAIC/QAEAAAAPhAYBAADzDxCHRAEAAA8v8A+H9QAAAA8uxkyLx3oCdCvzDxCPqAAAAA8vwQ+G2gAAAPMPEJesAAAAuQACAADoqID//4XAD47AAAAAQYC4ZB8AAAB0DkGDuEwWAAD/D4WoAAAAQYO4xBYAAP8PhZoAAACAvzgBAAAAD4WNAAAAgL86AQAAAA+FgAAAAA+2hzkBAABAhG8wdCGEwHQHvf/////rLoC/tCEAAAB1JYO/TBYAAAB1HIvu6xiEwHQHvf/////rDYO/TBYAAACL7kAPlcWJr5AiAAC4IQAAAEGAuQgBAAAAuf////9BuAAUAABED0Xwwf0fRYvOjVUD6Crw///Hh5QiAAD/////gL9RIgAAAEyLtCTAAAAASIusJLAAAAB1DYC/EiIAAAB1BDLA6wKwAYiHESIAAEiLi8AhAADGg7chAAAASIXJD4TEAQAA90EUAAABAA+FtwEAAEiDu5gjAAAAD4WpAQAAZoO5rAEAAADzDxCBEAMAAPMPWQXQYDgAi5NgIgAA8w8QFR5gOADzD1lDSPMPWAXRXzgA8w8swGYPbtgPW9sPhY4AAACAubIBAAAAD4SBAAAAg/r/dHzzDxAN6mA4AIXSdAqD+gF1Mw8owusDDyjB8w9Zw4mx5AAAAImx7AAAAPMPWIHMAAAA8w8swGYPbsAPW8DzDxGB3AAAAIP6AnQIg/oDdS4PKMrzD1nLibHoAAAAibHwAAAA8w9YidAAAADzDyzBZg9uwA9bwPMPEYHgAAAARYTtD4TOAAAAgL9gCQAAAEiLx/MPEI/8CQAA8w8Qh9wJAADzD1yP7AkAAPMPXIfMCQAAdBOAv+QcAAAAdQrzDxAVrF44AOsagLhwCQAAAHQRgLjwHAAAAHUI8w8QFXRfOAAPLsZ6AnQ4gLn8AAAAAHQv8w9Zw4mx5AAAAImx7AAAAPMPWcLzD1iBzAAAAPMPLMBmD27AD1vA8w8RgdwAAAAPLs56AnQv8w9Zy4mx6AAAAImx8AAAAPMPWcrzD1iJ0AAAAPMPLMFmD27AD1vA8w8RgeAAAAAPKHQkcEWE5EyLpCS4AAAAdRBFhO11C2bHg7QhAAAAAOtWRYT/dFGAe3oAdEv2QzQEdEVIjUwkIOja8f//8w8QAPMPEEgE8w8Rh/QKAADzDxGP+AoAAPMPEYcYAQAA8w8RjxwBAABIx4cEAQAAAAAAAMaH6wAAAAGJs4wiAABIi0wkaEgzzOh84gcASIHEgAAAAEFfQV1fXlvDzMzMzMzMzMzMzMzMzEiJXCQYSIlsJCBWV0FXSIHsoAAAAEiLPXSXOQBEDylcJEBIi99EDylsJDCLbzBIi7fAIQAAQPbFAnQL9kc0AXQFQbEB6wNFMslAgOUBDym0JJAAAABFM/8PKbwkgAAAAEQ4v1IiAAB0L0iF9nQq9odUKgAAEHQZi5dgIgAASI0NHP43AOh3+AAASIs9AJc5AA9X9unwAwAAx4dgIgAA/////w9X9kyJv1QiAABIhfYPhJoDAABMOb+YIwAAD4WNAwAA90YUAAABAA+FgAMAAESLl2AfAADzDxAt8lw4APMPED32XDgAQfbCAQ+FzgAAAEWEyXRVRDi/IAkAAHRM8w8QhyQJAAAPL/B3Pw8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2GLl+AgAA6PR7//+FwH4KQYO4rBwAAP90bUCE7XRvRDi/UAEAAHRm8w8Qh1QBAAAPL/B3WQ8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2MrkBAgAA6Jp7//+FwH4kRTi4ZB8AAHQKQYO4TBYAAP91EUGDuNAWAAD/dQdEib9gIgAAQfbCAg+F0QAAAEWEyXRVRDi/MAkAAHRM8w8QhzQJAAAPL/B3Pw8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2GLl/AgAA6Bx7//+FwH4KQYO4uBwAAP90bUCE7XRyRDi/YAEAAHRp8w8Qh2QBAAAPL/B3XA8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2NbkCAgAA6MJ6//+FwH4nRTi4ZB8AAHQKQYO4TBYAAP91FEGDuNwWAAD/dQrHh2AiAAABAAAAQfbCBA+F0QAAAEWEyXRVRDi/QAkAAHRM8w8Qh0QJAAAPL/B3Pw8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2GLmAAgAA6EF6//+FwH4KQYO4xBwAAP90bUCE7XRyRDi/cAEAAHRp8w8Qh3QBAAAPL/B3XA8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2NbkDAgAA6Od5//+FwH4nRTi4ZB8AAHQKQYO4TBYAAP91FEGDuOgWAAD/dQrHh2AiAAACAAAAQfbCCA+F0QAAAEWEyXRVRDi/UAkAAHRM8w8Qh1QJAAAPL/B3Pw8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2GLmBAgAA6GZ5//+FwH4KQYO40BwAAP90bUCE7XRyRDi/gAEAAHRp8w8Qh4QBAAAPL/B3XA8uxkyLx3oCdCvzDxCPqAAAAPMPEJesAAAA8w9ZzfMPWdcPL8F2NbkEAgAA6Ax5//+FwH4nRTi4ZB8AAHQKQYO4TBYAAP91FEGDuPQWAAD/dQrHh2AiAAADAAAAi4dgIgAAiYdoIgAAx4d8IgAA//9/f8eHgCIAAP//f3/Hh4QiAAD//3//x4eIIgAA//9//0iF9nQdg7tgIgAA/3UUQITtdA/otQwAAEiLPe6SOQAPKPCLi2AiAABEiLtSIgAAg/n/dBlEi4tYIgAARIuDVCIAAIuTaCIAAOig6P//RDi7UCIAAHRbRDm7uCEAAHVS9oNUKgAAEHQsSIX2dAZIi1YI6wdIjRUz9zcARIuDzCEAAEiNDbX5NwDo8PMAAEiLPXmSOQBmx4MSIgAAAQFEibsgIgAARDh7fnQHxoO0IQAAAfNEDxAdn1k4APNEDxAtrlg4AEyJtCTIAAAARA8pRCRwRA8pTCRgRA8pVCRQRDi7UCIAAA+EGQIAAIO7ACIAAAMPhQwCAABEObvMIQAAD4X/AQAASIX2D4T2AQAAi6tUIgAASI2MJMAAAADzDxCGYAEAAESL9fMPEI5kAQAASIvW8w8QvnACAACD5QrzRA8QhnQCAADzQQ9c/fNEDxCWeAIAAPNFD1zF80QPEI58AgAA80UPWNXzRQ9YzfMPXPjzRA9cwfNED1zQ80QPXMnoyrv///MPEADzDxBIBPMPXIbMAAAA8w9cjtAAAADzD1j480QPWMHzRA9Y0PNED1jJQYPmBXQIhe0PhUYBAABIY4PMIQAASIPARUgDwPMPEATGDy/HciDzDxBExgRBDy/AchREDy9UxghyDEQPL0zGDA+DDgEAAPaDVCoAABB0E0iNDXD4NwDoc/IAAEiLPfyQOQDzDxCGEAMAAEEPKMrzD1kFDFc4AEEPKNHzDxAdZFg4APMPXM/zQQ9c0PMPXcjzD13QRYX2dQvzD1j580QPXNHrBw8o+0UPKNOF7XUM80QPWMLzRA9cyusIRA8ow0UPKMtIY4PMIQAASIPARUgDwPMPEETGBEQPL8B2BkEPKMjrCEEPKMnzD13I8w8QFMYPL/p2BQ8ox+sIQQ8owvMPXcLzDxEExvMPEUzGBPMPEETGDEQPL8B3CUUPKMHzRA9dwPMPEETGCA8v+HcIQQ8o+vMPXfjzDxF8xgjzRA8RRMYMRIm7uCEAAESJfCQkRIl8JCzrEQ9XwA8RRCQgSIX2D4QPAgAASGODzCEAAEiDwEVIA8DzDxAExg8vRMYIdxPzDxBExgQPL0TGDHcGDxAkxusDD1fk8w8QjmQBAAAPKMTzDxC+YAEAAA8o2YuDVCIAAA8o1w/GxFXzD1jU8w9Y2A8oxA/GxKoPxuT/8w9Y+PMPWMzzDxFUJCDzDxFcJCTzDxF8JCjzDxFMJCwPuuALD4OZAAAADy+WcAIAAHIsDy+edAIAAHIj8w8QhngCAAAPL8dyFvMPEIZ8AgAADy/BcgmDyCCJg1QiAAAPEEQkIPMPWN4PL8LzD1jO8w8RXCQkDxGDfCIAAPMPEUwkLHYI8w8Rk3wiAADzDxCDgCIAAA8vw3YI8w8Rm4AiAAAPL7uEIgAAdgjzDxG7hCIAAA8vi4giAAB2CPMPEYuIIgAARDi7UCIAAA+E2QAAAPaDVCIAAIBIi4fAIQAARIuDYCIAAEhji8whAABIi5YwBAAA8w8QoGABAADzDxCoZAEAAHVR8w8QhMpwBAAAQQ8uw3oYdRbzQQ9Y1fMPXdfzD1zU8w8RlMpwBAAA8w8QhMp0BAAAQQ8uw3obdRnzD1jL8w9ZDW5UOADzD1zN8w8RjMp0BAAAQY1A/oP4AXcj8w8QhMpwBAAAQQ8uw3oCdBLzD1jg8w8RZCQo8w8RZCQg6ydBg/gBdyHzDxCEynQEAABBDy7DegJ0EPMPWOjzDxFsJCzzDxFsJCQPEEQkIEyNnCSgAAAATIu0JMgAAABEDyhUJFBEDyhMJGBEDyhEJHAPKLwkgAAAAA8otCSQAAAASYtrOEUPKFugRQ8oa5APEYNsIgAASYtbMEmL40FfX17DzMxAU1ZXSIPsQEiLHYGNOQAz9kiNu5giAAA5dwh1EEiNgwgjAACL/jlwCEgPRfiLi1QiAACL0YHiAAQAAHQkSIX/dR+Du5QiAAABdAg5s5AiAAB1DkiNg0AjAAA5cAhID0X4i4NgIgAATIl0JDhMiXwkMIP4AnQUg/gDdA9MjXQkYEyLxkyNfCRo6xBMjXQkZEG4BAAAAEyNfCRsSIX/dXWF0nQKD7rpDomLVCIAADmzuCEAAHQcD7rhDnIWQDhzfnQHxoO0IQAAAWbHg7UhAAABAUiLg8AhAABIY5PMIQAASIuIMAQAAEiNBNFCx4QAcAQAAP//f3/2g1QqAAAQD4Q8AwAASI0NLvQ3AOjx7QAA6SsDAABIiWwkcPbBIHQYSI2L0CIAAItBCIXAdAo7g7ghAABID0X5SI2TCCMAAEg7+nRFObMQIwAAdD1IiwpIi4PAIQAASDmBAAQAAHUq8w8QRyTzDxCLLCMAAA8vwXcVDy7IehN1EfMPEEcoDy+DMCMAAHYDSIv6ObPMIQAAD4WUAAAASIsXTI1EJCBEi4tYIgAASI1MJGDzDxCSYAEAAPMPEJpkAQAADyjC8w9YRxDzD1hXGA8oy/MPWE8U8w9YXxzzDxFEJCDzDxFUJCjzDxFMJCTzDxFcJCzo4rf///aDVCIAAEB0MIO7YCIAAAJ1DUiLB/MPEIDYAAAA6wMPV8BIiwfzDxGA4AAAAImw6AAAAImw8AAAAEiLF0g5k8AhAAB0LvaDVCoAAAR0EEiLUghIjQ0p8zcA6LTsAABIiwdIiYPAIQAASMeDCCIAAP////+LRwg5g0wWAAB0FfeDVCIAAACAAAB1CTPSM8nor6T+/4tHCDmDuCEAAHUM94NUIgAAAAgAAHRQi4tUIgAAD7rhDXJEi4PIIQAAiYN4IwAAi0cIiYN8IwAAi0cMiYOAIwAAi4NcIgAAiYOEIwAAwekKgOEBiIuIIwAAi0cgwegVJAGIg4kjAAD2g1QqAAAQdCFMi4vAIQAASI0NofI3AESLg8whAACLVwhNi0kI6O7rAABIi4PAIQAATI1PEEhjk8whAABEi0cMSIuIMAQAAPIPEITRcAQAAItPCPIPEUQkaOhq1P//SItHMEiD+P90B0iJgwgiAAD3g1QiAAAABAAAdVrzDxBHGPMPWEcQSGOTzCEAAPMPWQU4UDgA8w8RRCRg8w8QRxzzD1hHFPMPWQUgUDgA8w8RRCRkQYsGQYkHSIuDwCEAAPIPEEQkaEiLiDAEAADyDxGE0XAEAACLg1QiAACLyEiLbCRwD7rgCnMT90cgAAAQAHUKD7rxDImLVCIAAA+64QxzM4tHCImD+CEAAImz/CEAAA+64QlzD8eD/CEAACAAAAC+IAAAAA+64QpzCYPODYmz/CEAAA+64Q5yHUiLBWeJOQCAeH4AdAfGgLQhAAABZseAtSEAAAEBTIt8JDBMi3QkOEiDxEBfXlvDzMzMzMzMzMzMzMzMzMzMSIlcJBBXSIPsMEiLPR+JOQBIi9+LRzCoAnQK9kc0AXQEsQHrAjLJqAF0O4C/IAIAAAB0MvMPEIckAgAAD1fJDy/IdyIPLsF6HXUbgL9kHwAAAHQJg79MFgAA/3UJg79sFwAA/3QuhMkPhHYCAACAf3kAuXsCAAC4fQIAAEG4/////w9FyDPS6CR2//+EwA+EUAIAAPaHVCoAABB0E0iNDeTwNwDo9+kAAEiLPYCIOQCDu0wWAAAAdBMz0jPJSItcJEhIg8QwX+kEov7/g7vMIQAAAA+EoQAAAEyLl8AhAABJi8royN///0iJh8AhAABIx4cIIgAA/////02F0nQk9odUKgAABHQbTItACEiNDTXuNwBJi1II6ITpAABIi4fAIQAAi4hIBAAAhcl0E0yNiFAEAABFM8Az0ugS0v//6xIzybIBiY/MIQAASIvI6I7g//9IiwXXhzkAgHh+AHQHxoC0IQAAAWbHgLUhAAABAUiLXCRISIPEMF/DSIuTwCEAAEiJdCRASIXSD4TPAAAASDuSEAQAAA+EwgAAAEiLujAEAAD3RxQAAAAED4WuAAAASIu3AAQAAEiF9g+EngAAADPSSIvO6ObL///zDxBnWEyNTCQg8w8Qb1wPKMTzDxCWYAEAAA8ozfMPEJ5kAQAA8w9cwvMPWGdg8w9Yb2SLj8QAAADzD1zLRTPAM9LzDxFEJCDzD1zi8w9c6/MPEUwkJPMPEWQkKPMPEWwkLOgf0f//SIsF+IY5AIB4fgB0B8aAtCEAAAFIi3QkQGbHgLUhAAABAUiLXCRISIPEMF/DTGODCCEAAEWFwH45SIuDECEAAElryDhMi0wB0E2FyXQkQfdBFAAAAAh1GkGNSP+yAUiLdCRASItcJEhIg8QwX+ltvP//M8k4S3x1BThLfXQUSIXSdA/3QhQAAAAEdAaJikgEAAA4S3x1BThLfXQSiYu4IQAAOEt9dAcz0ujRyv//SIt0JEBIi1wkSEiDxDBfw8xIiVwkCEiJbCQQSIl0JBhXQVZBV0iD7EBIiz0hhjkADyl0JDBIi/cPV/ZIi5/AIQAA90MUAAABAA+FBQMAAEiDv5gjAAAAD4X3AgAAgL+QAQAAAEyLx3UFRTLS6yOAv2QfAAAAdAmDv0wWAAD/dQmDvwAXAAD/dAVFMtLrA0GyAUGAuKABAAAAdQVFMsnrJkGAuGQfAAAAdApBg7hMFgAA/3UKQYO4DBcAAP90BUUyyesDQbEBQYC4sAEAAAB0XfNBDxCAtAEAAA8v8HdPDy7GegJ0JfNBDxCIqAAAAA8vwXY680EPEJCsAAAAuQcCAADo62r//4XAfiNBgLhkHwAAAHQKQYO4TBYAAP91D0GDuBgXAAD/dQVBtgHrA0Uy9kGAuMABAAAAdF3zQQ8QgMQBAAAPL/B3Tw8uxnoCdCXzQQ8QiKgAAAAPL8F2OvNBDxCQrAAAALkIAgAA6IFq//+FwH4jQYC4ZB8AAAB0CkGDuEwWAAD/dQ9Bg7gkFwAA/3UFQLUB6wNAMu1FOtF1CUQ69Q+ErAEAAEUz/0Q5v8whAAB0eEiLy+gV3P//SImHwCEAAEjHhwgiAAD/////SIXbdCT2h1QqAAAEdBtMi0AISI0Nguo3AEiLUwjo0eUAAEiLh8AhAACLiEgEAACFyXQTTI2IUAQAAEUzwDPS6F/O///rEbIBRIm/zCEAAEiLyOjc3P//SIs9JYQ5APaDrAEAAAEPhV0BAABEOLuyAQAAD4RQAQAARDi/kAEAAHRw8w8Qh5QBAAAPL/B3Yw8uxnoCdCPzDxCPqAAAAA8vwXZP8w8Ql6wAAAC5BQIAAOhvaf//hcB+OUQ4v2QfAAB0CYO/TBYAAP91J4O/ABcAAP91HvMPEIt8AgAA8w9ci3QCAADzDxCD0AAAAPMPXMHrf0Q4v6ABAAAPhKkAAADzDxCHpAEAAA8v8A+HmAAAAA8uxnoCdCfzDxCPqAAAAA8vwQ+GgAAAAPMPEJesAAAAuQYCAADo6mj//4XAfmpEOL9kHwAAdAmDv0wWAAD/dViDvwwXAAD/dU/zDxCDfAIAAPMPXIN0AgAA8w9Yg9AAAADzDxGD4AAAAESJu/AAAABEibvoAAAAD1fASItcJGBIi2wkaEiLdCRwDyh0JDBIg8RAQV9BXl/DRYT2dAlEibvgAAAA68NAhO10zIuD2AAAAImD4AAAAOuw8w8Qi3wCAABFM8DzD1yLdAIAAEhjvswhAAC6AQAAAA8pfCQgSIPHRUgD/w9X/7kFAgAA8w9cixADAADzDxBE+wzzD1xE+wTzD1jI8w9f+ejnb///hMB0NQ8o98eGYCIAAAMAAAAPVzVfTDgADyh8JCAPKMbHhmgiAAACAAAAx4ZUIgAAEAgAAOk0////RTPAugEAAAC5BgIAAOicb///hMB0GQ8o98eGaCIAAAMAAADHhlQiAAAQCAAA639FhPZ0QPMPEAT7Dy9E+whEiXz7DESJfPsEdglEiXz7CESJPPsPKHwkIA8oxseGYCIAAAMAAADHhlQiAABQAAAA6cD+//9AhO10P/MPEEt08w8QBPsPL0T7CPMPEUz7DPMPEUz7BHcFDy/JdglEiXz7CESJPPvHhlQiAABQAAAAx4ZgIgAAAgAAAA8ofCQgDyjG6W/+///MzMzMzMzMzMxAVUiL7EiD7BBMixVQgTkASWOCzCEAAEmLisAhAABIg8BFRYuKYCIAAEgDwEWLglQiAAAPEATBDxFF8EWFyXVgQfbABQ+EBgIAAPMPEIGIAAAA8w9YQXDzDxFF+PMPEUXwQfbABA+EPAEAAPMPEFX8QbkCAAAA8w8QRfQPKMrzD1zID1cN50o4APMPWMHzD1jR8w8RRfTzDxFV/OkHAQAAQYP5AXVbQfbABQ+EoAEAAPMPEIGIAAAAD1cFsUo4APMPEUX48w8RRfBB9sAED4TUAAAA8w8QVfxBuQMAAADzDxBF9A8oyvMPXMjzD1jB8w9Y0fMPEUX08w8RVfzppgAAAEGD+QJ1REH2wAoPhD8BAADzDxCBjAAAAPMPWEF08w8RRfzzDxFF9EH2wAh0efMPEFX4RTPJ8w8QRfAPKMrzD1zID1cNJ0o4AOtKQYP5Aw+F+wAAAEH2wAoPhPEAAADzDxCBjAAAAA9XBQJKOADzDxFF/PMPEUX0QfbACHQp8w8QVfhBuQEAAADzDxBF8A8oyvMPXMjzD1jR8w9YwfMPEVX48w8RRfBJY4LMIQAADxBF8EiDwEVIA8APEQTBSYuCwCEAAEljkswhAABIi4gwBAAAx4TRcAQAAP//f39Ji4LAIQAASWOSzCEAAEiLiDAEAADHhNF0BAAA//9/f0GAuhIiAAAAQYuSWCIAAEGLimAiAAAPlcBBD7roB2ZBx4JQIgAAAABFiYJUIgAAQYiCESIAAEHGglIiAAABQYmKYCIAAEWJimgiAABBiZJYIgAASIPEEF3DzMzMzMzMzMzMzEiD7AhMiwX1fjkATGPRSYuAmCMAAPdAFAAAAAgPhSUBAABIiVwkEEgPv5gYAQAASIlsJBgz7UiJdCQgSIk8JEaNDBNFhcl4VE1jmIgVAABJY8lJO8t9RUiB+QEAAIB0PEmLgJAVAABIixTIQDiqAgEAAHQSSDuSEAQAAHUJ90IUAAACAHQKRQPKSQPKecTrDEljyUiLFMhIhdJ1dUmL+EWF0nkSRYuIiBUAAEGD6QFBi8F4eesFi8VEi81NY5iIFQAAi8hJO8t9ZEg7y3RfSYuAkBUAAEiLFMhAOKoCAQAAdBJIO5IQBAAAdQn3QhQAAAIAdApFA8pJA8p5yOsvSIuHkBUAAEljyUiLFMhIhdJ0HEmJkKAjAABJiZCYIwAASYmozCMAAEmJqMQjAABIizwkSIt0JCBIi1wkEEGIqLwjAABIi2wkGEiDxAjDzMzMzEiJXCQYVkFWQVdIg+wgSIs1m305AEUz/0iL2UiLhsAhAABIhcB0E0g7iBAEAAAPhFwBAABMi3BA6wNNi/cz0jPJ6AqX/v9Mix1jfTkARTh7fnQIQcaDtCEAAAFFi4sIIQAAZkHHg7UhAAABAUWFyQ+EyQAAAEiJfCRIQYv/SIlsJEBIhdt0d0WFyX5yTYuTECEAAEmL70mDwghmDx9EAABNOTp0SkmLkxAhAABEi8dIg8IISAPVSIsKSIXJdCNIi8NIOYsQBAAAdCVmDx9EAABIO8F0GkiLgAgEAABIhcB170H/wEiDwjhFO8F8yesU/8dIg8U4SYPCOEE7+XyiQTv5fTFB9oNUKgAACHQeSIXbdAZIi1MI6wdIjRUx4TcASI0NMuE3AOj13QAAM9KLz+hcsv//SItsJEBIi3wkSLoBAAAASIvL6OXA//9Ii57AIQAARDm7SAQAAHUKM9JIi8vo+9T//2aDu64BAAACdQrHhswhAAABAAAASItLQEk7znQOSIuG2AwAAEiFwHQC/9BIi1wkUEyJvpgjAABIg8QgQV9BXl7DzMzMzMzMzMzMzEBTVVZXQVRBVUFWQVdIg+xYSIs16Hs5AEUzyQ8pdCRASIv+RA8pTCQwTImMJLgAAACLhgghAACD6AFEiIwksAAAAHg7TIuGECEAAEhj0EmDwAhIa8o4TAPBDx+AAAAAAEmLKEiF7XQN90UUAAAACA+FyAAAAEmD6DhIg+oBeeFJi+lFD1fJTDmOoCMAAHRGTDmOmCMAAHU9RA8vjtQjAADzDxBGSPMPEI60IwAA8w9ZBRNCOADzD1zI80EPX8nzDxGOtCMAAHINRA8vyXIHTImOoCMAAL7/////SI0VmOM3AIveTI0N1lkKAEGwIw8fAEGA+CN1DEQ4AnUHRDhCAQ9E3g+2y0EPtsBED7YCSDPIwesISP/CQTMciUWEwHXRRItvMPfTSIs11Ho5AEH2xQJ0F/ZHNAF0EUG0AesPTImOmCMAAOk5////RTLkQYDlAUiF7XV+RIu3jCMAAEWF9nRyjUMBRIv7qf7///91B0SLvmwfAAD3hnAfAAAABAAAdVJFi8e6ASAAAEGLzuhPZP//hMB0N0WLx7ohIAAAQYvO6PuJ//+EwHQjQYHmAPAAAEGL10GLzug1if//SIs1Pno5AMaEJKAAAAAB6xVIizUtejkAMtKIlCSgAAAASIXtdXlEi7eQIwAARYX2dG2NQwFEi/up/v///3UHRIu+bB8AAPeGcB8AAAAEAAB1TUWLx7oBIAAAQYvO6MNj//+EwHQyRYvHuiEgAABBi87ob4n//4TAdB5BgeYA8AAAQYvXQYvO6KmI//9IizWyeTkAQbcB6wpIizWmeTkARTL/RYTkdGhIg7+YIwAAAHVejUMBRIvzqf7///91B0SLtmwfAAD3hnAfAAAABAAAdT5Fi8a6ACAAALl6AgAA6EJj//+EwHQhRYvGugAgAAC5egIAAOjsiP//hMB0C0iLNUF5OQCwAesJSIs1Nnk5ADLASIXtdQiEwHQEsQHrBzLJSIXtdSJIg7+YIwAAAEQPtrQkoAAAAHUYRYT2dQVFhP90DkGyAesMRA+2tCSgAAAARTLSQDLthMB0JcaHvCMAAAHHh8AjAAB6AgAAx4cAIgAAAwAAAMeHuCMAAAMAAACEyXUJRYTSD4QXAQAASIuHwCEAAEiFwHQbQDioAgEAAHQSSDuAEAQAAHUJ90AUAAACAHRjRIuHiBUAAEGD6AF4S0xjjogVAABJY8hJO8l9PEiB+QEAAIB0M0iLhpAVAABIixTIQDiqAgEAAHQWSDuSEAQAAHUN90IUAAACAA+ElQAAAEH/yEiD6QF5vzPASIXAD4SNAAAARYTSdQlAOK+KIwAAdBVIi4AQBAAASImHoCMAAEiJh5gjAABFM+RBD7bCg/ABTImnsCMAAIPAAkyJp8wjAABMOafAIQAATImnxCMAAEAPlMWJhwAiAACJh7gjAABFhPZ1BUWE/3Qqi4+QIwAAi9MLj4wjAACB4QDwAADooIb//+sPSWPISIsEyOlq////RTPkSIuHmCMAALkBAAAA8w8QNe89OABIhcB1DDiHvCMAAA+E+gAAAIO/uCMAAAMPhe0AAABIhcAPhI8AAADzDxBHSPMPWIewIwAA8w8Rh7AjAADzD1wFPz04APMPXgUXPTgARA8vyHYGQQ8oyesHDyjO8w9dyPMPEIe0IwAAi9HzD1/BRTPAuYICAADzDxGHtCMAAOiJZP//RTPAD7bYugEAAAC5gwIAAOh0ZP//D7bIi8MrwXQWQITtdRGLyOjf9///x4e0IwAAAACAP4C+4AgAAAB0CYC+hBwAAAB0Qw8vt7QjAAAPl8CEh7wjAAB0FEiDv8AhAAAAdBnGhCSwAAAAAesPSIuHmCMAAEiJhCS4AAAATImnmCMAAMaHvCMAAABIg7+YIwAAAA+EogAAAIO/uCMAAAIPhZUAAADzDxBHSLkA8AAA8w9Yh7AjAACLh4wjAAC6APAAAIXAD0XIi4eQIwAA8w8Rh7AjAACFwPMPXAUjPDgAD0XQI9GLyoHhAPAAAPMPXgXuOzgARA8vyHYGQQ8o8esE8w9d8PMPEIe0IwAA8w9fxvMPEYe0IwAARYT2dQVFhP90d0CE7XVyQQ+2zoPxAY0MTf/////o0Pb//0yLvCS4AAAASIuHwCEAAEUy9sdEJCARAgAAx0QkJBUCAABIhcB0dvdAFAAAAQB1bUiNXCQgRYTtdBWLKzPSi81BuP/////oBWP//4TAdSpIg8MESI1EJChIO9h12Os+i4c8AQAAI8IlAPAAADvBdJBMi7+YIwAA649BtgGJr8AjAABEiLe8IwAAx4cAIgAAAgAAAMeHuCMAAAIAAACAv7wjAAAAD4Q4AgAAg7+4IwAAAg+FKwIAAIO/GAwAAAC6mgIAAA+P7AAAAIC/OAEAAAAPhd8AAACAvzkBAAAAD4XSAAAAgL87AQAAAA+FxQAAAEWE9nUV8g8Qh6gWAABmDy5HGHoGD4SrAAAAi4/AIwAAgfkAAgAAfAiB+ZsCAAB8IIH5ABAAAHQYgfkAIAAAdBCB+QBAAAB0CIH5AIAAAHVsgL5kHwAAAHQUg75MFgAA/3QLjYEA/v//g/h3dlj3wQDwAAB0NoH5ABAAAHUHuZcCAADrJ4H5ACAAAHUHuZgCAADrGIH5AEAAAHUHuZkCAADrCYH5AIAAAA9EykhjwUiNDECDvI7E/v///3UJg77wHQAA/3QHxoe8IwAAAIuPwCMAAIvB98EA8AAAdDaB+QAQAAB1B7iXAgAA6yeB+QAgAAB1B7iYAgAA6xiB+QBAAAB1B7iZAgAA6wmB+QCAAAAPRMJIY9BIgersAQAASAPSRA8vTNYID4ewAAAAgDzWAA+FpgAAADPS6ESB//+EwA+ElwAAADiXvCMAAA+EiwAAADmXTBYAAHQIOJdZFgAAdHtIjYf0CgAASIXAdQdIjYYYAQAA8w8QAPMPEA3lOjgADy/B8w8QUARyCQ8v0XIEsQHrAjLJSI2HGAEAAEiFwHUHSI2GGAEAAPMPEAAPL8HzDxBQBHIJDy/RcgSwAesCMsCLlCSwAAAAOsEPttK4AQAAAA9E0ImUJLAAAACLj8AjAAAz0uj4X///hMB1BoiXvCMAAEiLh5gjAABIhcAPhFwBAAD2QBQED4VSAQAAi4cAIgAAQQ8o0UEPKNmD+AJ1K4C/OQEAAAB1R/MPEJZsAQAA8w8QnowBAADzD1yWXAEAAPMPXJ58AQAA6yWD+AN1IPMPEJbcCQAA8w8QnvwJAADzD1yWzAkAAPMPXJ7sCQAAQQ8u0XoOdQxBDy7ZegYPhNsAAADzDxBPQA9X9vMPEEdID1ft8w9dT0TzD1kFdDk4AMaHtSEAAAHzD1nI8w9Z0fMPWdnzD1iXxCMAAPMPWJ/IIwAA8w8swvMPEZfEIwAA8w8Rn8gjAADzDyrw8w8sw0EPLvHzDyroegp1CEEPLul6AnRrSIuHmCMAAEiNlCSgAAAADyjGDyjNQbgBAAAASIuIIAQAAPMPWEFY8w9YSVzzDxGEJKAAAADzDxGMJKQAAADomkj///MPEIfIIwAA8w8Qp8QjAADzD1zF8w9c5vMPEYfIIwAA8w8Rp8QjAABNhf90CEmLz+jF8///gLwksAAAAAAPhM4AAABIg7/AIQAAAA+EwAAAADPSM8no8Ir+/0iLn8AhAABIjYsABAAASIM5AHQo9oOsAQAAAnUfi0MUJQAAABU9AAAAAXUQSIsZSI2LAAQAAEiDOQB12EiLt8AhAABIO950ETPSSIvL6H61//9IibNABAAASIuHwCEAAPaArAEAAAJ0C4uPzCEAAIPxAesDQYvMO4/MIQAAdDiD+QF1EUiDu8AEAAAAdQdEiaBMBAAA6LbI//9IiwWvcDkAgHh+AHQHxoC0IQAAAWbHgLUhAAABAQ8odCRARA8oTCQwSIPEWEFfQV5BXUFcX15dW8PMzMzMzMzMzMzMzMzMQFVIg+xQSIstY3A5APMPEAVLNjgADy+FsCMAAA+H3gIAAEiLhUAhAAAz0kiJdCRwDyl0JEAPKXwkMEiLCEiJfCR48w8QURDzDxBJFIONACAAABDzD1kVDTY4APMPWQ0FNjgA8w8RlUggAADzDxGNTCAAAMeFUCAAAP//f3/HhVQgAAD//39/SImVWCAAAEiJlWAgAABIjVQkIPMPEFEQ8w8QSRTzD1kV6DU4AMdEJCACAAAA8w9ZDdg1OADzD1hRCPMPWEkMg40AIAAAAUiNjbggAADHhRwgAAAAAAA/8w8RlRQgAADHhSAgAAAAAAA/8w8RjRggAADHhQQgAAABAAAAxoVEIAAAAfMPELWkDQAA8w8QvagNAADzDxF0JCTzDxF8JCjopuMAAPMPWPYz0vMPWP9BuEcTAwBIjQ3f1zcA8w8RtaQNAADzDxG9qA0AAOjKDP//gH0gAEiNVSBIi4XYFQAADyh8JDAPKHQkQEiLPfpuOQBIiYWoIwAAdFRIi4fYFQAAxoADAQAAAUiLh9gVAACAuAYBAAAAdTZMi8JIg/r/cx5BD7YIhMl0FkmNQAGA+SN1BDgIdAlMi8BIg/j/cuIPV9votDgDAEiLPZ1uOQCLhYgVAACD6AFIY/APiAIBAABIiVwkaGYPH0QAAEiLhZAVAABIixzwgLsCAQAAAA+E0AAAAEg7mxAEAAAPhcMAAAD3QxQAAAIAD4W2AAAATItTCEmLykmD+v9zI5APthGE0nQWSI1BAYD6I3UEOBB0CUiLyEiD+P9y40w70XVci0MUD7rgGnMJSIuHkCkAAOs8D7rgCnMcSI0Vj9Y3AEmLyugJzAcAhcB1CUiLh4gpAADrGkiDu8AEAAAAdAlMjRV51jcA6xVIi4eYKQAASIXATI0VBr03AEwPRdBIOZ2YIwAATI1MJGBJi8pIx0QkYAAAAAAPlMJFM8DobwoEAEiLPZhtOQBIg+4BD4kO////SItcJGjopD///7kBAAAA6Oox/v9Ii3wkeEiLdCRwSIPEUF3DzMzMzMzMzMzMzEBTSIPsIEiLHVNtOQCAu9gjAAAAdBX2g1QqAAACdAxIjQ0C1jcA6KXOAAAzycaD2CMAAABIiYv0IwAAD1fASImL6CMAADPAiYvwIwAADxGDACQAAA8RgxAkAABmiYMgJAAAx4P8IwAA/////4iDIiQAAImLUCQAAEiJi1wkAABIjYtwJAAAx4NYJAAA//9/f8eDZCQAAP/////oMQj+/w9XwA8Rg4AkAABIg8QgW8PMSIlcJAhIiWwkEEiJdCQYV0iD7CBIix2VbDkAi7uwHwAASIuT2BUAAIX/D4QmAQAAObtMFgAAD4UaAQAAD76DXxYAADPJPP+L8A9E8UxjxkE4jBggAQAAD4T5AAAAOIoGAQAAD4XtAAAAiItZFgAAQoC8AyABAAAASGOKQAEAAEiLgkgBAACLbIj8SIvLdQQy0usc8w8Qi6QAAADzQg8QhIP8CwAA8w9ZyQ8vwQ+TwoC5EiIAAADHgWAfAAAPAAAAD5XAxoFkHwAAAYiBESIAAGbHgVAiAAAAAITSdHmAu9gjAAAAdVXoZf7///aDVCoAAAJ0FUyNBWVDCgCL10iNDZzUNwDoF80AAIm79CMAAImr+CMAAMaD2CMAAAHHg9wjAADlAAAAibPkIwAAO7tMFgAAdQfGg1oWAAABi0MEg6O4HwAA/omD4CMAALABxoPZIwAAAesCMsBIi1wkMEiLbCQ4SIt0JEBIg8QgX8PMzMxIiVwkCEiJdCQQV0iD7CBIizUqazkASIv6QbggAAAASI0Vqr83AEiNjgAkAAD/Fc0XCABIjY5wJAAAxoYgJAAAADPS6NjkAABIjY6AJAAAD1fADxEBSImO6CMAAEiLB0iJAceG8CMAAAgAAACLRgSJhvwjAACLRgSLjmQkAAA7yHQY/8g7yHQSMsBIi1wkMEiLdCQ4SIPEIF/DSItcJDCwAUiLdCQ4SIPEIF/DzMzMzEiJXCQIV0iD7CBIix1/ajkAg7v8IwAA/w+E+QAAAEiNkwAkAABIjQ30vjcA6HHIBwCFwA+F3gAAAA8QkygkAACLi0gkAACLk2AkAAAPKNoPKMIPxtr/DyjKD8bCVQ/GyqrzD1zY8w9cyvMPWdkPL5tYJAAAD4edAAAAO9HzDxGbWCQAAMeDUCQAAAAMAAAPlMCJi1wkAACIgyEkAAD2g9wjAAAQi0MEiYNkJAAAdE6Du+QjAAD/dUU70XUIOYPgIwAAfEwzwIiDIiQAAITAdBv2g1QqAAACdBKLk0gkAABIjQ3q0jcA6BXLAABIjYPoIwAASItcJDBIg8QgX8M70XXDi4vkIwAA6LRY//+EwHW0uAEAAADrr0iLXCQwM8BIg8QgX8PMzMzMzMzMzMzMzMxIiVwkEEiJbCQYSIl0JCBXSIPsIEiDudgpAAAASI2Z4CkAAEmL8EiL6kiL+XR6RItLBEyJdCQwRTP2RYXJeRxBi8GZK8JBi9bR+EKNDAiFyQ9P0UiLy+jV5QAATIvGRIkzSIvVSIvL6OQn/v+LA0iNDddoOQBMi4/YKQAAhcCNUP9Ii4foKQAAQQ9E1kiFwExjwroBAAAASA9FyP8VJxUIAEyLdCQw6whIi8vooCf+/0iLXCQ4SItsJEBIi3QkSEiDxCBfw8zMzMzMzMzMzMzMSIlMJAhIiVQkEEyJRCQYTIlMJCBIg+woSIsFcWg5AIC4yCkAAAB0EEiL0UyNRCQ4SIvI6Pj+//9Ig8Qow8zMzEiJXCQISIlsJBBIiXQkGFdBVEFVQVZBV0iD7EAPKXQkMEmL+PMPEDWILjgASIvqTIvpRTPkZmZmDx+EAAAAAABIizUJaDkASIue8CkAAEyLvvgpAABMi7bYFQAATImm+CkAAEyJpvApAABIhf91JkiL/UiD/f9zHQ+2D4TJdBZIjUcBgPkjdQQ4CHQJSIv4SIP4/3LjSY1FBE2F7XQh8w8QjgAqAADzD1iO4A0AAPMPEADzD1jODy/BdgSxAesHMslNhe10H4sAiYYAKgAAhMl0E0iNDffQNwDo4v7//8aGySkAAAFIhdt0IUjHwP////9EOGQDAUiNQAF19UyNBBhIi9NJi83o9f7//0GLhtgBAACLjgQqAAA7yH4IiYYEKgAAi8hFi7bYAQAARCvxZpBMi8e6CgAAAEwrxUiLzehrwwcASIXASIvfSA9F2Eg763UFSDvfdGFEi8tCjRS1AAAAAEQrzUQ4pskpAAB1BboBAAAATI0Fhj4KAEiJbCQgSI0NUtA3AOg1/v//RIimySkAAIA7CnUTSI0NMtA3AOgd/v//xobJKQAAAUg733QJSI1rAel4////TYX/dB5Ix8D/////RThkBwFIjUABdfVKjTw4SYvv6WX+//9Ii1wkcEiLbCR4SIu0JIAAAAAPKHQkMEiDxEBBX0FeQV1BXF/DSIsNSWY5AIC5yCkAAAB1WUiLgdgVAAAz0saBShYAAAHGgcgpAAABx4HMKQAACAAAAEiJgdApAABIiZH4KQAASImR8CkAAIuA2AEAAImBBCoAAImRCCoAAMeBACoAAP//f3/GgckpAAABw8zMzMzMzEiJXCQQSIlsJBhIiXQkIFdIg+wgSIsdxWU5ADPtQDirACkAAA+FsgAAAEiLS1BIhckPhJ4AAABMjUQkMEiJbCQw6OoZ/v9Ii/BIhcAPhIMAAABIi1QkMEiF0nQISIvI6LwBAABMiwV1ZTkATYXAdFxJD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJaQRm/0EGQf+AGCsAAEiLzv8VQxAIAMaDACkAAAHzDxCDBCkAAA9XyQ8vwXZ/8w9cQ0gPL8jzDxGDBCkAAHJtSIt7UEiF/3RXSIsF0mQ5AEiNTCQwSIlsJDCJqAQpAADoTQMAAEiNFUrONwBIi89Ii/DoSxf+/0iL+EiFwHQoTItEJDBMi8i6AQAAAEiLzv8V9RAIAEiLz/8V9BAIAOsHxoPsAAAAAYmrBCkAAEiLXCQ4SItsJEBIi3QkSEiDxCBfw0iD7AhED7YJTI1BAUyLFU1kOQBBu/////9Bi8NFhMl0QkiJHCRIjR30QgoADx9AAEGA+SN1DUU4CHUIRThIAUEPRMMPttBBD7bJRQ+2CEgz0cHoCEn/wDMEk0WEyXXRSIscJEljihgpAAD30E2LgiApAABIjRTJSY0M0Ew7wXQPQTlACHQQSYPASEw7wXXxM8BIg8QIw0mLwEiDxAjDzMxIiVQkEEiJTCQIU1VWV0FUQVVBVkFXSIPsKEyLJZ9jOQBMi/pIi+lIhdJ1FknHx/////9J/8dBgDwPAHX2TIl8JHhBi4wkDCkAAEGNXwE72X4ohcl0C4vBmSvC0fgDwesFuAgAAAA7w0mNjCQIKQAAi9MPT9DoFuAAAEGJnCQIKQAATYvHTYu0JBApAABIi9VJi85MibQkiAAAAEuNND7ogL8HAMYGAEmLnCQgKQAASWOEJBgpAABIjQzASI08y0g733QaSItDGEiFwHQISIvTSYvM/9BIg8NISDvfdeZFM+1Ji85MO/YPg/sAAABFi/0PtgE8CnQEPA11BUj/wevwSIvZSDvOcxMPtgM8CnQMPA10CEj/w0g73nLtxgMAD7YBPDsPhKAAAAA8Ww+FfAAAAEg72XZ3gHv/XUiNe/91bUiNaQHGBwBMi8dIi81MK8W6XQAAAOjEvgcATIvwSIXAdGdIjUgBulsAAABIK/lMi8foqL4HAEiL+EiFwHRLSIvNQcYGAOjW/f//TIvoSIXAdBZMi0ggTI1HAUiL0EmLzEH/0UyL+OshRTP/6xxNhe10F02F/3QSSYtFKEyLyUmLzE2Lx0mL1f/QSI1LAUg7zg+CGv///0yLfCR4SItsJHBMi7QkiAAAAE2Lx0HGhCQAKQAAAUiL1UmLzuglvgcASYucJCApAABJY4QkGCkAAEiNDMBIjTzLSDvfdB4PH0AASItDMEiFwHQISIvTSYvM/9BIg8NISDvfdeZIg8QoQV9BXkFdQVxfXl1bw8zMzMzMSIlcJAhIiWwkEEiJdCQYV0FWQVdIg+wgSIs1UWE5AEUz/0yL8UiNvggpAABEib4EKQAARItHBEWFwHkcQYvAmSvCQYvX0fhCjQwAhckPT9FIi8/o6N0AAESJP0Q5fwR1DboIAAAASIvP6NLdAABIYw9Ii0cIRIg8Af8HSIueICkAAEhjhhgpAABIjQzASI0sy0g73XQiZmYPH4QAAAAAAEiLQzhMi8dIi9NIi87/0EiDw0hIO9116E2F9nQRiweFwI1I/0EPRM9IY8FJiQZIi44QKQAASI0FgGA5AEiLXCRASIXJSItsJEhIi3QkUEgPRcFIg8QgQV9BXl/DzMzMzEiJXCQISIlsJBhWV0FUQVZBV0iD7CBIizVTYDkASIvZgL66AAAAAHUyD7YRSI1BAYTSdCdIi8iA+iN1FTgQdRE4UAF1DA+2EUiNWP9I/8Dr4w+2EEj/wITSddlJx8T/////SYv8SP/HgDw7AHX3SIHGKCkAAESNdyxBg+b8TGM+i04EQ40sPjvpfiOFyXQLi8GZK8LR+APB6wW4CAAAADvFi9VIi84PT9DoktwAAIkuSItGCEWJNAdIi3YISIPGBEkD93QUD1fAM8APEQYPEUYQiUYgZkSJZhxFM8BIi9dIi8voeRH+/0yNRwGJBkiNTiRIi9Po27sHAEiLXCRQSIvGSItsJGBIg8QgQV9BXkFcX17DzMzMzMzMzMzMzMzMzEiLgYAVAABIY5F4FQAATI0E0Ek7wHQWSIsQSIPACMeCFAMAAP////9JO8B16kiBwSgpAADph/r9/8zMzMzMzMxAU0iD7FBNi9BBuP////9Bi9hFD7YKSY1SAUWEyXQ3TI0dqj0KAEGA+SN1DUQ4CnUIRDhKAUEPRNgPtstBD7bBRA+2CkgzyMHrCEj/wkEzHItFhMl10EyLDbNeOQAzwPfTTYuBMCkAAE2FwEmNSARID0XBSIXAdC05GHUGgHghAHQlSGNQ/EljiSgpAABIA9BIg8EEM8BJA8hIO9FID0XCSIXAddMzwEiFwHQvD1fAuf////8PEQAz0g8RRCQwZolMJDwPEEQkMA8RQBCJUCCJGMZAIAFIg8RQW8NJi8rovf3//4kYxkAgAUiDxFBbw8xIiVwkCEiJfCQQVUiL7EiD7EBIiwVHQjkASDPESIlF8EmL+UiNFY7HNwBJi9hMjU3kSIvPTI1F4OiT+v3/g/gCdRsPt0XgZolF6A+3ReRmiUXqi0XoiUME6UwBAABMjU3kSIvPTI1F4EiNFVnHNwDoXPr9/4P4AnUbD7dF4GaJRegPt0XkZolF6otF6IlDCOkVAQAATI1F7EiLz0iNFTbHNwDoKfr9/4P4AXULi0XsiUMQ6fIAAABMjU3kSIvPTI1F4EiNFSfHNwDoAvr9/4P4AnUbD7dF4GaJRegPt0XkZolF6otF6IlDDOm7AAAATI1F6EiLz0iNFQzHNwDoz/n9/4P4AXUPg33oAA+VwIhDHumUAAAATI1F6EiLz0iNFfXGNwDoqPn9/4P4AXUMg33oAA+VwIhDH+twTI1N6EiLz0yNRexIjRXdxjcA6ID5/f+D+AJ1EItF7IlDFA+3RehmiUMc60RMjUXsSIvPSI0VxcY3AOhY+f3/g/gBdQ6LReyJQxRmx0Mc///rHkyNRexIi89IjRWvxjcA6DL5/f+D+AF1BotF7IlDGEiLTfBIM8zoO6cHAEiLXCRQSIt8JFhIg8RAXcPMzMzMzMzMzMzMzEiJXCQQV0iD7CBIi5EwKQAAM9tIhdJIi/lIjUIESA9F2EiF23RjSIl0JDBIizUeXDkAgHsgAHQiixNIjY64FQAA6GoX/v9IhcB0C0iL00iLyOiax/7/xkMgAExjQ/xIi5cwKQAATAPDSGOPKCkAAEiDwgQz20gD0Uw7wkkPRdhIhdt1rkiLdCQwSItcJDhIg8QgX8PMzMzMzMzMzMzMzMxIiVwkEFVWV0FWQVdIg+wgSIuxgBUAAEmL+EhjgXgVAABMi/pMi/FIjSzGSDv1D4RhAQAATIsNdVs5AA8fRAAASIse90MUAAEAAA+FOAEAAEhjgxQDAACD+P90DEyLwE0DgTApAADrUU2LkTApAABFM8BNhdJJjUIETA9FwE2FwHQ0RItbEEU5GHUHQYB4IQB0J0ljUPxJY4koKQAASQPQSIPBBEUzwEkDykg70UwPRcJNhcB10EUzwE2FwHUiSItLCOh5+v//TIsN4lo5AIvIQSuOMCkAAEyLwImLFAMAAPMPEENY8w8QS1zzD1xDTPMPXEtQ8w8syPMPLMFmiUwkUGaJRCRSi0QkUEGJQATzDyxDaGaJRCRg8w8sQ2xmiUQkYotEJGBBiUAIi0NIQYlAEPMPLENMZolEJGjzDyxDUGaJRCRqi0QkaEGJQAyLg8gEAABBiUAUi0MgQYlAGA+3g44EAABmQYlAHA+2gwQBAABBiEAeSDmbEAQAAEHGQCEAD5XAQYhAH0iDxghIO/UPhav+//9EiwdBi4YoKQAAQY1Q/40MQAPJA9FFhcAPRNFIi8/oyNYAAEmLjjApAAAz20iFyUiNQQRID0XYSIXbD4TUAQAAgHshAA+FnAEAAE2LB0yNSyRIjRX7wzcASIvP6HsY/v+Aex8AdC1IjRX2wzcASIvP6GYY/v9ED79LCkiNFfLDNwBED79DCEiLz+hNGP7/6e4AAACLQxCFwHQzPRERERF0LEQPv0sOSI0V1sM3AEQPv0MMSIvP6CEY/v9Ei0MQSI0V1sM3AEiLz+gOGP7/D79DBGaFwHUPZjlDBnUJgXsQEREREXUXRA+/SwZIjRXCwzcARIvASIvP6N8X/v8Pv0MIZoXAdQZmOUMKdBdED79LCkiNFVzDNwBEi8BIi8/ouRf+/0QPtkMeSI0VlcM3AEiLz+ilF/7/RItDFEWFwHRCD79DHEiLz2aD+P91DkiNFYDDNwDogxf+/+sPRIvISI0Vf8M3AOhyF/7/RItDGEWFwHQPSI0VgsM3AEiLz+haF/7/iwe9AQAAAItXBIXAD0XojXUBO/J8DwPSSIvPO/IPT9boRdUAAItPBDvxfiOFyXQLi8GZK8LR+APB6wW4CAAAADvGi9ZIi88PT9DoG9UAAIk3SItHCEhjzcZECP8KSItHCMYEAQBMY0P8SYuWMCkAAEwDw0ljjigpAABIg8IEM9tIA9FMO8JJD0XYSIXbD4Us/v//SItcJFhIg8QgQV9BXl9eXcPMzMzMzMxIiVwkCEiJdCQQV0iD7EBMi1lATIvKSIs901c5AEiL2Q8pdCQwDyl8JCBMO9oPhH8CAACLQgQPuuALD4NyAgAAD7rgDA+CaAIAAPMPEEII8w8QeVgPKMgPL/jzDxBaDA8o7/MPEHFcDyjT8w9YShDzD1hSFPMPWGlgDyjm8w9YYWQPgisCAAAPL/MPgiICAAAPL80PghkCAAAPL9QPghACAACAv4UAAAAAdQn3QSwAAgAAdC/3h8QSAAAABAAAdCP2gY0EAAABdRqLQRSpAAAAE3UQJQAAAAw9AAAABA+FzwEAAEyLl0AhAABIY4c4IQAASY00wkw71g+E6gAAAGaQSYsSSTvRD4TPAAAASTvTD4TGAAAA8w8QSgwPKMHzD1hCFA8vxg+GsAAAAA8v4Q+GpwAAAPMPEEoIDyjB8w9YQhAPL8cPhpEAAAAPL+kPhogAAABEi0c0QYHgACAAAHQgSIvKSItBOEiLyEiFwHQLSTvBde9IjUo46x9IjUo46wpMOUo4SI1KOHQPQYuBgAAAADmCgAAAAH5CTYXbD4QQAQAARYXAdBxIi8pmDx9EAABIi0E4SIvISIXAdAxJO8N17+sYTDkZdBNBi4OAAAAAOYKAAAAAD47XAAAASYPCCEw71g+FGP///zP2SI2LAAEAAEA4swABAAAPhIwAAABIjYsAAQAAi9Y5t3gVAAB+ZESLxg8fQABmZg8fhAAAAAAASIuHgBUAAEmLDABIi0FASTvDdSpAOLEAAQAAdApIOUhwdQRIiXAQTIlJQEGLAYlBSEk5SXAPlMCIgQABAAD/wkmDwAg7l3gVAAB8tEiNiwABAABAOLMAAQAAdA5Ii0NASDlYcHUESIlwEEyJS0BBiwGJQ0hJOVlwD5TA90MUACAAAIgBdQhIi8voEpn//7AB6wIywEiLXCRQSIt0JFgPKHQkMA8ofCQgSIPEQF/DzMxAU0iD7DBIiwUTVTkASIvZ8w8QEvMPEEoE80EPEBgPKOlIi4iAFQAA8w9c2kSLkMQSAABEi5jIEgAAQYHiAAQAAPNBDxBgBEGB4wAEAABIY4B4FQAA8w9c4fIPEALzQQ9YaQQPKXQkIA8o8vNBD1gxTI0EwfIPEQQkSTvID4QhAgAASItUJGDzDxBUJAQPKXwkEPMPEDwkSIsBRTvTdVxIOVhAD4XoAQAA80EPEAEPLgJ6EHUO80EPEEEEDy5CBHoCdDjzDxBIWA8vz/MPEEBcD4K7AQAADy/CD4KyAQAA8w9YSGAPL/EPgqQBAADzD1hAZA8v6A+ClgEAAA8oww8ozPMPWEBY8w9YSFzzDxFAWA8ow/MPWICwAgAA8w8RSFwPKMzzD1iItAIAAPMPEYCwAgAADyjD8w9YgLgCAADzDxGItAIAAA8ozPMPWIi8AgAA8w8RgLgCAAAPKMPzD1iAYAIAAPMPEYi8AgAADyjM8w9YiGQCAADzDxGAYAIAAA8ow/MPWIBoAgAA8w8RiGQCAAAPKMzzD1iIbAIAAPMPEYBoAgAADyjD8w9YgHACAADzDxGIbAIAAA8ozPMPWIh0AgAA8w8RgHACAAAPKMPzD1iAeAIAAPMPEYh0AgAADyjM8w9YiHwCAADzDxGAeAIAAA8ow/MPWIBQAQAA8w8RiHwCAAAPKMzzD1iIVAEAAPMPEYBQAQAADyjD8w9YgGABAADzDxGIVAEAAA8ozPMPWIhkAQAA8w8RgGABAAAPKMPzD1iAaAEAAPMPEYhkAQAADyjM8w9YiGwBAADzDxGAaAEAAA8ow/MPWIBwAQAA8w8RiGwBAAAPKMzzD1iIdAEAAPMPEYBwAQAA8w8RiHQBAABIg8EISTvID4X5/f//Dyh8JBAPKHQkIEiDxDBbw8zMSIsFaVI5AEUzwEyLyUiLkEAhAABIY4A4IQAATI0Uwkk70nRfSIsK90EEgBAAAHVK8w8QSQjzQQ8QEQ8v0XI780EPEFkE8w8QQQwPL9hyK/MPWEkQDy/KdiHzD1hBFA8vw3YXTYXAdA+LgYAAAABBOYCAAAAAfQNMi8FIg8IISTvSdaFJi8DDzMzMzMzMzMzMTIvcU1VBVUiB7LAAAABIiwULNjkASDPESIlEJGhIix28UTkAM+1JiXMISYl7EE2JYxiLg8QSAABNiXPgJQAEAABNiXvYQQ8pe7gPV/+JRCQwD4RJAgAASIuzQCEAAESL9UhjgzghAABMjSTGSTv0D4QrAgAAZmZmDx+EAAAAAABIiz5Ii4PoDAAARA+2f2hIhcB0HkWE/3QZSIvP/9CLTwSEwHQGD7rpDOsED7rxDIlPBEiLg+AMAABIhcB0IUWE/3QcSIvP/9CLTwSEwHQJD7rpDUyL9+sED7rxDYlPBEiDxghJO/R1mE2F9g+ErwEAAEWLBouTYCEAAEE70A+EbgEAAPeDVCoAAAAIAAB0IkmLRnBIhcB0BkyLSAjrB0yNDa+7NwBIjQ20uzcA6B+yAABMiwWoUDkASYuIQCEAAEljgDghAABIjRTBSDvKdCZEi4tgIQAAZmYPH4QAAAAAAEiLAUQ5CA+EfwAAAEiDwQhIO8p167EBi4OwIQAAQTmGgAAAAHQP/8CJg7AhAABBiYaAAAAAQYsGiYNgIQAASIvFQjisACABAAAPhcIAAABI/8BIg/gFfOmEyQ+FsQAAAEA4q4kAAAAPhKQAAABIi4vAIQAAQQ+2hqAAAABIhcl0G0w5cUB1FbEB6xNAOGhoD4SA////Msnpe////zLJCsFJi05wQYiGoAAAAEiFyXVXhMB0UUGLgIgVAACD6AF4QEhj0EmLgJAVAABMjQTQZpBJiwhIhcl0HkA4qQIBAAB0FUw5cUB1D4tBFCUAAgEAPQACAQB1EUmD6AhIg+oBedBIi83rAjPJugMAAADo75P//0iLg8AhAABIhcB0Ckw5cEB1BLAB6wIywEGIhqAAAABMjaNAIQAASYsEJEyLKOsZTI2jQCEAAEmLBCRMiyhMiWwkSDlsJDB0SEiLg7gMAABIjUwkSEmL1f/QQfdFBAAQAADyDxBLOPIPEUwkQPIPEADyDxFEJDhMiWwkSHQy8kEPEEUI8kEPEE0QTIlsJEjrE/IPEEs4SI1EJDhIiWwkOPIPEADyDxFMJEDyDxFEJDhMjUwkQMdEJCAECAAATI1EJDi6ERERETPJ6KIHAACL9YmrABMAAEiJq0ghAABIiatQIQAAOas4IQAAD470AgAARItsJDBMi/1EDylEJHDzRA8QBc0UOAAPKbQkkAAAAJBJiwQkSYs8B4l3eIX2fh6LQwSD6AI5R3x9E0iLz+hOCwAA/85Jg+8I6YICAABED7Z3aEWF7Q+EqQAAAPdHBAAQAAAPhZwAAABFhPYPhJMAAABAOG9pdDRIi4O4DAAASI1MJDhIi9f/0PMPEADzDxBIBPMPEYcoAQAA8w8RjywBAADzDxFHCPMPEU8MQDhvanQ0SIuDyAwAAEiNTCRASIvX/9DzDxAA8w8QSATzDxGHMAEAAPMPEY80AQAA8w8RRxDzDxFPFEiLg9AMAABIhcB0E0iL10iNTCRQ/9DyDxAA8g8RRxhIi8/opBQAAA8Qh1ABAABIia9YAQAASImvUAEAAA8Rh0ABAABIi4MoDQAASIXAdBtFhPZ0FkiL10iNTCRY/9APEEQkWA8Rh1ABAAD3RwQACAAASI1HEPMPEF8ITI1HCPMPEGcMSI2XiAAAAA8oww8ozPMPWIdAAQAA8w9Yj0QBAAAPKNfzDxFHIPMPEEAE8w8RTyTzD1yHRAEAAPMPEAjzD1yPQAEAAPMPXIdMAQAA8w9cj0gBAADHh5gAAAAAAIA/8w9f0A8ox/MPX8HzDxFXLPMPEUco8w9cGvMPXGIEdCIPLt96CXUHDy7negJ0FEyNj5AAAABIiUQkIEiLz+hZ9///SIuDGA0AAEiFwHQPRYT2dApIi8//0A8o8Os0SA+/h6IAAABmg/j/dBZIjQxASIuDaA0AAEgDyfMPEHTIIOsQ8w8QdzAPLvd6BnUEQQ8o8PMPEEcwDy7HegJ0aA8u8HoCdGEPKO7zD17oQDiriwAAAHRRSItPcEiFyXQKDyjN6JZ5/v/rPkiLBe1LOQBMi4CAFQAASGOAeBUAAE2NDMBNO8F0IGYPH0QAAEmLCEg5eUB1CA8ozehfef7/SYPACE07wXXm8w8RdzD/xkmDxwg7szghAAAPjD/9//9EDyhEJHAPKLQkkAAAAEyLbCRIx4OYIQAA//9/f0iNi6QhAADHg5whAAD//39/x4OgIQAA//9//8cB//9//w8ovCSAAAAATIu8JKAAAABMi7QkqAAAAEyLpCTgAAAASIu8JNgAAABIi7Qk0AAAADmrYA0AAA+FLAEAAPJBDxBFCEiL0fIPEYNoIQAA8kEPEE0Q8g8Ri3AhAADyQQ8QRSDyDxGDeCEAAPJBDxBNKPIPEYuAIQAAQYtFMImDiCEAAPMPEIt4IQAA8w8Qg5ghAAAPL8F2D/MPEYuYIQAASI2TpCEAAPMPEIt8IQAASIvB8w8Qg5whAAAPL8F2C/MPEYucIQAASIvC8w8Qg3ghAAAPL4OgIQAAdgvzDxGDoCEAAEiLyPMPEIN8IQAADy8BdgTzDxEB8w8Qk3ghAABIi8HzD1iTgCEAAPMPEIOYIQAA8w8Qi4QhAADzD1iLfCEAAA8vwnYP8w8Rk5ghAABIjYOkIQAA8w8Qg5whAAAPL8F2C/MPEYucIQAASIvIDy+ToCEAAHYI8w8Rk6AhAAAPLwl2LfMPEQnrJ0iLg2gNAAAPEAAPEYNoIQAADxBIEA8Ri3ghAAAPEEAgDxGDiCEAAEiLi2gNAABIY4NgDQAASI0UQEjB4gRIA9FIO8oPhM0AAADzDxBJEPMPEIOYIQAADy/BdgjzDxGLmCEAAPMPEEkU8w8Qg5whAAAPL8F2CPMPEYucIQAA8w8QQRAPL4OgIQAAdgjzDxGDoCEAAPMPEEEUDy+DpCEAAHYI8w8Rg6QhAADzDxBRGPMPWFEQ8w8Qg5ghAADzDxBJHPMPWEkUDy/CdgjzDxGTmCEAAPMPEIOcIQAADy/BdgjzDxGLnCEAAA8vk6AhAAB2CPMPEZOgIQAADy+LpCEAAHYI8w8Ri6QhAABIg8EwSDvKD4Uz////OWwkMHUMTImrUCEAAOmsAQAA90M0ABAAAA+ExAAAAESLgzQBAABFhcB0WUiLBbFIOQBIi5BAIQAASGOAOCEAAEyNDMJJO9F0EUiLCkQ5AXQMSIPCCEk70XXvSIvNSIXJD4QBAQAA9kEEgA+E9wAAAEiNixgBAADo9/X//0iLyOnjAAAASI2TWCEAAEiLzUiLwkiLAEiFwHUNSIuDQCEAAEiLAEiJAkiLk/gVAABIhdJ0CUiLUkBIhdJ1A0iL0EiJk1AhAABAOKvYIwAAD4SzAAAASIXJD4XRAAAASIvI6cQAAABIiwX5RzkASIvNTIuAQCEAAEhjgDghAABNjQzATTvBdGNJixD3QgSAEAAAdU7zDxBKCPMPEJMYAQAADy/R8w8QQgxyN/MPEJscAQAADy/YcirzD1hKEA8vynYg8w9YQhQPL8N2FkiFyXQOi4KAAAAAOYGAAAAAfQNIi8pJg8AITTvBdZ1IjZNYIQAASIvCSIXJD4QX////SIkKSIvB6SH///85q0wWAAB0GkiLBU9HOQCAvCggAQAAAHUgSP/FSIP9BXztSIXJdBJIO8p0DfZBBIB1B0iJi1AhAABIi0wkaEgzzOjokQcASIHEsAAAAEFdXVvDzMzMzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0FUQVVBVkFXSIPsUEiLBR0rOQBIM8RIiUQkQE2L6U2L4ESL+kiL6UiLNcJGOQCLvCSgAAAAg88BSIXJdECLURSLyoHhAAIBAEiLhvgVAABIhcB0D0g5qCAEAAB1BoHPoAAAAIvHD7roB4H5AAIBAA9Fx4v4D7riDHMDg88gSIuOQCEAAEhjhjghAABIjRTBSDvKdBVIixlEOTsPhDkBAABIg8EISDvKdeu5YAEAAP8VXPEHAEyLyEyLBTJGOQAz202FwHRcRYtQBEkPv5AcKwAASY2IICsAAEiNDNFEORF0NY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkRiVkEZv9BBEH/gBQrAABMiUwkMEiNRCQgSIlEJDhMiUwkKE2FyXQLSYvJ6F7j/f9Ii9hEiTtMjbY4IQAAQYsGiUN48kEPEAwk8w8Ri4gAAAAPKMEPxsBV8w8Rg4wAAADzDxFLCPMPEUMM8kEPEFUA8w8Rk5AAAAAPKMIPxsBV8w8Rg5QAAADzDxFTEPMPEUMUiXsESIvL6HIMAABFi0YEQYsOQTvID4W3AAAA/8FFhcAPhJgAAABBi8CZK8LR+EEDwOmNAAAASIXbD4TH/v//8w8QUwjzDxBLDPMPEGMQ8w8QWxSAe2kAdAiBOxERERF1CvJBDxAA8g8RQwiAe2oAdAiBOxERERF1CvJBDxAB8g8RQxCBYwQAMAAACXsEDy5TCHoedRwPLksMehZ1FA8uYxB6DnUMDy5bFHoGD4QCAQAASIvL6MQLAADp9QAAALgIAAAAO8EPT8iL0UmLzuh7vQAASWMOSYtGCEiJHMhB/wb/hqghAAD3hlQqAAAACAAAdCFIhe10BkyLRQjrB0yNBemoNwBBi9dIjQ2XrzcA6KqlAADzDxCGQBMAAPMPXUMI8w8RhkATAADzDxCGRBMAAPMPXUMM8w8RhkQTAADzDxBLEPMPWEsI8w8QhkgTAADzD1/B8w8RhkgTAADzDxBLFPMPWEsM8w8QhkwTAADzD1/B8w8RhkwTAABIiw3NQzkASA+/k6IAAABmhdJ4GTuRYA0AAH0RSI0EUkjB4ARIA4FoDQAA6wdIjYFoIQAAi0AgiUMwSIlrcItGBIlDfPMPEJtAAQAA8w8Qi0QBAADzD1hLDA8ow/MPWEMI8w8RQyDzDxFLJPMPEEMU8w9cg0QBAADzD1yDTAEAAA9XyQ9X0vMPX9DzDxBDEPMPXMPzD1yDSAEAAPMPX8jzDxFLKPMPEVMsSIvDSIXtdAfGhQABAAABSItMJEBIM8zo340HAEyNXCRQSYtbMEmLazhJi3NASYvjQV9BXkFdQVxfw8xIiVwkCEiJdCQQV0iD7CBIiz3aQjkASIvZM/ZIi4eAFQAASGOXeBUAAEiNDNBIO8F0HUiLEEg5WkB1C0iJckBAiLIAAQAASIPACEg7wXXjSDufWCEAAHUHSIm3WCEAAPeHVCoAAAAIAAB0JEiLQ3BIhcB0BkyLQAjrB0yNBWOtNwCLE0iNDeatNwDo0aMAAEiLy+g5CwAASGNTeEiLh0AhAABMY4c4IQAATCvCSI0M0EiNUQhOjQTF+P///+jtnwcA/484IQAASIvL6GHh/f9MiwUaQjkATYXAdFxJD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJcQRm/0EGQf+AGCsAAEiLy0iLXCQwSIt0JDhIg8QgX0j/JdjsBwBAU1VWQVRBV0iD7FBMix2NQTkASIvZRIt5FEmL68dBVP////9B94PEEgAAAAQAAEmLg0AhAABMiyB1PoC5AAEAAAB0EEiLQUBIOUhwdQYz9kiJcBBMiWFAQYsEJIlBSEk5XCRwD5TAiIEAAQAASIPEUEFfQVxeXVvDSIm8JIgAAAAz9kyJrCSQAAAARYvvTIm0JJgAAAAPKXQkQMaBAAEAAABBgeUAAAAGdBBAOLEIAQAAdAdIiXFAiXFIQfeDACAAAAAIAAAPha4AAABIOXFAD4WkAAAASIuBAAQAAEiFwHQfQDiwCgEAAHQJQDiwAgEAAHQNSItAQEiJQUBIhcB1eYtRSIXSdHJJi4tAIQAASWODOCEAAEyNBMFJO8h0FZBIiwE5EA+ErwAAAEiDwQhJO8h17EiJc0DzDxBDTEyNQ0zzDxANowc4AA8uwXoCdCrzDxBDUA8uwXoCdB6LUxBMjUtgSIvLiXQkIOgx+f//TIsdKkA5AEiJQ0DzDxA1ogc4AEUy9veFACAAAAAIAAAPhI8AAABJi4tAIQAASWODOCEAAEyNBMFJO8h0FouFbCAAAEiLETkCdC9Ig8EISTvIdfBIjXtASIk3i4VsIAAAiUNIQbYB6ZUBAABIiUNASIXAdZfpUP///0iJU0BIjXtAi4VsIAAAiUNISIXSdNT3QxQAAIAAdMtIOXJwdMVIiVpwQbYBi0sQSIsHiUtIiQjpSwEAAEH3xwAAABEPhSwBAABIi4O4BAAASIXAdBxIi4CIAAAASIXAdBBIi0BASI17QEiJB+kWAQAAQQ+65xlzE0iLhVAhAABIjXtASIkH6fwAAABBOLOFAAAAdQn3QywAAgAAdDJB94PEEgAAAAQAAHQl9oONBAAAAXUci0MUqQAAABN1EiUAAAAMPQAAAAR0BkiNe0DrREiLhfgVAABIhcB0W0g5mCAEAAB1UvNBDxCDGAEAAA8vxvNBDxCLHAEAAHI7Dy/OcjZIi0NASI17QEiFwHR6SDlYcHV0i1MQTI1LYEyNQ1iJdCQgSIvL6I73//9Mix2HPjkASIkH61FIi0NASI17QEiFwHRESDtYcHU+ObVMFgAAdAlAOLVZFgAAdC1Ji5NAIQAASIvLSIsS6Fzm//9Mix1FPjkA6xJIi4MABAAASI17QEiLSEBIiQ9IOTd1MEmL1EiLy+gx5v//hMB1GotTEEyNS2BMjUNYiXQkIEiLy+gG9///SIkHTIsd/D05AEWE9kyLtCSYAAAAD4UfAgAARYXtD4QvAQAAQQ+65xlzCUiNhRgBAADrHIuFGCEAAP/ISJhIa8g4SIuFICEAAEiDwCxIA8HyDxAA8g8RRCQwQDi1tCEAAHQWQDi1tSEAAHQNSDm1wCEAAHQEMtLrArIB8w8QRCQwDy/Gcg/zDxBEJDQPL8ZyBLEB6wIyyUA4swgBAAB1CUH3xwAAABJ0CITSdCiEyXUTSItDQA+/sKIAAACJc1TpdgEAAPIPEABIjUQkOPIPEUQkOOsKSI1MJDDoB5f//0lji2ANAACFyX5c8w8QIEyLwUmLi2gNAABIi9ZmZmYPH4QAAAAAAPMPEAEPL+DzDxBZBA8oyPMPWEkIDyjT8w9YUQxyFPMPEEAEDy/DcgoPL8x2BQ8v0HcT/8ZI/8JIg8EwSTvQfMC+/////4lzVOnnAAAASIsPSIXJD4TFAAAATItJcEk72Q+EuAAAAE2FyQ+ErwAAAEEPuucYD4KkAAAASDmzuAQAAA+FlwAAAA+2k40EAACA4gX3QxQAAIAAdE2LRQQ5QXx9RYD6AXRA94VUKgAAAAgAAHQXRIsBSI0N66c3AE2LSQhIi1MI6KadAABIi0NASIlYcItDEEiLS0CJAUiLQ0CJsIQAAADrTUmLk0AhAABIi8tIixLoF+T//4TAdTeLUxBMjUtgTI1DWMdEJCAgAAAASIvL6Oj0//9IiUNA6xY5c1R9EUEPuucYcgoPv4GiAAAAiUNUSItLQA8odCRATIusJJAAAABIi7wkiAAAAEg7WXAPlMCIgwABAACLAYlDSEiDxFBBX0FcXl1bw8zMzMzMSIlcJAhIiXQkEFdIg+wgSIs9ejs5AEiL2UiLSUBIi/Iy0g9X2zhRaXQn90MUAAEAAPIPEEEI8g8RQ1h1Kg8vnwQpAAByIYtHTImHBCkAAOsWSItBCEg7Q1h0DPIPEENYsgHyDxFBCEiLS0CAeWoAdDv3QxQAAQAA8w8QQRDzDxBJFPMPEUNo8w8RS2zzDxFDYPMPEUtkdSoPL58EKQAAciGLR0yJhwQpAADrFkiLQRBIO0NgdAzyDxBDYLIB8g8RQRBIi0NA8w8QkEABAADzDxCIRAEAAA8owvMPWEAI8w9YSAzzDxFAIPMPEEAU8w8RSCQPV8nzD1yARAEAAPMPXIBMAQAA8w9fyPMPEEAQ8w9cwvMPXIBIAQAA8w8RSCzzD1/Y8w8RWCiE0nQJSItLQOiLAQAARItTFEWLykyLW0BBgeEAAAAIRYvCQYHgAAAAFkGLSwSB4ef6//+L0Q+66gpBD7riGQ9D0YC/hgAAAAB1B4vKRYXAdAqLykWFyXUDg8kQgL+HAAAAAHUKRYXAdBWDyQjrCIPJCEWFwHQIRYXJdQODyWCLQyyL0AvRhcCLQzAPRNGFwHQE99Aj0IvKD7rpCEH2woAPRcpBiUsEi1Mkg/r/dFlIi0NAi0g0iVA0TItTQEWLSjREO8kPhLwAAABIi49AIQAASGOHOCEAAEyNBMFJO8h0EUiLEUQ5CnQLSIPBCEk7yHXvM9JJiVI4SItcJDBIi3QkOEiDxCBfw0H3wgAAAAZ0QEiF9nQ7gL4KAQAAAHQJgL4CAQAAAHQpSItLQEiLRkBIiUE4SItGQEiLS0CLAIlBNEiLXCQwSIt0JDhIg8QgX8Mz0jiXiAAAAHQEi8rrCkiLh0AhAABIiwhIi0NASIlIOLkREREROJeIAAAASItDQA9FyolINEiLXCQwSIt0JDhIg8QgX8PMzMxIg+x4TIsdxTg5AEyLyQ8pfCRQRA8pRCRARA8pTCQw80QPEEkMRYuTYA0AAEUPKMFEDylUJCDzRA8QUQhBDyj68w9YeRDzRA9YQRRBg/oBfxBBjUL/ZomBogAAAOkkAQAADyl0JGBFM8DzDxA1I/43AEEPKMBEDylcJBDzQQ9cwUQPKSQkQYvQRA8o50GLyPNFD1zi80QPWeDzRA9ZJVL+NwDzRA9fJYn+NwAPH0QAAEQPL+ZEDyjeD4avAAAASYuDaA0AAPMPEAQBRA8v0PMPEEwBBA8o6PMPWGwBCA8o0fMPWFQBDHIVRA8vyXIPDy/vcgpBDy/QD4OkAAAAQQ8vyXYFDyjh6wgPKOLzQQ9d4UEPL8J2BQ8o2OsIDyjd80EPXdpBDy/IdwgPKMrzQQ9dyA8vx3cHDyjF8w9dx/MPXMPzD1zM8w9ZwQ8v8HcDDyjwRA8v2IvCQQ9HwP/CSIPBMESLwEE70g+MQ////2ZFiYGiAAAARA8oXCQQDyh0JGBEDygkJA8ofCRQRA8oRCRARA8oTCQwRA8oVCQgSIPEeMNmQYmRogAAAOvKzMzMzMxIiVwkCFdIg+wggHloAEiL2UiLPQg3OQB0XveHVCoAAAAIAAB0JEiLQXBIhcB0BkyLQAjrB0yNBdihNwCLEUiNDcOiNwDoRpgAAEiLh0ANAABIhcB0BUiLy//QSIuHoAwAAEiFwHQFSIvL/9CBOxERERF0BMZDaAAzwEiJQ1hIiUNQSIlDSGaJQ2mIQ2tIi1wkMEiDxCBfw8zMzMzMzMzMM9JIiVEwSIlROEiJUUhIiVFQSIlRWA9XwA8RQWQPEUF0x0Fo/////8aBgQAAAAFIiRFIiVEMiVEISIlRKEiJUSBIiVEYSIlRQMdBYP////+JURTHgYQAAAD/////SImRkAAAAEiJkYgAAABIiZGgAAAASImRmAAAAImRqAAAAEjHgbAAAAD/////x4GsAAAA/////0iJkbgAAABIiZHAAAAAi4HIAAAAJQn+//+DyAmJgcgAAACAoc0AAAD4xoHMAAAAAUiJkegAAABIiZHwAAAASImR+AAAAEiJkQABAABIiZEIAQAASImREAEAAEiJkRgBAABIiZEgAQAASImRKAEAAEiJkTABAACJkdAAAABIiZHYAAAAx4HgAAAA/////4mR5AAAAMeB6AAAAP//f3/HgewAAAD//39/x4HwAAAA//9//8eB9AAAAP//f//HgfgAAAD//39/x4H8AAAA//9/f8eBAAEAAP//f//HgQQBAAD//3//x4EIAQAA//9/f8eBDAEAAP//f3/HgRABAAD//3//x4EUAQAA//9//8eBGAEAAP//f3/HgRwBAAD//39/x4EgAQAA//9//8eBJAEAAP//f//HgSgBAAD//39/x4EsAQAA//9/f8eBMAEAAP//f//HgTQBAAD//3//SIvBw8zMzMzMzMzMzMzMzMxIi8RWQVRBVkiB7IAAAABFM+RIi/FFi/REOaHAKAAAD474AQAASIl44EyJeNhFi/xEDylAqEUPV8BIiVgQSIloGA8pcMgPKXi4Dx+AAAAAAEiLhsgoAABJi3wHCEiF/w+EegEAAItGBDmHsAAAAA+FawEAAA+2h8wAAACoAQ+EXAEAAEiLl4gAAABIhdIPhEwBAABMOWcgD4VCAQAAqAQPhToBAADzDxCetA4AAPMPEEdMSIsFxzM5AA8o+PMPEGdI8w8QSlgPKPTzD1h3UPMPEKjgDQAA80EPWODzDxBSXPMPWO3zD1h/VPMPEXQkOPMPEWQkMPMPWKjwEgAA8w8RfCQ88w9Y6A8ow/MPWMHzD1hKYPMPEWwkNA8vxPMPXMsPKMPzD1jC8w9YUmQPk8EPL/HzD1zTQQ+TwA8vxUEPk8IPL/pBD5PBRYTSdAuEyXQHuBAAAADrCEGLxEWE0nQKuyAAAABFhMB1A0GL3AvYRYTJdBiEyXQFg8tA6wVFhMl0Cr2AAQAARYTAdQW9AAEAAEiLkhgDAABFM8BIjYqIAAAA6LlrAQBIi4+IAAAATI1EJDhEi4+EAAAASI1UJDAL3YlcJCjzDxCBkAAAAEiLiRgDAADzDxFEJCDoEWEBAEH/xkmDxxBEO7bAKAAAD4xd/v//RA8oRCRADyh8JFAPKHQkYEyLfCRwSIt8JHhIi6wksAAAAEiLnCSoAAAASIHEgAAAAEFeQVxew8zMzMzMzEiJXCQYVVZXSIPsIEiNscAoAACL+kiL6YXSdSW/AQAAAEiLzovX6IXt/f9IhcB0Ef/HSIvOi9fodO39/0iFwHXv94VUKgAAAAQAAHQOi9dIjQ1SnjcA6GWTAAC50AAAAP8VCt0HAEyLBeMxOQBFM9JIi9hNhcB0ZEkPv5AcKwAASY2IICsAAEWLSARIjQzRRDkJdDaNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJCUSJUQRm/0EESI21wCgAAEH/gBQrAABIhdsPhMYAAABMiVMwD1fATIlTOEyJU0hMiVNQTIlTWA8RQ2QPEUN0x0No/////8aDgQAAAAGJO0yJUwxMiVMETIlTKEyJUyCLg8gAAAAlCf7//0yJUxiDyAlMiVNAgKPNAAAA+ImDyAAAAMdDYP////9EiVMUx4OEAAAA/////0yJk5AAAABMiZOIAAAATImToAAAAEyJk5gAAABEiZOoAAAASMeDsAAAAP/////Hg6wAAAD/////TImTuAAAAEyJk8AAAADGg8wAAAAB6wNJi9qLE0yLw0iLzujV7f3/SIvDSItcJFBIg8QgX15dw8zMzMzMSIlcJAhIiWwkEEiJdCQYSIl8JCBBVkiD7CD3gVQqAAAABAAAQQ+28EiL2kiL+XQOixJIjQ3HnDcA6LKRAABIi4OIAAAARTP2SIXAdAdMibDABAAASItTGECE9nQfSIXSdD5Mi0IgTDvDdQRMi0IoSIvP6LlhAADprwAAAEiF0nQfuCAAAABIg/gwfRRIORwCdQhIi0sYTIk0CEiDwAjr5osTSI2PwCgAAEUzwOgP7f3/SIvL6IcTAABMiwXALzkATYXAdF1JD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ2jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQlEiXEEZv9BBkH/gBgrAABIi8v/FY3aBwBIi1wkMEiLbCQ4SIt0JEBIi3wkSEiDxCBBXsPMzMzMzMzMzMzMSIsCRTPJTIsRRYvBSItIGEiFyXQXZmZmDx+EAAAAAABIi0kYQf/ASIXJdfRJi0oYSIXJdBdmZmYPH4QAAAAAAEiLSRhB/8FIhcl19EUrwUGLwMPMzMzMzMzMzMzMzMzMSIlcJBBIiXQkGEiJfCQgVUFUQVVBVkFXSIvsSIPscEiLBeoSOQBIM8RIiUX4TIvhSIlNwEUz9kyJddBFi+5MiXXYTIl14EyJdehMiXXwSGOZ4CgAAEiL+0jB5wSF234hSIvP6PhQ/v9Mi+hIiUXYiV3USIvP6OZQ/v9IiUXoiV3kRYv+QYuMJOAoAAC+/////4XJD47dAQAATYvmSItFwEiLsOgoAABJA/SLHr//////RIvHi9NIjU3g6OHo/f87x3QTSJhIweAESQPFdAhEiTbpfgEAAItWBIXSdClEi8dIjU3g6Lfo/f87x3QLSJhIweAESQPF6wNJi8ZIhcB0BkSLcAzrA0SL84vTSI1N4Oic6f3/SIvISGMAO8d0DUjB4ARMi23YSQPF63hIY0XwiQFIi/iLXdA7w3U7/8OLTdQ72X4nhcl0C4vBmSvC0fgDwesFuAgAAACL0zvDD0/QSI1N0OhorgAAi0XwiV3Q/8BMi23Y6wxIA8BMi23YQYtExQCJRfBIi89IA8lIjQTNAAAAAEkDxXQIM8lIiUgEiQj/RfREiXAMi1YEhdIPhJ8AAABIjU3g6PXo/f9Ii8hIYwCD+P90DUjB4ARMi23YSQPF63tIY0XwiQFIi/iLXdA7w3U7/8OLTdQ72X4nhcl0C4vBmSvC0fgDwesFuAgAAACL0zvDD0/QSI1N0OjArQAAi0XwiV3Q/8BMi23Y6wxIA8BMi23YQYtExQCJRfBIi89IA8lIjQTNAAAAAEkDxXQLM8lIiUgEiQiJSAz/RfT/QAhFM/ZB/8dJg8QkSItFwIuI4CgAAEQ7+Q+MMv7//0yL4L7/////QYvehckPjq8AAABJi/4PH0AADx+EAAAAAABJi4Qk6CgAAESLTDgIRYXJdHpMix0nLDkATYuTMCkAAEmNQgRNi8ZNhdJMD0XATYXAdFlFOQh1B0GAeCEAdCZJY1D8SQPQSWOLKCkAAEiDwQRJA8pNi8ZIO9FMD0XCTYXAddDrJ0GLUBSF0nQfRIvGSI1N4OiX5v3/g/j/dA5ImEjB4ARJA8V0A/9ACP/DSIPHJEE7nCTgKAAAD4xg////SYuMJDApAABIjUEESYveSIXJSA9F2EiF2w+EhwAAAJCLexSF/3RORIvGi9dIjU3g6Dvm/f+D+P90O0iYSMHgBEkDxXQw/wCLUAw713QkRIvGSI1N4OgW5v3/g/j/dAtImEjB4ARJA8XrA0mLxkiFwHQD/0AETGND/EwDw0ljjCQoKQAASYuUJDApAABIg8IESAPRSYveTDvCSQ9F2EiF2w+Fev///0SJdchBg7wk4CgAAAAPjssCAABJi85IiU24TYukJOgoAABMA+FFizwkRIvGQYvXSI1N4OiS5f3/g/j/D4R3AgAASGPYSMHjBEkD3Q+EZwIAAESLM0GD/gEPj1wDAACLUwxEO/p1BUiL++sfRIvGSI1N4OhT5f3/g/j/dAxIY/hIwecESQP96wIz/0GLdCQEhfZ0IkG4/////4vWSI1N4Ogm5f3/g/j/dAxIY9BIweIESQPV6wIz0kGD/gF1KYX2dSU5cwh1IEH3RCQUAAgAAHUVQYvGRTP2SIX/dCSDfwQAdB4yyescM8BFhfZ150Uz9oX2deM5Qwh13rgBAAAA69exAQrID4SwAAAASItFwPeAVCoAAAAEAAB0D0GL10iNDX6WNwDoQYsAAEyLHcopOQBFi9ZJi4swKQAASI1BBE2LzkiFyUwPRchNhckPhF4BAABmDx+EAAAAAABJi8ZBi0kUQTsMhHQLSP/ASIP4AXzx6xhFiXEUZkHHQRz//0H/wkGD+gEPjSUBAABNY0H8TQPBSWOLKCkAAEmLkzApAABIg8IESAPRTYvOTDvCTQ9FyE2FyXWl6fUAAABIhdIPhPAAAACDeggBD4XmAAAASItFwPeAVCoAAAAEAAB0EkSLxkGL10iNDQCWNwDoe4oAAEGLfCQEQYs0JEiLHfsoOQD3g1QqAAAABAAAdBFEi8eL1kiNDbOZNwDoTooAAEGL1oO7eBUAAAB+NE2LxkiLg4AVAABJiwwAObHIBAAAdRBIg7m4BAAAAHUGibnIBAAA/8JJg8AIO5N4FQAAfM9Ii4swKQAASI1BBE2LzkiFyUwPRchNhcl0OQ8fQABBOXEUdQRBiXkUTWNB/E0DwUhjiygpAABIi5MwKQAASIPCBEgD0U2Lzkw7wk0PRchNhcl1y0WJNCS+/////4tFyP/AiUXISItNuEiDwSRIiU24TItlwEE7hCTgKAAAD4w8/f//SI1N4OiDw/3/TItN2E2FyQ+EgQAAAEjHRdAAAAAATIsF9yc5AE2FwHRgRYtQBEkPv5AcKwAASY2IICsAAEiNDNFEORF0OY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkRx0EEAAAAAGb/QQZB/4AYKwAASYvJ/xXB0gcATIl12EjHRfAAAAAASI1N4OiUkAAASI1N0OiLkAAAkEiLTfhIM8zoLnIHAEyNXCRwSYtbOEmLc0BJi3tISYvjQV9BXkFdQVxdw0Uz9un2/v//zMzMzMzMzMxFhcAPjjwCAABMi9xVQVZIg+xYSIsFVgs5AEgzxEiJRCQ4SYlbGEiL6UmJe+hIjXoYTYlj4EyNJbQFCgBNiXvYQb//////SYlzIE1j8A8fAItf6IXbD4SpAQAAi9NIjY3AKAAA6Cfi/f9IhcB0I/eFVCoAAAAEAAAPhIYBAACL00iNDemTNwDoFIgAAOlzAQAAi9NIi83oRfT//4tX7EiL2IXSdBFIjY3AKAAA6N/h/f9Ii8jrAjPJSIlLGA+/RwJmD27ID78HD1vJZg9uwPMPEUtMD1vA8w8RQ0gPv0cGZg9u0A+/RwQPW9JmD27AD1vA8w8RU1TzDxFDUA+/RwpmD27ID79HCIGjyAAAAEn+//+Di8gAAABJD1vJZg9uwPMPEUtcD1vA8w8RQ1hIhcl0GEiDeSAAdQZIiVkg6wtIg3koAHUESIlZKItH9EyLy4mDvAAAAA++R/iJQ2CLT/yLQwyB4SD8AwALQwQLwYlLCIlDEEiLQxhIhcB0EA8fQABMi8hIi0AYSIXAdfRFiwlMjQWykTcAuhQAAABIjUwkIOhb1f3/RA+2TCQgTI1EJCFBi9dFhMl0MEGA+SN1DUU4CHUIRThIAUEPRNcPtspBD7bBRQ+2CEgzyMHqCEn/wEEzFIxFhMl10EiLDUElOQD30kiBwbgVAADok+D9/0iJg4gAAABIg8ckSYPuAQ+FPv7//0yLfCRATItkJEhIi3wkUEiLtCSIAAAASIucJIAAAABIi0wkOEgzzOjCbwcASIPEWEFeXcPMzMzMzMzMzMzMSIlcJBBIiWwkGFZIg+wgSIuZgBUAAEiL8UhjgXgVAABIjSzDSDvddFNIiXwkMGaQSIs7i5fIBAAAhdJ0MYtGBP/IOYfYAgAAfCRIg7+4BAAAAHUaSI2OwCgAAOjg3/3/QbABSIvXSIvI6HIJAABIg8MISDvddblIi3wkMEiLXCQ4SItsJEBIg8QgXsPMzMzMSIvESIPsWEiJWBBIi1oISIlwGEiJePhIi3oQTIlg8EyJaOhMi+lMiXDgTIvyTIl42IuBVCoAAEyLehglAAQAAE2F/3R0hcB0NItCIEiF23QGTItDCOsHTI0FVoE3AEiF/3QEixfrAjPSTYtPCEiNDWyRNwCJRCQg6EOFAABJi7fABAAASceHwAQAAAAAAABIhfZ0HEUz5Ew5ZiB1QEiLRkBEi2AkRYXkdTNEi2Ag6y1Fi6fAAAAA6ySFwHQbSIX/dASLF+sCM9JFi0YgSI0NbZE3AOjohAAARTPkM/ZIhf91TzPSSYvN6BTx///yDxBDWEiL+PIPEUBI8g8QS2DyDxFIUEiDu8AEAAAAdSRBsAFIi9NIi8joNQgAAEiLT0BIi1EQgWIE//9//4CLjQQAAAFBi0Ygg/j/dFe7AQAAADvDdgVEi8PrB0UzwIXAdAeD+AJ0AjPb80EPEEYkRIvLSIl0JChIi9dJi83zDxFEJCDo+1EAAIvDSIPwAUiLTMcgSIuHiAAAAEiL+UiJgYgAAACBZwj/3///i0cMC0cEC0cIiUcQSDv+D4SdAQAAi0cwhcB+PkiDf0AAdTdIi8/o3TcAAItHMEUz9oXAfiUz25BMi0c4M9JIi09ATYsEGOid/AMAi0cwSI1bCEH/xkQ78HzeSIX2D4QfAQAASIN+IAAPhO4AAACFwH4mSIueoAAAAEiLz0iL0+g0DAAASIvXSIvL6CkMAACLE4sP6NByAAD3RxAACAAAdGWLlrgAAABJjY3AKAAA6GXd/f9Mi8BIi9BIi0gYSIXJdBJmDx9EAABIi9FIi0kYSIXJdfSBSAgACAAAi0AMQQtABEELQAhBiUAQi08Ii0cMD7rxCwtHBAvBiU8IiUcQTImCmAAAAEiLTiBIiU8gSItGKEiJRyhIhcl0BEiJeRhIi0coSIXAdARIiXgYi0ZgQbABiUdgSIvW8g8QRlhJi83yDxFHWEjHRigAAAAASMdGIAAAAADo3vD//+tdix5Ii9ZIi8/oTwsAAIsXi8vo9nEAAEGwAUiL1kmLzei48P//6zdNhf90MkGLn8gEAABBsAFJi9dMib+QAAAASIvP6BUGAACF23QSixeLy+i4cQAA6weAj80AAAACSItHQEyLfCQwTIt0JDhMi2wkQEiLfCRQSIt0JHBIi1wkaEiFwHQERIlgJEiLDc0gOQAPV8BMi2QkSA8vgQQpAAByCYtBTImBBCkAAEiDxFjDzMzMzMzMzMzMzMzMzMxIiVwkCFdIg+wg94FUKgAAAAQAAEiL2kEPtvh0E0iLUghIjQ2ojjcARIvH6OCBAABIi4u4BAAASIXJdCdAhP90DzPASIvTRIvA6LIHAADrG4uDyAQAAEiL00SLwOifBwAA6wgzwImDyAQAAICjjQQAAPhIi1NASIsNIyA5AMaDBAEAAABIhdJ1D/MPEENo8w8QS2zpowAAAPeBxBIAAAAEAADzDxBCKPMPEBVJ5jcA8w9ZwvMPLMDzDxBCLPMPWcJmD27Y8w8swA9b22YPbuAPW+R0VUgPv5KiAAAAZoXSeBk7kWANAAB9EUiNFFJIweIESAORaA0AAOsHSI2RaCEAAPMPEEIY8w8QShzzD1nC8w9ZyvMPLMBmD27Y8w8swQ9b22YPbuAPW+TzDxBDaPMPEEts8w9dw/MPXczzDxFDaPMPEUNgD1fA8w8RS2zzDxFLZA8vgQQpAAByCYtBTImBBCkAAEiLXCQwSIPEIF/DzEiD7Dj3gVQqAAAABAAASIlcJEBIi9lIiXQkUEiJfCQwSIv6TIl0JChMiXwkIHQOixJIjQ2IjTcA6GOAAABIi1cYRTP/SIXSdFf3RxAACAAAdU5IOXogQbkgAAAAQYvBQbgoAAAAQQ9FwEiLy0UPRcFMiTwQSItXGE2LBBDoX1AAAEiLTxiLgcgAAAAlv/7//w+66AeJgcgAAABMiX8Y60Iz0kiLy+g27P//8g8QR0hIi9dIi8hIi9jyDxFASPIPEE9Q8g8RSFDyDxBHWPIPEUBY6FoIAACLE4sP6AFvAABIi/tIi3c4SGNHMEyNNMZJO/YPhM4AAABIiWwkSA8fQABIix6BYxT////+SIurAAQAAEiF7XRPSIuV8AEAAExjhegBAABIi8JKjQzCSDvRczVIORh0C0iDwAhIO8Fy8uslSCvCSMH4A0wrwEiNDMJOjQTF+P///0iNUQjoj3sHAP+N6AEAAEiNgzAEAABMibsABAAASIkYSImbKAQAAEiJmyAEAABIiZsYBAAASImbEAQAAPdDHAABAAB0GA8fRAAASIubAAQAAEiJGPdDHAABAAB17UiDxghJO/YPhUD///9Ii2wkSIOnyAAAAMmDj8gAAAAJSItHOEyLfCQgTIt0JChIi3QkUEiLCEiLXCRASItRQEiLDTcdOQBIhdJ1D/MPEEdQ8w8QT1TpowAAAPeBxBIAAAAEAADzDxBCKPMPEBVk4zcA8w9ZwvMPLMDzDxBCLPMPWcJmD27Y8w8swA9b22YPbuAPW+R0VUgPv5KiAAAAZoXSeBk7kWANAAB9EUiNFFJIweIESAORaA0AAOsHSI2RaCEAAPMPEEIY8w8QShzzD1nC8w9ZyvMPLMBmD27Y8w8swQ9b22YPbuAPW+TzDxBHUPMPEE9U8w9dw/MPXcyAj80AAAAB8w8RR1APV8DzDxFPVA8vgQQpAABIi3wkMHIJi0FMiYEEKQAASIPEOMPpCwAAAMzMzMzMzMzMzMzMSIlcJAhIiXQkEFdIg+wgSIvZSIt5QDP2SIX/D4SGAAAASI2PoAAAAOgzhQAASI1PCOgqhQAATIsFAxw5AE2FwHRcRYtIBEkPv5AcKwAASY2IICsAAEiNDNFEOQl0NY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkJiXEEZv9BBkH/gBgrAABIi8//FdHGBwBIiXNASIlzKEiJcyBMi0s4TYXJdHNMiwV9GzkATYXAdF1Fi1AETQ+/mBwrAABJjZAgKwAASo0U2kQ5EnQ2QY1LAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkSiXIEZv9CBkH/gBgrAABJi8n/FUrGBwCQSItcJDBIi3QkOEiDxCBfw8xIiVwkGEiJbCQgVldBVkiD7CBIiz3nGjkASIvZSIuKuAQAAEEPtvBIi+pIhcl0CEUzwOgpAgAA94dUKgAAAAQAAHQSTItFCEiNDXqJNwCLE+gbfAAASIO7iAAAAAB1L4N7MAF1KUiLQzhIiwiAuQIBAAAAdRmAuQEBAAAAxoEJAQAAAQ+UwP7AiIEjAQAAi0s0RItDMEQ7wXUqQf/Ahcl0C4vBmSvC0fgDwesFuAgAAABBO8BIjUswRA9PwEGL0Og8kwAASGNLMEiLQzhIiSzI/0MwgIvNAAAAAkiJnbgEAACLA4mFyAQAAIN7MAEPtoWNBAAAD5/BJP4KyIDh94iNjQQAAEiDu4gAAAAAdUxIg3sYAHVF90MQAAQAAHU8i4PIAAAAqAd1DIPg+oPIAomDyAAAAKg4dQyD4NeDyBCJg8gAAACpwAEAAHUPJb/+//8PuugHiYPIAAAAQIT2dGZIg3tAAHVOSIvL6OIuAABIi0tAM/aLg7wAAACJQSRIi0tAi0EkiUEgi0Mw/8iFwH4kM/9Mi0M4M9JIi0tATosEB+iL8wMAi0MwSI1/CP/I/8Y78HzeSItLQEyLxboAAIAA6GvzAwCLSxCLwUiLUyDB6QvB6AqD4QGD4AFIg3sYAA9EyIN7MAC4AQAAAA9PyEiF0nQIhILMAAAAdQIzwAvISItDKEiFwHQN9oDMAAAAAXQEsAHrAjLAgKPMAAAA/grICIvMAAAATIuDiAAAAE2FwHQPi1UUSIvND7rqGOgvtf7/SItcJFBIi2wkWEiDxCBBXl9ew8zMzMzMzMzMzMzMzEiJXCQYSIlsJCBWV0FWSIPsIEiLLYcYOQBBi/BIi9pIi/n3hVQqAAAABAAAdBJMi0IIixFIjQ1lhzcA6NB5AACAo40EAAD2RTP2gWMU/////omzyAQAAEiLswAEAABMibO4BAAASIX2dE9Ii5bwAQAATGOG6AEAAEiLwkqNDMJIO9FzNUg5GHQLSIPACEg7wXLy6yVIK8JIwfgDTCvASI0Mwk6NBMX4////SI1RCOirdQcA/47oAQAATImzAAQAAEiJmzAEAABIiZsoBAAASImbIAQAAEiJmxgEAABIiZsQBAAA90McAAEAAHQbSIvDkEiLgAAEAABIiYMwBAAA90AcAAEAAHXpSIuHiAAAAEiFwHQfRDiwAAEAAHQWTIlzQESJc0hEiLMAAQAAxoMJAQAAAUhjVzBBi8aF0n44TItHOEmLyEg5GXQM/8BIg8EIO8J88esgSJhJjQzATIvCTCvASI1RCE6NBMX4////6Ox0BwD/TzBIOZ+QAAAAdQdMibeQAAAAgI/NAAAAAkiLT0BIhcl0J4uTwAAAAOgg8gMAi0cQJQAIAAD32BvAg8ACOUcwfQhIi8/oBC0AAItXMIXSdSyLRxAPuuALciMPuuAKch2LBzmDyAQAAHQTQbABSIvXSIvN6Dbm///pkwAAAESLwoP6AXUu90cQAAgAAHUlTIuPiAAAAE2FyXQZSItHOEiLCEEPtoEEAQAAiIEEAQAARItHMItPELoBAAAAi8HB6QvB6AqD4QGD4AFMOXcYD0TISItHIEWFwA9PykiFwHQIhJDMAAAAdQKL0UiLRyhIhcB0DfaAzAAAAAF0BLAB6wIywICnzAAAAP4KwgiHzAAAAEiLXCRQSItsJFhIg8QgQV5fXsPMzMzMzMzMzMzMzEiJXCQISIlsJBBIiXQkGFdBVEFVQVZBV0iD7CBIi0JASI15QEUz5EiL8kiL6UiFwHQRTDkndQxIiQdBtwFMiWJA6wNFM/9Ii1o4SGNCMEyNNMNJO950M0EPtv9AgPcBkEiLE0QPtsdIi82Aoo0EAAD+TImiuAQAAOiD+v//SIPDCEk73nXaSI19QEiNTjDo3bD9/0WE/w+FswAAAEiLRkBIhcAPhKYAAABIiw9Ihcl0BotAIIlBIEiLXkBIhdsPhIsAAABIjYugAAAA6FB+AABIjUsI6Ed+AABMiwUgFTkATYXAdF1JD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ2jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQlEiWEEZv9BBkH/gBgrAABIi8v/Fe2/BwBMiWZASItcJFBIi2wkWEiLdCRgSIPEIEFfQV5BXUFcX8PMzMzMSIlcJAhIiWwkEEiJdCQYV0iD7CBIjWoQSIv6SIv1SIvZg3swAH4QSIN/CAB1BEiJXwj/BkiL7vdDEAAIAAB0A0iJH4N9AAF+BkiDPwB1GkiLSyBIhcl0CEiL1+ig////SItbKEiF23W4SItcJDBIi2wkOEiLdCRASIPEIF/DzMxIiVwkGFVWV0iD7CBIi0EYSI15BEiLLfUTOQBIi9lIhcB0BYtABIkHgKHMAAAA30iLSSBIhcl0BejD////SItLKEiFyXQF6LX///+LUzAz9kyJdCRIx0MMAAAAAIXSD47KAAAARTP2Zg8fhAAAAAAASItDOESLg7AAAACLTQRB/8BJizwGRDvBdRCLh9gCAAD/wDvBfQSyAesHMtJEO8F1K/aDzAAAAEB1DouHwAAAADmDwAAAAHUUgL8MAQAAAHQL90cUAAAEAHUCsgEPto+NBAAAD7bBwOgDJAEKwnQ0gOH3iI+NBAAAi0Mwg/gBdQ33QxAACAAAD4TYAAAARIsDSIvXSIvL6GX6////zkmD7gjrBotHOAlDDItTMP/GSYPGCDvyD4xG////SI17BEQPtoPNAAAATI1LCItLCEyNUxCLL0SL2USLcwxEC91FC95BD7bARIlbEEH2wAJ0NEyNSwhMjVMQg/oBdSdMjUsITI1TEEH2w0B0GUyNSwhMjVMQQQ+64w1yCgwETI1LCEyNUxAk/YiDzQAAAEQPtsCoBHQZSIu7kAAAAEiF/3QN90c4ACAAAHQEQYDg+4P6AQ+OhQAAAA+68Q1BiQlBC84LzemNAAAASIuLiAAAAEiFyXQnSDmZwAQAAHUOSMeBwAQAAAAAAACLQzBIx4OIAAAAAAAAAIP4AXUYSItLOEiLAUiJg5AAAABIiwGAoI0EAAD+SIN7QAB0CEiLy+gBKAAARIsDSIvXSIvLx0MUAQAAAOgs+f//6YcAAABBi8tB9sAEdBNBgTEAIAAAQYvOC0sEQQsJQYkKi8FBgOD7wekLwegKg+EBg+ABRIiDzQAAAEiDexgAD0TIhdJIi1MguAEAAAAPT8hIhdJ0CISCzAAAAHUCM8ALyEiLQyhIhcB0DfaAzAAAAAF0BLIB6wIy0g+2g8wAAAAk/grCCsGIg8wAAABMi3QkSEiLXCRQSIPEIF9eXcPMzMzMzMzMzMzMzMzMzEBTSIPsIIChzAAAAN9Ii9lIi0kgSIXJdAXo4v///0iLSyhIhcl0BejU////SIN7GAB1HUiLg5gAAABIhcB0EZCAiMwAAAAgSItAGEiFwHXwSIPEIFvDzMzMzMzMzMzMzEBVVldBVUFXSI1sJMlIgeywAAAASIsF5fQ4AEgzxEiJRQ9IizWXEDkARTP/SIv5TIvui0YEgKHMAAAA+4mBrAAAAEyJuaAAAABMibmYAAAATDl5GA+FTQEAAOhR/P//M8APV8CLyEiJRe8PEUXfOUcwfg7/wUiJfeeJTe9Mi8frBEyLRef3RxAACAAASItV30gPRddIiVXfg/kBfgVIhdJ1QEiLRyBIhcB0F0iNVd9Ii8joefv//4tN70iLVd9Mi0XnSItHKEiFwHQXSI1V30iLyOhZ+///i03vSItV30yLReeD+QFIiZeYAAAASYvHiY+oAAAASQ9EwEiJh6AAAABEOb+4AAAAdQ5NhcB0c0GLAImHuAAAAE2FwHRlSYtAOEG5AQAAAEiLCA8QQSAPEUdkDxBJMA8RT3RJY0AwQTvBfj9Ni1g4TIvQRYvBSY1LCEiLAUQ4eD10EUH/wUn/wEiDwQhNO8J86OsXSWPBSYsMww8QQSAPEUdkDxBJMA8RT3RIhdJ0GmZmDx+EAAAAAACAiswAAAAgSItSGEiF0nXwSIs1GQ85AEw5f0B0GPdHEAAQAAB0D0iLz+giJQAASIs1+w45AEUywEiJnCToAAAATDl/GA+FCwIAAPdHEAAEAAAPhf4BAACLVzCD+gF/I0w5fyB1HUU4hYMAAAB1FIXSdA1Ii0c4SIsIRDhBPHUDQbABRDm/qAAAAHQJRYTAD4TBAQAAg/oBD4XgAAAASItHOEiLGEiLh4gAAADyDxBDWPIPEUdI8g8QS2iBp8gAAACS/v//gY/IAAAAkgAAAPIPEU9QSIXAdBpJOYXAIQAAdREz0kiLy+jFUv//SIs1Pg45AEyLh4gAAABNhcB0dkH3hVQqAAAACAAAdClNi0BASI0NWn03AEiLQwhEi0sQixdFiwBIiUQkIOhzbwAASIs1/A05AEiLh4gAAABIi1BASIlTQEiLh4gAAACLSEiJS0hIi4eIAAAARDi4AAEAAHQUi0MQiQJIi0NASIlYcMaDAAEAAAGLQ0iJh8QAAABIi4eIAAAASIXAdBdIObjABAAAdQdMibjABAAATIm/iAAAAIN/MAF1GEiLTzhIiwFIiYeQAAAASIsBgKCNBAAA/kw5f0B0D0iLz+iEIwAASIs1XQ05AICnzAAAAKf2h80AAAABx0cUAQAAAESJv8AAAABBi0UEiYewAAAAD4TUCgAAg38wAQ+FygoAAEiLRzhIixhIi8voaDL+//MPEI4ACwAA8w8QhvwKAADzD1xPTPMPXEdISIme+BUAAPMPEY5oFgAA8w8RhmQWAACAp80AAAD+6X4KAAD2h8wAAAABdHZMOb+IAAAAdW1MOX8YdWf3RxAABAAAdV5MOX8gdViLl7wAAACF0nQpSItPOEhjRzBMjQTBSTvIdBhIiwE5UBB0C0iDwQhJO8h17+sFSIXAdQdIi0c4SIsARDi4IAEAAH8JRDi4IQEAAH4Mx0cUAgAAAOn/CQAASGNXMEyJtCT4AAAARIt3EEQPKYQkkAAAAESJdbuF0n4LQQ+65g5yBLEQ6wIyyQ+2h8wAAAAk7wrBQYvOJPeIh8wAAABMi0c4TY0M0E07wXRHSYsQD7aHzAAAAA+2igwBAADA4QMKyCT3gOEIMsiDfzABiI/MAAAAD7aCjQQAAA+fwST+SYPACArIiIqNBAAATTvBdbyLTxBBD7rmD3IJRTi9sA4AAHUHgKfMAAAA90mL34hdtw+64QpzDEiLn4gAAADpyAIAAEiLRxhIhcAPhUMCAAD2h8wAAAABD4ROAgAAOV8wfglIi0c4SIsI6wNJi8+Lh8gAAADB4B3B+B2D+AJ1E0iFyXQ+g44AIAAAAfIPEEFY6xCD+AF1KwmGACAAAPIPEEdIxoZEIAAAAceGBCAAAAEAAABMib4cIAAA8g8RhhQgAACLh8gAAADB4BrB+B2D+AJ1EkiFyXQwCYYAIAAA8g8QQWjrEYP4AXUeg44AIAAAAvIPEEdQx4YIIAAAAQAAAPIPEYYkIAAAi4fIAAAAJDg8EHUjSIXJdB4PtoEEAQAAg44AIAAACIiGRSAAAMeGDCAAAAEAAACLh8gAAAAlwAEAAD2AAAAAdSRIhcl0BYtBSOsKi4fEAAAAhcB0EIGOACAAAAAIAACJhmwgAACBjgAgAAAAIAAATI0FcnY3AA8QR2S6FAAAAEiNTfcPEYZ0IAAADxBPdA8RjoQgAABEiw/oA7r9/0iLHSwKOQBIjVW/x0W/AgAAAIOLACAAAEBIjYu4IAAARIm7aCAAAPMPEIOkDQAA8w8Qi6gNAADzDxFFw/MPEU3H6E1+AAAz0kyJu6QNAABBuDkRggBIjU336IWn/v+5AQAAAOg7zv3/SIuHiAAAAEmLndgVAADGRbcBSIXAdBVIO8N0EEg5uMAEAAB1B0yJuMAEAABIibvABAAASImfiAAAAPMPEENY8w8QS1zzDxGDUAEAAPMPEYtUAQAASIuPiAAAAPMPEUdI8w8RT0zyDxBDYPIPEUdQRDi5CAEAAHQF6B5N//9IizVHCTkA6w5Ii5iIAAAASImfiAAAAIGnyAAAAAD+///2h80AAAABdFdMi7eIAAAATYX2dEdJi87oYC7+//MPEI4ACwAA8w8QhvwKAADzD1xPTPMPXEdITIm2+BUAAPMPEY5oFgAA8w8RhmQWAACAp80AAAD+SIs10Qg5AESLdbtEib/EAAAATDl/GA+FdgAAAEmLlcAhAABIhdJ0akiLkhAEAABIhdJ0Xg8fQABIi4q4BAAASIXJdE5Ii0EYSIXAdBdmZmYPH4QAAAAAAEiLyEiLQBhIhcB19Eg7z3QaSIuRiAAAAEiF0nQdSIuSEAQAAEiF0nW36w9Ii4K4BAAAiwiJj7gAAABIg38YAEUPV8BMi7+YAAAATImkJPAAAAAPhcQBAABIhdsPhLsBAABB9sYID4SxAQAATYX/D4SoAQAASYN/IAAPhZ0BAABBg38wAA+FkgEAAIC+2CMAAABBtAF0PUyNtugjAABBg34U/3QvTYX2dCpJjVYYSI0NXFw3AOjZZQcAhcB1FkmLFkiLy0iLEuhlHwAAhMAPhUwBAABJi0cYSYvPDym0JKAAAABIhcB0FWYPH4QAAAAAAEiLyEiLQBhIhcB19PMPEEFI80EPEF9IDyjoDy/Y80EPEFdMDyjj8w8QcUwPKMrzD1hpUPNBD1hnUPNBD1hPVPMPWHFUdgnzQQ9YncwVAAAPL+x2CfNBD1ylzBUAAA8vUUx2CfNBD1iVzBUAAA8v8Q8otCSgAAAAdgnzQQ9cjcwVAAAPL9wPh6QAAAAPL9F2CUiLRxjpowAAAEiLiwAEAADzD1zK8w9c4w8ow/NEDyzBDyjKZkSJRcHzDyzUZolVv4tFv4mD0AIAAPMPXENY8w9cS1zzDyzAZolFv/MPLMFmiUXBi0W/iYPUAgAASIXJdD5miVW/ZkSJRcGLRb+JgdACAADzD1xZWPMPXFFc8w8sw2aJRb/zDyzCZolFwYtFv4mB1AIAAEiLRxjrEEUy5EiLRxhIhdsPhMMBAABIhcAPheEAAABMi0NgRTPJSItTWEiLz+gIOwAADxCGeBAAAEiNjqggAADHRd8bAAAASI1V3w8RRePotnsAAIO+pCAAABt0D0EPEIUYDwAADxGGeBAAAEiLNfcFOQBIjVXfx0XfHQAAAA8QhpgQAABIjY6oIAAADxFF4+h1ewAAg76kIAAAHXQPQQ8QhcgQAAAPEYaYEAAASIs1tgU5AEiNVd/HRd8cAAAADxCGiBAAAEiNjqggAAAPEUXj6DR7AACDvqQgAAAcdA9BDxCFuBAAAA8RhogQAABIi8/olD4AALkDAAAA6CrI/f9Ig38gAA+FzgAAAIN/MAAPhcQAAAD2h8wAAAABD4S3AAAASIuTGAMAAEUzwEiNiogAAADoEj4BAIt1u0D2xgh0FoCPzAAAAATHh4QAAAAAAAAA6YUAAABIiwUMBTkASI1Nzw8QgGgRAAAPEUXPD8bA//MPWYCcDQAA8w8RRdvoR739/4mHhAAAAIXAdEPzDxBHUEiNV0jzDxBPVEyNRb/zD1gC8w9YSgRIi4sYAwAARIvIx0QkKAAAAADzRA8RRCQg8w8RRb/zDxFNw+gKMwEAgI/MAAAABOsDi3W7TIu0JPgAAABIhdsPhFIBAABIg38YAA+FGwEAAED2xggPhBEBAAD2h8wAAAABD4QEAQAASIuTGAMAAEUzwEiNiogAAADoJT0BAEiLBT4EOQBIjU3fDxCA6A4AAA8RRd8PxsD/8w9ZgJwNAADzDxFF60WE5HR580EPEEdI80EPEE9M8w8RRb/zQQ9YR1DzDxFNw/NBD1hPVPMPEUXH8w8QR0jzDxFNy/MPEE9M8w8RRc/zD1hHUPMPEU3T8w9YT1TzDxFF1/MPEU3b6CC8/f9Ii4sYAwAASI1Vz0SLyPNEDxFEJCBMjUW/6EK/AQDrSfMPEEdQ8w8QT1TzD1hHSPMPWE9M8w8RRb/zDxFNw+jdu/3/SIuLGAMAAEiNV0hEi8jHRCQoAAAAAEyNRb/zRA8RRCQg6McxAQBIi5MYAwAAQbgBAAAASI2KiAAAAOgePAEAg38wAH4NSIvTSIvP6I0CAADrEYCnzAAAAL3Hh8AAAAAAAAAASItHQEQPKIQkkAAAAEyLpCTwAAAASIXAdAeLQCCFwHUTg38wAH4TSItHOEiLCIuBwAAAAImHvAAAAEiF23Q59ofMAAAAAXQwSIN/GAB1KUmLhfgVAABIhcB0CUg5mCAEAAB0FEiLy+ieTQAAQYtFBImHsAAAAOsPQYtFBImHsAAAAEiF23QrSItPIEiFyXQF6MXx//9Ii08oSIXJdAXot/H//0iDfxgAdQhIi8voaIz+/4B9twB0Beh91P7/SIucJOgAAABIi00PSDPM6BlNBwBIgcSwAAAAQV9BXV9eXcPMzMzMzMzMzMzMTItJCLn///9/TItCCEEPv4GOBAAAZoP4/3UCi8FBD7+QjgQAAGaD+v90AovKK8F1EkEPv4gWAQAAQQ+/gRYBAAArwcPMzMzMzMzMzMzMzMxIiVwkIFdIg+xAQYtACEmL+EiL2oP4AXVPSIsFwAE5AEiNDflQNwBEi0oQQcHpDUGA4QHGRCQgAUyLgLApAABNhcBJD0XIRTPA6KK/AwCEwA+E0wAAAICLzQAAAARIi1wkaEiDxEBfw0iJbCRQM+2FwA+OrQAAAEiJdCRYi90PKXQkMPMPEDW9yDcADx9EAABIi3cQ90QzBAAAIAB1bYtHIDkEM0iLTDMID5TCSMdEJGAAAAAASIXJdAZIi0kI6x1IY0QzKIP4/3UJSI0N33Q3AOsKSIvISAOPqAAAAEyNTCRgRTPA6MadAwCEwHQGiwQziUckDyjOD1fA6FEi//9IjQ1ecDcA6DWQAgD/xUiDwzg7bwgPjHb///8PKHQkMEiLdCRYSItsJFBIi1wkaEiDxEBfw8zMzMzMzMzMzMzMzEBVVkFUQVZBV0iNrCRA////SIHswAEAAEiLBcHkOABIM8RIiUVgi4GwAAAARTP/TIs1agA5AP/AiUQkaEyL4kiL8UiJTYhIi9FBi0YEgKHMAAAAv0QPtoHMAAAAiUWARIm5wAAAAEiLQRhIhcB0EZBIi9BIiUWISItAGEiFwHXwSYuGmCMAAEiJnCQAAgAASIXAdA9IObC4BAAAD5TD6aMAAABJi47AIQAASIXJD4SRAAAAiwY5grgAAAAPhYMAAABIi4EQBAAA90AUAAAAEHQXSIuAAAQAAEiLgBAEAAD3QBQAAAAQdelIi4jABAAASIXJdQxIi4i4BAAASIXJdERIi0EYSIXAdBMPH4AAAAAASIvISItAGEiFwHX0SDvKD4TAAQAASIuBiAAAAEiFwHQTSIuAEAQAAEiLiLgEAABIhcl1vDLbi0YQiFwkMA+64A0PgggUAAAPuuAMD4L+EwAAQQ+2jCQGAQAASIm8JLgBAABMiawksAEAAA8ptCSgAQAADym8JJABAABEDymEJIABAABEDymMJHABAACITCRID7rgCnIURYi8JAYBAABBx4QkqAEAAAEAAACLDugv4f7/SItGQEiJRCQ4SIv4SIXAdQxIi87oFhQAAEiLfkAPtobMAAAARA+260UC7USJfCRMJP0PV/ZECuj3RhAAQAAARIiuzAAAAA+FFQIAAEGDvsgNAAD/D4QHAgAASIsFfv44AEiNDf9tNwAz0sZEJDEBSIuY2BUAAEhjg0ABAABMi4NIAQAARYtEgPzoQbD9/0iLC0SLyIlEJFA5gTAWAAB1IEyNBcBtNwC6CwAAAIvI6MxjAABEi0wkUEQPtq7MAAAASIsdGP44AEhjgxghAAA5gwghAAAPjnwBAABIa8g4SIuDECEAAEQ5DAEPhWcBAADzDxCL4A0AAPMPWMlEi28k8w8QVkhEiWwkUPMPWIvwEgAA8w9YTkxEObvIDQAAdQwPV8DrFLMB6Vr+///zD1hWUPMPEAULxDcAg4sAIAAAAfMPEZMUIAAA8w8RixggAAAPFMbyDxFEJGDzDxBEJGDzDxBMJGTzDxGDHCAAAPMPEYsgIAAAx4MEIAAAAQAAAMaDRCAAAAHo9TX//4TAD4SaAAAAgI7MAAAAAkyLx0iLg/goAABIi9ZIi8v/0EiLHS39OABIi4PYFQAA90AUAAAABHReRDm7GCEAAHRVSDmDwCEAAHUgRDi7USIAAHQXRDm7zCEAAHUOg6NUIgAA8oOLVCIAAAL3QBQAAAABRIurQBUAAHQJi0AQiYNAFQAA6O3O/v9EiatAFQAARItsJFDrDEiNDShiNwDo4xL//4tHJIXAdA1BO8VBi9cPRdCJVCRMRA+2rswAAABBD7bF0OgkAQhEJDDrFA+2RCQwiEQkMOsJRIh8JDGIXCQwSIsFbvw4APMPEH5M80QPEE5IDyjH8w8RfCR0RQ8owfMPELDgDQAADyjvTIl9kPMPWPbzD1iA8BIAAPNEDxFNuPMPEX2880QPWEZQ8w9Y8PNEDxFFwEEPKNDzDxF1xPMPEICwDQAA8w8QiNwNAAAPKODzDxCY8BIAAPNBD1jh8w8RdCR88w9c0PMPWKjgDQAA8w9Y4fMPXNHzDxFkJHDzDxFUJHhB9sUIdCQPKMIPKMvzD1iI9A0AAPMPXMPzD1zRDxTF8g8RRZDzDxFUJHhB9sUQdDyLkMgNAACF0nUU8w9YmPQNAADzD1jc8w8RXCRw6x6D+gF1GQ8o4vMPXOPzD1iY9A0AAPMPXNPzDxFUJHgPKMyLRwhFi+8PFM0PEEQkcIlEJGDyDxFMJHAPEUWYRDl+MA+OfAAAAEmL32YPH4QAAAAAAEiLRjhMiwwDRYuBwAAAAEWFwHQpi1cIQYvHhdJ+H0iLTxBEOQF0DP/ASIPBODvCfPHrCkhryDhIA08QdRBNi8G6AACAAEiLz+gT1QMAQf/FSIPDCEQ7bjB8pvMPEHXE80QPEEXA8w8QfbzzRA8QTbgPtlwkMITbdApBi0YEiYa0AAAARTi8JAQBAAB0B7kMAAAA6wyE20mLzw+VwUiDwQpIiwWJ+jgASAPJDxCEyMgOAABIjUwkUA8RRCRQD8bA//MPWYCcDQAA8w8RRCRc6L2y/f/zQQ8QnrQOAABEi9DzQQ8QTCRY80EPEFQkXA8owfNBD1hMJGDzD1jD8w9cy0EPL8EPKMLzQQ9YVCRkD5PC8w9Yw0QPL8HzD1zTQQ+TwQ8vxw+TwQ8v8kEPk8CEyXQLhNJ0B7gQAAAA6wdBi8eEyXQKuSAAAABFhMl1A0GLzwvBRYTAdBiE0nQFg8hA6wVFhMB0CrmAAQAARYTJdQW5AAEAAPNBDxCEJJAAAABMjUXAC8FIjVW4SYuMJBgDAABFi8qJRCQo8w8RRCQg6P4nAQBEOHwkMQ+ExgAAAEljhCRAAQAASI0NxEg3AE2LhCRIAQAAM9JFi0SA/OhQq/3/SYsMJESL6DmBMBYAAHUTTI0Fmkg3ALoLAAAAi8jo3l4AAEyLxkiNVCRwQYvN6O6gAgCEwHQF6EUs//9IiwUe+TgAi4hMFgAAhcl0DzuIsB8AAHUHi0cgiUQkTLkAEAEA6NsU/v+EwHQ680EPEIZAFgAADy8FC783AHYoSIsF3vg4AEiNFRdINwBIi4jAKQAASIXJSA9F0UiNDb5LNwDoLSv//0SLbwhBjU3/hcl4NUhjwUhr0DhmZg8fhAAAAAAATItHEEKLRAIED7rgF3MVD7rwF0SL6UKJRAIESIPqOIPpAXncRItHCEU7xQ+OMQEAAEH3hlQqAAAABAAAdCqLFkGNRQFEO8BIjQ3qZzcATI0N+88JAEwPT8lFK8VIjQ3lZzcA6KhZAABBi82JTCRQRDtvCH1+SWPFSGvYOA8fQABB94ZUKgAAAAQAAEiLVxB0TkyLRBMITYXAdA5FD7+IjgQAAE2LQAjrI0hjRBMoQbn/////QTvBdQlMjQWwazcA6wpMi8BMA4eoAAAAixQTSI0Nqmc3AOg1WQAAi0wkUP/BSIPDOIlMJFA7Twh8kg+2XCQwQfeGVCoAAAAEAAB0LUmLhsAhAABIhcB0CUSLgMAAAADrBkG4/////4uWvAAAAEiNDYBnNwDo41gAAItPCEGNRQE7yH4qQSvNSGPRSIP6AXYeSWPFTI0NIvX//0hryDhBuDgAAABIA08Q/xU2pAcASYuGwCEAAEiFwHQZSIuAEAQAAEg5sLgEAAB1CYuAwAAAAIlHIEw5fCQ4dTVEi4a8AAAARYXAdCmLVwhBi8eF0n4fSItPEA8fhAAAAAAARDkBD4QuBwAA/8BIg8E4O8J87UhjRwg7RCRgfhlIa8g4SItHEEiLTAHQi4HAAAAAiUcgiUckQb3DAFAARTi8JAQBAAB1C4TbuMMAcABED0XoSIsFmPY4AEiNDdlmNwAz0kiLmNgVAABIY4NAAQAATIuDSAEAAEWLRID86GCo/f9IiwuJRCRgOYEwFgAAdRdMjQWiZjcAugsAAACLyOjuWwAAi0QkYIlHHEiNVZjzDxBGSEWLxfNBD1iEJJQAAABIi8/zDxFHcPMPEE5Q8w9YTkjzQQ9cjCSUAAAA8w8RT3Tom7oDALkJAAAASI1F2GaQTIl4+EyJOEiNQBBIg+kBde9BDxCWyA4AAESJfCRQDylV0EEPEIboEAAADylF4EEPEI74EAAADylN8EEPEIYIEQAADylFAEEPEI4YEQAADylNEEEPEIYoEQAADylFIEEPEI44EQAADylNMEEPEIZIEQAADylFQEEPEI5YEgAATIm+kAAAAA8pTVBEOX4wD479BAAA8w8QNS27NwBNi+9mkEiLRjhKixwoi4PYAgAA/8BBO0YEfQ2LRYA5RCRoD4SyBAAAi4uQBAAAD1fbi1M0D1fAD7bBD1fJg8oBD1fS90MUAAAEAA9EUzTzSA8q2IvBRIvKQYPJBPZHGAhED0TKwegID7bA8w9Z3vNIDyrAi8HB6RjB6BAPtsAPxtvh80gPKsiLwfNIDyrQ8w9ZxvMPWc7zDxDY8w9Z1g/G28YPV8DzDxDZD1fJD8bbJ/MPENoPV9IPxts5QQ8RnsgOAACLi5QEAAAPV9sPtsHzSA8q2IvBwegID7bA80gPKsCLwcHpGMHoEA+2wPMPWd7zSA8qyIvBD8bb4fNIDyrQ8w9ZxvMPWc7zDxDY8w9Z1g/G28YPV8DzDxDZD8bbJ/MPENoPxts5QQ8RnugQAACLi5gEAAAPtsEPV9vzSA8q2IvBwegID7bA80gPKsCLwcHoEPMPWd7zD1nGD8bb4Q9XyfMPENgPtsAPxtvGD1fSwekYD1fA80gPKsiLwfNIDyrQ8w9ZzvMPWdbzDxDZD1fJD8bbJ/MPENoPV9IPxts5QQ8RnvgQAACLi5wEAAAPV9sPtsHzSA8q2IvBwegID7bA8w9Z3vNIDyrAi8HB6RjB6BAPtsAPxtvh80gPKsiLwfNIDyrQ8w9ZxvMPWc7zDxDY8w9Z1g/G28YPV8DzDxDZD1fJD8bbJ/MPENoPV9IPxts5QQ8RnggRAACLi6AEAAAPV9sPtsHzSA8q2IvBwegID7bA8w9Z3vNIDyrAi8HB6BAPtsDB6RgPxtvh80gPKsiLwfNIDyrQ8w9ZxvMPWc7zDxDY8w9Z1g/G28bzDxDZD8bbJ/MPENoPxts5QQ8RnhgRAACLi6QEAAAPtsEPV9vzSA8q2PMPWd4PV8CLwcHoCA9XyQ+2wA9X0g/G2+HzSA8qwIvBwekYwegQD7bA80gPKsiLwfNIDyrQ8w9ZxvMPWc7zDxDY8w9Z1g/G28YPV8DzDxDZD1fJD8bbJ/MPENoPV9IPxts5QQ8RnigRAACLi6gEAAAPV9sPtsHzSA8q2IvBwegID7bA80gPKsCLwcHpGMHoEA+2wPMPWd7zSA8qyIvB80gPKtAPxtvh8w9ZxvMPWc7zDxDY8w9Z1g/G28YPV8DzDxDZD1fJD8bbJ/MPENoPV9IPxts5QQ8RnjgRAACLi6wEAAAPV9sPtsHzSA8q2IvBwegID7bA80gPKsCLwcHoEA+2wMHpGPMPWd7zSA8qyIvBD8bb4fNIDyrQ8w9ZxvMPWdbzDxDY8w9Zzg/G28bzDxDZSIlcJCAPxtsnTI1FsPMPENoPV8APxts5D1fJQQ8RnkgRAACLi7AEAAAPV9sPtsEPV9LzSA8q2IvBwegID7bA8w9Z3vNIDyrAi8HB6RjB6BAPtsAPxtvh80gPKsiLwUiLz/NIDyrQ8w9ZxvMPWc7zDxDY8w9Z1g/G28bzDxDZD8bbJ/MPENoPxts5QQ8RnlgSAADGRbABRDi7DAEAAEiLUwhND0TH6BfUAwBEOH2wdQyLg8AAAACJhsAAAACLg8AAAAA5Ryh1B0iJnpAAAABBi4a4HwAAiYMgAgAAQQ8QhrwfAAAPEYMkAgAASYuGwCEAAEiFwHQgSDmYEAQAAHUX9oOsAQAAAnUOi4PAAAAAQYmEJEwEAACLRCRQSYPFCP/AiUQkUDtGMA+MFPv//w8oVdBBDxGWyA4AAA8oReBBDxGG6BAAAA8oTfBBDxGO+BAAAA8oRQBBDxGGCBEAAA8oTRBBDxGOGBEAAA8oRSBBDxGGKBEAAA8oTTBBDxGOOBEAAA8oRUBBDxGGSBEAAA8oTVBBDxGOWBIAAEiLjpAAAABIhcl0G0iLRYhEOHwkMHUJTDm4kAAAAHUHSImIkAAAAA+2hswAAAAkCHQzSIuOkAAAAEiFyXQnRDi5DAEAAHQeQbUB6QgBAABIa8g4SANPEA+Ezvj//0GLwOnj+P//hMAPhFwCAABIix2U7zgAi4NwHwAATI2r6CAAAA+66AqJg3AfAABFi0UEQYtNAIlEJGhBO8h1L//BRYXAdA1Bi8CZK8LR+EEDwOsFuAgAAAA7wQ9PyIvRSYvN6LR0AABIix097zgASWNNAEmLRQiLVCRoRIl9mIkUiEiNi6ggAABB/0UASI1VmA8Qg8gOAADzQQ8QttQOAADzQQ8QvsgOAADzRQ8QhswOAADzRQ8QjtAOAADzD1k1/LQ3AA8RRZzof2QAAEUy7UQ5u6QgAAB0IvMPEbvIDgAA80QPEYPMDgAA80QPEYvQDgAA8w8Rs9QOAABJY4QkQAEAAEiNDUpDNwBNi4QkSAEAADPSRYtEgPzofqD9/0mLDCSL2DmBMBYAAHUTTI0FIUM3ALoLAAAAi8joDVQAAEiNVZCLy+jSkgIAhMB0Y4COzAAAAEBFi8dEOX8IflNJi89mZmYPH4QAAAAAAEiLVxCLRBEED7rgFXIqqQEBAACLBBF1GMZEETABOUcodRbHRBEQ/////0yJfyDrCDlHKHQDiUckQf/ASIPBOEQ7Rwh8u0WE7Q+FswAAAEiLHevtOACLg6ggAACD+AF9HUiNDZE9NwDoBAT//0SLg6ggAABBi8BFhcB+S+sTQbgBAAAADx9AAGYPH4QAAAAAAEiLi7AgAABB/8hImEiNFIBIY0SR7A8QRJHwSAPADxGEw8gOAAD/i6ggAACLg6ggAABFhcB/ykiLFXPtOABIY4roIAAAg/kBfw5IjQ2YQjcA6IsD///rGo1B/4mC6CAAAEiLgvAgAACLTIj4iYpwHwAASWOEJEABAABIjQ2AXTcATYuEJEgBAAAz0kWLRID86Ayf/f9Jiwwki9hEDyiMJHABAABEDyiEJIABAAAPKLwkkAEAAA8otCSgAQAATIusJLABAAA5gTAWAAB1E0yNBS1dNwC6CwAAAIvI6HFSAABBi4Y0FgAAhcB0ETvDdA1BOZ5MFgAAD4W7AAAASIsFruw4ADmYTBYAAHUGiZhQFgAAOZh8FgAAdQfGgIUWAAABTI1NsMdEJCAAEAAARTPASI1NuIvT6PeAAgBBOZ40FgAAdQdBiZ6wHwAARDh9sHRnRTPAM9Izyegl3P7/hMB0B4tHIIlEJExEi0cgRYXAdEeLVwhBi8eF0n49SItPEA8fAEQ5AXQM/8BIg8E4O8J88eslSGvIOEgDTxB0G0iLSQhIhcl1B0iLjogAAABFM8BIi9boOhL+/4tXJIXSD0RUJEyF0nRPRItHCEGLx0WFwH5DSItPEDkRdA3/wEiDwThBO8B88esuSGvYOEgDXxB0JEiLSwhIhcl0GzPS6DEw//9FOb64IQAAdQtIi0sIM9LoTUT//+hYswMASIsFkes4AEiLvCS4AQAASIuI2BUAAIuBQAEAAIP4AX8OSI0NeEE3AOibAf//6wj/yImBQAEAAPdGEAAEAAB1fg+2RCRIQYiEJAYBAABFibwkqAEAAOtnRDl+MH4HSItGOEyLOEGA4P1Mib6QAAAAD7bDAsBBCsCIhswAAACE23QKQYtGBImGtAAAAE2F/3QuhNt1CkiDupAAAAAAdQdMibqQAAAASItWQEiF0nQQSIuGkAAAAIuIwAAAAIlKKEiLnCQAAgAASItNYEgzzOiWNQcASIHEwAEAAEFfQV5BXF5dw8zMzMzMzEiJXCQQV0iD7CBIi/m5sAAAAP8VuJUHAEyLDZHqOABFM9JIi9hNhcl0XEkPv5EcKwAASY2BICsAAEWLQQRIjQTQRDkAdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmJHCsAAEgPv8FIBWQFAABJjQTBRIkARIlQBGb/QARB/4EUKwAASIXbdDMz0kG4sAAAAEiLy+h/RgcAuP////9Ix0Ms/////2aJg4YAAABIiV9ASItcJDhIg8QgX8NIi1wkOEyJV0BIg8QgX8PMzMxIiVwkEFdIg+wgSItZQEiL+UiF2w+ElgAAAEiNi6AAAABIiXQkMOjVUgAASI1LCOjMUgAATIsFpek4ADP2TYXAdFxJD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJcQRm/0EGQf+AGCsAAEiLy/8VcZQHAEiJd0BIi3QkMEiLXCQ4SIPEIF/DzMzMzMxMi8lIi4rABAAASIXJdB73QRAABAAAdBUPt4IWAQAAZkE5gRYBAAAPjJUAAABIjUIgSIXJSI1RZEGLSSBID0TQiwI7wXQfhcB0DIB6HQB0BoXJdQbrD4XJdGhBgHk9AHRhhcB1XUyLBbToOABJY4gIIQAAjUH/hcB4RU2LgBAhAABIjVH/SGvKOEmDwAhMA8FJiwhIhcl0HUmLwUk5iRAEAAB0Hkg7wXQZSIuACAQAAEiFwHXvSYPoOEiD6gF50bABwzLAw8zMzMzMzMzMzMzMSIlcJAhIiXQkEFdIg+wgTIuawAQAAEiL2kiL8U2F23QRSYN7IAB1UEGLQzCFwH426wW4AQAAAIv4RTPSDx9AAE2F23QKSYtDOEqLDNDrA0iLy0iL1ujW/v//hMB1Gkn/wkw713zaMsBIi1wkMEiLdCQ4SIPEIF/DSItcJDCwAUiLdCQ4SIPEIF/DzMzMzMzMSIPsKEiLBbXnOABMi9nzDxBpTEyLVCRQDyjNDyl0JBDzDxCA4A0AAPMPEHFI8w9YwPMPEWwkBA8o1vMPWIjwEgAA8w9YUVDzD1jI8w8RTCQMSIXSdBPzDxEy8w8RagTzDxFSCPMPEUoM8w8QiNwNAADzDxCAsA0AAA+2icwAAADzD1zQ8w8QmPASAAAPKODzD1jm8w9c0fMPWOEPKM3zD1iI4A0AAPMPEVQkCPMPESQk9sEIdDRNhdJ0Gg8owvNBDxFKBPMPXMPzQQ8RAkEPtovMAAAADyjD8w9YgPQNAADzD1zQ8w8RVCQI9sEQdEaLiMgNAACFyXUT8w9YmPQNAADzD1jc8w8RHCTrKYP5AXUkDyjiDyjN8w9YiOANAADzD1zj8w9YmPQNAADzD1zT8w8RVCQITYXAdAgPEAQkQQ8RAE2FyXQL80EPESHzQQ8RSQQPKHQkEEiDxCjDzMzMzEiD7FjzDxBpCPMPEFEMSIsFS+Y4APMPEB27rDcATIuUJIAAAAAPKXQkQPMPEIjwEgAA8w8QMQ8o4Q8pfCQw8w9c7kQPKUQkIPNEDxBBBEQPKUwkEPNBD1zQ80QPEA0irDcA80EPWckPKMXzD1nj8w9dwvMPWQXOqzcA8w9fyPMPXeFFhMl0OQ8oxPNBD1nR8w9ZJRWsNwDzD1nD80EPWenzDyzAZg9u2PMPLMQPW9tmD27gD1vk8w9c1PMPXOzrLPMPLMTzD1kl7Ks3AGYPbtjzDyzED1vbZg9u4A8o0/MPWRUSrDcAD1vkDyjq8w9YcQjzRA9YQQzzDyzC80EPWfHzRQ9ZwWYPbsDzDyzFD1vAZg9u+PMPLMYPW/9mD27o80EPLMAPW+1mD27wD1v2g/r/dTgPKMUPKM7zD1zD8w9cy/NBDxEADyjF80EPEUgE8w9Yww8ozvMPWMvzQQ8RQAjzQQ8RSAzptQAAAIP6AnUJDyjW8w9c0OsMg/oDdTkPKNbzD1jQDyjFDyjK8w9cw/MPXMzzD1jU80EPEQAPKMXzQQ8RSATzD1jD80EPEUAI80EPEVAM62mF0nUsDyjVDyjO8w9c1/MPXMsPKMLzD1jU8w9cxPNBDxEA80EPEUgE80EPEVAI6yyD+gF1NPMPWP0PKM7zD1zLDyjH8w9Y/PMPXMTzQQ8RAPNBDxFIBPNBDxF4CA8oxvMPWMPzQQ8RQAxNhdIPhAQBAABBDxAADxEEJPNEDxAMJPNEDxBEJATzDxB8JAjzDxBUJAxFhMkPhbUAAADzQQ8QIg9XyfMPXOUPKMPzD1kF9qk3APNBDxBqBPMPXO7zDyzADyjE8w9ZxPMPKsjzRA9cyfNED1zB8w9Y+fMPWNEPKM3zD1nN8w9YyA8ow/MPWQUpqjcA8w9ZHU2qNwDzD1nADy/BdgiD+v8PlMDra/MPWdsPL9l2Ow8o1A8oxQ9UBWatNwAzwA9UFV2tNwAPL9APV8B2DQ8v4A+XwDvQD5TA6zcPL+gPl8CDwAI70A+UwOsn80EPEApBDy/JchrzQQ8QQgRBDy/Acg4PL/l2CQ8v0HYEsAHrAjLADyh0JEAPKHwkMEQPKEQkIEQPKEwkEEiDxFjDzMzMzMzMSIlcJBhVVldBVkFXSIvsSIHsgAAAAEiLBTPHOABIM8RIiUX4TItdUE2L+EiLNd7iOABMi9FNi4jABAAATIld2EiF0nQp9oLMAAAAAXUgSItCGEyLwkiFwHQXZg8fRAAATIvASItAGEiFwHX06wNMi8JNhcl0BkGLSRDrBEGLTzhIhdJ0BYtCEOsEQYtCOEQPtnVgQcaD0QAAAAFFhPZ1dEQ4toEAAAB1aw+64BRyZUiF0nQaqAR0CfdCEAAIAAB1U0iDeiAAdQaDejAAdBZNhcl0EUmDeSAAdApJg7mgAAAAAHQwD7rhFXMSSIXSdCVIg3ogAHUeg3owAHUYD7rhFnMaSIXSdBVIg3ogAHUOg3owAHUIQcaD0QAAAABBxoPSAAAAAagQdT6AvoAAAAAAdTVFhPZ1KkiF0nQlSIN6GAB1HvdCEAAIAAB0FUWIs9IAAAAPtoLMAAAAwOgDJAHrKQ+64RNzCEHGg9IAAAAASIXSdA4PtoLMAAAAwOgDJAHrCEEPtoIMAQAAhMB1CUE4hwwBAAB0ArAIQQ+2i8wAAAC/AQAAAIDh9wrIQYiLzAAAAEiF0nQEi8frC0GLQhTB6AX30CPHwOAEgOHvCshJjUBIQYiLzAAAAE2FwHUESY1CWPIPEADyQQ8RQ0hNhcB0BkmDwFDrBE2NQmDyQQ8QADPb8kEPEUNQSYmT2AAAAEHHg+AAAAD/////QcaD0wAAAABBOJoEAQAAD4UiAgAAQTib0QAAAHRj80EPEENISI2GGAEAAPNBDxBLTE2Ng+gAAADzDxFFsEiNTbDzQQ9YQ1DzDxFNtEUPts7zQQ9YS1S6/////0iJRCQg8w8RRbjzDxFNvOgo+v//hMB0DkGJk+AAAABBiLvTAAAAQTib0gAAAA+EqQEAAPNBDxBDSEiNhhgBAADzQQ8QS0xNjYP4AAAA8w8RRbBIjU2w80EPWENQ8w8RTbRFD7bO80EPWEtUM9JIiUQkIPMPEUW48w8RTbzou/n//4TAdA5BiZvgAAAAQYi70wAAAEE4m9IAAAAPhDwBAADzQQ8QQ0hIjYYYAQAA80EPEEtMTY2DCAEAAPMPEUWwSI1NsPNBD1hDUPMPEU20RQ+2zvNBD1hLVIvXSIlEJCDzDxFFuPMPEU286E75//+EwHQOQYm74AAAAEGIk9MAAABBOJvSAAAAD4TPAAAA80EPEENISI2GGAEAAPNBDxBLTE2NgxgBAADzDxFFsEiNTbDzQQ9YQ1DzDxFNtEUPts7zQQ9YS1S6AgAAAEiJRCQg8w8RRbjzDxFNvOje+P//hMB0DkGJk+AAAABBiLvTAAAAQTib0gAAAHRj80EPEENISI2GGAEAAPNBDxBLTE2NgygBAADzDxFFsEiNTbDzQQ9YQ1DzDxFNtEUPts7zQQ9YS1S6AwAAAEiJRCQg8w8RRbjzDxFNvOhy+P//hMB0DkGJk+AAAABBiLvTAAAAQYuL4AAAAIP5/3UNQTib0QAAAHUEMsDrBEAPtsdBiIPQAAAAOF1YdRhBOJvTAAAAdQ84noIAAAB1B0GIm9AAAABBiZvkAAAAg/n/D4SpAQAATImkJLAAAABMiawkuAAAADvPdgxMjUXsQblUAAAA6wpMjUXoQblQAAAA8kEPEENID1fS8kEPEE9g8w8QpvQNAADyDxFFwPJBDxBDUPIPEUXISIld8EiJXejyDxFN0HYxTI1dyEiL30yJXeBIjVXsTI1d6EyNVexIjXXETI119EyNfcxMjWXUSI1FwEyNbfDrL0yNXcxIi/tMiV3gSI1V6EyNXexMjVXoSI11wEyNdfBMjX3ITI1l0EiNRcRMjW30iwDzQQ8QB/NBDxAMJPMPXMQPL8pMi6QksAAAAEGJRQBIi0XgTIldsEyLbbBMi13YiwAPKNjzD1kdlqM3AEGJRQBMi6wkuAAAAHYFDy/Zcw7zDyzDSYvSZg9uyA9byfMPXMHzDxEK8w8swGYPbsiNQf8PW8mp/f///3QS98H9////dReLRL3AiUSd8OsN8w9YDvMPWMzzQQ8RDvNBDxAA80MPXgQZ8w8QHWajNwAPL9B3Bw8o0/MPXdDyDxBF8I1B//IPEE3o8kEPEUNI8kEPEUtQqf3///91B/MPXNoPKNPzQQ8Rk+QAAABIi034SDPM6IonBwBIi5wkwAAAAEiBxIAAAABBX0FeX15dw8zMzEiLxFVTVldBVEFVQVZBV0iNqAj///9Igey4AQAATIstfNw4AEyL8Q8pcKhNi/gPKXiYRA8pQIhBD7adhAAAAEQPKYh4////RA8pkGj///9EDymYWP///0QPKaBI////RA8pqDj///9IiU3ASItJQEQPKbAo////RA8puBj///9MiU2wTIlFuEiJVYhMiW3ISIXJdQtJi4XYFQAASItIQEyNBQovNwC6AQAAAOgg//3/SYtPQPMPED0QojcASIlF8Ek5TkAPhPUAAACE2w+F7QAAAEiFyXUSSIsFwts4AEiLiNgVAABIi0lATI0FwC43ALoBAAAA6Nb+/f9BvAIAAABIiUX4TIllmPMPEBWkoTcATIsFids4AEiNTCRQQQ8QiFgRAADzQQ8QsJwNAAAPEUwkUA8oxg/Gyf/zD1nC8w9ZyPMPEUwkXOi0k/3/SI1MJFCL8A8oxkEPEIhYEQAADxFMJGgPxsn/hNt0cvMPWQWFoTcA8w8QPXGhNwDzD1nIDyjG8w9ZBYKhNwDzDxFMJHRBDxCIWBEAAA8RTCRQD8bJ//MPWcjzDxFMJFzoUJP9/0iNTCRoiUWQ6EOT/f/rYUG8AQAAAEyJZZiE2w+EN////w8o10yJZZjpM/////MPWQXzoDcA8w9ZyEEPEIBYEQAA8w8RTCR0DxFEJFAPxsD/8w9ZxvMPEUQkXOjxkv3/SI1MJGiJRZDo5JL9/0yJZZhBDxCAeBIAAEiNTCRQiUWU8w9Z9w8RRCRQD8bA//MPWcbzDxFEJFzotJL9/0mLj8AEAACJRCRgSIXJdAuDeTAAfwVAMv/rA0C3AUiLXbCAu9AAAAAAD4S9BQAAg7vgAAAA//NEDxBLSPMPEHNMQQ8o+fMPWHtQRA8oxvNEDxFMJFDzRA9YQ1TzDxF0JFTzDxF8JFjzRA8RRCRcdTVAhP90I/NBDxCA4A0AAPMPWMDzQQ9YgPASAADzD1jG8w8RRCRUDyjwgLvRAAAAAA+E8AAAADPbDx9AAGYPH4QAAAAAAPNBDxCdtA4AAPNBDxBOWPNBDxBWXA8owfNBD1hOYPMPWMPzD1zLQQ8vwQ8owvNBD1hWZA+TwvMPWMMPL/nzD1zTQQ+Twg8vxg+TwEQPL8JBD5PBhMB0C4TSdAe5EAEAAOsJuQABAACEwHQNRYTSdAhBuCAAAADrA0UzwEWEyXQLhNJ0B7pAAAAA6wcz0kWEyXQMRYTSdAe4gAAAAOsCM8DzQQ8QhpAAAAALyAvKRIvOQQvISI1UJFCJTCQoTI1EJFhIi0zd8PMPEUQkIOg/BwEASP/DSTvcD4wj////SItdsIC70AAAAAAPhEoEAABAhP8PhEEEAACDu+AAAAD/D4U0BAAAM/ZAOLPRAAAAD4QnBAAAD1fASIl0JCBFM8lMjUQkaDPSSIvLDxFEJGjorvD///NEDxBcJGhIi32IRQ8o60EPKPNIhf90WUiLT0BIhcl0UItHEA+64A1yHA+64AxyFvNFDxCt9A0AAPNED1hpUPNFD1jr629Ii0c4SIsQQDiyDAEAAHUS90IUAAAEAHUJSItSCEUzwOsuSItSCEGwAeslQYtGFA+64BdyOkE4lgwBAAB1Cw+64BJyBUUzwOsDQbABSYtWCEiNTCRQ6I7LAwDzRA8QbCRQ80UPWK30DQAA80QPWO5Ji4fABAAASIXAdBJIi0hASIlNgEiFyXQMi0EI6wxIi85IiU2AuAEAAABIY9BIiVWohcAPjh4DAADzRA8QTCR0TIvu80QPEFQkcPMPEHQkbEiJdaAPH0QAAEiFyXQSSItBEE6LfCgITYX/D4TAAgAASYvWSYvP6B7u//+EwA+EqQIAAEGAvwwBAAAAdQ9B90cUAAAEAHUFRTPA6wNBsAFJi1cISI1MJHjozMoDAPMPEEQkeEEPKP1Mi23I8w9Y+EiLBfPWOABFDyjl8w8QFUudNwBEDyjG80QPWEQkfPNBD1iF9A0AAPMPEIicDQAADy/KQYuXkAQAAPNED1jo80QPEWQkUPMPEXQkVPMPEXwkWPNEDxFEJFxzJIvCD1fAwegY80gPKsCLwiX///8A8w9ZwfNIDyzIweEYi9EL0A8vykWLp5wEAABzKEGLxA9XwMHoGPNIDyrAQYvEJf///wDzD1nB80gPLMjB4RhEi+FEC+APL8pBi5+wBAAAcySLww9XwMHoGPNIDyrAi8Ml////APMPWcHzSA8syMHhGIvZC9gzyejxl/3/i9O5OQAAAOjll/3/TIv2ZpBBi38Uwe8Sg+cBRQ8v43IVDy/2chBEDy/XcgpFDy/ID4OQAAAASot09fBBDyjDDyjO80QPEVwkaPNBD1/C8w8RdCRs80EPX8mLjqQAAABIjZ6gAAAARIsD8w8RRCRw8w8RTCR0RDvBdSlB/8CFyXQLi8GZK8LR+APB6wW4CAAAAEE7wEiLy0QPT8BBi9DoblYAAEhjE0iLzkiLQwhIA9IPEEQkaA8RBND/Aw8RRmDoHdoAADP2Sotc9fBIjVQkUEiLy0WLzESLx+jTyQMASYtHCEiNVCRQTYuN3A0AAESLx0iJdCRISIvLSIl0JEDGRCQ4AIl0JDCJdCQoSIlEJCDoLM4DAEUPL+NyEQ8v9nIMRA8v13IGRQ8vyHM5i4OgAAAAg+gBiYOgAAAAdQpIi0M4SIPAOOsP/8hImEjB4ARIA4OoAAAADxAASIvLDxFDYOh82QAASf/GTDt1mA+Mn/7//7kCAAAA6FWX/f9Mi22gTIt1wEiLTYBMi324SYPFOEiDbagBTIltoA+FEv3//0yLbchIi12w6wIz9kiLfYjzDxAN/po3AEyNo+wAAADzQQ9fjeQNAADzDxAVups3AEjHwP/////zDxAdw5o3AEyL+PNEDxAtS5o3AEUPV/9IiUXA8w8RTCR4TIlkJFAPH0AA80EPEEQk/EEPL0QkBA+HkAIAAPNBDxAEJEEPL0QkCA+HfgIAAEUPEEQk/EUPKOBFDyjYRQ8o8EUPxuBV80QPXPJFD8bYqvNED1zi80QPXNtEDxFFAEUPxsD/80QPXMM5g+AAAAB1DYC70wAAAABEi22QdQREi22URItkJGBFDyjTRQ8oyPNFD1jW80UPWMxIi/5BgeQAAAD/80UPWdXzRQ9ZzfNFDyzy80EPLPEPHwBFDy/PcxRmD27GD1vAQQ8uwXoCdAWNTv/rAovORQ8v13MWZkEPbsYPW8BBDy7CegJ0BkGNRv/rA0GLxkiLXP3wTI1FCGYPbvlIjVUAZg9u8EiLy8dEJCgAAAAARYvN8w8RTCQgD1v2D1v/6GEBAQBFheQPhLwAAAD2QzABQQ8o1kEPKNzHRCQgAAAAAPNBD1jVQQ8ow/NBD1jdQQ8oyEiLy3Qo80EPXMXzDxFVoPNBD1zN8w8RXaRMjUWoSI1VoPMPEUWo8w8RTazrLPMPXAWtmDcA8w9cDaWYNwDzDxFV2EyNRdDzDxFd3EiNVdjzDxFF0PMPEU3U8w8QXCR46K76AADzDxAFupg3AEiLy0SLTCRgRItDUEiLU1jzDxFEJCjHRCQgAQAAAOhz3AAAx0NQAAAAAEmD/wF3O0SLTCRgTI1F4PMPEXXgSI1V6PMPEXXoSIvL8w8QNWiYNwDzDxF0JCDzRA8RReTzRA8RZezoDf4AAOsI8w8QNUeYNwBJjUf+SIP4AXc0RItMJGBMjUQkaEiNVbjzRA8RXCRoSIvL8w8RfCRs80QPEXW48w8RfbzzDxF0JCDoxf0AAPMPEEwkeEj/x0g7fZgPjDL+///zDxAVApk3APMPEB0SmDcATItkJFBIi0XATIttyEiLXbBIi32ISIX/dAb2RxAQdStBgL2AAAAAAHUh/8BJg8QQSf/HSIlFwEyJZCRQvgAAAABJg/8ED4wn/f//TI2cJLgBAABBDyhz6EEPKHvYRQ8oQ8hFDyhLuEUPKFOoRQ8oW5hFDyhjiEUPKKt4////RQ8os2j///9FDyi7WP///0mL40FfQV5BXUFcX15bXcPMzMzMSIlcJAhIiWwkEEiJdCQYSIl8JCBBVEFWQVdIg+wgSIt0JGhIi/pMiyWz0DgASIvpSWPZTWP4SIX2dA5Fhcl0CUyL9kiJVhjrEzPS6ECe//9Mi/BIiXgYSIX2dAWD+wF1DTPSSIvN6CWe//9Ii/BIiX4YhdtIi08gSIvuSQ9E7kiJTSBIi0coSIlFKEiFyXQESIlpGEiLRShIhcB0BEiJaBiLR2BIi9eJRWDyDxBHWPIPEUVYSIuHkAAAAEyJdyBIiXcoSItM3yBIiYGQAAAAg6fIAAAAyYOPyAAAAAnzDxBPVESJf2BIx4eQAAAAAAAAAPNDDxCEvLgNAADzQg8QVL9Q8w9YwPNBD1yUJLQOAADzD1/Q8w8QR1DzDxFGWPMPEU5c80EPEUZY80EPEU5cSItM3yAPKMLzD1lEJGDzDyzAZg9uyA9byfMPXNHzQw8RTL5Y8w8swmYPbsAPW8DzQg8RRL5Y6Ha5//9Ii1TfIIsPixLoGCAAAEiLRxhIi9dIhcB0DEiL0EiLQBhIhcB19ICizAAAAN9Ii0ogSIXJdAXoG77//0iLSihIhcl0BegNvv//SIN6GAB1JkiLgpgAAABIhcB0GmZmDx+EAAAAAACAiMwAAAAgSItAGEiFwHXwTItHUEUzyUiLV0hIi8/ovQMAAItHBEGJRgSLRwSJRgSLRwglcPgDAIlFCIFnCI8H/P9Bi0YMQQtGCEELRgRBiUYQi0YMC0YIC0YEiUYQi0cMC0cEC0cIiUcQ90UQAAgAAHQgSItHGEiFwHQQDx9AAEiL+EiLQBhIhcB19EiJr5gAAABIi1wkQEiLbCRISIt0JFBIi3wkWEiDxCBBX0FeQVzDzMzMzMzMzMzMzMzMzMxIiVwkEEiJbCQYSIl0JCBIiUwkCFdBVEFVQVZBV0iD7EBIiwUozjgARTPkSItyIE2L+EiLeihIi9oPKXQkMEyL6feAVCoAAAAEAAAPKXwkIHQoSIX/dAVEiwfrA0WLxEiF9nQEixbrA0GL1ESLC0iNDTs+NwDoRi8AAEmLTyDzDxBzWPMPEHtcSIlLIEmLRyhIiUMoSIXJdARIiVkYSItDKEiFwHQESIlYGEGLR2CJQ2DyQQ8QR1jyDxFDWE2JZyhNiWcgSIX2dBRIi9ZIi8vofLf//4sTiw7oIx4AAEiF/3QUSIvXSIvL6GO3//+LE4sP6AoeAABMi3M4SGNDMEmNLMZMO/V0OGYPH4QAAAAAAEmLDkiNU0hBuAEAAADoHqT+/0G4AQAAAEiNU1DoX6X+/0mDxghMO/V11kyLbCRwgaPIAAAAAP7//0mLh5AAAACLUwhIiYOQAAAAi8Iljwf8//MPEXNY8w8Re1yJQwhIhfZ0BYtGCOsDQYvEM9CB4o8H/P8z0IlTCEiF/3QFi08I6wNBi8yB4XD4AwALyolLCEiF9nQFi1YM6wNBi9RIhf90BYtHDOsDQYvEC8KJQwwLQwQLwYlDEEmNncAoAABIhfYPhIoAAACLFkUzwEiLy+isif3/SIvO6CSw//9MiwVdzDgATYXAdGBJD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ5jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQnHQQQAAAAAZv9BBkH/gBgrAABIi87/FSd3BwBIhf8PhIsAAACLF0UzwEiLy+gZif3/SIvP6JGv//9MiwXKyzgATYXAdGFND7+QHCsAAEmNkCArAABFi0gESo0U0kQ5CnQ6QY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkKx0IEAAAAAGb/QgZB/4AYKwAASIvP/xWTdgcADyh0JDBMjVwkQEmLWzhJi2tASYtzSA8ofCQgSYvjQV9BXkFdQVxfw8zMzEyL3FNVSIHsuAAAAEUPKUO4RQ8pS6hFDylTmEUPKVuISIsFSa84AEgzxEiJRCRI80QPEB0ckTcAZkkPbsDzRA8QFU6RNwBIi9lJiXMQZkwPbsJJiXvoRQ9XyUEPKXPYQQ8pe8jyDxFEJChmDx9EAABIiy25yjgASIvLTYXJdAVMO8t1C/JEDxFDSPIPEUNQTItTIE2F0g+EjwIAAEiLWyhBDyjw8g8RdCRADyjI8g8RRCQ4Dyj48g8RRCQwTYXJdBFJi8FJO8J0P0iLQBhIhcB18jLSTYXJdBVJi8EPH0AASDvDdCdIi0AYSIXAdfJAMv9BD7ayzAAAAED2xgF1EoTSdQ5FMsDrDLIB681AtwHr4EGwAUQPtpvMAAAAQfbDAXUJQIT/dQQywOsCsAFFhMAPhJYBAACEwA+EjgEAAEhjSWDzDxCttA4AAPMPEFSMKPMPEISNuA0AAPMPXNXzD1jA80EPX9EPKMrzD13I80EPWcvzDyzBZg9u4A9b5ECE9nlWTI1EJDhNjQSIRYTbeCUPKMrzQQ9cyvNBD11MilDzD1zR80EPEUyKWPMPEVSLWOnnAAAA80EPEAgPKMHzD1hEjDDzD17I8w9ZyvMPLMFmD27ID1vJ68dFhNt5Ng8owkyNRCQ480EPXMIPKMpNjQSI8w9dRItQ8w9cyPMPEUSLWPMPEUSMMPNBDxFMiljpjwAAAPNBDxBEilhBDy7BegJ0E0H2wyB0DQ8oyvMPXMzzD13I61rzDxBci1hBDy7ZegJ0KUD2xiB0Iw8owkyNRCQ48w9cxA8oyk2NBIjzD13D8w8RRIww8w9cyOs28w9Y2A8ozPMPXsPzD1nC80EPWMPzDyzAZg9uwA9bwPMPX8hMjUQkOE2NBIjzD1zR8w8RVIwwDyjB8w9YzfNBDxEA8g8QfCQw8w9YTIxA8w8RTIxA8g8QdCRA8g8QTCQ4TYXJdSeAo8wAAAB/QQ+2kswAAACA4n9BiJLMAAAAD7a7zAAAAECA5wGA4gGE0nQVRTPJZkkPfshmTA9+wkmLyujv/P//QIT/dBVFM8nyDxF8JChEDyjGDyjH6UX9//8PKLwkkAAAAA8otCSgAAAASIu8JLAAAABIi7Qk2AAAAEiLTCRISDPM6KgSBwBEDyiEJIAAAABEDyhMJHBEDyhUJGBEDyhcJFBIgcS4AAAAXVvDzMzMQFNVVldBVkiD7DBIiwXeqzgASDPESIlEJChIg3kgAEyNcSBJi+lIiUwkIEGL+IvySIvZdHJJiw5Ii8NIi9NmkPaBzAAAAAF0IzlwYHURhf90DUiLQij2gMwAAAABdQ1Mi81Ei8eL1uiU////SItDKPaAzAAAAAF0OzlzYHURg/8BdAxJiw72gcwAAAABdSVIi0ggTI1wIEiJRCQgSIvYSIvQSIXJdZlIjVQkIEiLzej8LgAASItMJChIM8zovxEHAEiDxDBBXl9eXVvDzMzMzEiLxEiJWBBIiXAYSIl4IFVBVEFVQVZBV0iNaLhIgewgAQAADylwyA8peLhEDylAqEQPKUiYRA8pUIhIiwXfqjgASDPESIlFyEiL+UiDeSAAD4TSBQAAugAAAQDzRA8QFVCMNwBFD1fJDx+EAAAAAABMiz1pxjgASItfIEiJXCRQTItvKEyJbCRg9oPMAAAAAQ+EdQUAAEH2hcwAAAABD4RWBQAASGN3YPMPEENI8w8RRZjzDxBLTPMPEU2c8kEPEEVI8g8RRaDzDxBEs1DzD1hEtZjzDxFEtZhIi8ZIg/AB80EPEESFUPMPWESFoPMPEUSFoEGLRRALQxC5AAACAIX2D0TKqCAPhY8EAACFyA+FhwQAAEmLn9gVAACLF0iLy+jLpv7/RIvoTI2jQAEAAESLg0QBAABBiwwkQTvIdSj/wUWFwHQNQYvAmSvC0fhBA8DrBbgIAAAAO8EPT8iL0UmLzOjpSgAASWMMJEmLRCQIRIksiEH/BCRIjQWBLgAASIlEJCBMjQ31LgAAuhAAAABBuAIAAABIjU2o6IEXBwCQ80UPEIS3uA0AAEiLRyBBDyjw8w9YdLBISItHKPMPEHywUPMPWHywSPNBD1z4SIsFDMU4AEiLmNgVAABIY4NAAQAATIuDSAEAAEWLRID8M9JIjQ2RNTcA6NR2/f9Ei+BIiws5gTAWAAB1E0yNBXc1NwC6CwAAAIvI6GMqAABIi1wkUEU5p0wWAAAPhdoAAABMjU2oQbgBAAAAi9ZIi8vo7fz//0yNTbhFM8CL1kyLbCRgSYvN6Nf8//+LRaiFwH5VSItNsIvQZmYPH4QAAAAAAEiLAfMPEEhM8w8QQEjzDxFEJHjzDxFMJHzzD1hAUPMPEUWA8w9YSFTzDxFNhEEPKMDzD1hEtHjzD1/wSIPBCEiD6gF1u0iLRbiFwH5RSItNwIvQSIsB8w8QSEzzDxBASPMPEUWI8w8RTYzzD1hAUPMPEUWQ8w9YSFTzDxFNlPMPEES1kPNBD1zA8w9d+EiDwQhIg+oBdbzrBUyLbCRg8w8QRLNQ8w8RRCRY80UPEES1UPNEDxFEJGDzD1x0s0jzRQ9YRLVI80QPXMdIix2fwzgADxCD6A4AAA8RRCRoD8bA//MPWYOcDQAA8w8RRCR0SI1MJGjo13v9/0SL4PNBDxC/zBUAAEiLm9gVAABIY4tAAQAATIuDSAEAAEWLRIj8M9JIjQ3wMzcA6DN1/f9Ei/hIiws5gTAWAAB1E0yNBdYzNwC6CwAAAIvI6MIoAABEiWQkSPNEDxFUJEDzDxF8JDjzRA8RRCQw8w8RdCQoSI1EJGBIiUQkIEyNTCRYRIvGQYvXSI1NmOgVkQIATIs93sI4AITAD4RHAQAARItFqEWFwA+OOgEAAEiLVbhIi1wkUIXSD44uAQAA8w8QRCRY8w8RRLNY8w8RRLNQ8w8QVCRgDyjK80EPXEy1UPNBDxBEtUjzD1zB80EPEUS1SPNBDxFUtVjzQQ8RVLVQRTPJRYXAflUz0g8fQAAPH4QAAAAAAEiLRbBIiwwQSIPBGEiLAUg7x3QjOXBgdQtIi0AggIjMAAAAgEiLCUiDwRhIiwFIO8d14USLRahB/8FIg8IIRTvIfL1Ii1W4RTPAhdJ+RkUzyUiLRcBKiwwISIPBGEiLAUg7x3QjOXBgdQtIi0AogIjMAAAAgEiLCUiDwRhIiwFIO8d14UiLVbhB/8BJg8EIRDvCfL1FM8lMi0NQSItTSEiLy+iJ9v//RTPJTYtFUEmLVUhJi83odvb//0UPL48EKQAAchJBi0dMQYmHBCkAAOsFSItcJFBJi4/YFQAAi4FAAQAAg/gBfw5IjQ15FzcA6JzX/v/rCP/IiYFAAQAATI0NeyoAALoQAAAAQbgCAAAASI1NqOi/EgcA619BDxCHeBAAAA8RRCRoD8bA//NBD1mHnA0AAPMPEUQkdEiNTCRo6Ht5/f9Ei8hJi4/YFQAAx0QkKAAAAADzQQ8Qh+QNAADzDxFEJCBMjUWgSI1VmEiLiRgDAADoVu8AAPaDzAAAAAF0CEiLy+j1+f//QfaFzAAAAAF0E0mL/UmDfSAAugAAAQAPhUj6//9Ii03ISDPM6HwLBwBMjZwkIAEAAEmLWzhJi3NASYt7SEEPKHPwQQ8oe+BFDyhD0EUPKEvARQ8oU7BJi+NBX0FeQV1BXF3DzMxAU0iD7CBIi9lIi0kgSIXJdQlIi8NIg8QgW8Po4P///0iFwHUOSItLKEiDxCBb6c3///9Ig8QgW8PMzMzMzMzMQFNIg+xA9oHMAAAAAUiL2Q8pdCQwZkgPbvLyDxF0JCAPhIgAAADzDxBJSA9XwPMPEFFMDyjZ8w9YWVDzDxBsJCDzD1zIDyji8w9YUVTzD1zg8w9Y2A8v6fMPWNByUPMPEEQkJA8vxHJFDy/ddkAPL9B2O0iLSSBIhcl0JGZID37y6Hr///9IhcB1JUiLSyhmSA9+8uhn////SIXASA9F2EiLww8odCQwSIPEQFvDM8APKHQkMEiDxEBbw8zMzMzMSIlcJAhXSIPsIIvaSIv5RYXAdBAPvoEsAQAAQYXAD4SSAAAAi4EsAQAAD7bIJQD///+B4fEAAAALyImPLAEAADmXyAQAAHRuSIsNIb84AEiBwcAoAADodXr9/0iFwHQ5SIN4IAB0MkiLSBhIhcl0DEiLwUiLSRhIhcl19EiLmJgAAABIhdt1B0iNmLgAAACLGzmfyAQAAHQdSIuPuAQAAEiFyXQLRTPASIvX6CCm//+Jn8gEAABIi1wkMEiDxCBfw8zMzMzMzMzMzMzMzMzMzEiJXCQQSIlsJBhIiXQkIFdBVEFVQVZBV0iD7FBIiwW9ojgASDPESIlEJECL6UyLPWy+OABNja/AKAAARTPShcl0RIvRSYvN6LR5/f9Mi/BIhcAPhG0DAADGRCQgAIuAyAAAAMHgGsH4HYlEJCxFi6bIAAAAQcHkHUHB/B1EiWQkKEUz0usVTYvyRIhUJCBFi+JEiVQkKESJVCQsRIlUJDRBi9qJXCQwSYvyTIlUJDhBi/pBg30AAA+O6QAAALoBAAAARItkJCBmDx+EAAAAAABJi0UISItcMAhIiVwkIEiF2w+EnAAAAIXtdCU5Kw+EkAAAAEiLQxhIi8tIhcB0DZBIi8hIi0AYSIXAdfQ5KXVz90MQAAgAAEUPtuRED0Xihe10L0mLh9goAABJY4/QKAAASMHhBkgDyEg7wXQVDx8ASDlYEHUDRIkQSIPAQEg7wXXuTYX2dBVIi9NJi87oPqf//0GLFosL6OQNAABIjVQkIEiNTCQw6CUlAABFM9K6AQAAAP/HSIPGEEE7fQAPjD3///9EiWQkIEiLdCQ4i1wkMESLZCQoTYX2dCuLTCQsjQzNAAAAAEGL1EEzlsgAAACD4sCLwUEzxIPgxzPQM9FBiZbIAAAASYuPMCkAAEiNQQRNi8pIhclMD0XITYXJdFZFi0EURYXAdCJBi9KF234bSIvOSIsBRDkAdAz/wkiDwQg703zu6wRBiWkUTWNB/E0DwUljjygpAABJi5cwKQAASIPCBEgD0U2Lykw7wk0PRchNhcl1qoP7AX4fSGPTSIP6AXYWTI0NFY3//0G4CAAAAEiLzv8VLmkHAIXbfhtIi/5FM8BIixdJi8/ooYv//0iNfwhIg+sBdeiF7Q+FkgAAAEmLzeh3V/3/TYtNGE2FyQ+EowAAADPbSYldEEyLBe27OABNhcB0XEWLUARJD7+QHCsAAEmNiCArAABIjQzRRDkRdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEYlZBGb/QQZB/4AYKwAASYvJ/xW7ZgcASYldGOsmgHwkIAB0H02JtpgAAABBgU4IAAgAAEGLRgxBC0YEQQtGCEGJRhBIhfZ0d0yLBUu7OABNhcB0YUWLSARND7+QHCsAAEmNkCArAABKjRTSRDkKdDpBjUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/RSIHCZAUAAEmNFNBEiQrHQgQAAAAAZv9CBkH/gBgrAABIi87/FRRmBwCQSItMJEBIM8zongUHAEyNXCRQSYtbOEmLa0BJi3NISYvjQV9BXkFdQVxfw0iJXCQQSIlsJBhXSIPsIEiLHZq6OAAz/w+26oTSdFBIi4swKQAARIvPSIXJSI1BBEwPRchNhcl0Ng8fgAAAAABNY0H8QYl5FE0DwUiLkzApAABMi89IY4soKQAASIPCBEgD0Uw7wk0PRchNhcl10Tm7eBUAAH4zSIl0JDBIi/eQSIuTgBUAAEQPtsVIi8tIixQy6HmZ////x0iNdgg7u3gVAAB820iLdCQwSItcJDhIi2wkQEiDxCBfw8zMzMzMzEiJXCQISIlsJBBIiXQkGFdBVkFXSIPsIEyLNdG5OABMi/qAoY0EAAD4SIv5SYvuQYC+gwAAAAB1BoB5PAB0XvdBFAEACAF1VYC5CgEAAAB1TIO5yAQAAAB1dLsBAAAASY2OwCgAAIvT6ON0/f9IhcB0Iw8fQABmZg8fhAAAAAAA/8NJjY7AKAAAi9PowHT9/0iFwHXriZ/IBAAA6zGLSRSB4QAACABB9oYAIAAAAXQaD76HKQEAAEGFhgQgAAB0CkGAvkQgAAAAdT+FyXU7i5/IBAAASIu3uAQAAIXbD4RTAQAASIX2D4VKAQAASY2OwCgAAIvT6FZ0/f9Ii/BIhcB0LkiDeCAAdFJBsAFIi9dIi83oOZj//0iLXCRASItsJEhIi3QkUEiDxCBBX0FeX8OL00iLzehmhv//SIvwgaDIAAAAkv7//4GIyAAAAJIAAABBi0YEiYasAAAA9obMAAAAAQ+FmwAAAEyL1g8fRAAASYtCGEiFwHQM9oDMAAAAAUyL0HTrSYtCGEmL0kiFwHQMSIvQSItAGEiFwHX0gKLMAAAA30iLSiBIhcl0Begep///SItKKEiFyXQF6BCn//9Ig3oYAHUpSIuCmAAAAEiFwHQdDx9AAGYPH4QAAAAAAICIzAAAACBIi0AYSIXAdfBNi0JQTIvOSYtSSEmLyui97P//D7aezAAAAEGwAUiL10iLzujYnP//D7aGzAAAAEyLNcq3OAAPtsgyy4DhATLIiI7MAAAAi0UEOYasAAAAfTZIi0YYSIXAdBJmDx9EAABIi/BIi0AYSIXAdfSLRQQ5hqwAAAAPjJ7+//+Aj40EAAAB6aD+//9MjQUymgkATIvPTSvITI0VSZoJAA8fRAAASWMISMHhBEiBwcgOAABJA87oqm/9/0OJhAiQBAAASYPABE07wnzZSIuGiAAAAEiFwHVCg34UAnUHgI+NBAAAAYN+MAEPjj3+//+AvwgBAAAAD4Qw/v//gL8BAQAAAMaHCQEAAAEPlMD+wIiHIwEAAOkS/v//9kYQAcdGFAMAAAB1FA+3gBYBAABmOYcWAQAAD4zj/f//QYOOACAAAAEz0vIPEEZIQYOOACAAAALyQQ8RhhQgAABJiZYcIAAAQceGBCAAAAEAAABBxoZEIAAAAfIPEEZQ8kEPEYYkIAAAQceGCCAAAAEAAACIlUQgAAAPtoeNBAAAJPsMA4iHjQQAAPZGEAEPhX39//9IOb6QAAAAdQgMBIiHjQQAAItHFINPHAINAgAAAYlHFESLRhBBD7rgDXIMQQ+64AxyBYPg/usDg8gBiUcUSDlWQHRZOJcCAQAAdFFIi4e4BAAATItQQE2F0nQ1RIuHwAAAAEWFwHQpSWNCCIXAfiFMi8hIi8pJi0IQRDkAD4SQAAAA/8JI/8FIg8A4STvJfOm6/////2aJl44EAAD2hswAAABAdQ6Lh8AAAAA5hsAAAAB1CU2F/3QEQcYHAEiLh7gEAAAz0kiLbwhIi81Ii5iIAAAASGODQAEAAEyLg0gBAABFi0SA/OhbZ/3/SIsLi/A5gTAWAAB1D0yLxboLAAAAi8jo7xoAAIm3xAAAAOlr/P//SYtKEEhjwkhr0DhIA8oPhGr///9IuCVJkiRJkiRJSPfqSMH6BEiLwkjB6D9IA9DpT////0iLxEiJWBBIiXAYSIl4IFVBVEFVQVZBV0iNqHj9//9IgexgAwAADylwyA8peLhEDylAqEQPKUiYSIsFEZk4AEgzxEiJhRACAABIi/FIiz29tDgAgL/YIwAAAA+EHAUAAESLWRDzRA8QQVxBDyjw8w9YcWTzRA8QSVhBDyj58w9YeWDzRA8RTCRA80QPEUQkRPMPEXwkSPMPEXQkTEyLl9gVAABIi4foFQAASIXAD4TJBAAASIuAIAQAAEk5giAEAAAPhbUEAABBsAFIjVQkSEiNTCRA6Fel/v+EwA+EmwQAAEQ7n/QjAAAPhI4EAABBgLoGAQAAAA+FgAQAAPNEDxGPKCQAAPNEDxGHLCQAAPMPEb8wJAAA8w8RtzQkAABBDxCCsAIAAA8RhzgkAABEiZ9IJAAAM9uJn0wkAABEiIfaIwAAg7/8IwAA/w+EGQQAAEiNlwAkAABIjQ1CCDcA6L8RBwCFwA+F/gMAAEiLh+gjAABMizhJi9dIi87oQMv//4TAD4ThAwAA6PNI//9MizV8szgASIXAD4S4AwAARTLtSIuOwAQAAEiFyXRdSIuXGAEAAOgo8///SIvYSIXAdHn3QBAABAAAdDlIg3gYAHUySIuAmAAAAEiFwHQHSIN7IAB0HEiLSyBIhcl0Fuiv8v//SIXAdQlIi0so6KHy//9Ii9hIhdt0MusPSIuGuAQAAEiFwHQhSIvYSItLQEiFyXQYi0MQD7rgDXIPD7rgDHIJDxBZNOtLQbUB80EPEJbgDQAA8w8QXljzDxBGXA8oy/MPWE5g8w9Y0vNBD1iW8BIAAPMPWNAPxtvh8w8Q2A/G28bzDxDZD8bbJ/MPENoPxts5gL+CAAAAAA+FyQAAAEmLhtgVAAAPKPMPxvNV8w9fsLQCAAAPKPvzD1+4sAIAAA8o6w/G6//zD12ovAIAAA/G26rzD12YuAIAAPNBDxCmBA4AAPNFDxCGGAEAAA8ox/MPXMREDy/AcmnzQQ8QjggOAADzQQ8QlhwBAAAPKMbzD1zBDy/QcksPKMPzD1jEQQ8vwHY+8w9YzQ8vynY1SYuGUCEAAPMPEGAM8w8QUAgPKMrzD1hIEA8oxPMPWEAUDy/Gdg8PL+x2Cg8vz3YFDy/adwVFMuTrA0G0AYC/ISQAAAB1DYC/IiQAAAAPhOUBAABIhdt1CUWE7Q+E1wEAAEiNjdAAAADoBnv//5BIjU2Q6Px6//+QTI210AAAAEiF23RlSItDGEiFwHUP90MQAAgAAHUGSDlDIHRNSIvTSIXAdBFIi9BIi0AYSIXAdfRIhdJ0LcZEJDABRIhkJChIjUWQSIlEJCBNi8dIi87oEM7//0iNRZCAfWMASQ9ExkyL8EiDeyAAdSTGRCQwAESIZCQoSI2F0AAAAEiJRCQgTYvHSIvTSIvO6NbN//8PtoWgAQAASI1NkEw78bkAAAAAD0TBiIWgAQAATI2N0AAAAE2Lx0iL00iLzugV1P//TI1NkE2Lx0iL00iLzugD1P//QYC+0AAAAAAPhL0AAACAvyIkAAAAD4SwAAAAD1f2x0QkUAEAAABIiXQkWEmLhtgAAABIiUQkYEyJfCRoQYuG4AAAAIlEJHDzQQ8QhuQAAADzDxFEJHRIjUWQTDvwD5REJHhIgcfQKAAARItHBIsPQTvIdSj/wUWFwHQNQYvAmSvC0fhBA8DrBbgIAAAAO8EPT8iL0UiLz+iXNAAASGMPSMHhBkiLRwgPKEQkUA8RBAEPKEwkYA8RTAEQDyhEJHAPEUQBIA8RdAEw/wdIjU2Q6I+T//+QSI2N0AAAAOiCk///TIs1u684AEHGhtojAAAAQYC+IiQAAAB1EOsTiJ/aIwAAOJ8iJAAAdAXoNEL//0iLjRACAABIM8zoVfoGAEyNnCRgAwAASYtbOEmLc0BJi3tIQQ8oc/BBDyh74EUPKEPQRQ8oS8BJi+NBX0FeQV1BXF3DSIlcJAhIiXQkEFdIg+wgSIsdOq84AIv6i/H3g1QqAAAABAAAdBFEi8KL0UiNDe4fNwDoiRAAADPSOZN4FQAAfjRFM8BIi4OAFQAASYsMADmxyAQAAHUQSIO5uAQAAAB1Bom5yAQAAP/CSYPACDuTeBUAAHzPSIuTMCkAADPASIXSSI1KBEgPRcFIhcB0NGaQOXAUdQOJeBRMY0D8SIuTMCkAAEwDwEhjiygpAABIg8IEM8BIA9FMO8JJD0XASIXAdc5Ii1wkMEiLdCQ4SIPEIF/DzMzMzMzMzMzMzMzMzMxAU0iD7CBMi4noKAAASIvZTYXJD4SLAAAATIsFUK44AEiJfCQwM/9IibngKAAATYXAdFxJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJeQRm/0EGQf+AGCsAAEmLyf8VEFkHAEiJu+goAABIi3wkMLIB6BXz//8zyUiDxCBb6Rnv///MzMzMzMzMzMxAU0iD7CCDuXgVAAAASIvZdQXoyX7//0SLg+AoAABIi8tIi5PoKAAA6FOG//9Ii8tIg8QgW+mWiP//zMzMzMzMM8BMjQ1/HjcAi8gPH0QAAEEPthQISP/BQTpUCf91C0iD+QV160E6VAn/D5TAw8zMSIlcJBBIiXQkGFVXQVZIi+xIgeyAAAAASIsFYZE4AEgzxEiJRfAz/8ZF6AAPV8CJfbgzwIl9vA8RRdCJReBJi9lMi/GJfbQPEUXAxkXQ/5APtgM8IHQEPAl1BUj/w+vwvggAAABIjRX0HTcARIvGSIvL/xWQWQcAhcB1FEgD3pAPtgM8IHQEPAl1Pkj/w+vwQbgJAAAASI0VWx03AEiLy/8VYlkHAIXAD4V6AwAASIPDCQ+2AzwgdAQ8CXUFSP/D6/CBTdQABAAATI1NtEiLy0yNRcBIjRWVHTcA6BBJ/f+D+AEPhT8DAABIY0W0TI1NtEgD2EyNRcRIi8tIjRV+HTcA6OlI/f+D+AF1EEhjRbRIA9g5fcQPhAwDAABMjU20SIvLTI1FyEiNFWodNwDovUj9/4P4AXUQSGNFtEgD2Dl9yA+E4AIAAEiNRbRIi8tMjU28SIlEJCBMjUW4OX3EdXpIjRVIHTcA6INI/f+D+AIPhbICAABIY0W0TI1NvEgD2EyNRbgPt0W4SI0VMB03AGaJRbBIi8sPt0W8ZolFsotFsIlF2EiNRbRIiUQkIOg9SP3/g/gCD4VsAgAASGNFtEgD2A+3RbhmiUWwD7dFvGaJRbKLRbCJRdzrLkiNFe4cNwDoCUj9/4P4AnUdSGNFtEgD2A+3RbhmiUWwD7dFvGaJRbKLRbCJReBMjU20SIvLTI1F6EiNFc0cNwDo0Ef9/4P4AXUoSGNFtA+2TehIA9iA+Vh1BkCIfdDrEg+2RdCA+Vm6AQAAAA9EwohF0EyNTbRIi8tMjUW4SI0VmRw3AOiMR/3/g/gBdRBIY0W0SAPYOX24dASDTdQgTI1NtEiLy0yNRbhIjRV9HDcA6GBH/f+D+AF1E0hjRbRIA9g5fbh0B4FN1AAIAABMjU20SIvLTI1FuEiNFWYcNwDoMUf9/4P4AXUTSGNFtEgD2Dl9uHQHgU3UABAAAEyNTbRIi8tMjUW4SI0VRxw3AOgCR/3/g/gBdRNIY0W0SAPYOX24dAeBTdQAIAAATI1NtEiLy0yNRbhIjRUwHDcA6NNG/f+D+AF1E0hjRbRIA9g5fbh0B4FN1ABAAABMjU20SIvLTI1FuEiNFSEcNwDopEb9/4P4AXUTSGNFtEgD2Dl9uHQHgU3UAIAAAEyNTbRIi8tMjUXMSI0VChw3AOh1Rv3/i1XEhdJ0S0ljhuAoAACFwH5ATYuO6CgAAEyLwEmLwUiLzw8fADkQdBD/x0j/wUiDwCRJO8h87usZSGPHSI0MwEmNBIlIhcB0CQ+2QBH+wIhF0UmNnuAoAABEi0MEiwtBO8h1Iv/BRYXAdAxBi8CZK8LR+EGNNAA78Q9PzovRSIvL6E8hAABIYwMPEEXASI0MwEiLQwgPEQSIDxBN0EiNFIgPEUoQi0XgiUIg/wNIi03wSDPM6NzzBgBMjZwkgAAAAEmLWyhJi3MwSYvjQV5fXcPMzMzMSIlcJCBVVldBVkFXSIPsUEGL8EiL+kiL6UUz/w8fQACLB4lEJCBIi0cYZkSJfCQySIXAdAiLAIlEJCTrBUSJfCQk90cQAAQAAHQhSIuHiAAAAEiFwHQVSIuAAAQAAEiFwHQJi0AQiUQkKOsFRIl8JCiLh7wAAACJRCQsTDl/IHQKD7ZHYIhEJDDrBcZEJDD/i0cIRItFJCUg/AMAi00giUQkNECIdCQx8w8sR0hmiYQkkAAAAPMPLEdMZomEJJIAAACLhCSQAAAAiUQkOPMPLEdQZomEJIAAAADzDyxHVGaJhCSCAAAAi4QkgAAAAIlEJDzzDyxHWGaJhCSIAAAA8w8sR1xmiYQkigAAAIucJIgAAABBO8h1Kf/BRYXAdA1Bi8CZK8LR+EEDwOsFuAgAAAA7wQ9PyIvRSI1NIOi/HwAASGNFIA8QRCQgDxBMJDBIjQzASItFKA8RBIgPEUyIEIlciCD/RSBIi1cgSIXSdAxEjUYBSIvN6IT+//9Ii38oSIX/dAf/xumU/v//SIucJJgAAABIg8RQQV9BXl9eXcNIi8RIiUgIV0FVQVdIg+xQ9kEwgEyNqcAoAABJi/hMi/oPhBQEAABFi0UkSIlYEEiJcCAz9kyJYOBMiXDYRYXAeRxBi8CZK8KL1tH4Qo0MAIXJD0/RSY1NIOgCHwAAQYl1IEmNTSBBi1UA6PEeAACL3kE5XQB+N2YPH4QAAAAAAEmLRQhIi1QwCEiF0nQSSIN6GAB1C0UzwEmLzejA/f///8NIg8YQQTtdAHzUM/ZJY1UgRIvmSIXSfhxJi00oSIPBEQ++AUiNSSRBO8RED03gSIPqAXXsTYsHSI0VyBg3AEiLz+goZf3/QYN9IABEi/4Pjh8DAABMi3QkcEyNDQYXNwBIi85IiawkgAAAAEiJTCRwSI0V530JAEmNnsAoAACLB4XASIlUJDCNaP8PRO5IjQWCGDcASYt1KEgD8UGLzEQPvkYRQSvIA8n3RhQABAAAiUwkKEiLz0kPRcFMi8pIjRViGDcASIlEJCBFA8DonWT9/0SLBkiNFVsYNwBIi8/oi2T9/0SLRgRFhcB0Hg+/RiJIjRVPGDcARA+/TiBIi8+JRCQg6GZk/f/rQUSLRghFhcB0D0iNFUwYNwBIi8/oTGT9/w+/ThxIjRVJGDcAD79GHkQPv04aRA+/RhiJRCQoiUwkIEiLz+gjZP3/D7ZGEDz/dBxFM8BIjRUxGDcAhMBIi89BD5XAQYPAWOj/Y/3/9kYUIHQPSI0VIhg3AEiLz+jqY/3/90YUAAgAAHQPSI0VGhg3AEiLz+jSY/3/90YUABAAAHQPSI0VEhg3AEiLz+i6Y/3/90YUACAAAHQPSI0VChg3AEiLz+iiY/3/90YUAEAAAHQPSI0VAhg3AEiLz+iKY/3/90YUAIAAAHQPSI0VAhg3AEiLz+hyY/3/RItGDEWFwHQPSI0VAhg3AEiLz+haY/3/QYC+ugAAAAAPhAwBAACLFkiLy+jiX/3/SIvYSIXAD4TvAAAAiw9MjQ0dfAkAhcm4AAAAAI1R/0iLzw9E0LgCAAAAK+pIjRXDFzcARI1FXEGD+AJED07A6P5i/f/3QxAABAAAdCtIi4OIAAAASIXAdB9Mi4AABAAATYXAdBNNi0AISI0Vihc3AEiLz+jKYv3/SYuOMCkAADPSSIXJi9qL6kiNQQRID0XYSIXbdGZFM+2LBjlDFHUqi8X/xYXAdQ9IjRVcFzcASIvP6Ixi/f9MjUMkSIvPSI0VVhc3AOh5Yv3/TGND/EmLljApAABMA8NJY44oKQAASIPCBEgD0UmL3Uw7wkkPRdhIhdt1pE2NrsAoAABJjZ7AKAAASI0VaQ43AEiLz+gxYv3/SItMJHBIjRUVewkASIPBJEyNDRIUNwBB/8dIiUwkcL4AAAAARTt9IA+ME/3//0iLrCSAAAAASI0VJA43AEiLz+jsYf3/TIt0JEBMi2QkSEiLtCSIAAAASItcJHhIg8RQQV9BXV/DzMzMzMzMzMzMzMxAVldIg+xISIv5SIHBACgAAOhaPv3/M8n/FZpLBwCFwHUJM8BIg8RIX17DuQ0AAABIiVwkYP8VRUwHAEiL2EiFwHUU/xXnSwcASItcJGAzwEiDxEhfXsNIi8tIiWwkaP8VU0cHAEiL6EiFwA+EtAAAAEyJdCRwQbn/////TIl8JEBMi8BFM/8z0kyJfCQ4uen9AABMiXwkMESJfCQoTIl8JCD/FRhHBwCLjwQoAABEi/A7wX4phcl0C4vBmSvC0fgDwesFuAgAAABBO8ZIjY8AKAAAQYvWD0/Q6PIeAABEibcAKAAAQbn/////TIl8JDhIgccIKAAATIl8JDBMi8VEiXQkKDPSuen9AABIiwdIiUQkIP8Vp0YHAEyLfCRATIt0JHDrB0iBxwgoAABIi8v/FZNGBwD/FfVKBwBIiwdIi2wkaEiLXCRgSIPESF9ew8xAV0iD7DAzyUiL+v8VV0oHAIXAD4SqAAAAM8BIiVwkQIlEJChBuf////9Mi8dIiUQkIDPSSIl0JEi56f0AAP8VDEYHAEhj8LkCAAAASIvWSAPS/xUARgcASIvYSIXAdFNIi8j/Ff9FBwBBuf////+JdCQoTIvHSIlEJCAz0rnp/QAA/xXIRQcASIvL/xXnRQcA/xXJSQcASIvTuQ0AAAD/FVtKBwBIhcB1CUiLy/8VrUUHAP8VJ0oHAEiLdCRISItcJEBIg8QwX8PMzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0iD7EBIi/Iz7YlsJChIiWwkIEG5/////0yLwjPSuen9AAD/FUhFBwCL+EiJbCQwi91IiVwkOIXAfh6L0LgIAAAAO9APTNCF0n4OSGPKSAPJ6AvD/f9Ii9iJfCQoSIlcJCBBuf////9Mi8Yz0rnp/QAA/xX5RAcAx0QkKAoAAABIiWwkIEUzyUyLw0iNFd8TNwAzyf8Vf0gHAEiD+CBAD5/HSIXbdHJMiwUjoDgATYXAdFxFi0gESQ+/kBwrAABJjYggKwAASI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJaQRm/0EGQf+AGCsAAEiLy/8V8UoHAJBAD7bHSItcJFBIi2wkWEiLdCRgSIPEQF/DzMzMzMzMzMzMzMzMzMzMQFNVVkiD7HBIiwXBgzgASDPESIlEJGBIi1pgSYvoSIvySIXbD4S/AAAASIvLSIm8JJAAAAD/FY1DBwBIi/hIhcAPhJoAAAAPV8DHRCRAIAAAAPMPf0QkTEiNVCRA8w8QRQTzD1xGCPMPLMjzDxBFCPMPXEYMiUwkREiLz/MPLMCJRCRI/xVGQwcA8w8QTQRIjVQkIPMPXE4ID1fAx0QkIAAAAADzD39EJDBIi8/HRCQkQAAAAPMPEEUI8w9cRgzzDyzBiUQkKPMPLMCJRCQs/xXjQgcASIvXSIvL/xXfQgcASIu8JJAAAABIi0wkYEgzzOhq6QYASIPEcF5dW8PMzEiJTCQISIlUJBBMiUQkGEyJTCQgU1VWV0FWQVdIg+woSIs9aZ44AEyNfCRoRTP2SIvpi4dYKgAASI2PWCoAAESLRwSFwI1w/0EPRPZEOHcgdBVFi8hIjRUsEjcATI1HIOjrXP3/6wxIjRUqEjcA6N1c/f9Ni8dIjY9YKgAASIvV6Ptc/f+Lh1gqAABIjR3qnTgAhcBIjY9oKgAASIvTRIvGRI1I/0iLh2AqAABFD0TOSIXASA9F0Oj0Xf3/SIuHYCoAAEiFwEhj9kgPRdhIA/P3h1QqAAAAABAAdA9Ii9ZIjQ2m8DYA6PU5/f/3h1QqAAAAACAAdBZIjQ2iETcA/xUkQgcASIvO/xUbQgcASIPEKEFfQV5fXl1bw8zMzMzMzEiLxFNWV0iB7KAAAABIix1cnTgADylw2A8peMiAu4oqAAAAdAHMSIuD2BUAAEyNBUzwNgAPELOwHwAAM/a6AQAAAA8Qu8AfAACJs3QfAABIi0hA6EjA/f/zDxAFtGM3AA8ozw/Gz1UPKNfzD1zQD8b/qg/G9v/zD1j48w9c8EiL+PMPWMjyDxCDGAEAAA8o4PIPEYQk2AAAAA/G5FUPL9R2BQ8o2usHDyjf8w9d3PMPEKQk2AAAAA8v9HYFDyjG6wcPKMHzD13E9kAwAUyNhCTAAAAA8w8RnCTUAAAASI2UJMgAAAAPV9vzDxGEJNAAAACJdCQgSIvPdBrzDxAFkmI3APMPXMjzD1z48w9Y8PMPWNDrIPMPXA10YjcA8w9cPWxiNwDzD1g1aGI3APMPWBVgYjcA8w8RjCTAAAAA8w8RvCTEAAAA8w8RtCTIAAAA8w8RlCTMAAAA6GPEAADzDxA1b2I3AEG5AP8A/0SLR1BIi89Ii1dY8w8RdCQox0QkIAEAAADoJ6YAAEG5AP8A//MPEXQkIEyNhCTQAAAAiXdQSI2UJNgAAABIi8/o4McAAA8otCSQAAAADyi8JIAAAABIgcSgAAAAX15bw8zMzMzMSIlcJBhIiXQkIFdIg+wgi/JIi9k5EXRaiRFmx0EFAP+LSQxMiXQkMIXJeRmLwZkrwjPS0fgDyIXJD0/RSI1LCOj7HgAATIt0JDBIjUsYx0MIAAAAAIM5AH4HSItBCMYAAEyNRCQ4xkQkOAAz0ujeGAAAxkMEAIX2D4SwAAAASA++UwZMjUMED7bKhNJ4OEyNQwQ7Uwh9L0iLQxBIjQxSgHyIBQBMjRSITI1DBHUSQYB6BAJMjUMED7bKfgpMjUMEjUoBiEsGRItLCA++0UE70Q+UwIhDBYD5/3UWQcYAAYvGSItcJEBIi3QkSEiDxCBfw4TJeDlBO9F9NEgPvsFIjQxASItDEP5EiARID75DBkHGAAFIjQxASItDEIsEiEiLXCRASIt0JEhIg8QgX8NIi1wkQDPASIt0JEhIg8QgX8NMiUwkIFVBVkFXSIPsQEiLLUuaOABEi/JEi/mAvdQqAAAAD4QfAgAATA++jdYqAABIiXQkaEiLtdgVAABIiVwkYEiJfCRwQYD5/w+F+gAAAMaF1ioAAAAzwESLtkABAACLjdwqAABB/8ZIiUQkMESITCQ2RDvxfimFyXQLi8GZK8LR+APB6wW4CAAAAEE7xkiNjdgqAABBi9YPT9DoXx0AAEhjhdgqAABEO/B+Qklj1kg7wn068g8QTCQwSI0MQEjB4QJIK9BmZg8fhAAAAAAASIuF4CoAAEiNSQzyDxFMAfTHRAH8/////0iD6gF14USJtdgqAAAz24uOQAEAAI1BAYXAD44vAQAARIvDi9NmkDvZfQxIi4ZIAQAAiwwC6wNBi89Ii4XgKgAA/8NIg8IEQYkMAEmDwAyLjkABAACNQQE72HzL6e4AAABEO45AAQAAD4XhAAAASIuF4CoAAEuNDEmDfIgI/0iNNIgPhbkAAAAz20GLzkiJXCQwSIlcJHiD6QR0ZoPpB3Qxg+kBdBGD+QF1cEWLz0yNBcoNNwDrVU2LyEiNVCR4TI0FqQ03AEiNTCQw6PdI/f/rSUjHx/////9I/8dBOBw4dfdMiUQkIEiNVCR4TI0FcA03AESLz0iNTCQw6MdI/f/rGUWLyEyNBRcMNwBIjVQkeEiNTCQw6KxI/f9Mi0QkeEiNjegqAACLAYXAjVD/D0TTSf/AiVYISItUJDDoJlb9/4B+Bv/GRgUBdQREiHYGSItcJGBIi3wkcEiLdCRoSIPEQEFfQV5dw8zMzMzMzMzMzMzMzMzMzEiJXCQQSIl8JBhBVkiD7CBIi9lMi/KLSQSLOzv5D4XbAAAA/8eFyXQLi8GZK8LR+APB6wW4CAAAADvHD0/4O/kPjrgAAABIY89IweEDSIl0JDDoObr9/0iLUwhIi/BIhdIPhIsAAABMYwNIi8hJweAD6O7zBgBMi0sITYXJdGpMiwV6lzgATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xVGQgcASIlzCEiLdCQwiXsESGMTSItLCEmLBkiLfCRASIkE0f8DSItcJDhIg8QgQV7DzEyLSQhNhcl0dEyLBdCWOABNhcB0XkWLUARJD7+QHCsAAEmNiCArAABIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJETPAiUEEZv9BBkH/gBgrAABJi8lI/yWbQQcAw8zMM8BIiQFIiUEISIvBw8zMzEiJXCQISIl0JBBXSIPsIEiL2UiDwRDopTH9/0yLSwgz9k2FyXR4SIkzTIsFIJY4AE2FwHRcRYtQBEkPv5AcKwAASY2IICsAAEiNDNFEORF0NY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkRiXEEZv9BBkH/gBgrAABJi8n/Fe5ABwBIiXMISIlzIEiNSxDoxf7//0iLy0iLXCQwSIt0JDhIg8QgX+mu/v//zMzMzMzMzMzMzMzMzMxIiVwkEEiJdCQYV0iD7CBIi9lIi/KLSQSLOzv5D4XjAAAA/8eFyXQLi8GZK8LR+APB6wW4CAAAADvHD0/4O/kPjsAAAABIY8dIiWwkMEiNDMBIweED6La3/f9Ii1MISIvoSIXSD4SPAAAASGMLTI0EyUiLyEnB4APoZ/EGAEyLSwhNhcl0akyLBfOUOABNhcB0XkkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyDPARIkRiUEEZv9BBkH/gBgrAABJi8n/Fb8/BwBIiWsISItsJDCJewRIYwMPKAZIjQzASItDCA8RBMgPKE4QDxFMyBAPKEYgDxFEyCAPKE4wDxFMyDDyDxBGQEiLdCRA8g8RRMhA/wNIi1wkOEiDxCBfw8xIiVwkCFdIg+wgSIvZSIPBEOiKL/3/TItLCDP/TYXJdHhMiwUIlDgASIk7TYXAdFxJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJeQRm/0EGQf+AGCsAAEmLyf8V0z4HAEiJewhIiXsgSItcJDBIg8QgX8PMzMzMzMzMzEBTSIPsIEiL2ehC////SI1LEOiJ/P//SIvLSIPEIFvpfPz//8zMzMzMzMzMzMzMzEiJXCQISIlsJBBIiXQkGFdIg+wgM+1Ii/mL3TkpfhuQSGPDSI0MQEjB4QVIA08I6Cww/f//wzsffOZMi08ITYXJdHhMiwUGkzgASIkvTYXAdFxJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJaQRm/0EGQf+AGCsAAEmLyf8V0T0HAEiJbwhIi1wkMEiLbCQ4SIt0JEBIg8QgX8NAU0FXSIPsKEUz/0iJbCRASIvZTIl0JCBBi+9EOXkQflJIiXQkSEGL90iJfCRQZpBIi0MYSGNMBgiD+f90IEhp+bAAAABIA3sISI2PoAAAAOhL+///SI1PCOhC+////8VIg8YQO2sQfMdIi3wkUEiLdCRISI1LEOh0Lf3/TItLCEyLdCQgSItsJEBNhcl0eUyLBeqROABMiTtNhcB0XUkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDaNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEUSJeQRm/0EGQf+AGCsAAEmLyf8VtDwHAEyJewhMiXsgSIPEKEFfW8PMzMzMzMzMzMzMzMxAU0iD7CBIi9no0v7//0iNSxDoafr//0iLy0iDxCBb6Vz6///MzMzMzMzMzMzMzMxIiVwkIEFWSIPsIEUz9kiJbCQwSIvZSIl0JDhBi/ZEOXEQfjpIiXwkQEGL/g8fQABIi0MYSGNMBwiD+f90EEhpyVACAABIA0sI6HIx/f//xkiDxxA7cxB810iLfCRASI1LEOg5LP3/TItLCEiLdCQ4SItsJDBNhcl0eUyLBa+QOABMiTNNhcB0XUkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDaNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEUSJcQRm/0EGQf+AGCsAAEmLyf8VeTsHAEyJcwhMiXMgSItcJEhIg8QgQV7DzMzMzMzMzMzMzMzMzEBTSIPsIEiL2eji/v//SI1LEOgp+f//SIvLSIPEIFvpHPn//8zMzMzMzMzMzMzMzEBVQVZBV0iD7CAz7UiJfCRQTIvxi/05KQ+OtgAAAEiJXCRASIl0JEiL9WYPH0QAAEmLRghIixwGSIXbdH5Ii8vo6y79/0yLBaSPOABNhcB0YUkPv5AcKwAASY2IICsAAEWLSARIjQzRRDkJdDqNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8FJjYggKwAASI0MwUSJCUGJrMAkKwAAZv9BBkH/gBgrAABIi8v/FW06BwD/x0iDxghBOz4PjGb///9Ii3QkSEiLXCRATYtOCEiLfCRQTYXJdHlMiwUHjzgASYkuTYXAdF1ND7+YHCsAAEmNkCArAABFi1AESo0U2kQ5EnQ2QY1LAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkSiWoEZv9CBkH/gBgrAABJi8n/FdE5BwBJiW4ISIPEIEFfQV5dw8zMzMzMzMzMzMzMSIlcJAhXSIPsIESLQQRIi9mLCUiL+kE7yHUo/8FFhcB0DUGLwJkrwtH4QQPA6wW4CAAAADvBD0/Ii9FIi8voHRAAAEhjAw8QB0hryDhIi0MIDxEEAQ8QTxAPEUwBEA8QRyAPEUQBIPIPEE8w8g8RTAEw/wNIi1wkMEiDxCBfw8xIiVwkGFdIg+wgSIvZi/qLSQQ70Q+OBAEAAEiJdCQ4hcl0C4vBmSvC0fgDwesFuAgAAAA7x4v3D0/wO/EPjsoAAABIY8ZIa8g8SIlsJDDoPbD9/0iLUwhIi+hIhdIPhIsAAABIYwtMa8E8SIvI6PLpBgBMi0sITYXJdGpMiwV+jTgATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xVKOAcASIlrCEiLbCQwiXMESIt0JDiJO0iLXCRASIPEIF/DSIt0JDiJO0iLXCRASIPEIF/DiTtIi1wkQEiDxCBfw8zMzMzMSIlcJBBIiWwkGFdIg+wgSIvZSIvqi0kEizs7+Q+F2wAAAP/Hhcl0C4vBmSvC0fgDwesFuAgAAAA7xw9P+Dv5D464AAAASGPPSMHhBEiJdCQw6Aqv/f9Ii1MISIvwSIXSD4SLAAAATGMDSIvIScHgBOi/6AYATItLCE2FyXRqTIsFS4w4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8VFzcHAEiJcwhIi3QkMIl7BEhjCw8QRQBIi0MISAPJSItsJEAPEQTI/wNIi1wkOEiDxCBfw8zMzMzMzMzMzMzMzMzMzEiJXCQQSIlsJBhXSIPsIEiL2UiL6otJBIs7O/kPheMAAAD/x4XJdAuLwZkrwtH4A8HrBbgIAAAAO8cPT/g7+Q+OwAAAAEhjx0iJdCQwSI0MQEjB4QLo1q39/0iLUwhIi/BIhdIPhI8AAABIYwtMjQRJSIvIScHgAuiH5wYATItLCE2FyXRqTIsFE4s4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8V3zUHAEiJcwhIi3QkMIl7BEhjA/IPEEUASI0MQEiLQwjyDxEEiEiNFIiLRQhIi2wkQIlCCP8DSItcJDhIg8QgX8PMzMzMzMzMzMzMSIlcJBBIiWwkGFdIg+wgSIvZSIvqi0kEizs7+Q+F4wAAAP/Hhcl0C4vBmSvC0fgDwesFuAgAAAA7xw9P+Dv5D47AAAAASGPHSIl0JDBIjQyASMHhAuiWrP3/SItTCEiL8EiF0g+EjwAAAEhjC0yNBIlIi8hJweAC6EfmBgBMi0sITYXJdGpMiwXTiTgATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xWfNAcASIlzCEiLdCQwiXsESGMDDxBFAEiNDIBIi0MIDxEEiEiNFIiLRRBIi2wkQIlCEP8DSItcJDhIg8QgX8PMzMzMzMzMzMzMzMxIiVwkGFdIg+wgSIvZi/qLSQQ70Q+OBAEAAEiJdCQ4hcl0C4vBmSvC0fgDwesFuAgAAAA7x4v3D0/wO/EPjsoAAABIY8ZIa8h4SIlsJDDoXav9/0iLUwhIi+hIhdIPhIsAAABIYwtMa8F4SIvI6BLlBgBMi0sITYXJdGpMiwWeiDgATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xVqMwcASIlrCEiLbCQwiXMESIt0JDiJO0iLXCRASIPEIF/DSIt0JDiJO0iLXCRASIPEIF/DiTtIi1wkQEiDxCBfw8zMzMzMSIlcJBBXSIPsIEhj+kiL2Tt5BA+OvQAAAEiNDP9IiXQkMEjB4QLoVar9/0iLUwhIi/BIhdIPhI8AAABIYwtMjQTJSIvIScHgAugG5AYATItLCE2FyXRqTIsFkoc4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8VXjIHAEiJcwhIi3QkMIl7BEiLXCQ4SIPEIF/DzMzMzMzMzMzMzMzMzMzMSIlcJBBXSIPsIEhj+kiL2Tt5BA+OuAAAAEiLz0iJdCQwSMHhA+hmqf3/SItTCEiL8EiF0g+EiwAAAExjA0iLyEnB4APoG+MGAEyLSwhNhcl0akyLBaeGOABNhcB0XkkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyDPARIkRiUEEZv9BBkH/gBgrAABJi8n/FXMxBwBIiXMISIt0JDCJewRIi1wkOEiDxCBfw8zMzMxIiVwkGFdIg+wgSIvZi/qLSQQ70Q+O/AAAAEiJdCQ4hcl0C4vBmSvC0fgDwesFuAgAAAA7x4v3D0/wO/EPjsIAAABIY85IiWwkMOhhqP3/SItTCEiL6EiF0g+EhwAAAExjA0iLyOga4gYATItLCE2FyXRqTIsFpoU4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8VcjAHAEiJawhIi2wkMIlzBEiLdCQ4iTtIi1wkQEiDxCBfw0iLdCQ4iTtIi1wkQEiDxCBfw4k7SItcJEBIg8QgX8PMzMzMzMzMzMzMzMzMSIlcJBBXSIPsIEhj+kiL2Tt5BA+OvQAAAEiNDL9IiXQkMEjB4QLoVaf9/0iLUwhIi/BIhdIPhI8AAABIYwtMjQSJSIvIScHgAugG4QYATItLCE2FyXRqTIsFkoQ4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8VXi8HAEiJcwhIi3QkMIl7BEiLXCQ4SIPEIF/DzMzMzMzMzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYSIl8JCBBVkiD7CBEi0kESIv5SIvaSYvoSCtZCIsJSMH7BEiNdwhBO8l1LP/BRYXJdA1Bi8GZK8LR+EEDwesFuAgAAAA7wQ9PyIvRSIvP6J4EAABIjXcITGMHSTvYfR1MK8NIi9NIweIESANXCEnB4ARIjUoQ6DXhBgDrBEiNdwhIiwYPEEUASItsJDhIweMEDxEEGP8HSIsGSIt0JEBIA8NIi1wkMEiLfCRISIPEIEFew8zMzMzMzMzMzMzMzMzMzEiJXCQQV0iD7CBIY/pIi9k7eQQPjrAAAABIi89IiXQkMOiapf3/SItTCEiL8EiF0g+EhwAAAExjA0iLyOhT3wYATItLCE2FyXRqTIsF34I4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8Vqy0HAEiJcwhIi3QkMIl7BEiLXCQ4SIPEIF/DzMzMzMzMzMzMzMzMSIlcJAhIiXQkEEiJfCQYQVZIg+wgSGPySIv5i0kETYvwO/F+I4XJdAuLwZkrwtH4A8HrBbgIAAAAO8aL1kiLzw9P0OjY/v//SGMfO/MPjqAAAABEi8ZEK8NBg/gQcmxFD7YeTI1PCI1G/0yL000DEUiYSQMBTTvRdwVJO8FzTE071ncFSTvGc0JBgeAPAACAfQpB/8hBg8jwQf/Ai8aLy0ErwIPDEDvYfPkrwUmLyoPAD5mD4g8DwkEPttPB+ARMY8BJweAE6O/dBgBIY9NIO9Z9IA8fQABmDx+EAAAAAABIi08IQQ+2BogECkj/wkg71nztSItcJDCJN0iLdCQ4SIt8JEBIg8QgQV7DzMzMzMxIiVwkEFdIg+wgSGP6SIvZO3kED462AAAASIvPSIl0JDBIA8nop6P9/0iLUwhIi/BIhdIPhIoAAABMYwNIi8hNA8DoXd0GAEyLSwhNhcl0akyLBemAOABNhcB0XkkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyDPARIkRiUEEZv9BBkH/gBgrAABJi8n/FbUrBwBIiXMISIt0JDCJewRIi1wkOEiDxCBfw8zMzMzMzEiJXCQIV0iD7CBIi/lIg8Fw6MqzAABIjU946GHp//+QTItPaE2FyXR0TIsFMIA4AE2FwHReRYtQBEkPv5AcKwAASY2IICsAAEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkRM8CJQQRm/0EGQf+AGCsAAEmLyf8V/CoHAJBIi1wkMEiDxCBfw8zMzMzMzMzMSIlcJAhXSIPsIEiL+UiDwSjoGrMAAEiNTzDosej//5BMi08YTYXJdHRMiwWAfzgATYXAdF5Fi1AESQ+/kBwrAABJjYggKwAASI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiREzwIlBBGb/QQZB/4AYKwAASYvJ/xVMKgcAkEiLXCQwSIPEIF/DzMzMzMzMzMxIiVwkEFdIg+wgSGP6SIvZO3kED464AAAASIvPSIl0JDBIweEE6Gah/f9Ii1MISIvwSIXSD4SLAAAATGMDSIvIScHgBOgb2wYATItLCE2FyXRqTIsFp344AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8VcykHAEiJcwhIi3QkMIl7BEiLXCQ4SIPEIF/DzMzMzEiJXCQQV0iD7CBIY/pIi9k7eQQPjrUAAABIa884SIl0JDDoiaD9/0iLUwhIi/BIhdIPhIsAAABIYwtMa8E4SIvI6D7aBgBMi0sITYXJdGpMiwXKfTgATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xWWKAcASIlzCEiLdCQwiXsESItcJDhIg8QgX8PMzMzMzMzMSIlcJBBXSIPsIEhj+kiL2Tt5BA+OtQAAAEhrzxxIiXQkMOipn/3/SItTCEiL8EiF0g+EiwAAAEhjC0xrwRxIi8joXtkGAEyLSwhNhcl0akyLBep8OABNhcB0XkkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyDPARIkRiUEEZv9BBkH/gBgrAABJi8n/FbYnBwBIiXMISIt0JDCJewRIi1wkOEiDxCBfw8zMzMzMzMxIiVwkEFdIg+wgSGP6SIvZO3kED469AAAASI0Mf0iJdCQwSMHhAujFnv3/SItTCEiL8EiF0g+EjwAAAEhjC0yNBElIi8hJweAC6HbYBgBMi0sITYXJdGpMiwUCfDgATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xXOJgcASIlzCEiLdCQwiXsESItcJDhIg8QgX8PMzMzMzMzMzMzMzMzMzMxIiVwkEFdIg+wgSGP6SIvZO3kED464AAAASIvPSIl0JDBIweEG6Nad/f9Ii1MISIvwSIXSD4SLAAAATGMDSIvIScHgBuiL1wYATItLCE2FyXRqTIsFF3s4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8V4yUHAEiJcwhIi3QkMIl7BEiLXCQ4SIPEIF/DzMzMzEiJXCQQV0iD7CBIY/pIi9k7eQQPjrgAAABIi89IiXQkMEjB4QLo9pz9/0iLUwhIi/BIhdIPhIsAAABMYwNIi8hJweAC6KvWBgBMi0sITYXJdGpMiwU3ejgATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xUDJQcASIlzCEiLdCQwiXsESItcJDhIg8QgX8PMzMzMSIlcJAhXSIPsIESLQQRIi9mLCUiL+kE7yHUo/8FFhcB0DUGLwJkrwtH4QQPA6wW4CAAAADvBD0/Ii9FIi8voTQAAAEhjAw8QB0iNDMBIi0MIDxEEyA8QTxAPEUzIEA8QRyAPEUTIIA8QTzAPEUzIMPIPEEdA8g8RRMhA/wNIi1wkMEiDxCBfw8zMzMzMzMzMSIlcJBBXSIPsIEhj+kiL2Tt5BA+OvQAAAEiNDP9IiXQkMEjB4QPohZv9/0iLUwhIi/BIhdIPhI8AAABIYwtMjQTJSIvIScHgA+g21QYATItLCE2FyXRqTIsFwng4AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8VjiMHAEiJcwhIi3QkMIl7BEiLXCQ4SIPEIF/DzMzMzMzMzMzMzMzMzMzMSIlcJBBIiWwkGFZXQVZIg+wQi1wkUEUz9kyL0WZJD27hQYvoZg9s5IvyRYvejUv/hckPjkQBAACD+QgPgjsBAACDPXhcOAACD4wuAQAAi8EPKTQkZg9vNfQ/NwAlBwAAgH0H/8iDyPj/wGYPby2uPzcATY1BKIvRvwQAAAAr0JDzD37eZkEPbstmD3DJAI1H/mYP/stNjYCAAAAA8w9+xUGDwwhmD/7I8w9+xWYPOCXRZg9z8gRmD9TUZg9uyGZBD9aQYP///41HAmYPc9oIZkEP1pBw////Zg9wyQBmD/7LZg/+yPMPfsVmDzgl0WYPc/IEZg/U1GYPbs9mQQ/WUICDxwhmD3PaCGZBD9ZQkGYPcMkAZg/+y2YP/sjzD37FZg84JdFmD3PyBGYPbshmD9TUZkEP1lCgZg9z2ghmQQ/WULBmD3DJAGYP/stmD/7IZg84JdFmD3PyBGYP1NRmQQ/WUMBmD3PaCGZBD9ZQ0EQ72g+MCP///w8oNCRJY/tIY8FIO/h9M0yLx0GNUwFJweAESCvHSYPACE0DwUQD2JBIY8pNjUAQSMHhBP/CSQPJSYlI8EiD6AF15kljw0mNSihIA8BNiXTBCI1D/0GJagQDxkiLbCRAmUGJWhRJx0IMAQAAAE2JSiBJiUoYQYky9/tIi1wkOEGJQghJjUI4SYlCMIkwRIkxRYlyLEHHQjwAAABATYlyQEiDxBBBXl9ew0SJTCQgSIlUJBBIiUwkCFNWV0FUSIPsaEyL2kWNYP9EA2IIuwAAAEBBi8SJXCQQmYmcJKAAAABB93sIM/ZBi/lEK+JIiXQkCEGLE0SLy0SJZCQUiVQkKEQ74g+PNwMAAEWLQwREiUQkGEE7+A+PJQMAAEmNQxhMiWwkWEyLKEyJfCRITIv4SIlEJDBIiWwkYEGLTQBMiXQkUEyJbCQgiUwkLEKNBCE7wg+PLAEAAEGLQxBEi/GJBCQPH4QAAAAAAEONLCZFM9sz9kUz0kmL/TvNfX2LXwRBO9t+LIsXi8tIi38IQSvLQQ+vykSL20SLD0GLwUE71n0IQSvGRAPQ6zErwkQD0OsqTItHCEGL1EEr0kWLCEGLySsPSYv4QY0ECkE7xA9O0UGLyyvLRAPSD6/KA/FEO818m0SLjCSgAAAAi1QkKIsEJItcJBBEi0QkGIXAdSJFO9lMD018JAhFD03ZSYv3TIl8JAhFi8tEiZwkoAAAAOs6i4QkqAAAAEEDw0E7wH8mRTvZfAZ1HzvzfRuL3kSJnCSgAAAAiVwkEEWLy0mL90yJfCQI6wVIi3QkCE2NfQhNi20IQYtNAESL8UKNBCE7wosEJA+O8v7//0iF9nQHSIsGiwDrAjPASIuMJJgAAACJBCSDeRABD4VzAQAASItUJCBMi+pEOWQkLH0OSItSCEQ5Inz3SIlUJCBIhdIPhE0BAABJi30ITY11CEyJtCSYAAAAQYvMRIs/Dx8ARIsiRYvcRCvZRTv7fyJmkEyJdCQwTIvvTI13CEiLfwhEiz9FO/t+6EyJtCSYAAAAM/Yz7UUz0kmLxUU5ZQAPjYkAAABEi3QkFA8fgAAAAACLWAQ73n4sixBEi8NIi0AIRCvGRQ+vwovzRIsIQYvJQTvTfQhBK8tEA9HrMyvKRAPR6yxMi0AIQYvWQSvSRYsIQYvJKwhCjQQRQTvGSYvARIvGD07RRCvDRAPSRA+vwkED6EU7zHyZTIu0JJgAAACLTCQUSItUJCBEi0QkGIuEJKgAAABEi4wkoAAAAAPGQTvAfzdBO/F/MnwQO2wkEHwKiwQkdShEO9h9I0SLzom0JKAAAABIi3QkMEGLw0iJdCQIiQQkiWwkEOsIiwQkSIt0JAhIi1IISIlUJCBIhdIPhcz+//9Ii4wkkAAAAEyLfCRITIt0JFBMi2wkWEiLbCRgiQFIi8FEiUkESIlxCEiDxGhBXF9eW8NIiTFIi8FIiXEISIPEaEFcX15bw8zMzMzMQVZIg+wwSIlcJEBMjXIUSIlsJEhIi9pBxwYAAAAAi2oESIl0JFBIiXwkWEiL+YXtD4TPAAAAi3IIhfYPhMQAAABIi9FEi85IjUwkIESLxej8+///TItYCEyLAE2F23R9SYvISMHpIAPOO08Ef29Mi08gTYXJdGZJi0EIRYkBQYlJBEiJRyBJiwtEOQF9DUiNQQhIi0kITIkI6wNNiQtIi1EISIXSdCZFjRQoDx9EAABEORJ/GEiLRyBIiUEISIlPIEiLykiLUghIhdJ140GNBChJiUkIOQF9B4kB6wNFM9tIjUMMuRAAAABNhdt0CUSJAEnB6CDrIMcA////f0G4////f+sSSI1CDEUzwMcAAAAAALkQAAAARIkEGYE4////f0iLfCRYSIt0JFBIi2wkSEiLXCRAdRlBgfj///9/dRBBxwYAAAAAM8BIg8QwQV7DQccGAQAAALgBAAAASIPEMEFew8zMzMzMzMzMzMzMzMxIiVwkCEiJfCQQSGN6CEyL0otaDESLx0yL2UUzyboCAAAARDvDfAQywOsRSYsCSWPIQf/AD7YEAUWJQghBweEID7bARAvISIPqAXXWRYXJdH5EO8N8BDLA6w1JiwJJY8hB/8APtgQBD7bIi9FBD6/RQQPQO9N/BIXSeQKL00UzwEGJUgiEwHQwTIvJDx9EAAA703wEMsDrEEmLAkhjyv/CD7YEAUGJUghBweAID7bARAvASYPpAXXYQf/IRAPCRDvDfwVFhcB5A0SLw0WJQghEK8dJxwMAAAAAScdDCAAAAACF/3ghRYXAeBxBi0IMO/h/FCvHRDvAfw1Ii8dJAwJJiQNFiUMMSItcJAhJi8NIi3wkEMPMzMzMzMzMzMzMzMxIg+wITGNBCEyLyUSLUQxFO8J8BDLA6w9IiwFBD7YEAEH/wESJQQgPttCNQuA91gAAAHcLjYJ1////SIPECMONggn///+D+AN3PUU7wnwUMsnB4ggPtsEFbAn//wPCSIPECMNJiwFJY8jB4ggPtgwBQY1AAUGJQQgPtsEFbAn//wPCSIPECMONggX///+D+AN3QUU7wnwWMsnB4gi4lPoAAA+2ySvCK8FIg8QIw0mLAUljyMHiCA+2DAFBjUABQYlBCLiU+gAAK8IPtskrwUiDxAjDg/ocdV1FO8J8FDLAMtIPtsDB4AgPtsoLwUiDxAjDSYsBSWPIQf/AD7YEAUWJQQhFO8J8DzLSweAID7bKC8FIg8QIw0mLCUlj0MHgCA+2FApBjUgBQYlJCA+2ygvBSIPECMOD+h0PheUAAABIiRwkRTvCfCFIixwkMsBED7bAQcHgCEHB4AhBweAID7bAQQvASIPECMNJiwFFjVgBSWPID7YUAUWJWQhEi8JFO9p8HUiLHCQywEHB4AhBweAIQcHgCA+2wEELwEiDxAjDSWPLQf/DQcHgCA+2FAFEC8JFiVkIRTvafBlIixwkMsBBweAIQcHgCA+2wEELwEiDxAjDSWPLQf/DQcHgCA+2FAFEC8JFiVkIRTvafBVIixwkMsAPtsBBweAIQQvASIPECMNIixwkQY1LAUlj00HB4AgPtgQCD7bAQQvAQYlJCEiDxAjDM8BIg8QIw8zMzMzMzEiJXCQISIlsJBBIiXQkGEiJfCQgQVZIg+wgi0IMRTP2hcBBi/ZBi+hIi9oPSPBIi/mJcgg78A+NzgAAAA8fQABIY1MIRItLDEE70Q+NowAAAEyLE0EPtgQSPBxyWzwedU2NQgFBO8F/P4XAeDuJQwhBO8F9y4vQQTvBfSVIY8r/wIvQRg+2BBFBD7bIiUMIgOEPgPkPdKlBgODwQYD48HSfQTvRfNHrmESJSwjrkkiLy+ga/f//64hCD7YMEkSNQgFEiUMIi8GA+Qx1LkU7wXwLMsAPtsAPuugI6x5JY8hB/8BCD7YEEQ+2wA+66AhEiUMI6wZBi8ZEi8I7xXQ9QYvwRTvBD4w2////TIk3TIl3CEQ5cwx8BkiLA0iJB0iLXCQwSIvHSIt8JEhIi2wkOEiLdCRASIPEIEFewyvWTIk3TIl3CIX2eNWF0njRi0MMO/B/yivGO9B/xEhjxkgDA4lXDOu2zMzMzMzMzMzMzMzMQFNEi0oMRTPbRYXJSIlsJBBIiXQkIEyL0kUPSNlIi9lFO9l8CTP2weYIMsDrQEmLAkGNUwFJY8tEi9oPtjQBQTvRfAfB5ggywOsjRI1aAcHmCEhjyg+2FAEL8kU72XwEMsDrCkljy0H/ww+2BAEPtuiLxUEPr8BBA8NBO8F/BIXAeQNBi8FFM9tBiUIIhe10b0iJfCQoTIvFDx+AAAAAAEE7wXwEMsnrEEmLCkhj0P/AQYlCCA+2DApBweMID7bJRAvZSYPoAXXXSIv9Dx9AAEE7wXwEMsnrEEmLCkhj0P/AQYlCCA+2DApBweAID7bJRAvBSIPvAXXXSIt8JCjrA0UzwEjHAwAAAACNRgEPr8VBjUsCSMdDCAAAAABFK8NIi3QkIEiLbCQQA8h4H0WFwHgaQTvJfxVEK8lFO8F/DUhjwUkDAkiJA0SJQwxIi8Nbw8zMzMzMzMzMzMzMzMzMzEiJXCQISIl8JBCLwo16DEUzyUiL2UQPtlQIBA+2RAgFQcHiCEQD0HRKRQ++GA8fAEGLwcHgBAPHD7YMGEE7y3UqD7ZUGAFBD75IATvRdRwPtlQYAkEPvkgCO9F1Dg+2VBgDQQ++SAM70XQVQf/BRTvKfL0zwEiLXCQISIt8JBDDD7ZUGAkPtkwYCkiLfCQQweEIweIQA9EPtkwYCA+2RBgLSItcJAjB4RgD0QPCw8zMD7YBTIvBPDF1CYB5AQDpDgEAADx0D4XdAAAAgHkBeXUPgHkCcHUfgHkDMekFAQAAgHkBcnUQgHkCdXUKgHkDZQ+E9QAAADx0D4XyAAAAOEEBD4XpAAAAgHkCYw+F3wAAAIB5A2YPhdUAAABED7ZJBQ+2QQbB4AhBweEQRAPID7ZBBMHgGEQDyA+2QQdEA8hBgfkAAAEAdA1BgfkAAAIAD4WbAAAAD7ZJCUEPtkAIweAIA8hBD7ZACsHhCAPIQQ+2QAvB4QgDyDvRfXWNBJUAAAAASGPQSQPQD7ZCDQ+2Sg7B4QjB4BADwQ+2SgzB4RgDwQ+2Sg8DwcM8T3UZgHkBVA+FQP///4B5AlQPhTb///84QQPrIITAD4Up////gHkBAQ+FH////4B5AgAPhRX///+AeQMAD4UL////99obwMO4/////8PMzMzMzMzMzMzMSIlcJAhIiWwkIFZXQVZIg+xgSIsF90w4AEgzxEiJRCRQSYvARTP2SIvqRIl0JCBIi/lMiXQkMEiL0EiNTCRAQbgSAAAA6Ob6//9Bi94PEAAPEUQkQItEJEw5RCRIfRdIjUwkQOiX+P//iUScMEj/w0iD+wJ830hjdCQ0hfYPhLUAAACLTCQwhckPhKkAAABMiXQkMEyJdCQ4hfZ4IYXJeB2LRQw78H8WK8Y7yH8QSIvGiUwkPEgDRQBIiUQkMA8oRCQwSI1UJEBBuBMAAABmD39EJEBIjUwkMOhS+v//SYveDxAADxFEJEAPH4AAAAAAi0QkTDlEJEh9F0iNTCRA6Pz3//+JRJwgSP/DSIP7AXzfi0QkIIXAdB+LTQwDxjvBfwSFwHkCi8FIi9WJRQhIi8/oqvb//+sHTIl3CEyJN0iLx0iLTCRQSDPM6FGyBgBMjVwkYEmLWyBJi2s4SYvjQV5fXsPMzMzMzMzMzMzMzMxIiVwkIFVWV0FUQVVBVkFXSI1sJNlIgeyQAAAASIsFfUs4AEgzxEiJRRdIiVEITIvyRYvgM9tEiWEQTI0Fw9w2AEiJWUBIi/lIiVlIQYvUSYvO6Dn8//9Bi9REi/hJi85MjQWl3DYA6CT8//9Bi9SJRxhJi85MjQWY3DYARIvo6Az8//9Bi9SJRxxJi85MjQWI3DYAi/Do9fv//0GL1IlFx0mLzolHIEyNBXbcNgDo3fv//0GL1IlFz0mLzolHJEyNBWbcNgDoxfv//0GL1IlFy0mLzolHKEyNBVbcNgDorfv//0GL1IlHLEmLzkyNBUncNgDomPv//4lHMEWF/3R7hfZ0dzldz3RyOV3LdG05Xcd0EUWF7XRjQYvEQYPEDOlOAwAAQw+2RCYEi9NHD7ZEJgVMiWXXQYPEDMHgCMdF0wIAAACJXceJXcuJXc9EA8B0KYvKweEEQQPMSQPOgDlDdRKAeQFGdQyAeQJGdQaAeQMgdDD/wkE70HzXM8BIi00XSDPM6KewBgBIi5wk6AAAAEiBxJAAAABBX0FeQV1BXF9eXcMPtlEJD7ZBCsHgCMHiEAPQD7ZBCMHgGAPQD7ZBCwPQdLZIiZ+AAAAASImfiAAAAEiJn5AAAABIiZ+YAAAAi8JJA8ZIiUdAiV9Ix0dMAAAAIA8QT0CLT0hIi0dIg8ECZg9vwUjB6CBmD3PYDGYPfsIPKU33O8h/F4XJeBM7yn0PSGPJZkgPfshED7YEAesDRTLAQQ+2wEiNTbc7wg9O0IlV/0iNVffoIvT//0iNVfdIjU236BX0//9FM8BIjVW3SI1NBw8QAA8pRbfovvj//0iNVfdIjU23DxAADylFB+jq8///SI1V90iNTbfo3fP//0G4EQAAAEiNVQdIjU23DxAADxFHYOgT9///SIvzDxAADxFFt4tFwzlFv30WSI1Nt+jI9P//iUS1x0j/xkiD/gF84kG4BgEAAEiNVQdIjU236Nj2//9Ii/MPEAAPEUW3i0XDOUW/fRZIjU236I30//+JRLXTSP/GSIP+AXziQbgkAQAASI1VB0iNTbfonfb//0iL8w8QAA8RRbcPHwCLRcM5Rb99FkiNTbfoT/T//4lEtctI/8ZIg/4BfOJBuCUBAABIjVUHSI1Nt+hf9v//SIvzDxAADxFFtw8fRAAAi0XDOUW/fRZIjU236A/0//+JRLXPSP/GSIP+AXziDyhFB0yNRbcPKFX3SI1VB0iNTd9mD39Ft2YPf1UH6N/6//+DfdMCDxAIDxFPcA+Fuf3//0SLbcdFhe0PhKz9//+LRcuFwHRwSGN1z4X2D4SZ/f//Zg9z2gxmD37RO8F/B4lF/4XAeQOJTf9IjVX3SI1N3+hq8v//i00Di9Er1kiJXQdIiV0PDxAADxGHgAAAAIX2eBaF0ngSO/F/DkiLxolVE0gDRfdIiUUHDxBFBw8Rh5AAAADrA4tNA0Q76X8JRIlt/0WF7XkDiU3/SI1V90iNTd/oCfL//w8QAEiLRdcPEUdQRg+2RDAFi9NCD7ZEMATB4AhEA8B0NQ8fhAAAAAAAi8rB4QRBA8xJA86AOW11FoB5AWF1EIB5Anh1CoB5A3APhNoAAAD/wkE70HzTuv//AACJVxTHRzT/////Rw+2TDcCQw+2RDcDQcHhCIlfOEQDyA+EfAAAAA8fhAAAAAAAQY1HBI0E2EYPtkQwAYvIQg+2BDDB4AhEA8B0IUGD+AN1S0IPtkQxAkIPtlQxA8HgCAPQg+oBdAWD+gl1MEIPtkQxBEYPtkQxBUIPtlQxB8HgCEQDwEIPtkQxBkHB4AhBA8DB4AhBA8cD0IlXOP/DQTvZfIyDfzgAD4QN/P//SGNHHEIPtkwwMkIPtlQwM7gBAAAAweEIA9GJVzzp7fv//w+2UQkPtkEKweAIweIQA9APtkEIweAYA9APtkELA9APhAj///+LwkIPtlQyBUIPtkwwBMHhCAPR6fX+///MzMxIiVwkEEiJbCQYSIl0JCBXQVRBVUFWSItZCEG9AAEAAItxOExj0g+2PB4PtkQeAUEPr/1mA/h1KQ+2TB4CD7ZEHgPB4QiDwPoDyEQ70Q+N9AIAAEqNBBYPtkQYBunoAgAAZoP/BnVQD7ZEHgYPtlQeB8HgCAPQRDvSD4LIAgAAD7ZEHggPtkweCcHgCAPCA8hEO9EPg64CAABEK9JDjQQSSAPGD7ZUGAsPtkQYCsHgCAPC6ZICAABmg/8CD4SGAgAAZoP/BA+FvgEAAA+2RB4LRI12Dg+2VB4GRA+2ZB4HD7ZsHgoPtnweCUEPr9VBD6/tZkQD4g+2VB4IQQ+v1WYD6GZB0ey4//8AAGYD+mbR70Q70A+PLgIAAA+2RB4MD7ZMHg3B4AgDyEyJfCQo0elFi/6NFAmLwkaNHDJJA8cPtgwYD7ZEGAHB4QgDyEQ70UUPTN5Bg+sCZoXtdFFBvf//AAAPH0AAZmYPH4QAAAAAAGbR70GLyw+3x0SNDABBi8FIA8MPthQBRA+2RAEBQ40EGcHiCEQDwkU70EEPTsNEi9hmQQPtdclBvQABAABMi3wkKEUr3kGDwwJFD7fMQdHrQQ+3w0yNBABDjQQJSQPAS40UMEgDxg+2bBgQD7ZEGBHB5QgD6EQ71Q+MWQEAAA+2BBoPtkwaAcHgCAPIRDvRD49CAQAAQ40ESQPAi/hJA8BIA8ZED7ZcGBEPtlQYEEEPt8UPr9BmRAPadTFCjQyNAAAAAEkDyEgDzkQPtkQZEQ+2VBkQQQ+3zQ+v0WZEA8JmRQPCQQ+3wOntAAAARCvVQQ+3y0ONBBJImEgDx0gDyEkDyEgDzg+2RBkRD7ZMGRDB4QgDwenAAAAAjUf0ZoP4AQ+HsQAAAA+2RB4MRTPbRA+2RB4NweAIRAPAD7ZEHg5BweAIRAPAD7ZEHg9BweAIRAPARYXAD458AAAADx9EAABFi8hFK8tB0flFA8tDjQRJweACSGPISAPOD7ZsGREPtkQZEsHgCMHlEAPoD7ZEGRDB4BgD6A+2RBkTA+hEO9VzBUWLwessD7ZUGRUPtkQZFsHgCMHiEAPQD7ZEGRTB4BgD0A+2RBkXA9BEO9J2IkWNWQFFO9h8iTPASItcJDBIi2wkOEiLdCRAQV5BXUFcX8MPtlQZGQ+2RBkaweAIweIQA9APtkQZGMHgGAPQD7ZEGRsD0GaD/wx1CCvVQY0EEuu4i8LrtMzMzMzMzMzMzMzMO1EUD43AAAAAi0E8g/gCD420AAAATItRCExjQRhEi0kghcB1Mo0EEkhjyEkDyEIPtkQRAUIPthQRRg+2RBEDweIIA9BCD7ZEEQLB4AgD0kQDwEUDwOtfjQSVAAAAAEhjyEkDyEIPtgQRQg+2VBEBRg+2RBEFweAIA9BCD7ZEEQLB4ggD0EIPtkQRA8HiCAPQQg+2RBEEweAIRAPAQg+2RBEGQcHgCEQDwEIPtkQRB0HB4AhEA8BBjQQRuv////9DjQwBO8EPRMLDuP/////DzEiD7AhMY9JMi9lFhckPhIQAAABEi0wkSEiJHCSLXCRARYXAdDeLVCRQTWvCDo0EE0H/wtH4ZkGJBAhBxkQIDAOLTCRYZkOJVBgEZkOJTBgGQY0ECdH4ZkOJRBgCSWPCSGvIDg+3RCQwZkKJBBkPt0QkOGZCiUQZAkGNQgFmQolcGQRIixwkQsZEGQwDZkaJTBkGSIPECMMPt0QkMElryg5mQokEGQ+3RCQ4ZkKJRBkCRYXAdCUPt0QkUGZCiUQZBA+3RCRYZkKJRBkGQY1CAULGRBkMA0iDxAjDM8BCxkQZDAJCiUQZBEGNQgFIg8QIw0iLxEiJWCBVVldBVEFVQVZBV0iB7FABAAAPKXC4Dyl4qEQPKUCYRA8pSIhEDymQeP///0QPKZho////RA8poFj///9EDymoSP///0QPKbA4////RA8puCj///9IiwUOQDgASDPESImEJKAAAABMi1kIM+2L/UyJRCR4i/VNi+BMi+nouf3//0mJLCSFwA+Ieg0AAExj0EG5AAEAAEEPv8FDD7YMGkMPtlQaAQ+vyGYD0WaJVCRQZoXSD47/AwAAD7/CTY1LCk0DykUz5EWL9EyJTCRoRI0EAE1j+EcPtmw5/0uNBBdCD7ZMGAtCD7ZcGApJg8MMSMHjCEmNBA9IA9hDD7ZEOf7B4AhJA9pEA+hJA9tBjUABQQPFSGPISGvJDuibff3/SIv4SIXAD4TcDAAAQY1NAUSJZCRgMtJEi9lNa9cOTIlcJHCFyQ+EHQMAAEyNQAxFi8tNA8JmDx9EAACE0nUgD7YrQA+2zYDhCHQED7ZTAYTJSYvED5XASP/ASAPY6wOAwv9BiChJg8AOSYPpAXXMTY0MOkWLxE2L00G8AAEAAA8fQAAPH4QAAAAAAEEPtlEMgOIQQfZBDAJ0FA+2C0j/w4vB99iE0g9EyEQDwesdhNJ1GQ+2QwEPthNBD7/MD6/RZgPCmEQDwEiDwwJmRYkBSYPBDkmD6gF1sk1rzw5FM+RNi9NJg8ECRYvETAPPQbsAAQAADx+EAAAAAABBD7ZRCoDiIEH2QQoEdBQPtgtI/8OLwffYhNIPRMhEA8HrHYTSdRkPtkMBD7YTQQ+/yw+v0WYDwphEA8BIg8MCZkWJAUmDwQ5Jg+oBdbIzwESJZCRcRIvQRIvYRIvoi+gPv0QkUEGLzAPAiUwkVEiYQYvUSGvYDkWL/EgD3+sFkItMJFQPtkMMRA+/A0QPv0sCiEQkUGZEiUQkWGZEiUwkWkQ5bCRgD4XjAAAASIXtdEGLRCRcRYvORIl8JEhEi8ZEiWQkQIlMJDhIi8+JRCQwRIlUJChEiVwkIOgR/P//RA+3RCRYi9APtkQkUEQPt0wkWkQPtvBB99ZBD7/AQQ+/yUGD5gF0NfZDGgFEi8lED79bDkQPv1MQiUQkXIlMJFR1DkQD2EQD0UHR+0HR+usXQf/FSP/FSIPDDusLRItMJFREi9hEi9FMi0QkaEhjwv/CSGvIDjPAi/CJRDkExkQ5DAFmRIkcOWZEiVQ5AkEPtkgBQQ+2AP/BweAIA8FJg8ACiUQkYEyJRCRo6aMAAACoAXVAhfZ0L0hjwv/CSGvIDkONBATR+GaJBDlDjQQP0fhmiUQ5AsZEOQwDZkSJZDkEZkSJfDkGRYvgRYv5vgEAAADrWkhjwkhryA6F9nQRZkSJvCSYAAAAZkSJZCRk6w0zwImEJJgAAACJRCRkhfYPlcAEAohEOQyLRCRkZkSJBDlmRIlMOQJmiUQ5BIuEJJgAAABmiUQ5BjPAi/D/wkSLTCRUQf/FSP/FSIPDDkg7bCRwD4w5/v//i0QkXOsUM8lBi9REi9FEi9lFi8xBi8RFi/xEiXwkSESLxkSJZCRASIvPRIlMJDhFi86JRCQwRIlUJChEiVwkIOhk+v//TItkJHiL8EmJPCSLxulRCQAAefNmRA9vPXcgNwBJjVsK80QPEDUaHTcASQPaDx+AAAAAAEQPtnMDRQ9X5EQPtnsCRQ9X7UiJrCSYAAAAD7ZrAUiDwwREDxG8JIAAAABA9sUCdGRMjUMBQPbFAXQ2QQ+2AEQPtkMDD7YTQQ+/yQ+v0Q+2SwJmA9BIjUMCuAABAABED7/KmEiDwwQPr8FmQQPAmOsMRA++C0mNWAFBD74AZkUPbuFBuQABAABmRA9u6EUPW+1FD1vkQPbFCHQyD7ZDAUUPV8kPthNFD1fAQQ+/yQ+v0WYDwphIg8MCZg9u8A9b9vNBD1n2Dyj+6RABAABA9sVAdFAPtkMBRQ9XyQ+2E0UPV8BED7ZDA0EPv8kPr9FBD7/JZgPCmGYPbvgPtkMCD6/BD1v/ZkEDwJhIg8ME80EPWf5mD27wD1v280EPWfbpugAAAECE7Q+JiwAAAA+2QwFED7ZDAw+2E0EPv8kPr9FBD7/JZgPCmGYPbvgPtkMCD6/BQQ+/yQ9b/2ZBA8BED7ZDBZjzQQ9Z/mZED27AD7ZDBA+vwUEPv8lFD1vAZkEDwEQPtkMHmPNFD1nGZkQPbsgPtkMGD6/BRQ9byWZBA8CYSIPDCPNFD1nOZg9u8A9b9vNBD1n26ybzDxC0JIwAAADzRA8QjCSIAAAA80QPEIQkhAAAAPMPELwkgAAAAA8ox0EPKMjzD1nH80EPWcjzD1jID1fADy7BdwtFD1fb80QPUdnrDA8owehQswYARA8o2EEPKMkPKMbzQQ9ZyfMPWcbzD1jBD1fJDy7IdwtFD1fS80QPUdDrCeggswYARA8o0EGL10yNhCSYAAAAweIISYvNQQPW6KceAABMY/iFwA+OuwUAADPATYvHRIvQSYP/BA+MaQMAAEmNV/xEi8hIweoCSP/CTI0UlQAAAAAPH0AASIuMJJgAAAAPV9sPV9JBD79ECQLzDyrQQQ+/BAnzDyrYDyjC8w9Z1g8oy/NBD1nB8w9Zz/NBD1nY8w9YyPMPWNoPV9LzQQ9YzPNBD1jd80EPWcvzQQ9Z2vMPLMFmQYkECfMPLMMPV9tmQYlECQJBD79ECQbzDyrQQQ+/RAkE8w8q2A8owvMPWdYPKMvzQQ9ZwfMPWc/zQQ9Z2PMPWMjzD1jaD1fS80EPWMzzQQ9Y3fNBD1nL80EPWdrzDyzBZkGJRAkE8w8sww9X22ZBiUQJBkiLjCSYAAAAQQ+/RAkQ8w8q0EEPv0QJDvMPKtgPKMLzD1nWDyjL80EPWcHzD1nP80EPWdjzD1jI8w9Y2g9X0vNBD1jM80EPWN3zQQ9Zy/NBD1na8w8swWZBiUQJDvMPLMMPV9tmQYlECRBBD79ECRTzDyrQQQ+/RAkS8w8q2A8owg8oy/NBD1nB8w9Zz/MPWMjzQQ9YzPNBD1nL80EPWdhBDyjB8w8swfMPWdYPKM9mQYlECRIPV+TzD1jaQQ8o0PNBD1jd80EPWdrzDyzDD1fbZkGJRAkUSIuMJJgAAABCD79ECR7zDyrgQg+/RAkc8w8q2PMPWcTzD1nL8w9Z0w9X2/MPWMgPKMbzD1nE8w9Y0PNBD1jM80EPWNXzQQ9Zy/MPLMHzQQ9Z0mZCiUQJHPMPLMIPV9JmQolECR5CD79ECSLzDyrQQg+/RAkg8w8q2A8owvMPWdYPKMvzQQ9ZwfNBD1nY8w9Zz/MPWNoPV9LzD1jIQQ8owfNBD1jd80EPWMzzQQ9Z2vNBD1nL8w8swWZCiUQJIPMPLMMPV9tmQolECSJIi4wkmAAAAEIPv0QJLPMPKtBCD79ECSrzDyrY8w9Zwg8oy/NBD1nY8w9Zz/MPWMgPKMbzD1nC8w9Y2PNBD1jM80EPWN3zQQ9Zy/MPLMHzQQ9Z2mZCiUQJKvMPLMNmQolECSxCD79ECTAPV9sPV9LzDyrQQg+/RAku8w8q2A8owvMPWdYPKMvzQQ9ZwfMPWc/zQQ9Z2PMPWMjzD1ja80EPWMzzQQ9Y3fNBD1nL80EPWdrzDyzBZkKJRAku8w8sw2ZCiUQJMEmDwThIg+oBD4W7/P//TTvQfA7p5gAAAEWF/w+O3QAAAElr0g5NK8JIi4wkmAAAAA9X0g9X2w9X5A+/RAoC8w8q0A+/BArzDyrYDyjC8w9Z1g8oy/NBD1nB8w9Zz/NBD1nY8w9YyEEPKMHzD1jaQQ8o0PNBD1jM80EPWN3zQQ9Zy/NBD1na8w8swQ8oz2aJBArzDyzDD1fbZolECgIPv0QKBvMPKuAPv0QKBPMPKtjzD1nE8w9Zy/MPWdPzD1jIDyjG8w9ZxPMPWNDzQQ9YzPNBD1jV80EPWcvzDyzB80EPWdJmiUQKBPMPLMJmiUQKBkiDwg5Jg+gBD4Uq////QY0EN0hjyEhryQ7oC3P9/0yL8EiFwA+EVQEAAIX2fhdIhf90EkhjzkiL10xrwQ5Ii8jouKwGAEiLlCSYAAAASGPGSGvIDk1rxw5JA87onawGAEiF/3R4TIsFLVA4AE2FwHRjSQ+/kBwrAABJjYggKwAARYtIBEiNDNFEOQl0PI1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAAM9JID7/BSY2IICsAAEiNDMFEiQlBiZTAJCsAAGb/QQZB/4AYKwAASIvP/xX0+gYATIuMJJgAAABJi/5Nhcl0b0yLBaVPOABNhcB0Y0kPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDyNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAADPSSA+/wUmNiCArAABIjQzBRIkRQYmUwCQrAABm/0EGQf+AGCsAAEmLyf8VbPoGAEED90D2xSAPhKr3//8z7UG5AAEAAOnK9///SIX/dHJMiwUOTzgATYXAdF1JD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ2jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/BSAVkBQAASY0MwDPARIkJiUEEZv9BBkH/gBgrAABIi8//Fdv5BgBMi4wkmAAAAE2FyXRzTIsFj044AE2FwHReTQ+/mBwrAABJjZAgKwAARYtQBEqNFNpEORJ0N0GNSwG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8FIBWQFAABJjRTAM8BEiRKJQgRm/0IGQf+AGCsAAEmLyf8VW/kGADPASIuMJKAAAABIM8zo4ZgGAEyNnCRQAQAASYtbWEEPKHPwQQ8oe+BFDyhD0EUPKEvARQ8oU7BFDyhboEUPKGOQRQ8oa4BFDyizcP///0UPKLtg////SYvjQV9BXkFdQVxfXl3DzMzMzMzMzMzMzMzMzMxAVYM5AA+26kyL0Q+EAwEAAESLWRxIiVwkEEiJdCQYRTvDfwaDeQQAdQdEiUEcRYvYi3EkSIPBBEQ7zn8LQYN6BAB1C0mNSgRFiUokQYvxQYtaGEiJfCQgSIv5RDvDfAtBg3oEAHULSY16BEWJQhhBi9hBi1IgSIvBRDvKfAiDOQBIi8d1CkWJSiBBi9FIi8hIi3wkIMcBAQAAAECA/QR1Y4tEJDBBO8N+B0GJQhxEi9iLTCQ4O85+BkGJSiSL8TvDfQZBiUIYi9g7yn0GQYlKIIvRi0wkQEE7y34EQYlKHItEJEg7xn4EQYlCJDvLfQRBiUoYO8J9BEGJQiBBx0IEAQAAAEH/QjBIi3QkGEiLXCQQXcNIY0EwSGvQDg+3RCQwSANRKP9BMGaJQgQPt0QkOGaJQgYPt0QkQECIagxmRIkCZkSJSgJmiUIID7dEJEhmiUIKXcPMzMzMzMzMzMzM8w8QSQhIi9EPLkkQehN1EfMPEEEMDy5BFHoGD4ShAAAAgzkA80QPLEkM80QPLNF0akyNQQREO1EcfwZBgzgAdQREiVEcRDtJJEmLyH8KQYM4AHUISI1KBESJSiTzDyzBTIvRO0IYfApBgzgAdQtMjVIE8w8swYlCGEiLwUQ7SiB8CIM5AEmLwnUHRIlKIEiLyP9CMMcBAQAAAMNIY0EwRTPASGvIDkiLQij/QjDGRAEMAmZEiRQBZkSJTAECTIlEAQTDzMzMzMzMzMzMzMzMzEiD7CgPKNlMi9noIf///0GDOwDzQQ9YWxDzQQ9YUxTzQQ8RWxDzQQ8RWwjzQQ8RUxTzQQ8RUwzzRA8sw3R9RTtDHH8HQYN7BAB1BEWJQxzzDyzCSY1TBEE7QyR/C0GDewQAdQhJjVMEQYlDJPMPLMNMi8JBO0MYfAtBg3sEAHUMTY1DBPMPLMNBiUMY8w8swkiLykE7QyB8CIM6AEmLyHUL8w8swkiL0UGJQyBB/0MwxwIBAAAASIPEKMNJY0MwSYtLKEhr0A7zDyzCZolECgIzwEH/QzBIiUQKBMZECgwBZkSJBApIg8Qow8zMzMzMzIM5AEyLwfMPWEkQ8w9YURTzDxFJEPMPEVEU80QPLMl0ckQ7SRx/BoN5BAB1BESJSRzzDyzCSI1RBDtBJH8Kg3kEAHUHSI1RBIlBJPMPLMFMi8o7QRh8CoN5BAB1C0yNSQTzDyzBiUEY8w8swkiLykE7QCB8CIM6AEmLyXUL8w8swkiL0UGJQCBB/0AwxwIBAAAAw0hjQTBIi0koQf9AMEhr0A7zDyzCZolECgIzwEiJRAoExkQKDAJmRIkMCsPMzEiJXCQISIlsJBBIiXQkGFdBVkFXSIPsUA8QipAAAABIi4KYAAAARYvwSMHoIEiL6kyL+WZJD37JDxFMJCCFwA+IDQEAAESLRCQsM/+JfCQoRYXAD44GAQAAQQ+2CbgBAAAAhMkPhPcAAACA+QMPhdYAAAC5AgAAAEQ7wH8KRTLSRIvYi9DrEkUPtlEBi8FEi9lIi9G5AwAAAEEPtvJFO9h8BDLS6wdCD7YUCovBweYID7bKC/FBO8B8BDLJ6wpIY8j/wEIPtgwJD7bZQTvAfAQyyesKSGPI/8BCD7YMCcHjCESL3w+2yQvZhfZ0XA8fAEE7wHwFRTLS6wpIY8j/wEYPthQJQTvAfAQyyesKSGPI/8BCD7YMCQ+20UE7wHwEMsnrCkhjyP/AQg+2DAnB4ggPtskL0UQ783wFRDvyfEFB/8OL2kQ73nynSYk/SYl/COtwZg9z2QxmQQ9+yEGL+IvHQY0MBkE7yH8Thcl4D0E7yH0KSGPBRg+2FAjrA0Uy0g8QhYAAAABFD7bCSI1UJCBIjUwkQA8pRCQg6AHc//8PEE1ATI1EJCBJi89IjVQkMA8QAA8pTCQwDylEJCDoPt///0iLXCRwSYvHSItsJHhIi7QkgAAAAEiDxFBBX0FeX8PMzMzMzMzMzMzMzMzMzMxIi8RIiVgYiVAQSIlICFVWV0FUQVVBVkFXSI2oCP7//0iB7MACAAAPKXC4SYv4Dyl4qESLwkQPKUCYSI1VkEQPKUiIQb0BAAAARA8pkHj///9FM+REDymYaP///zP2RA8poFj///9EDymoSP///0QPKbA4////RA8puCj///9Ii8EzyUSJbCR0iU2ASI1MJGDHRCRwAAAAAA8QQHBEiWQkfA8QSFAPEUVgDylNkOj+2v//80QPEEXATI0VIdv7//MPEH28D1f280QPEE2wRTPbDxAQ8w8QJRURNwBmD28t3RA3AGYPb8LzRA8QdbhmD2/K80QPEH20ZkkPftHzRA8QXazzRA8QZajzRA8QbaTzRA8QVaBmD3PYDGZBD37AZg9vwmYPc9gIZg9z2QgPKVQkYGYP1kQkaPMPEEXEZkEPfs7zDxBNyPMPEUQkSPMPEUwkQPNEDxFEJHjzDxF8JEzzRA8RTYREiUQkREyJTCRQSItEJGjzDxAdIAw3AEjB6CBJY9REO/APjU4BAABJY8ZBi9tB/8bHhRgCAAABAAAARIl0JGhGD7Y8CEEPtsf/yIP4Hg+HjAwAAEiYQYuMgugzBABJA8r/4YtcJHBFhe10DYvGmSvC0fgD2IlcJHCNQwdEiVwkdEWL64XAeQODwAfB+ANBA8ZEi/BBO8B/DYXAeAmJRCRo6fECAABFi/BEiUQkaOnkAgAAi8aZK8LR+AFEJHDp1AIAAESJXCR0RYvrg/4CD4yiAAAASGPGSIvP8w8QTIWY8w8QVIWc6BH6///pjgIAAESJXCR0RYvrg/4BfHlIY8YPKM5Ii8/zDxBUhZzo6/n//+loAgAARIlcJHRFi+uD/gF8U0hjxg8o1kiLz/MPEEyFnOjF+f//6UICAACD/gJ8NUG7AQAAAEyNVaCQ80EPEFIESIvP80EPEArojfr//0GDwwJNjVIIRDvefODpEwIAAIP+AX1wM8BMjZwkwAIAAEmLW1BBDyhz8EEPKHvgRQ8oQ9BFDyhLwEUPKFOwRQ8oW6BFDyhjkEUPKGuARQ8os3D///9FDyi7YP///0mL40FfQV5BXUFcX15dw4P+AXymSGPDDyjWSIvP8w8QTIWg6Aj6////wzveD42ZAQAASGPDDyjOSIvP8w8QVIWg6Or5////wzvefMjpegEAAIP+BA+MYP///+mpAAAAg/4ED4xS////TI1/EEyNZxRJi9dJi8yLxivDg/gFdQtIY8PzDxB8hbDrAw8o/vMPECpIY8PzD1ju8w8QZIWg8w9YIQ8o3fMPWFyFpPNEDyzV8w8s1A8ozA8o0/MPWFSFrPMPWEyFqPMPLMvzDyzBDyjB80EPEReJRCQ48w9Yx4lMJDBIi8+JVCQosgTzRA8swkSJVCQg80QPLMjzQQ8RBCToC/b//4PDBI1DAzvGD42pAAAASGPLi8Yrw/MPEGyNrIP4BXUI8w8QZI2w6wMPKObzDxBcjaBMjWcU80EPEBQkTI1/EPNBD1gf8w9Y1vNEDyzT8w8s0g8owg8oy/MPWESNqPMPWEyNpPMPWOjzD1jh8w8swPMPLMmJRCQ480QPLM2JTCQwSIvPiVQkKLIERIlUJCDzRA8sxPNBDxEn80EPESwk6Gj1//+DwwRJi8xJi9eNQwM7xg+Muv7///MPEHwkTPMPEEQkSEUz2/MPEEwkQESLRCRETItMJFCLjRgCAADzDxAl5ww3AEyNFdDW+/9mD28tqAw3AIXJRItkJHxBi8MPRMaL8OlD/P//g/4GD4yl/f//Qb8FAAAASI1dqJDzDxBr+PMPWG8Q8w8QY/zzD1hnFA8o3fMPWBvzDyzUDyjMDyjT8w9YSwTzD1hTCPMPLMvzDyzB80QPLNWJRCQ4iUwkMEiLz4lUJCiyBA8owfMPEVcQ8w9YQwzzRA8swkSJVCQg80QPLMjzDxFHFOh99P//QYPHBkiDwxhEO/58gOkd////g/4ID4wM/f//RI1u/kGD/QUPjrYAAABBvAUAAABMjX2oZmYPH4QAAAAAAPNBDxBv+PMPWG8Q80EPEGf88w9YZxQPKN3zQQ9YH/MPLNQPKMwPKNPzQQ9YTwTzQQ9YVwjzDyzL8w8swfNEDyzViUQkOIlMJDBIi8+JVCQosgQPKMHzDxFXEPNBD1hHDPNEDyzCRIlUJCDzRA8syPMPEUcU6Mfz//+DwwZBg8QGSYPHGIvDRTvlD4xx/////8A7xg+NUfz///MPEEQkSEUz20hjw0iLz/MPEFSFpPMPEEyFoOin9v//RItsJHTpOP7//4P+CA+MHvz//0SNfvpBg/8BfjpBuwEAAABMjVWg80EPEFIESIvP80EPEArobfb//4PDAk2NUghBg8MCi8NFO99824PABTvGD43a+///SGPD8w8QbIWg8w8QZIWk8w9YbxDzD1hnFA8o3fMPWFyFqPMPLNQPKMwPKNPzD1hUhbDzD1hMhazzDyzL80QPLNUPKMHzDxFXEPMPWESFtPMPLMHzRA8syIlEJDiJTCQwSIvPiVQkKLIERIlUJCDzRA8swvMPEUcU6LPy///pYP3//4P+BA+MT/v//4vGDyj+g+ABdARBDyj6RI1gA0Q75g+NBAgAAEiNXahIjRyDZpDzDxBvEEiLx/MPEGcUuRAAAADzDxATSIvX8w8QW/hBuBQAAADzDxBL/PMPEEMEQYD/G3Ug8w9Y5/MPWN3zD1jU8w9Yy/MPWMEPKPgPKMLzD1jG6yHzD1jv8w9Y3PMPWM3zD1jTDyjjDyjdDyj58w9Y/vMPWMLzDxE8AfNCDxEEAvMPLNTzDyzC8w8syYlEJDjzRA8s04lMJDBIi8+JVCQosgTzRA8syESJVCQg80QPLMfoyvH//0GDxARIg8MQDyj+RDvmD4w2////6V38//+DfYAASIudAAIAAHU2g7ucAAAAAHQdRIuFCAIAAEiNTXBIi9PoaPX//0Uz2w8QEA8RVWDHRYABAAAA6wdIi50AAgAAg/4BD4wP+v///85Bg/wKD40D+v//DyhEJGBJY8RB/8RIA8BEiWQkfA8RhMWAAAAASGPG80QPLESFoEiNRWBBgP8KdARIjUNgDxAISItACEjB6CAPKUwkYIXATItUJGBmD3PZDGZBD37JQYvJQQ9Jy4lMJGhBO8l8BDLA6w5IY8H/wYlMJGhCD7YEEA+20EE7yXwEMsDrDkhjwf/BiUwkaEIPtgQQweIID7bAC9CB+myEAAByB7gAgAAA6xOB+tgEAAC4awAAALlrBAAAD0PBRAPAeCNEO8J9Hg8oRCRgSI1UJGBIjU2QZg9/RCRg6PzR//9FM9vrDEyJXZBIx0WYAAAAAA8oRZBmD39EJGBmD3PYCGZID37ASMHoIIXAD4T1+P//TItMJGBFi/NEi0QkbEGLy/MPEEQkSPMPEEwkQEyJTCRQRIlcJGhEiUQkROns+v//RYXkD468+P//Qf/MSIvCSAPARIlkJHxBi8sPEFTFcGYPb8IPKVQkYGYPc9gMZg9vymZBD37AZkkPftFmD3PZCGYPb8JmD3PYCGYP1kQkaPMPEEQkSGZBD37O8w8QTCRARIlEJERMiUwkUOl9+v//SItEJGhIweggRDvwfAQywOsQSWPGQf/GRIl0JGhCD7YECA+2yIPpIg+EmQIAAIPpAQ+E5AEAAIPpAQ+EKQEAAIP5AQ+FDfj//4P+Cw+MBPj//0EPKNRBDyjb80EPWNIPKPnzQQ9Y3UQPKMHzQQ9Y0fNBD1jf80EPWNbzD1hcJEzzD1hUJHjzD1jYDyjKDyjDD1TND1TFDy/IdggPKPsPV/zrCEQPKMJED1fEQQ8o6kEPKOXzD1hvEPMPWGcUQQ8o3EEPKMtBDyjRQQ8ox/MPWN3zDyzU8w9YzPMPWNPzDyzL8w9YwfMPEVcQ8w8swfNEDyzViUQkOIlMJDBIi8+JVCQosgTzRA8syESJVCQg80QPLMLzDxFHFOiP7v//8w8QbCR4QQ8o3vNEDxBMJEjzDxBkJEzzD1hfEPMPWGcU8w9Y6/NED1jMDyjNQQ8o0fNBD1jI80QPEEQkePMPWNfzDxB8JEzpCwIAAIP+CQ+M5Pb//0EPKMtBDyjl8w9YZxRBDyjqQQ8o3PMPWG8QQQ8o0fMPLNTzD1jM8w9Y3fNEDyzV8w9Y0w8owfMPWMbzDyzB8w8sy4lEJDjzRA8syIlMJDBIi8+JVCQosgREiVQkIPNEDyzC8w8RVxDzDxFHFOjJ7f//8w8QZxREDyjP8w9Y5kEPKMPzQQ9YxUEPKN9BDyjuQQ8oyPNED1jM8w9Yx0EPKNHzD1zQ6UwBAACD/g0PjDL2//9BDyjqQQ8o5fMPWG8Q8w9YZxRBDyjcQQ8oy0EPKNFBDyjH8w9Y3fMPLNTzD1jM8w9Y0/MPLMvzD1jB8w8RVxDzDyzB80QPLNWJRCQ4iUwkMEiLz4lUJCiyBPNEDyzIRIlUJCDzRA8swvMPEUcU6Bbt///zRA8QTCRIDyjn8w9YZxTzDxBVzEEPKN7zDxBMJEBBDyjo80QPWMzzQQ9Y0emgAAAAg/4HD4yG9f//8w8QZxRBDyjM8w9Y5kEPKOrzD1hvEEEPKN1BDyjT8w8s1PMPWMzzD1jd80QPLNXzD1jTDyjB8w9YxvMPLMHzDyzLiUQkOPNEDyzIiUwkMEiLz4lUJCiyBESJVCQg80QPLMLzDxFXEPMPEUcU6Gvs///zDxBnFEEPKNnzD1jmQQ8o70EPKM5EDyjM80UPXMxBDyjR8w9Y1vMPWF8Q8w9Y6/MPWM3zDyzU80EPLMHzDyzNiUQkOPNEDyzTiUwkMEiLz4lUJCiyBPMPEU8Q80QPLMpEiVQkIPNEDyzB8w8RVxTo9+v///NEDxBNhOme9v//QYD//3RcQfbH4HUKQYD/HA+FgPT//0H/zkU78H8KRIl0JGhFhfZ5BUSJRCRoSI1MJGDolcn//0yLTCRgRTPbRItEJGxEi3QkaA+/yESJRCRETIlMJFBmD27BD1vA6YoAAABFO/B8BDLA6xBJY8ZB/8ZEiXQkaEIPtgQID7bIRTvwfAQywOsQSWPGQf/GRIl0JGhCD7YECMHhCA+2wAvIRTvwfAQywOsQSWPGQf/GRIl0JGhCD7YECMHhCA+2wAvIRTvwfAQywOsQSWPGQf/GRIl0JGhCD7YECMHhCA+2wAvIZg9uwQ9bwPMPWcOD/jAPjaHz//9IY8ZBi8v/xvMPEUSFoPMPEE3I8w8QRcTzRA8QRcDzDxB9vPNEDxBNsPNEDxB1uPNEDxB9tPNEDxBdrPNEDxBlqPNEDxBtpPNEDxBVoPMPEUwkQPMPEUQkSPNEDxFEJHjzDxF8JEzzRA8RTYTpV/X///MPEHwkTOlG9f//SIvP6NPr//+4AQAAAOkV8///kDcmBABkMgQANyYEAHQmBADAJgQATycEAPUmBABMKQQAZDIEAJ8sBAA1LgQApC4EAGQyBADVMwQAZDIEAGQyBABkMgQANyYEAOclBADnJQQARyYEAJomBAA3JgQA5SkEANMqBACiKwQAoisEAGQyBADbLAQAnycEAJEnBADMzMzMzMzMzMzMzMxIiVwkIFVWV0iB7KAAAABIiwW6GzgASDPESImEJJAAAAAz7UjHRCQgAQAAAA9XwEiJbCRID1fJiWwkUEmL2EiJbCRYTI1EJCCJrCSIAAAADxFEJCiL8kiL+fMPf0wkOA8RRCRg8w9/TCRw6EHv//+FwA+EoQAAAEhjRCRQSGvIDv8VKuIGAEyLBQM3OABMi8hNhcB0XEkPv4AcKwAASY2QICsAAEWLUARIjRTCRDkSdDWNSAG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv9FIgcJkBQAASY0U0ESJEolqBGb/QgRB/4AUKwAATI1EJFhMiQuL1kyJjCSAAAAASIvP6KXu//+FwHQJi4QkiAAAAOsFSIkrM8BIi4wkkAAAAEgzzOgzgQYASIucJNgAAABIgcSgAAAAX15dw4N5TAAPhBba///psf7//8xIiVwkGFVWV0FWQVdIgeyQAAAADyl8JHBEDylEJGBIiwVbGjgASDPESIlEJFiDeUwADyj7SIu8JPAAAABEDyjCTIu0JPgAAABMi9lMi7wkAAEAAEiLtCQIAQAAdFEz20jHRCQgAQAAAA9XwEiJXCRID1fJiVwkUEyNRCQgDxFEJCjzD39MJDjo1O3//4XARIvbi+tEi8NED0VcJDgPRWwkQEQPRUQkPA9FXCRE637ondf//4XAD4iDAQAATYtLCLsAAQAATGPQD7/DQw+2VBEDRw+2RBEFQw+2TBECD6/IQw+2RBEJZgPRD7/LRA+/2kMPtlQRBA+v0Q+/y2ZEA8JDD7ZUEQYPr9FBD7/oRw+2RBEHD7/LZkQDwkMPtlQRCA+v0UUPv8BmA9APv9rzDxCcJOAAAAAPV9IPKbQkgAAAAEiF/3Q3ZkEPbssPW8nzQQ9ZyPMPWMsPL8rzDyzBcxBmD27AD1vADy7BegJ0Av/IZg9uwA9bwPMPLMCJB/MPELQk6AAAAE2F9nQ5Zg9uww8ozg9bwPMPWcfzD1zIDy/K8w8swXMQZg9uwA9bwA8uwXoCdAL/yGYPbsAPW8DzDyzAQYkGTYX/dB1mQQ9uwA9bwPNBD1nA8w9Yw+g+kgYA8w8swEGJB0iF9nQdZg9uzQ9byfMPWc/zD1zxDyjG6BuSBgDzDyzAiQYPKLQkgAAAAEiLTCRYSDPM6PR+BgBIi5wk0AAAAA8ofCRwRA8oRCRgSIHEkAAAAEFfQV5fXl3DM9tIhf90AokfTYX2dANBiR5Nhf90A0GJH0iF9nSziR7rr0iD7DjzDxBsJGDzDxBkJHAPLux6Bg+EIAEAAA8pfCQQ80EPEHgcDy/vD4cHAQAARA8pBCTzRQ8QQBhEDy/ED4ftAAAARA8vxQ8pdCQg8w8QdCRodiZBDyjQDyjG8w9c1Q8ozPMPXMPzD1zNQQ8o6PMPWdDzD17R8w9Y2g8v53YhDyjGDyjP8w9czPMPXOXzD1zD8w9ZyPMPXswPKOfzD1jxZg9uwg9bwA8vw3IwDy/GcisPKHQkIPMPXOVEDygEJA8ofCQQSGPC80EPWWAU8w9YJIHzDxEkgUiDxDjDjUIBZg9uyA9byQ8v2XIFDy/xczvzD1zYSGPC8w9c8PMPEAVA+TYA8w9c5fMPWN7zQQ9ZYBTzD1kd6vg2APMPXMPzD1nE8w9YBIHzDxEEgQ8odCQgRA8oBCQPKHwkEEiDxDjDTYXJD4Q/BgAASIvESIlYCFdIgezgAAAA8w8QDeT4NgBBi9hEDylYmEiL+vNEDxCcJBABAABMi9FEDyl0JFBFDyjzDylw6PNED1jxDyl42EQPKUDIRA8pSLhEDylQqEQPKWCIRA8pbCRgRA8pfCRARQ9X/w8fQABmDx+EAAAAAADzRQ8QaQxFDy7v80EPEHkIenV1c2YPbsMPW8APL8cPhkAFAABBDy//TYvB80QPEXQkMA8o3/MPEXwkKPNEDxFcJCByM/MPLNdJi8ro8P3///NEDxF0JDBIjU/88w8RfCQo/8IPKN/zRA8RXCQg6M79///p5QQAADPSSI1P/Oi+/f//6dUEAADzRQ8QQRhFDyjlRQ8vw/NBDxBxEPNED1jndhRBDyjY80EPXNvzQQ9Z3fMPWN/rBw8o30UPKMPzQQ8QYRxEDy/0dhMPKOzzQQ9c6/NBD1nt8w9Y7+sIQQ8o7EEPKOZBDy/fD4KQAgAAQQ8v7w+ChgIAAGYPbsMPW8APL8MPhnYCAAAPL8UPhm0CAADzDyzL8w8sxTvIdU8PV8BIY8HzDyrB80EPXODzD1jB80EPWWEUDyjI8w9cw/MPXM3zD1jI8w9ZDff2NgDzD1nM80EPWAyC80EPEQyC8w9YJIfzDxEkh+nwAwAADy/ddjMPVzW4+jYA80UPXMNBDyjG80EPXONBDyj880EPXMBFDyjG80QPXMQPKOAPKMUPKOsPKNjzRQ8QURQPV8nzRA8QLY72NgBFD1fk8w8sy/NEDyzdSGPBjVEB8w8qyvNFDyrjDyjB8w9cy/MPXMdFDyjM80QPXM9BDyj+8w9ZxvNED1nO80EPWMPzRQ9Yy/MPXfhFDy/ODyjX80EPXNDzQQ9Z0vMPWcrzQQ9ZzfNBD1gMgvNBDxEMgnYhQYvDRQ8ozivBg+gBdBNmD27AQQ8o9g9bwPMPXPfzD17wSGPKQQ8o2k1jw/MPWd5JO8gPjb8AAABJi8APKMtIK8HzQQ9ZzUiD+AQPjIMAAABJi9BJjUIISCvRSI0EiEiD6gRIweoCSP/CSI0MkWZmDx+EAAAAAAAPKMHzD1jC8w9Y0/MPWED48w8RQPgPKMLzD1jB8w9Y0/MPWED88w8RQPwPKMLzD1jB8w9Y0/MPWADzDxEADyjC8w9YwfMPWNPzD1hABPMPEUAESIPAEEiD6gF1pEk7yH0fDyjB8w9YwvMPWNPzQQ9YBIrzQQ8RBIpI/8FJO8h84UEPKMRJY8PzD1gFVfU2AA8oyPMPXMXzQQ9czPMPWMgPKMTzQQ9c4PNBD1zB80EPWc3zQQ9Z4vMPWcjzQQ9ZyvMPWMrzQQ9YDILzQQ8RDILzD1gkh/MPESSH6d4BAAAz0oXbD47cAQAADx+EAAAAAAAPV/aNQgFFD1fJ80QPKsrzDyrwRA8vz0UPKNFEDyjG80QPXNfzRA9cx/NFD17V80UPXsXzRQ9Y0/NFD1jDdktEDy/mdkXzRA8RVCQwDyjf80QPEUwkKE2LwUmLyvNEDxFcJCDoSPr///NEDxFEJDBBDyjZ8w8RdCQo80QPEVQkIOgr+v//6RUBAABFDy/MdlEPL/52TPNEDxFEJDAPKN/zDxF0JChNi8FJi8rzRA8RXCQg6Pn5///zRA8RVCQwDyje80QPEUwkKPNEDxFEJCDo3Pn//0EPKPFFDyjC6b4AAABEDy/PdgZFDy/hdwxFDy/MdjNBDy/5di3zRA8RVCQwDyjf80QPEUwkKE2LwUmLyvNEDxFcJCDolPn//0EPKPFFDyjC63kPL/d2NEQPL+Z2LvNEDxFEJDAPKN/zDxF0JChNi8FJi8rzRA8RXCQg6F35//+NSgFmD27xD1v260BBDy/0djMPL/52LvNEDxFEJDAPKN/zDxF0JChNi8FJi8rzRA8RXCQg6CT5//+NSgFmD27xD1v26wcPKPdFDyjD80QPEXQkMA8o3vNEDxFkJChNi8FJi8rzRA8RRCQg6O74////wjvTD4w0/v//8w8QDSDzNgBNiwlNhckPhZD6//9EDyh8JEBMjZwk4AAAAEmLWxBFDyhboEQPKGwkYEQPKGQkcEQPKJQkkAAAAEQPKIwkoAAAAEQPKIQksAAAAA8ovCTAAAAADyi0JNAAAABEDyh0JFBJi+Nfw8zMzMzMzMxMi9xWSIHsMAMAAEiLBX4QOABIM8RIiYQkcAIAAIsBSYlbIEmJa/BJiXvoSIv6TYlj4EyL4U2Ja9hNiXPQTYl7yEUPKUuIRTPbSWPwQYvbSIlcJFhFi/tFi/NBi+tFi+uD+EB+GI0ERQEAAABIY8hIweEC6GhO/f9Mi8jrBUyNTCRgi4wkaAMAAIvRSWMEJPNEDxANHPI2AEiJRCRQiUwkOEmNBIFMiUwkMEiJRCRIQYtEJAQDwUiNDLZmD27AD1vA80EPWMHzDxFEjwRBOVwkBA+OKgMAAA8ptCTwAgAADym8JOACAABEDymEJNACAABFD1fARA8plCSwAgAA80QPEBWy8jYARA8pnCSgAgAAZkQPbx0Y9TYARA8ppCSQAgAA80QPECVC8jYARA8prCSAAgAA80QPEC048TYA6wdmkEyLTCQwTWMEJEiNdCRYZg9u+kmLyQ9b/0nB4AIz0g8o9/NBD1j580EPWPDoSocGAEGLBCQz0kiLTCRI/8BMY8BJweAC6DGHBgBIhdt0KTPJDy9zHHIRSIsDSIkGTIkzTIvziUsU6wNIi/NIix5Ihdt13kiLXCRY8w8QRwQPL/gPgiIBAAAPLkcMegYPhAQBAABNhfZ0H/MPEFcISYvO8w8QRwzzD1wX8w9cRwRNizbzD17Q61KF7XUeuQhkAADo3Uz9/0iFwA+EyQAAAEyJOL0gAwAATIv48w8QVwiNRf/zDxBHDIvo8w9cF/MPXEcESGPISMHhBUiDwQjzD17QSQPPD4SOAAAAQQ8u0PMPEVEMegh1BkEPKMDrCEEPKMHzD17C8w8RQRAPKM7zD1xPBGYPboQkYAMAAA9bwPMPWcrzD1gP8w9cyPMPEUkIg38QAHQGQQ8owesEQQ8owvMPEUEUi0cEiUEY8w8QRwzzDxFBHEWF7XUURDmsJGgDAAB0Cg8v8HYF8w8RcRxIiRlIi9lIiUwkWPMPEEcYSIPHFA8v+A+D3v7//0iLdCQwSIXbdB5Ii1QkSEyLy0WLBCRIg8IESIvO8w8RdCQg6KH2//9FM9tBDyjIRYvDRTkcJH5hTIvOQbv/AAAASIt0JFAPHwDzQQ9YDLFBi8UPKMHzQQ9YAUEPVMPzQQ9ZxPNBD1jF8w8s0EE700EPT9NBD69EJAhJg8EEQQPAQf/ASGPISYtEJBCIFAFFOwQkfLVIi3QkMEiNTCRYSIXbdCBIi8MPHwDzDxBADPMPWEAI8w8RQAhIiwlIiwFIhcB15otUJDhB/8X/wolUJDhFO2wkBA+Mfv3//0QPKKwkgAIAAEQPKKQkkAIAAEQPKJwkoAIAAEQPKJQksAIAAEQPKIQk0AIAAA8ovCTgAgAADyi0JPACAADrBUiLdCQwRA8ojCTAAgAATIu0JAgDAABMi6wkEAMAAEyLpCQYAwAASIu8JCADAABIi6wkKAMAAE2F/w+EiQAAAEyLBQkoOABJix9NhcB0ZUkPv5AcKwAASY2IICsAAEWLSARIjQzRRDkJdD6NSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8FJjYggKwAASI0MwUSJCUHHhMAkKwAAAAAAAGb/QQZB/4AYKwAASYvP/xXL0gYATIv7SIXbD4V3////TIu8JAADAABIjUQkYEiLnCRYAwAASDvwD4R7AAAASIX2dG1MiwVdJzgATYXAdGFND7+QHCsAAEmNkCArAABFi0gESo0U0kQ5CnQ6QY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkKx0IEAAAAAGb/QgZB/4AYKwAASIvO/xUm0gYASIuMJHACAABIM8zornEGAEiBxDADAABew8zMzMzMg/oMD47RAQAASIlsJCBBVkiD7CBIiVwkMIvqSIl0JDhMi/FIiXwkQA8fhAAAAAAA80EPEFYEjXX/M9KLxUjR6ESL1Un/ykyNBIDzQw8QRIYES40EkvNBDxBMhgQPL8gPl8IzwA8vwg+XwDvCdD1DDxAEhjPJDy/KD5fBM8A7yg9FxkiYSI0MgEEPEAyOQYtUjhBBDxEEjkOLRIYQQYlEjhBDDxEMhkOJVIYQQw8QBIZBi04QQbsBAAAAQQ8QDkWLy0EPEQZDi0SGEEGJRhBDDxEMhkOJTIYQDx+EAAAAAADzQQ8QTgRKjQyNAQAAAEkDyUEPLwyOSY0MjnYTDx9AAEH/w0iNSRRJ/8EPLwl38UqNDJUBAAAASQPK80EPEASOSY0Mjg8vwXYaDx+AAAAAAPMPEEHsSI1J7P/OSf/KDy/Bd+1EO959QEuNDJJB/8NBDxAEjkuNFIn/zkEPEAyWRYtElhBJ/8FBDxEElkGLRI4QSf/KQYlElhBBDxEMjkWJRI4Q6Vj///9BK+tJY8M79Yv9i9YPTdcPTe5IjQyASY0cjkmLzkgPTcvoUv7//zv3SQ9N3kyL84P9DA+PcP7//0iLfCRASIt0JDhIi1wkMEiLbCRISIPEIEFew8zMzMzMQFNXQVRBVUFXSIHsgAAAAEGL+UyL+Q8pdCRgRTPJ8w8QtCTYAAAASYvYD1c1z+42AEyL4kiJTCRIM8lIiVQkUIX/fmCD/whyW0hj1w9XyUiD4vgPV9IzwA8fhAAAAAAA80EPbwSAg8EIZg/+yPNBD29EgBBIg8AIZg/+0Eg7wnzfZg/+0WYPb8JmD3PYCGYP/tBmD2/CZg9z2ARmD/7QZkEPftEz0khjyUUzwExj10k7yn09SYvCSCvBSIP4AnwmTY1a/w8fQAAPH4QAAAAAAAMUi0QDRIsESIPBAkk7y3zvSTvKfQREAwyLQY0EEEQDyEljwUj/wEiNDIBIweEC6HxG/f9Mi+hIhcAPhEEDAABIiawkuAAAADPtSIl0JHi+AQAAAEyJdCRwRTP2RIl0JECF/w+OLAEAAPMPEJQk6AAAAEyL//MPEJwk4AAAAPMPEKQk0AAAAGYPH4QAAAAAAEhjxUUz2zPSTY0UxIsDA+iFwA+O1gAAAESLZCRATY1CBP/ISGPIS40EtkyNDIUQAAAATQPNZmZmDx+EAAAAAADzQQ8QRMoESIv6QQ8uAHoCdHwzwEHHAQAAAADzQQ8QRMoEQQ8vAA+XwIXAdAlIi/lBiTFIi8oPKMQPKM7zQQ9ZBPpB/8RJ/8bzD1jD80EPEUHwDyjE80EPWUz6BPMPWMrzQQ8RSfQPKM7zQQ9ZBMrzD1jD80EPEUH480EPWUzKBPMPWMrzQQ8RSfxJg8EUSIvKQf/DSP/CSYPACEQ7Gw+MXP///0SJZCRATItkJFBIg8METCv+D4UF////RIt0JEBMi3wkSEGL1kmLzeiw+///SIusJLgAAABNY95MO94PjioBAABNjU0UM9tmDx9EAABFi1EQSIvWQQ8QEQ8oyg/GylVIg/4ED4KlAAAASY1J7PMPEEEEi8MPL8EPl8CFwA+ExQAAAA8QAYtBEA8RQRSJQSSLw/MPEEHwDy/BD5fAhcAPhJEBAAAPEEHsi0H8DxEBiUEQi8PzDxBB3A8vwQ+XwIXAD4RmAQAADxBB2ItB6A8RQeyJQfyLw/MPEEHIDy/BD5fAhcAPhDoBAAAPEEHEi0HUSIPqBA8RQdiJQehIg+lQSIP6Aw+PZP///0iF0n45SI0EkkiNDIXs////SQPN8w8QQQSLww8vwQ+XwIXAdBkPEAGLQRBI/8oPEUEUiUEkSIPpFEiF0n/WSDvydA9IjQSSQQ8RVIUARYlUhRBI/8ZJg8EUSTvzD4zi/v//i4Qk+AAAAEWLxolEJChJi9WLhCTwAAAASYvPiUQkIOjO9P//TIsFFyE4AEyLdCRwSIt0JHhNhcB0YEkPv5AcKwAASY2IICsAAEWLSARIjQzRRDkJdDmNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJCcdBBAAAAABm/0EGQf+AGCsAAEmLzf8V18sGAA8odCRgSIHEgAAAAEFfQV1BXF9bw0iDwv3pG////0iDwv7pEv///0j/yukK////SIvESIlYCEiJcBBXSIHs0AAAAIucJCgBAAAPKMoPKXjYDyjD8w8QvCQAAQAASIvyRA8pQMhIi/nzRA8QhCQIAQAARA8pSLjzRA8QjCQQAQAARA8pUKjzQQ9YyfNEDxCUJBgBAABEDylYmPNBD1jCRA8pYIhFDyjgRA8pbCRQ80UPWODzRA8QLQjmNgBEDyjf80EPWc3zRA9Y3/NBD1nF80QPWOPzRA9Y2vNFD1ji80UPWNnzRA9ZJbDlNgDzRA9ZHaflNgDzQQ9cxPNBD1zLg/sQD4/WAAAA8w9ZwPMPWckPKXDo8w8QtCQgAQAA8w9YwQ8vxg+GkgAAAA8oyw8owvNBD1jI/8OJXCRI8w9Yx/MPEXQkQPNEDxFkJDjzRA8RXCQw80EPWc3zQQ9ZxfMPEUwkKPMPEUQkIOjC/v//iVwkSPNFD1jC8w8RdCRA80EPWPnzRA8RVCQ4QQ8o3PNEDxFMJDBBDyjTSIvWSIvP80UPWcXzQQ9Z/fNEDxFEJCjzDxF8JCDodv7//+saSGMKSIX/dA3zRA8RDM/zRA8RVM8EjUEBiQIPKLQkwAAAAEyNnCTQAAAAuAEAAABJi1sQSYtzGEEPKHvgRQ8oQ9BFDyhLwEUPKFOwRQ8oW6BFDyhjkEUPKGuASYvjX8PMzMzMzEiLxEiJWAhIiXAQ8w8RWCDzDxFQGFdIgewAAQAA8w8QpCRAAQAADyjr8w8QnCRQAQAADyjEDylw6EiL8g8peNgPKPLzDxCUJEgBAABIi/lEDylAyA8oykQPKUi4RA8pUKhEDylYmEQPKNtEDylgiPNED1zeRA8pdCRwRA8o4/NEDxC0JDABAADzRA9c5EQPKXwkYPNBD1zG8w8QpCRYAQAARQ8o1vNEDxC8JDgBAADzRA9c1vNBD1zPQQ8o/0QPKMzzD1z98w9ZwPNED1zKRA8oxPMPWcnzRA9cxfMPWMgPV8APLsF3CQ9X9vMPUfHrCw8oweiUewYADyjw8w9Z/w9XyfNFD1nS80EPWPoPLs93CQ9XwPMPUcfrCA8ox+hqewYA80UPWcnzD1jw80UPWeQPV8DzRQ9YzEEPLsF3Cg9XwPNBD1HB6wlBDyjB6Dt7BgDzRQ9ZwPMPWPDzRQ9Z2w9XwPNFD1jDQQ8uwHcKD1fA80EPUcDrCUEPKMDoDHsGAIucJGgBAADzD1n28w9ZwPMPXPCD+xAPj7wCAADzRA8QBf/iNgBEDymsJIAAAADzRA8QrCRgAQAADx+EAAAAAABBDy/1D4ZbAgAA80QPEKQkSAEAAP/D80QPEIwkQAEAAEiL1vNEDxCUJCgBAABIi8/zRA8QnCQgAQAAQQ8o4vNBD1jniVwkWPNFD1j880QPEWwkUPNED1ikJFgBAABBDyjr80EPWO7zRQ9Y8fNBD1ng80QPWIwkUAEAAPNFD1n480UPWfBBDyjP80UPWeDzRQ9ZyA8o0UEPKMbzQQ9Z6EUPKPzzRA8RpCRIAQAARQ8o8fNEDxGMJEABAADzRA9Y+Q8o2PNED1jw8w9Y1PMPWN3zRQ9Z+PNBD1nQ80EPWdhBDyj38w9Y8vNFD1nwQQ8o/vMPWPvzQQ9Z8PMPEXQkSPNBD1n48w8RfCRA8w8RVCQ4QQ8o0/MPEVwkMEEPKNrzDxFkJCjzDxFsJCDoEv3///MPEJQkUAEAAEEPKMHzDxCcJFgBAADzQQ9cxkEPKMzzDxG8JCABAADzQQ9cz/MPEbQkKAEAAEQPKNpFDyjW80UPXNlFDyjH8w9ZwPNED1zX8w9ZyUQPKMvzRA9cxvNFD1zMRA8o4vMPWMgPV8DzRA9c5w8o+/MPXP4PLsF3CQ9X9vMPUfHrCw8owegPeQYADyjw80UPWcAPV8DzRQ9Z0vNFD1jCQQ8uwHcKD1fA80EPUcDrCUEPKMDo4XgGAPNFD1nJ8w9Y8PNFD1nbD1fA80UPWMtBDy7BdwoPV8DzQQ9RwesJQQ8oweiyeAYA8w9Z//MPWPDzRQ9Z5A9XwPNBD1j8Dy7HdwkPV8DzD1HH6wgPKMfoh3gGAPNEDxAFluA2APMPWfbzD1nA8w9c8IP7EA+Onf3//+sqSGMOSIX/dB3zDxCUJFABAADzDxEUz/MPEJQkWAEAAPMPEVTPBI1BAYkGRA8orCSAAAAARA8odCRwTI2cJAABAABJi1sQSYtzGEEPKHPwQQ8oe+BFDyhD0EUPKEvARQ8oU7BFDyhboEUPKGOQRA8ofCRgSYvjX8PMzMzMQFNVVldBVEFWQVdIgezgAAAARA8plCSQAAAASIsF/v03AEgzxEiJhCSIAAAASIusJEABAAAz9jP/TGP6RTPASIlMJHBFM/ZIiWwkeEyJfCRoRA8o0vNFD1nSTYvhSIvZhdJ+JEiDwQxJi9cPH0QAAIA5AUGNQAFIjUkOQQ9FwESLwEiD6gF16ESJRQBFhcB0GEljyEjB4QLo0zv9/0mJBCRIhcB1Col1ADPA6YMDAABMiawkKAEAADPtDym0JNAAAABEi+0PKbwkwAAAAEQPKYQksAAAAEQPKYwkoAAAAIlsJGAPH0AAZg8fhAAAAAAARQ9XwEUPV8lBg/0BdRhIY89IweED6GY7/f9Ii/BIhcAPhFsCAACJrCSAAAAAi/1Ix8X/////TYX/D44dAgAASIPDCkUz7WZmDx+EAAAAAAAPtksCg+kBD4SUAQAAg+kBD4RQAQAAg+kBD4S4AAAAg/kBD4XHAQAAD79D+EiNlCSAAAAARIlsJFhBDyjZ80QPEVQkUEEPKNBIi85mD274D79D9g9b/2YPbvAPvwPzDxF8JEgPW/ZmD27oD79D/vMPEXQkQA9b7WYPbuAPv0P88w8RbCQ4D1vkZg9uyA+/Q/rzDxFkJDAPW8lmD27AD1vA8w8RTCQo8w8RRCQg6G/5//8Pv0P2i7wkgAAAAGZED27AD79D+EUPW8BmRA9uyEUPW8npGAEAAA+/Q/hIjZQkgAAAAESJbCRISIvO80QPEVQkQGYPbtgPv0P2D1vbZg9u0A+/Q/zzDxFcJDhBDyjZD1vSZg9uyA+/Q/rzDxFUJDBBDyjQD1vJZg9uwA9bwPMPEUwkKPMPEUQkIOjx9v//D79D+EQPv0P2i7wkgAAAAGZED27IZkUPbsBFD1vJRQ9bwOmJAAAAD79D9mZED27AD79D+EUPW8BmRA9uyEhjx0UPW8mNeAGJvCSAAAAASIX2dF3zRA8RBMbzRA8RTMYE605Ihe14DEmLBCSLz0ErzokMqA+/Q/ZI/8VMY/dmRA9uwA+/Q/hBjX4BibwkgAAAAEUPW8BmRA9uyEUPW8lIhfZ0DfNGDxEE9vNGDxFM9gRIg8MOSYPvAQ+FA/7//0SLbCRgTIt8JGhIi1wkcEmLBCRB/8WLz0SJbCRgQSvOiQyoQYP9Ag+NnAAAADPt6X/9//8zyf8Vn8EGAE2LDCRNhcl0bEyLBVcWOABNhcB0YEkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDmNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEcdBBAAAAABm/0EGQf+AGCsAAEmLyf8VIcEGAEiLRCR4SYksJIkoM8DrA0iLxkQPKIQksAAAAA8ovCTAAAAADyi0JNAAAABMi6wkKAEAAEQPKIwkoAAAAEiLjCSIAAAASDPM6G1gBgBEDyiUJJAAAABIgcTgAAAAQV9BXkFcX15dW8PMzEyL3EmJawhJiXMYV0iB7IAAAAAPKXQkcEmNQxDzDxC0JLgAAABBi9EPKXwkYE2NS2DzDxC8JLAAAAAPKMbzD13HSYlDmEiL8TPtSYvIQYlrEEmJa2DzD17IDyjR6D/7//9Ii/hIhcAPhE0BAACLjCTYAAAASIvQ8w8QhCTIAAAA8w8QjCTAAAAARIuMJJgAAABMi4Qk6AAAAIlMJEiLjCTQAAAAiUwkQEiLzvMPEUQkOPMPEUwkMPMPEXQkKPMPEXwkIOjI7///SDmsJOgAAAB0aEyLBacUOABNhcB0XEkPv5AcKwAASY2IICsAAEWLSARIjQzRRDkJdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJCYlpBGb/QQZB/4AYKwAASIuMJOgAAAD/FXC/BgBMiwUxFDgATYXAdF1ND7+QHCsAAEmNkCArAABFi0gESo0U0kQ5CnQ2QY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkKiWoEZv9CBkH/gBgrAABIi8//Ff6+BgAPKHQkcEyNnCSAAAAASYtrEEmLcyAPKHwkYEmL41/DzMzMzMzMzEyL3EFUSIHsAAEAAEiLBc33NwBIM8RIiYQkiAAAAIN5TABJiVvwi5wkWAEAAEmJa+hBi+lJiXPgSYl72EiL+U2Jc9BFi/BNiXvITY2DeP///0EPKXO4TIv6QQ8pe6iL00UPKUOYRQ8pS4h1B+j/tv//6wXomNv///MPELQkUAEAAIvw80QPEIQkQAEAAEiNRCRg80QPEIwkOAEAAEUz5PMPELwkSAEAAEEPKNhMiWQkSEEPKNFMiWQkQIvTSIlEJDhIi89IjUQkZEiJRCQw8w8RdCQo8w8RfCQg6IHc//+LhCQwAQAARYX2SIu8JOAAAABIi5wk+AAAAEyJfCR4TIu8JNAAAABEiXQkaEyLtCTYAAAAiUQkcIlsJGx0S4XtdEeLRCRgSI1MJGhMi4QkgAAAAESLzvMPEA1z2DYAiUQkSItEJGSJRCRA8w8RdCQ48w8RfCQw80QPEUQkKPNEDxFMJCDouPz//0yLjCSAAAAARA8ojCSQAAAARA8ohCSgAAAADyi8JLAAAAAPKLQkwAAAAEiLtCToAAAASIusJPAAAABNhcl0aUyLBfIROABNhcB0XUkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDaNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEUSJYQRm/0EGQf+AGCsAAEmLyf8Vv7wGAEiLjCSIAAAASDPM6EdcBgBIgcQAAQAAQVzDzMzMzMzMzMzMzMzMzEWFwA+OnwIAAFNWV0FWSIPsOEiLBYf1NwBIM8RIiUQkKIu0JIAAAACLwkiJbCRoK8ZMiWQkcESL8kyJfCQwSIv5SGPYSMdEJCAAAAAATWP5QYvoDx9AAGYPH4QAAAAAAEyLxkiNTCQgM9LoW20GAEUzyYvGg+gCD4RxAQAAg+gBD4QXAQAAg+gBD4SzAAAAM8mD+AF0WEiF2w+ImAEAAEyL10yNWwFmZg8fhAAAAAAARQ+2Ak2NUgFIY8FBi9CD4AcPtkQEICvQjQQOg+AHRAPKM9L/wUSIRAQgQYvB9/ZBiEL/SYPrAXXH6UkBAABIhdsPiEABAABMi9dMjVsBZpBFD7YCTY1SAUhjwUGL0IPgBw+2RAQgK9CNQf2D4AdEA8r/wUSIRAQguM3MzMxB9+HB6gJBiFL/SYPrAXXD6fUAAAAzyUiF2w+I6gAAAEyL10yNWwEPH0AADx+EAAAAAABFD7YCTY1SAUhjwUGL0IPgBw+2RAQgK9CNQfyD4AdEA8r/wUSIRAQgQYvBwegCQYhC/0mD6wF1yOmaAAAAM8lIhdsPiI8AAABMi9dMjVsBkEUPtgJNjVIBSGPBQYvQg+AHD7ZEBCAr0I1BA4PgB0QDyv/BRIhEBCC4q6qqqkH34dHqQYhS/0mD6wF1xOtJM8lIhdt4QkyL10yNWwEPH0AARQ+2Ak2NUgFIY8FBi9CD4AcPtkQEICvQjUECg+AHRAPK/8FEiEQEIEGLwdHoQYhC/0mD6wF1yUE7zn06TGPBQYvGK8GLyE2NFDhmDx9EAABJi8BNjVIBg+AHM9JJ/8APtkQEIEQryEGLwff2QYhC/0iD6QF12kkD/0iD7QEPhd39//9Mi3wkMEyLZCRwSItsJGhIi0wkKEgzzOiRWQYASIPEOEFeX15bw8zMzMzMzMyF0g+OjAIAAFNWV0FWQVdIg+wwSIsF1vI3AEgzxEiJRCQoRIu0JIAAAABBi9hIiWwkaEEr3klj8UWL+EiL+UjHRCQgAAAAAEyJZCRwi+pmkE2LxkiNTCQgM9Lou2oGAEUz0kGLxoPoAg+EYAEAAIPoAQ+EBgEAAIPoAQ+EsgAAADPJg/gBdFmF2w+IiAEAAEUz2w8fQABmZg8fhAAAAAAAi8FNY8uD4AdEA95FD7YEOQ+2VAQgQYvAK8Iz0kQD0EGNBA6D4Af/wUSIRAQgQYvCQff2QYgEOTvLfsXpNwEAAIXbD4gvAQAARTPbDx9EAACLwU1jy4PgB0QD3kUPtgQ5D7ZUBCBBi8ArwkQD0I1B/YPgB//BRIhEBCC4zczMzEH34sHqAkGIFDk7y37D6eUAAAAzyYXbD4jbAAAARTPbkIvBTWPLg+AHRAPeRQ+2BDkPtlQEIEGLwCvCRAPQjUH8g+AH/8FEiEQEIEGLwsHoAkGIBDk7y37I6ZoAAAAzyYXbD4iQAAAARTPbZg8fRAAAi8FNY8uD4AdEA95FD7YEOQ+2VAQgQYvAK8JEA9CNQQOD4Af/wUSIRAQguKuqqqpB9+LR6kGIFDk7y37E60kzyYXbeENFM9tmDx+EAAAAAACLwU1jy4PgB0QD3kUPtgQ5D7ZUBCBBi8ArwkQD0I1BAoPgB//BRIhEBCBBi8LR6EGIBDk7y37JQTvPfUmLxkxjyQ+vwUxjwEGLx0wDxyvBi8gPH0AAZmZmDx+EAAAAAABJi8Ez0oPgB0n/wQ+2RAQgRCvQQYvCQff2QYgATAPGSIPpAXXbSP/HSIPtAQ+F3v3//0yLZCRwSItsJGhIi0wkKEgzzOj3VgYASIPEMEFfQV5fXlvDzMzMzMzMzMzMzMxIg+woDyl0JBAPKTwkSIXJdQ5Iiw33CzgASIHBkA0AAMeBOAEAAAAAgD8z0seBPAEAAAAAgD/HgUABAAAAAIA/x4FEAQAAAACAP8eBSAEAAAAAAD/HgUwBAAAAAAA/x4FQAQAAAAAAP8eBVAEAAAAAgD/HgVgBAACPwnU9x4FcAQAAj8J1PceBYAEAAI/CdT1Ix4FkAQAA16NwP0iJkWwBAACJkXQBAADHgXgBAAAK16M9x4F8AQAACtejPceBgAEAAArXoz3HgYQBAADXo3A/x4GIAQAA9ijcPseBjAEAAPYo3D7HgZABAAAAAAA/SMeBlAEAAAAAAD9IiZGcAQAAiZGkAQAAx4GoAQAACtcjPseBrAEAAOF6lD7HgbABAACPwvU+x4G0AQAAcT0KP8eBuAEAALgehT7HgbwBAAA9Chc/x4HAAQAASOF6P8eBxAEAAM3MzD7HgcgBAAC4HoU+x4HMAQAAPQoXP8eB0AEAAEjhej/HgdQBAAAfhSs/x4HYAQAACtcjPceB3AEAAArXIz3HgeABAAAK1yM9x4HkAQAAAACAP8eB6AEAAArXIz7HgewBAADhepQ+x4HwAQAAj8L1PkjHgfQBAAAAAIA/SImR/AEAAMeBBAIAAFyPAj/HgQgCAAApXA8+x4EMAgAAKVwPPseBEAIAAClcDz7HgRQCAAAAAIA/x4EYAgAACtejPMeBHAIAAArXozzHgSACAAAK16M8x4EkAgAAFK4HP8eBKAIAAFK4nj7HgSwCAABSuJ4+x4EwAgAAUriePseBNAIAAAAAgD/HgTgCAACF69E+x4E8AgAAhevRPseBQAIAAIXr0T7HgUQCAAAAAIA/x4FIAgAAXI8CP8eBTAIAAFyPAj/HgVACAABcjwI/x4FUAgAAAACAP8eBWAIAALgehT7HgVwCAAA9Chc/x4FgAgAASOF6P8eBZAIAAAAAgD/HgWgCAACPwnU+x4FsAgAAuB4FP8eBcAIAAK5HYT/HgXQCAAAAAIA/x4F4AgAAuB6FPseBfAIAAD0KFz/HgYACAABI4Xo/x4GEAgAAAACAP8eBiAIAALgehT7HgYwCAAA9Chc/x4GQAgAASOF6P8eBlAIAAM3MzD7HgZgCAAC4HoU+x4GcAgAAPQoXP8eBoAIAAEjhej/HgaQCAAAAAIA/x4GoAgAAj8J1PceBrAIAABSuBz/HgbACAABI4Xo/x4G0AgAAAACAP8eBuAIAALgehT7HgbwCAAA9Chc/x4HAAgAASOF6P8eBxAIAAFK4nj7HgcgCAAC4HoU+x4HMAgAAPQoXP8eB0AIAAEjhej/HgdQCAADNzEw/x4HYAgAAuB6FPseB3AIAAD0KFz/HgeACAABI4Xo/x4HkAgAAAACAPw8QgYgBAAAPEYHoAgAAx4H4AgAAzczMPceB/AIAAM3MzD7HgQADAAAAAEA/x4EEAwAAFK5HP8eBCAMAAM3MzD3HgQwDAADNzMw+x4EQAwAAAABAP8eBFAMAAAAAgD/HgRgDAAC4HoU+x4EcAwAAPQoXP8eBIAMAAEjhej/HgSQDAADNzEw+x4EoAwAAuB6FPseBLAMAAD0KFz/HgTADAABI4Xo/x4E0AwAAH4UrP8eBOAMAALgehT7HgTwDAAA9Chc/x4FAAwAASOF6P8eBRAMAADMzcz/zDxA9bs02AA8QgTgBAAAPEYFIAwAADxCByAIAAA8RgVgDAADzDxCBwAIAAPMPEIm8AgAA8w8QmfABAADzDxCp7AEAAPMPXNjzDxChuAIAAPMPXOnzDxCR9AEAAPMPWd/zD1nv8w9Y2PMPEIHoAQAA8w9cxPMPWOnzDxCJxAIAAPMPXNHzD1nH8w9Z1/MPWMTzD1jR8w8RgWgDAADzDxGpbAMAAPMPEZlwAwAA8w8RkXQDAADzDxCB3AIAAPMPELHsAQAA8w8QHYrMNgDzD1zw8w8QqdgCAADzD1nz8w9Y8PMPEIHgAgAA8w8QieQCAADzDxCh8AEAAPMPEJH0AQAA8w9c4PMPXNHzD1nj8w9Z0/MPWODzDxCB6AEAAPMPXMXzD1jR8w9Zw/MPWMXzDxGBeAMAAPMPEbF8AwAA8w8RoYADAADzDxGRhAMAAA8QgdgCAAAPEYGIAwAA8w8QgXADAADzDxCJbAMAAPMPEKFoAwAA8w8QmeABAADzDxCp3AEAAPMPXNjzDxCR5AEAAPMPXOnzD1nf8w9Z7/MPWNjzDxCB2AEAAPMPXMTzD1jp8w8QiXQDAADzD1zR8w9Zx/MPWdfzD1jE8w9Y0fMPEYGYAwAA8w8RqZwDAADzDxGZoAMAAPMPEZGkAwAA8w8QJUzLNgDzDxCBfAMAAPMPEImEAwAA8w8QqXgDAADzDxCR5AEAAPMPELHcAQAA8w9c0fMPEJngAQAA8w9c8PMPWdTzD1n08w9Y0fMPWPDzDxCBgAMAAPMPXNjzD1nc8w9Y2PMPEIHYAQAA8w9cxfMPWcTzD1jF8w8RgagDAADzDxGxrAMAAPMPEZmwAwAA8w8RkbQDAADHgbgDAAAAAAA/x4G8AwAAAAAAP0jHgcADAAAAAAA/8w8QkeQCAADzD1kVsco2AIuB2AIAAPMPEIHcAgAA8w8QieACAACJgcgDAADzDxGBzAMAAPMPEYnQAwAA8w8RkdQDAADHgdgDAADNzEw+x4HcAwAAzcxMPseB4AMAAM3MTD7HgeQDAAAAAIA/x4HoAwAA9igcP8eB7AMAAPYoHD/HgfADAAD2KBw/x4H0AwAAAACAP8eB+AMAAAAAgD/HgfwDAAD2KNw+x4EABAAAMzOzPseBBAQAAAAAgD/HgQgEAABmZmY/SMeBDAQAADMzMz/HgRQEAAAAAIA/x4EYBAAAAACAP0jHgRwEAACamRk/x4EkBAAAAACAP8eBKAQAAFyPQj7HgSwEAABcj0I+x4EwBAAAzcxMPseBNAQAAAAAgD/HgTgEAABSuJ4+x4E8BAAAUriePseBQAQAADMzsz7HgUQEAAAAAIA/x4FIBAAAH4VrPseBTAQAAB+Faz7HgVAEAAAAAIA+SMeBVAQAAAAAgD9IiZFcBAAAiZFkBAAAx4FoBAAAAACAP8eBbAQAAAAAgD/HgXAEAAAAAIA/x4F0BAAAj8J1PQ8QgdgCAAAPEYF4BAAAx4GIBAAAuB6FPseBjAQAAD0KFz/HgZAEAABI4Xo/x4GUBAAAMzOzPg8QgYgBAAAPEYGYBAAAx4GoBAAAAACAP0jHgawEAAAAAIA/SMeBtAQAAGZmZj9IiZG8BAAAiZHEBAAAx4HIBAAAAACAP8eBzAQAAAAAgD/HgdAEAAAAAIA/x4HUBAAAAACAP8eB2AQAALgehT7HgdwEAAA9Chc/x4HgBAAASOF6P8eB5AQAAAAAgD/HgegEAAAAAIA/x4HsBAAAAACAP8eB8AQAAAAAgD/HgfQEAAAzMzM/x4H4BAAAzcxMP8eB/AQAAM3MTD/HgQAFAADNzEw/x4EEBQAAzcxMPseBCAUAAM3MTD/HgQwFAADNzEw/x4EQBQAAzcxMP8eBFAUAADMzsz4PKHQkEA8oPCRIg8Qow8zMzMzMzMzMzMxAU0iD7CBIi9lIg8FY6J5q//9IjUtISIPEIFvpkGr//0iJXCQQSIlMJAhXSIPsIEiL2kiL+TPJSIkPSIlPCEiJTxBIiU8YSIlPIEiJTyhIiU9QSIlPWEiJT2BIiU9oSIlPcEiJT3gPV8AzwA8Rh4gAAABIiYeYAAAASImPoAAAAEiJj6gAAABIiY+wAAAASImPuAAAAEiJj8AAAABIiY/IAAAAM9JBuOAAAABIi8/oR10GAEiL00iLz+jyAAAAkEiLx0iLXCQ4SIPEIF/DzMzMSIlcJAhXSIPsIEiL+eguAwAATItHOE2FwHRDTYtQYEmLykljQFhJjRTCTDvScy+QSDk5dAtIg8EISDvKcvLrHkyLyU0ryknB+QNIjUL4SDvIcwdIiwBLiQTKQf9IWEjHRzgAAAAASI2PwAAAAOhuaf//SI2PsAAAAOhiaf//SI2PoAAAAOhWaf//kEiNj4gAAADoqTMAAEiNj5AAAADoPWn//5BIjU9Q6DNp//9IjU8g6Cpp//9IjU8Q6CFp//9Ii89Ii1wkMEiDxCBf6Q9p///MzMzMzMzMzMzMzMzMzMxAV0iD7CBMi0k4SIv5TYXJdD9Ni1FgSWNBWE2LwkmNDMJMO9FzK0k5OHQLSYPACEw7wXLy6xtIjUH4TDvAcw5IiwBNK8JJwfgDS4kEwkH/SVhIiVc4SIXSdE9Ei0Jci0pYSIlcJDBIjVpYQTvIdSj/wUWFwHQNQYvAmSvC0fhBA8DrBbgIAAAAO8EPT8iL0UiLy+hJeP//SGMLSItDCEiJPMj/A0iLXCQwSIPEIF/DzEiJXCQISIlsJBBIiXQkGFdIg+xwg7mMAAAAAUiL2X4PSIvRSIHBiAAAAOhRNAAAi0sEM+2FyXkYi8GZK8KL1dH4A8iFyQ9P0UiLy+jAhf//iSuLSxSFyXkZi8GZK8KL1dH4A8iFyQ9P0UiNSxDofn3//4lrEItLJIXJeRmLwZkrwovV0fgDyIXJD0/RSI1LIOiref//iWsgD1fASItDOItINDPAiUswDxFDYA8RQ3BIiYOAAAAAiWs0SIlrQEiJa0iLi6QAAACFyXkci8GZK8KL1dH4A8iFyQ9P0UiNi6AAAADoSX///4mroAAAAIuLtAAAAIXJeRyLwZkrwovV0fgDyIXJD0/RSI2LsAAAAOgdf///SI2LwAAAAImrsAAAADPS6Ol3//+LS1SFyXkZi8GZK8KL1dH4A8iFyQ9P0UiNS1Do6Xb//w9XwIlrUDPAiauIAAAASI1UJCBIiUQkYEiLy8eDjAAAAAEAAAAPEUQkIA8RRCQwDxFEJEAPEUQkUOj7g///SItDOEyNXCRwSYtrGEmLcyCLSDCJi9AAAABJi1sQSYvjX8PMzMzMzMzMzEiJXCQIV0iD7CBIi9no3pj8/0iNSxDo1Zj8/0iNSyDozJj8/zP/SIl7MEiJe0BIiXtITIuLqAAAAE2FyXR/TIsFO/03AEiJu6AAAABNhcB0XEkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEYl5BGb/QQZB/4AYKwAASYvJ/xUCqAYASIm7qAAAAEyLi7gAAABNhckPhIAAAABMiwWs/DcASIm7sAAAAE2FwHRdTQ+/mBwrAABJjZAgKwAARYtQBEqNFNpEORJ0NkGNSwG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv9FIgcJkBQAASY0U0ESJEol6BGb/QgZB/4AYKwAASYvJ/xVypwYASIm7uAAAAEiNi8AAAADol5f8/0iNS1Dojpf8/0iNi4gAAABIi1wkMEiDxCBf6YgvAADMzMzMzMzMzEiLxFNIgeygAAAARItBBEiL2Q8pcOgPV/YPKXjYDxB5YEQPKUDIM8BEDxBBcEiJRCRISIlEJGCLgYAAAACJRCRAi0EQiwmJRCREQTvIdSj/wUWFwHQNQYvAmSvC0fhBA8DrBbgIAAAAO8EPT8iL0UiLy+hpgv//SGMDDyhEJEBIjQzASItDCA8RPMgPKLwkgAAAAEQPEUTIEEQPKEQkcA8RRMgg8g8QRCRgDxF0yDAPKLQkkAAAAPIPEUTIQP8DSIHEoAAAAFvDzMzMzMzMzMxIiVwkEEiJbCQYSIl0JCBBVkiD7CBMYzFIi/FIi0EIS40U9otM0OBIjRzQhcl0HkiLQ7hIO0ZgdQpIi0PASDtGaHQKSIvO6OX+///rUEiJfCQwhcl1OkGD/gF+NEG4JAAAAEiNk3D///9IjU5g6BZXBgCFwHUai0OYA0OUO0PcdQ9Ig3ugAHUIQY1G/4kG6wgPEEZgDxFDuEiLfCQwSItcJDhIi2wkQEiLdCRISIPEIEFew8zMzMzMzMzMzMzMzMxIiVwkEEiJbCQYVkFWQVdIg+wgTGM5SIvZSItBCEuNFP+LTNDgTI000IXJdB5Ii0N4STlG0HUKSItDcEk5Rsh0CkiLy+gn/v//61tJg37oAHVUSIl8JECFyXU9QYP/AX43QbgkAAAASY2WcP///0iNS2DoUVYGAIXAdR1Bi0aYQQNGlEE7Rtx1D0mDfqAAdQhBjUf/iQPrCQ8QQ3BBDxFGyEiLfCRASItcJEhIi2wkUEiDxCBBX0FeXsPMzMzMzMxIg+woDyjBDyjR8w9YBf6/NgDzDyzAg/g/dxRIY9BIi0E4D7aEAvQBAABIg8Qow0iLQTjzDxAF2b82APMPEEgs8w9dyvMPXsrzD1zB6DVXBgDzDxAN/782APMPXsgPKMHoJ1cGAPMPLMD/wJkrwtH4A8CD+AR9CrgEAAAASIPEKMO5AAIAADvBD0/BSIPEKMNIiVwkCFdIg+ww8w8QEkiL+fMPEEoE80EPECjzQQ8QYATzDxFUJCDzDxFMJCRFhMl0Qg8QQWAPL8J2CfMPEUQkIA8o0A8o2A/G2FUPL9l2CfMPEVwkJA8oyw8o2A/G2KoPL+t2Aw8o6w/GwP8PL+B2Aw8o4EiNmaAAAABEi0ME8w9f1YsL8w9fzPMPEVQkKPMPEUwkLEE7yHUo/8FFhcB0DUGLwJkrwtH4QQPA6wW4CAAAADvBD0/Ii9FIi8voXnn//0hjC0iLQwhIA8kPEEQkIA8RBMj/A0iLzw8RR2BIi1wkQEiDxDBf6QP9///MzMxIiVwkCEiJbCQQSIl0JBhXQVZBV0iD7CBEi0k0QYv4RQPIi+pIi9lBgfkAAAEAcjz2QTAIdDZIYwFEi0EgRImBgAAAAMdBNAAAAABIjQzASItDCIN8yOAASI0UyHQKSIvL6Mr7///rBESJQthIYwNIjQzASItDCAFsyOBMY3sgi0skQY00P78IAAAAO/F+IYXJdAuLwZkrwtH4A8HrAovHO8ZIjUsgi9YPT9DokHL//4lzIEuNDL9Ii0MoTGN7EEiNDIhIiUtAQY00L4tLFDvxfh6FyXQKi8GZK8LR+I08ATv+SI1LEIvWD0/X6AB2//9Ii2wkSIlzEEiLQxhIi3QkUEqNDHhIiUtISItcJEBIg8QgQV9BXl/DzMzMzMzMzMxAU0iD7EBIi0FISIvZ80EPEFkETYvR80EPECDzDxBqBEyLXCRwDyl0JDDzQQ8QMUQPt0k080EPEBMPKXwkIPNBDxB7BEQPKUQkEEGNSQHzRA8QAkQPKQwk80UPEEgEZkSJCEiLQ0hmiUgCQY1JAkiLQ0hmiUgESItDSGZEiUgGZkGDwQNIi0NIZolICEiLQ0iLTCR4ZkSJSAryDxACSItDQPIPEQDyQQ8QCkiLQ0DyDxFICEiLQ0CJSBBIi0NA8w8RYBTzDxFoGEiLQ0DzDxFQHPMPEVggSItDQIlIJPJBDxAASItDQPIPEUAo8kEPEAtIi0NA8g8RSDBIi0NAiUg4SItDQPNEDxFAPEQPKEQkEPNEDxFIQEiLQ0BEDygMJPMPEXBEDyh0JDDzDxF4SEiLQ0APKHwkIIlITEiDQ0BQg0M0BEiDQ0gMSIPEQFvDzMxMi9xFiUsgU1dBVkFXSIHs+AAAAE1j8EWL+UiL+kiL2UGD/gIPjOIOAABB98EAAAD/D4TVDgAASItBOEGNTv+LUzBJiWsID7asJEABAABNiWvIQIDlAUEPKXO48w8QMEEPKXuo8w8QeARBi8YPRMFFDylDmPNEDxCEJEgBAABFDylLiPNEDxCL0AAAAEUPL8FMY+hAiKwkQAEAAEyJbCRIQQ+XwESIRCQi9sIBD4RJDAAASYlz2EGLyYHh////AE2JY9BFDymTeP///0QPKWwkYPNEDxAtSrs2AIlMJCzzRQ9fxfNBDyzIiUwkQPbCAnRQg/kgfUvzDxANero2AEEPKNBmD27BD1vA8w9c0A8vynIvRQ8uzXopdSdDjTQ2xkQkIAGNFECJdCQoA9JEi8ZIi8voWfz//8aEJDABAAAB610z9kCIdCQgRYTAdDBCjQy1AAAAAI0UwIlMJChEi8ED0kiLy+gn/P//ugUAAABAiHQkIECItCQwAQAA6yZDjQx2jRRAiUwkKESLwcHiAkiLy+j6+///QIi0JDABAAC6AwAAAEiLSzhBD6/WSIPBSOiMwQAASItDOEUz0vMPECUNvjYATYvmQYvKRYvCD1ftSItwUE6NHPZJg/0ED4y6AQAASY1F/b0CAAAATIvgRIv5To0sx0mL0o1N/0E7zkmNQAFID0XQ8w8QDNfzDxBU1wTzQQ9cTQDzQQ9cVQQPKMEPKNrzD1nB8w9Z2vMPWNgPL912DPMPUsPzD1nI8w9Z0PNCDxEUxk6NDMYPV8xJjUgC80EPEUkEQTvuSYvCSA9FwfMPEAzH8w8QVMcE80EPXE0I80EPXFUMDyjBDyja8w9ZwfMPWdrzD1jYDy/ddgzzD1LD8w9ZyPMPWdDzQQ8RUQhJjVADD1fMSIlUJDDzQQ8RSQyNRQFBO8ZJi8pID0XK8w8QDM/zDxBUzwTzQg9cTMcQ80EPXFUUDyjBDyja8w9ZwfMPWdrzD1jYDy/ddgzzD1LD8w9ZyPMPWdDzQg8RVMYQjUUCQTvGSY1IBEiLRCQwD1fM80EPEUkUSYvSSA9F0UyLwfMPEAzX8w8QVNcE8w9cDMfzQQ9cVRwPKMEPKNrzD1nB8w9Z2vMPWNgPL912DPMPUsPzD1nI8w9Z0EGDxwTzDxEUxoPFBA9XzPNBDxFJHEk7zA+Mdv7//0yLbCRITYvmD7asJEABAABEiXwkJItMJCREi7wkOAEAAE07xX1l/8FBO85JjVABSYvCSA9FwvMPEAzH8w8QVMcE80IPXAzH80IPXFTHBA8owQ8o2vMPWcHzD1na8w9Y2A8v3XYM8w9Sw/MPWcjzD1nQD1fM80IPERTG/8HzQg8RTMYETIvCSTvVfJ1AhO11DvJCDxBE5vDyQg8RROb480QPEBXDtzYARDiUJDABAAAPhbwEAABEOFQkIg+EvwQAAPNFD1zB80UPWcJAhO0PhYcBAABBDyjYQo0Etfz////zQQ9Y2UhjyEEPKNAPKMMPKMvzD1kG8w9ZTgTzD1gH8w9YTwTzQQ8RA0EPKMDzQQ8RSwRBDyjI8w9ZBvMPWVYE8w9YB/MPWFcE80EPEUMIQQ8owPNBDxFTDPMPWUYE8w9ZDvMPEFcE8w9c0PMPEAfzD1zBDyjL80EPEVMU80EPEUMQ8w9ZTgTzDxBXBPMPEAfzD1zRDyjL8w9ZDvNBDxFTHPMPXMEPKMvzQQ8RQxgPKMPzQg9ZROb480IPWUzm/PNCD1hE5/jzQg9YTOf880EPEQTLQQ8owPNBDxFMywRBDyjI80IPWUTm+PNCD1lM5vzzQg9YROf480IPWEzn/PNBDxFEywhBDyjA80EPEUzLDEEPKMjzQg9ZROb880IPWUzm+PNCDxBU5/zzD1zQ80IPEETn+PMPXMEPKMvzQQ8RVMsU80EPEUTLEPNCD1lM5vzzQg9ZXOb480IPEFTn/PNCDxBE5/jzD1zR8w9cw/NBDxFUyxzzQQ8RRMsYi0M0iYQkMAEAAE2F7Q+ORAIAAEyLZCRITYvqRA8pnCSAAAAAvQEAAABFDyjYRA8pZCRw80QPECVktTYA80UPWNnzRA8QDaq2NgBEi/hJjUUBQTvuSYvKSY1VAEgPRchMi+h1BkSLQzTrBEWNRwTzDxAk1kiNBM0AAAAA8w8QbDAE8w9YbNYE8w9YJDBEiYQkMAEAAPNBD1nq80EPWeIPKM3zD1nNDyjE8w9ZxPMPWMhBDy/MdhhBDyjF8w9ewUEPKMnzD13I8w9Z4fMPWelIweEFRY1IAUGNVwJBDyjT8w9Z1EEPKNtBg8AC/8XzD1ndDyjC80EPWeDzD1gEOA8oy/NBD1no80IPEQQZDyjE8w9YTDgE80IPEUwZBA8ozfMPWAQ480IPEUQZCPMPWEw4BPNCDxFMGQzzDxAEOPMPXMTzQg8RRBkQ8w8QTDgE8w9czfNCDxFMGRTzDxAEOPMPXMLzQg8RRBkY8w8QTDgE8w9cy/NCDxFMGRxBjU8BSItDSGZEiQhIi0NIZolIAkiLQ0hmiVAESItDSGaJUAZIi0NIZkSJQAhIi0NIZkSJSApIi0NIZkSJSAxIi0NIZolIDkiLQ0iLjCQwAQAAZkSJeBBIi0NIZkSJeBJmQYPHA0iLQ0hmiUgUZoPBA0iLQ0hmRIlIFkiLQ0hmRIlAGEiLQ0hmiVAaSItDSGZEiXgcSItDSGZEiXgeSItDSESLvCQwAQAAZolIIEiLQ0hmRIlAIkiDQ0gkTTvsD4wQ/v//RA8oZCRwTYvmRA8onCSAAAAARIu8JDgBAABNheQPhJsEAACLTCQsSYPDEA8fQADyQQ8QQ/BNjVsgSItDQEn/wvIPEQBIi0NA8w8RcAjzDxF4DEiLQ0CJSBDyQQ8QQ9hIi0NA8g8RQBRIi0NA8w8RcBzzDxF4IEiLQ0BEiXgk8kEPEEPgSItDQPIPEUAoSItDQPMPEXAw8w8ReDRIi0NARIl4OEiLQ0DyQQ8QQ+jyDxFAPEiLQ0DzDxFwRPMPEXhISItDQIlITEiDQ0BQTTvUD4xa////6eQDAABFDyjI80UPWcrzRQ9YzUCE7Q+FxgAAAEEPKMFDjQQ28w9ZBkEPKMlIY8jzD1lOBPMPWAfzD1hPBPNBDxEDQQ8owfNBDxFLBEEPKMnzD1lGBPMPWQ7zDxBXBPMPXNDzDxAH8w9cwUEPKMnzQQ8RUwzzQQ8RQwhBDyjB80IPWUTm+PNCD1lM5vzzQg9YROf480IPWEzn/PNBDxFEy/BBDyjB80EPEUzL9EEPKMnzQg9ZROb880IPEFTn/PNCD1lM5vjzD1zQ80IPEETn+PMPXMHzQQ8RVMv880EPEUTL+ESLQzRNhe0PjrwBAADzDxAtl7E2AE2L6vMPECXgsjYAvQEAAABMi3wkSEQPtqQkMAEAAA8fRAAASY1FAUE77kmLyk2NTQBID0XITIvodQWLUzTrDg+2VCQgg/IBg8ICQQPQ80IPEBTOSI0EzQAAAADzQg8QXM4E8w9YFDDzD1hcMATzQQ9Z0vNBD1naDyjC8w9Zwg8oy/MPWcvzD1jIDy/NdhdBDyjF8w9ewQ8ozPMPXcjzD1nR8w9Z2UgDyfNBD1nRRY1IAfNBD1nZDyjC8w9YBDgPKMvzQQ8RBMvzD1hMOATzQQ8RTMsE8w8QBDjzD1zC80EPEUTLCPMPEEw4BPMPXMvzQQ8RTMsMjUoBSItDSGaJTCQiZokQSItDSGZEiUACSItDSEWE5HQlZkSJSARIi0NIZolIBkiLQ0hmRIlICEiLQ0hmiVAKSINDSAzrYEGNSAJmiUgESItDSGaJSAaNSgJIi0NIZolICEiLQ0gPt0wkImaJUApIi0NIZolIDEiLQ0hmRIlIDkiLQ0hmRIlAEEiLQ0hmRIlAEkiLQ0hmiVAUSItDSGaJSBZIg0NIGP/FRIvCTTvvD4x6/v//RIu8JDgBAABNi+ZEOJQkMAEAAA+EnwAAAEiLQzhIY1QkQEgD0kiLSAgPEATRDxFEJDBNheQPhA4BAADzDxBMJDzzDxBUJDjzDxBcJDTzDxBkJDAPH4AAAAAA8kEPEANNjVsQSItDQEn/wvIPEQBIi0NA8w8RYAjzDxFYDEiLQ0BEiXgQSItDQPJBDxBD+PIPEUAUSItDQPMPEVAc8w8RSCBIi0NARIl4JEiDQ0AoTTvUfKfpkQAAAE2F5A+EiAAAAItMJCwPH0QAAPIPEAdIjX8ISItDQE2NWxBJ/8LyDxEASItDQPMPEXAI8w8ReAxIi0NARIl4EPJBDxBD8EiLQ0DyDxFAFEiLQ0DzDxFwHPMPEXggSItDQIlIJEiLQ0DyQQ8QQ/jyDxFAKEiLQ0DzDxFwMPMPEXg0SItDQIlIOEiDQ0A8TTvUfIEPt0QkKAFDNEQPKGwkYEQPKJQkkAAAAEyLpCToAAAASIu0JPAAAADp3wEAAI0UQEiLywPSRI0EhQAAAADogPD//02F7Q+OwQEAAPNED1kFwq42AEUz0kGL0r0BAAAAD1ft8w8QJNdMjUIBQTvuSYvKSQ9FyPMPEBTP8w8QXM8E8w9c1PMPXFzXBA8owg8oy/MPWcLzD1nL8w9YyA8vzXYM8w9SwfMPWdDzD1nYSItDQP/F80EPWdjzQQ9Z0A8ow/MPWMTzDxEADyjD8w8QTNcESItDQPMPXMrzDxFIBEiLQ0DzDxFwCPMPEXgMSItDQESJeBDzD1gEz0iLQ0DzDxFAFPMPEEzPBEiLQ0DzD1zK8w8RSBgPKMpIi0NA8w8RcBzzDxF4IEiLQ0BEiXgk8w8QBM9Ii0NA8w9cw/MPEUAo8w9YTM8ESItDQPMPEUgsSItDQPMPEXAw8w8ReDRIi0NARIl4OPMPEATXSItDQPMPXMPzDxFAPPMPWFTXBEiLQ0BJi9DzDxFQQEiLQ0DzDxFwRPMPEXhISItDQESJeExIi0tID7dDNEiDQ0BQZokBD7dLNEiLQ0hm/8FmiUgCSItDSA+3SzRmg8ECZolIBEiLS0gPt0M0ZolBBkiLQ0gPt0s0ZoPBAmaJSAgPt0s0SItDSGaDwQNmiUgKSINDSAyDQzQETTvFD4xW/v//RA8ohCSwAAAADyi8JMAAAAAPKLQk0AAAAEyLrCTgAAAASIusJCABAABEDyiMJKAAAABIgcT4AAAAQV9BXl9bw8zMzMzMzEGD+AMPjHwFAABMi9xTVldBV0iB7JgAAABBi/BFi/lIi/pIi9lB98EAAAD/D4RIBQAA9kEwBEiLQThFDylLmEUPKVOI80QPEAjzRA8QUAQPhIoEAABJiWsIjRT1+v///02JYxBBi8FNiWsgJf///wBNiXPYA9ZBDylzyA8pfCRwiUQkII0ENkUPKUOoRIvARA8pXCQw80QPEJnQAAAAiUQkJOjJ7f//RItzNEG4AgAAAEiLQ0hBD7fQZgPSQf/AZkED1mZEiTBIi0NIjUr+ZolIAkiLQ0hmiVAESINDSAZEO8Z8zUiLSziL1kiDwUjoLbMAAEiLQzhEjW7/8w8QJa2vNgBFM+RFi8QPV+1Bi+xMi0hQg/4ED4yVAQAATGPGjUb8Sf/IwegCSIvXScHgA0G9DAAAAEmNSQxJK9FNK+n/wEG7AwAAAESL0I0EhQAAAACJhCTQAAAADx+EAAAAAADzDxBMEfTzDxBUEfjzQQ9cDDjzQQ9cVDgEDyjBDyja8w9ZwfMPWdrzD1jYDy/ddgzzD1LD8w9ZyPMPWdDzQw8RFAgPV8zzQw8RTAgE8w8QTAr88w8QFArzD1xMEfTzD1xUEfgPKMEPKNrzD1nB8w9Z2vMPWNgPL912DPMPUsPzD1nI8w9Z0PMPEVH0D1fM8w8RSfjzDxBMCgTzDxBUCgjzD1xMCvzzD1wUCg8owQ8o2vMPWcHzD1na8w9Y2A8v3XYM8w9Sw/MPWcjzD1nQ8w8RUfwPV8zzDxEJ8w8QTAoM8w8QVAoQ8w9cTAoE8w9cVAoIDyjBDyja8w9ZwfMPWdrzD1jYDy/ddgzzD1LD8w9ZyPMPWdDzDxFRBE6NBCkPV8xIg8UE8w8RSQhJi8NIg8EgTY1bBEmD6gEPhcL+//9Ei4Qk0AAAAESNbv9EO8Z8COtxSGPGSP/ISI0MxQAAAACLxkErwEiNFO9Ei8DzDxAK8w8QUgTzD1wMOfMPXFQ5BA8owQ8o2vMPWcHzD1na8w9Y2A8v3XYM8w9Sw/MPWcjzD1nQ80IPERQJD1fM80IPEUwJBEiLykgrz0iDwghJg+gBdanzDxAtmqk2AEyNVwTzRA8QBR2pNgBBjW4B8w8QNcGpNgBNi9nzDxA9Wqo2AEwr34t8JCDzRA9Z3WYPH0QAAPNDDxBcE/xJY8XzQQ8QZMEE80MPWCQT80EPWBzB8w9Z5fMPWd0PKMzzD1nMDyjD8w9Zw/MPWMhBDy/IdhYPKMbzD17BDyjP8w9dyPMPWdnzD1nh80EPEEL8QQ+31EiLQ0BmRQPtZgPSQQ8o0/MPWdNBDyjb8w9Z3EONDC5GjQQy8w9cwvMPEQDzQQ8QCkiLQ0DzD1zL8w8RSARIi0NA80QPEUgI80QPEVAMSItDQESJeBDzQQ9YUvxIi0NA8w8RUBTzQQ9YGkiLQ0BJg8II8w8RWBhIi0NA80QPEUgc80QPEVAgSItDQIl4JEiLQ0hIg0NAKGZEiQBIi0NIZolIAkGLzUiLQ0gDzUWL7EH/xGaJSARIi0NIZolIBo0MKkiLQ0hmiUgISItDSGZEiUAKSINDSAxEO+YPjMT+//9EDyhcJDBEDyhEJGAPKHwkcA8otCSAAAAATIu0JJAAAABMi6wk2AAAAEyLpCTIAAAASIusJMAAAAAPt0QkJOmMAAAAjUb+RIvGjRRA6IPp//9Ii85Ii0NA8g8QB0iNfwjyDxEASItDQPNEDxFICPNEDxFQDEiLQ0BEiXgQSINDQBRIg+kBdc1BuAIAAAAPH4AAAAAASItLSA+3QzRmiQFBjUj/ZgNLNEiLQ0hmiUgCQQ+3yEiLQ0hB/8BmA0s0ZolIBEiDQ0gGRDvGfMgPt8YBQzREDyhMJFBEDyhUJEBIgcSYAAAAQV9fXlvDzMzMzMzMzMzMQFNVQVZBV0iD7DjzDxAFIac2AEGL2USLtCSAAAAATIv6Dyl0JCBIi+kPKPIPL8Z2V0SLQVSLSVBBO8h1Kf/BRYXAdA1Bi8CZK8LR+EEDwOsFuAgAAAA7wQ9PyIvRSI1NUOiqWf//SGNVUEmLB0iLTVhIiQTR/0VQDyh0JCBIg8Q4QV9BXl1bw0iJdCRgDyjOSIl8JGhMiWQkeEyJbCQw6Lzm//+LyMZEJHAAuDAAAACZ9/lEi8CD+AF9F0GLxr8BAAAAK8OL94vI99kPSMj/wetRuAwAAABEO8BED0/AQYvGK8NBi/BEi8hBi/hB99lED0jIQY1JAUGD+AF+JkGLwZlB9/iNSAGF0n4Y/8HGRCRwAUWFyX4MQYvAK8KZK8LR+Cvwi0VQiYQkiAAAAESNJAiLTVREO+F+LYXJdAuLwZkrwtH4A8HrBbgIAAAAQTvESI1NUEGL1A9P0OixWP//i4QkiAAAAEyLbCQwSGPIRIllUEiLRVhMi2QkeEyNBMiLy4P7L3YeuKuqqir368H6A4vCwegfA9CNBFLB4AQryHkDg8EwSGPRTGPOTGPXRDvzfF4PH0AAZmYPH4QAAAAAAEiLRThIjUrQSIP6MA8oxkgPTMoD3ov38w9ZRMhwSo0UCU2LyvMPEEzIdPMPWc7zQQ9YB/NBDxEA80EPWE8E80EPEUgESYPACEE73n6z60+QSIXSSI1CMA8oxkgPScIr3kiL0Iv3SItFOPMPWUTQcPMPEEzQdEkr0fMPWc5Ni8rzQQ9YB/NBDxEA80EPWE8E80EPEUgESYPACEE73n2ygHwkcABIi3wkaEiLdCRgdFO4q6qqKg8oxkH37sH6A4vCwegfA9CNBFLB4AREK/BBjUYwQQ9JxkhjyEiLRTjzD1lEyHDzDxBMyHTzD1nO80EPWAfzQQ8RAPNBD1hPBPNBDxFIBA8odCQgSIPEOEFfQV5dW8PMzMzMzMzMzMzMzMzMzEiJXCQYVkFWQVdIgeyAAAAA8w8QBTukNgBMi/KLQVBMi/lEDylEJFBEDyjCQQ8vwEQPKUwkQEQPKMt2S4tJVDvBdSxEjUABhcl0DIvBmSvC0fiNNAHrBb4IAAAAQTvwSY1PUEQPT8ZBi9DowVb//0ljV1BJiwZJi09YSIkE0UH/R1DpIQEAAEiJrCSgAAAASIPBUIusJMgAAABIibwkqAAAAI1VAQPQ6IRW//8z/4XtD4jiAAAADyl0JHC+CAAAAA8pfCRg8w8QvCTAAAAARA8pVCQw80EPXPlmRA9u1UUPW9IPH0AAZmYPH4QAAAAAAA9X9vMPKvfzQQ9e8vMPWffzQQ9Y8Q8oxugFOwYA80EPWcDzQQ9YBvMPEUQkIA8oxugROwYARYtHVEGLT1DzQQ9ZwPNBD1hGBPMPEUQkJEE7yHUm/8FFhcB0DUGLwJkrwtH4QQPA6wKLxjvBD0/Ii9FJjU9Q6MdV//9JY1dQ/8dJi09YSItEJCBIiQTRQf9HUDv9D45o////RA8oVCQwDyh8JGAPKHQkcEiLrCSgAAAASIu8JKgAAABIi5wksAAAAEQPKEQkUEQPKEwkQEiBxIAAAABBX0FeXsPMzMzMzMzMQFdIg+ww8w8QBXaiNgBIi/oPL8J2WESLQVRIiVwkQEiNWVCLSVBBO8h1KP/BRYXAdA1Bi8CZK8LR+EEDwOsFuAgAAAA7wQ9PyIvRSIvL6A1V//9IYxNIi0sISIsHSIkE0f8DSItcJEBIg8QwX8OLRCRgRo0MjQAAAACNBIUAAAAAiUQkIOjG+v//SIPEMF/DQFNXQVZBV0iB7JgAAADzDxAF3qE2AEyL+kQPKUwkUEyL8UQPKMpEDylUJEBBDy/BRA8o03ZORItBVItJUEE7yHUq/8FFhcB0DkGLwJkrwtH4QY08AOsFvwgAAAA7+Q9Pz4vRSY1OUOhkVP//SWNWUEmLB0mLTlhIiQTRQf9GUOn+AgAAi4Qk6AAAAIXAfh3zDxCEJOAAAACJRCQo8w8RRCQg6Pn8///p1gIAAEiLQTgPKbQkgAAAAA8pfCRwRA8pRCRg8w8QgPABAABBDy/BD4LHAgAA8w8QvCTgAAAAQQ8oykQPL9dIiawkwAAAAEiJtCTIAAAATImkJNgAAABMiawkkAAAAPNEDxAFuaE2AA8o9/NBD1nw80EPWcjzD141bKE2APMPXg1koTYAdj0PV8APL8jzDyzBcxBmD27AD1vADy7BegJ0Av/IZg9uwA9bwPNEDyzoDyjG6E44BgDzRA8s4EGLxUErxOtBDyjB6Dk4BgAPV8kPL/HzRA8s6HMW8w8sxmYPbsAPW8APLsZ6AnQE/8jrBPMPLMZmD27AD1vA80QPLOBBi8RBK8VmQQ9uxUmNdlAPW8C9AAAAAEiLzg9J6GZBD27M8w9ZBaigNgAPW8nzD1jA8w9ZDZmgNgDzQQ9ewPMPWMnzQQ9cwvNBD17ID1QFt6M2AA8vBYifNgAPKMfzD1zBD5PDD1QFn6M2AA8vBXCfNgAPk8APttCIhCTQAAAAD7bD/8AD0AMWA9Xom1L//78IAAAAhNt0fEEPKMJIi97oaDcGAPNBD1nB80EPWAfzDxFEJDBBDyjC6HM3BgBEi0YEiw7zQQ9ZwfNBD1hHBPMPEUQkNEE7yHUp/8FFhcB0DUGLwJkrwtH4QQPA6wKLxzvBD0/Ii9FIi8voLFL//0mNdlBIYxNIi0sISItEJDBIiQTR/wOF7UiLrCTAAAAAfhdFi81EiWQkIEEPKNFJi9dJi87o4/f//4C8JNAAAAAATIusJJAAAABMi6Qk2AAAAHRwDyjH6LM2BgDzQQ9ZwfNBD1gH8w8RRCQwDyjH6L82BgBEi0YEiw7zQQ9ZwfNBD1hHBPMPEUQkNEE7yHUi/8FFhcB0DEGLwJkrwtH4QY08ADv5D0/Pi9FIi87oe1H//0hjFkiLTghIi0QkMEiJBNH/BkiLtCTIAAAADyi0JIAAAAAPKHwkcEQPKEQkYEQPKEwkUEQPKFQkQEiBxJgAAABBX0FeX1vD80QPEIQk4AAAAEEPKMnzDxA13p42AEEPKPjzQQ9c+g8oxg9UPeuhNgDzD17H8w8s2OhO3v//Zg9uwA9bwPMPWcfzD17G6MY1BgDzDyzASYvXSYvOQQ8o2kEPKNE7ww9N2IlcJCjzRA8RRCQg6JP5///pXf///8zMzMzMzMzMzMzMzMzMQFNBVkFXSIPscPMPEA3CnTYATYvwDyl0JGBMi/oPKPNIi9kPL/EPgqkAAABEi4wksAAAAEWL0fMPEBXVnTYAQYHK8AAAAEH3wfABAABFD0XRQYvCJcAAAAA8wEGLwg+VwYPgMDwwD5XAhMh0BQ8o2usDDyjZ80EPEABBi8LzD1wCZg9vJQehNgAloAAAADygQYvCD5XBg+BQD1TEPFDzD1nDD5XA8w9cwvMPXfCEyHQFDyja6wMPKNnzQQ8QQATzD1xCBA9UxPMPWcPzD1zC8w9d8OsIRIuUJLAAAAAPL84Ph1cBAABBi8Il8AEAAD0AAQAAD4REAQAADyl8JFBEDylEJEBB9sIQdAUPKNbrAw9X0kH2wiB0BkQPKMbrBEUPV8BFhNJ5BQ8o/usDD1f/QfbCQHUDD1f2DyjCx0QkIAkAAADzD1gCDyjKQbkGAAAA8w9YSgRIjVQkMEiLy/MPEUQkMPMPEUwkNOji+f//80EPEAZIjVQkMEEPKMjHRCQgDAAAAPNBD1hPBPNBD1zAQbkJAAAAQQ8o0EiLy/MPEUwkNPMPEUQkMOij+f//80EPEAZIjVQkMPNBDxBOBPMPXMfzD1zPx0QkIAMAAABFM8kPKNdIi8vzDxFEJDDzDxFMJDToafn///NBDxBOBEiNVCQwDyjGx0QkIAYAAADzQQ9YB/MPXM5BuQMAAAAPKNZIi8vzDxFEJDDzDxFMJDToLfn//0QPKEQkQA8ofCRQDyh0JGBIg8RwQV9BXlvDi0tURItDUEiJrCSQAAAASIm0JJgAAAC+CAAAAEiJvCSgAAAASI17UEiL70Q7wXUqQf/Ahcl0C4vBmSvC0fgDwesCi8ZBO8BIi89ED0/AQYvQ6B1O//9IjWtQSGMXSIvfSItPCEmLB0iJBNGLD//BiQ/zQQ8QBvNBDxBPBESLRwTzDxFEJDDzDxFMJDRBO8h1KP/BRYXAdA1Bi8CZK8LR+EEDwOsCi8Y7wQ9PyIvRSIvP6L1N//9Ii91IYxdIi08ISItEJDBIi6wkkAAAAEiJBNGLD//BiQ9Ei0MESIu8JKAAAABBO8h1Jf/BRYXAdA1Bi8CZK8LR+EEDwOsCi8Y7wQ9PyIvRSIvL6GZN//9IYxNIi0sISYsGSIkE0YsL/8GJC/NBDxAH80EPEE4ERItDBPMPEUQkMPMPEUwkNEE7yHUi/8FFhcB0DEGLwJkrwtH4QY00ADvxD0/Oi9FIi8voEE3//0hjE0iLSwhIi0QkMEiLtCSYAAAADyh0JGBIiQTR/wNIg8RwQV9BXlvDzMzMzMzMzEH3wQAAAP8PhEYBAABIiWwkGEiJdCQgQVZIg+xQ8w8QAk2L8ESLQVRIi/GLSVBBi+lIiVwkYEiJfCRovwgAAAAPKXQkQPMPEDW3mTYA8w9YxvMPEUQkMPMPEEIE8w9YxvMPEUQkNEE7yHUm/8FFhcB0DUGLwJkrwtH4QQPA6wKLxzvBD0/Ii9FIjU5Q6E9M//9Ii0QkMEhjVlBIi05YSIkE0YtOUP/BiU5Q80EPEAbzQQ8QTgTzD1jGRItGVPMPWM4PKHQkQPMPEUQkMPMPEUwkNEE7yHUj/8FFhcB0DEGLwJkrwtH4QY08ADv5D0/Pi9FIjU5Q6OZL//9IY1ZQM/9Ii05YRIvNSItEJDDzDxCEJIAAAADzDxFEJChIiQTRSIvO/0ZQRItGUEiLVliJfCQg6Orc//9Ii1wkYEiLbCRwiX5QSIt8JGhIi3QkeEiDxFBBXsPMzMzMzMzMzMzMzMxB98EAAAD/D4ThAAAASIvESIlYCFZIg+xA9kEwAUGL8fMPEAV8mDYASIvZ8w8QGvMPEGIE8w9Y2PNBDxAI8w9Y4PNBDxBQBMdA2AAAAAB0JvMPXMjzDxFY8PMPXNDzDxFg9EyNQOhIjVDw8w8RSOjzDxFQ7Osy8w9cDSKYNgDzD1wVGpg2APMPEVwkMEyNRCQ48w8RZCQ0SI1UJDDzDxFMJDjzDxFUJDzzDxBcJHDoHfr///MPEIQkgAAAAESLzkSLQ1BIi8tIi1NY8w8RRCQox0QkIAEAAADo49v//8dDUAAAAABIi1wkUEiDxEBew8xB98EAAAD/D4SWAQAASIlcJAhIiWwkEEiJdCQYV0iD7EDzDxAFi5c2AEGL+fMPEFwkcEmL8A8vw0iL6kiL2Xc9i0wkeIvBJfABAAA9AAEAAHQriUwkIEiLy+iC+f//RItDUESLz0iLU1hIi8vof+r//8dDUAAAAADpEgEAALoGAAAADyl0JDBBuAQAAABIi8voy9j//w+3UzRIi0M48w8QDvMPEFUE8w8QXQCNSgHzDxBwBPMPECjzDxBmBEiLQ0hmiRBIi0NIZolIAo1KAkiLQ0hmiUgESItDSGaJUAZmg8IDSItDSGaJSAhIi0NIZolQCvIPEEUASItDQPIPEQBIi0NA8w8RaAjzDxFwDEiLQ0CJeBBIi0NA8w8RSBTzDxFQGEiLQ0DzDxFoHPMPEXAgSItDQIl4JPIPEAZIi0NA8g8RQChIi0NA8w8RaDDzDxFwNEiLQ0CJeDhIi0NA8w8RWDzzDxFgQEiLQ0DzDxFoRPMPEXBISItDQA8odCQwiXhMSINDQFCDQzQESINDSAxIi1wkUEiLbCRYSIt0JGBIg8RAX8PMzMzMzMzMzMzMzMxIiXQkGEFUQVZBV0iD7CD3RCRgAAAA/02L4U2L+EyL8kiL8Q+EAwEAAESLSVSLSVBIiVwkQEiJfCRIvwgAAABBO8l1Jv/BRYXJdA1Bi8GZK8LR+EEDwesCi8c7wQ9PyIvRSI1OUOh2SP//SGNWUEiLTlhJiwZIiQTRi05Q/8GJTlBEi0ZUQTvIdSb/wUWFwHQNQYvAmSvC0fhBA8DrAovHO8EPT8iL0UiNTlDoMEj//0hjVlBIi05YSYsHSIkE0YtOUP/BiU5QRItGVEE7yHUj/8FFhcB0DEGLwJkrwtH4QY08ADv5D0/Pi9FIjU5Q6O1H//9IY1ZQSItOWEmLBCREi0wkYEiJBNFIi87/RlBEi0ZQSItWWOgl6P//SIt8JEhIi1wkQMdGUAAAAABIi3QkUEiDxCBBX0FeQVzDzMzMzEH3wQAAAP8PhK0AAABIiVwkCFdIg+ww8w8QBaWUNgBBi/kPL8JIi9kPh4IAAACLRCRghcB/FUUzycdEJCAwAAAA6Ert////S1DrS4P4A30HuAMAAADrCrkAAgAAO8EPT8FmD27AD1fbD1vA/8hIi8uJRCQoDyjI8w9cDYWUNgDzD1kN2ZQ2APMPXsjzDxFMJCDoOvL//0SLQ1BEi89Ii1NYSIvL6Ffn///HQ1AAAAAASItcJEBIg8QwX8PMzMzMzEiJXCQYSIl0JCBBVEFWQVdIg+xARIu0JJAAAABNi/lNi+BIi/JIi9lB98YAAAD/D4QVAQAASItBeEiJbCRgSIl8JGhIOUIIdRVIi0FwSDkCdQxAMu1IjbmwAAAA611IjbmwAAAAQLUBi08ERIsHRDvBdSlB/8CFyXQLi8GZK8LR+APB6wW4CAAAAEE7wEiLz0QPT8BBi9DoRE7//0hjD0iLRwhIA8kPEAYPEQTI/wdIi8sPEUNw6LXS//+6BgAAAEG4BAAAAEiLy+ji1P//SIuEJIgAAABNi8dMi4wkgAAAAEmL1ESJdCQoSIvLSIlEJCDo2tX//0CE7UiLbCRgdEVIYw+NQf+JB4XAdQ4zwEiJRCQwSIlEJDjrF0iLg7gAAABIg+kCSAPJDxAEyA8RRCQwSI1EJDBIi8sPEAAPEUNw6CvS//9Ii3wkaEiLXCRwSIt0JHhIg8RAQV9BXkFcw8xIiWwkEEiJdCQYV0iD7CAz9kiL+TlxCH5KSIlcJDBmkEhj3kjB4wU7N3UQSItHEA9XwA8RBAMPEUQDEEiLTxBIA8voqWf8/0iLTxBIg8EQSAPL6Jln/P//xjt3CHzCSItcJDBIjU8IxwcAAAAAx0cEAQAAAEiLbCQ4SIt0JEBIg8QgX+loZ/z/zMzMzMzMzMxAU1VWV0FWSIPsIEhjcQhIi+lJY9g7830+i9NIg8EI6AyaAABEi0UMQTvYfidFhcB0DUGLwJkrwtH4QQPA6wW4CAAAADvDSI1NCIvTD0/Q6NyZAACJXQiJXQQPV8BIi0UQTIvzDxEADxFAEEiD+wEPjrcAAABMiWQkUL8BAAAATIl8JGhFM+RMi/6+IAAAAJBIi10QSAPeSTv/fCVIiVwkWEiF23RsD1fADxEDDxFDEEyJI0yJYwhMiWMQTIljGOtRi0MEhcB5GYvIQYvUjUgB0fkDwUiLy4XAD0/Q6O9R//9EiSNIi10Qi0wzFIXJeR2LwUGL1I1BAdH4A8FIjUsQhcAPT9BIA87oo0n//0SJZDMQSP/HSIPGIEk7/g+Mbv///0yLfCRoTItkJFBIg8QgQV5fXl1bw8zMzMzMzMzMzEFVQVZIg+xIg3kEAUyL8kyL6Q+ObwMAAEiJXCRoRTPASIlsJEBIiXQkOEiJfCQwTIlkJChMiXwkIOhSAwAAQYsGhcB+O0SLwA8fhAAAAAAAQYvAQY1Q/0iNDMBJi0YIg3zI4ABMjQzIQYvAdRNJg3noAHUMQYkWRIvCi8KF0n/QRYtFBEUz/0Uz20SJfCRwRIlcJGBFhcB+IoXAfh7/yEhjyEmLRghIjRTJSI0s0EiF7XQKi30oA30k6wQz7TP/QbwBAAAARTvED44VAQAAuSAAAABIiUwkeA8fhAAAAAAASYtdEEgD2UhjE4vyhdJ+IUiLQwhIjQzSRI1C/4N8yOAAdQ5Ig3zI6AB1BkSJA0GL8ESL1oX2fmVIhe10YEyLewhBuCQAAABJi9dIi83o1iUGAESL1oXAdTpIg30wAHUzSYN/MAB1LEGLRygBRShIYwNIi0sIQQN/KEyNBMBOjQTFuP///0iNUUjoACcGAP8LRIsTRItcJGBEi3wkcEQDWxBFA/pEiXwkcESJXCRgRYXSfjVMi0sIQY1K/0hj0TPAM8lMjQTSS40swWYPH0QAAEGJfAEkSI1ASEyLSwj/wUEDfAHgOwt86EiLTCR4Qf/ESIPBIEiJTCR4RTtlBA+M/f7//0GLPrsIAAAAQYtOBEED/zv5fiWFyXQLi8GZK8LR+APB6wKLwzvHi9dJi84PT9Doek///0SLXCRgQYk+QYt+EEGLThRBA/s7+X4jhcl0CovBmSvC0fiNHAE730mNThCL1w9P0+glR///RItcJGBBiX4QvgEAAABJYw5Ji1YISWPHSCvISI0EyUhjz0yNPMJJY8NIK8hJi0YYSI0sSEE5dQR+Y0G8IAAAAA8fRAAASYt9EEkD/EhjB4XAdBpIi1cISI0cwEjB4wNJi89Mi8PoXyQGAEwD+0hjRxCFwHQYSItXGEiL2EgD20iLzUyLw+g/JAYASAPr/8ZJg8QgQTt1BHysSYtWCEljBkyLfCQgTItkJChIi3wkMEiLdCQ4SItcJGhJiW5ISItsJECFwHQMSI0MwEiDfMroAHQISYvO6IvL//9JYwZJjVZgSI0MwEmLRghIjUn3g3zIKABIjQzIdSUPEAIPEQEPEEoQDxFJEItCIIlBIEHHRQQBAAAASIPESEFeQV3DQbgkAAAA6JUjBgCFwHQISYvO6DHL//9Bx0UEAQAAAEiDxEhBXkFdw0BTSIPsIEhjAUiL2kiL0UE7wA+EtQAAAA8QA0yLyEiLQRBJweEFQQ8RBAFIYwlIi0IQDxBDEEjB4QUPEUQBEEiLQhBEiQJJY8hIweEFDxAEAQ8RA0iLQhAPEEQBEA8RQxBIi0MYSGNLEEiNDEhIYwNIiUtIhcB0SEiNDMBIi0MISI1J90iNDMhIhcl0M4N5KABIjVNgdRoPEAIPEQEPEEoQDxFJEItCIIlBIEiDxCBbw0G4JAAAAOi8IgYAhcB0DUiLy0iDxCBb6VPK//9Ig8QgW8PMzMzMzMzMzMzMzMzMQFNWV0iD7CBIi/pJi9hJYxBIi/GF0g+ErwAAAIP6AXUVSYtACIN4KAB1C0iDeDAAD4SVAAAAQYO4wAAAAAB+O0mLQAhIjRTSTI0E0Ek7wHQqSIN4MAB0GkhjSESD+f90EYN4QAB+C0gDi8gAAABIiUg4SIPASEk7wHXWi08ERIsHRDvBdSlB/8CFyXQLi8GZK8LR+APB6wW4CAAAAEE7wEiLz0QPT8BBi9DokT7//0hjD0iLRwhIiRzI/wf/RgSLQyABRgyLQxABRghIg8QgX15bw8zMzMzMzMzMzMzMzMxIiVwkCEiJbCQQSIl0JBhIiXwkIEFWSIPsIEGL8UGL6Iv6SIvZ6BYBAABFM/aJexjHQwQCAAAAiWsciXMghf90EYP/AXQFQYvG6wy4AQAAAOsFuAQAAACJQyQPr8VEiHNWD6/GSGP4SIvP/xUQcAYATIsF6cQ3AEyL2E2FwHRxTQ+/kBwrAABJjZAgKwAARYtIBEqNFNJEOQp0N0GNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv9FIgcJkBQAASY0U0ESJCkSJcgRIg///dA1m/0IEQf+AFCsAAOsLZv9CBkH/gBgrAACLQyQz0g+vQxxJi8tMiVsoD69DIExjwOi+IAYASItsJDhIi3QkQEiLfCRITIlzMMdDOP////9EiXM8SItcJDBIg8QgQV7DzMzMzMzMzMzMzEiJXCQIV0iD7CBMi0koM/9Ii9lNhckPhIQAAABMiwX9wzcATYXAdFxJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJeQRm/0EGQf+AGCsAAEmLyf8Vy24GAEiJeyhAiHtWSItcJDBIg8QgX8NIi1wkMEiJeShAiHlWSIPEIF/DzMzMzMzMzMzMzMzMzEiJXCQISIlsJBBIiXQkGFdIg+wgSIv5xkFRAOiABAAASItfSEhjR0BIjTTDSDvedBFIiwvoB////0iDwwhIO95170iNT0DoFY8AADPbSIlfOEyLj6gCAABNhcl0ckyLBfzCNwBNhcB0XEWLUARJD7+QHCsAAEmNiCArAABIjQzRRDkRdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEYlZBGb/QQZB/4AYKwAASYvJ/xXKbQYAkEyLj4AAAABNhcl0ckyLBX7CNwBNhcB0XEWLUARJD7+QHCsAAEmNiCArAABIjQzRRDkRdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEYlZBGb/QQZB/4AYKwAASYvJ/xVMbQYAkEyLT3BNhcl0ckyLBQPCNwBNhcB0XEWLUARJD7+QHCsAAEmNiCArAABIjQzRRDkRdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEYlZBGb/QQZB/4AYKwAASYvJ/xXRbAYAkEyLT0hNhcl0c0yLBYjBNwBNhcB0XUWLUARND7+YHCsAAEmNkCArAABKjRTaRDkSdDZBjUsBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/RSIHCZAUAAEmNFNBEiRKJWgRm/0IGQf+AGCsAAEmLyf8VVWwGAJBIi1wkMEiLbCQ4SIt0JEBIg8QgX8PMzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0FWQVdIg+wgTItxcEUz/0hjQWhIi/lJjSzGTDv1dG6QSYs2SItOCEiFyXQISIvW6EwyAABEiX4wM8CIRjRMiT5Ii14oSGNGIEiNNMNIO950M0iLE0iLgoAAAABIhcB1DEiLh7gCAABIhcB0D0yLQCBNhcB0BkiLz0H/0EiDwwhIO951zUmDxghMO/V1k0iLn4AAAABIY0d4SI00wEjB5gRIA/NIO950FEiL0+jgIgAASIHDkAAAAEg73nXsSIt3cEhjR2hIjSzGSDv1D4SuAAAADx9AAGZmZg8fhAAAAAAASIseTItLKE2FyQ+EfgAAAEyLBfm/NwBMiXsgTYXAdGFJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ6jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/BSY2IICsAAEiNDMFEiRFFibzAJCsAAGb/QQZB/4AYKwAASYvJ/xW+agYATIl7KINLEARIg8YISDv1D4Vh////TIuPgAAAAE2FyQ+EfgAAAEyLBVq/NwBMiX94TYXAdF5ND7+YHCsAAEmNkCArAABFi1AESo0U2kQ5EnQ3QY1LAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkSRIl6BGb/QgZB/4AYKwAASYvJ/xUiagYATIm/gAAAAEiLXCRASItsJEhIi3QkUEiDxCBBX0FeX8PMzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0iD7CBIi3lwSIvZSGNBaEiNNMdIO/50HA8fhAAAAAAASIsXSIvL6EUPAABIg8cISDv+dexIi8voBEEAAEiLy+hs/f//M+2L9TlraH4bi/2QSItLcEiLDA/oI4MAAP/GSI1/CDtzaHzoTItLcE2FyXR5TIsFOL43AEiJa2hNhcB0XEkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEYlpBGb/QQZB/4AYKwAASYvJ/xUCaQYASIlrcECIa1JIi4uoAgAASGODoAIAAEiNFMFIO8p0GkiLAUg5WBB1CEiJaBhIiWggSIPBCEg7ynXmSItcJDBIi2wkOEiLdCRASIPEIF/DzMzMzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYSIl8JCBBVEFWQVdIg+wgi/JIi/lEiEFRSIPBUUWEwHQexkdSAUiNT1FIg7+wAgAAAHUMSIvP6IYQAABIjU9RgH9RAHUWgH9SAHUWSI0N/zI2AOg60/3/SI1PUYB/UgB0IUiLh7ACAACAuLkAAAAAdBGAOQB0DEiNDeQzNgDoD9P9/0iLr7ACAACJtaQAAABIi09wSGNHaEiNFMFFM+RIO8p0HQ8fQABmZg8fhAAAAAAASIsBTIkgSIPBCEg7ynXxRDml6AAAAA+O7gAAAEGL9EGL3IuFwAAAAIXAD47HAAAAi8uD4R+Lw4XbeQaNQx+D6SDB+AVMi43QAAAASGPQSGPBSGvIaE2LBNFMA8FB90BMAAAABA+FfQAAAIvOg+Efi8aF9nkGjUYfg+kgwfgFSGPQSGPBSGvIaEmLFNFIA9H/xkk70HRRQQ8QAA8RAkEPEEgQDxFKEEEPEEAgDxFCIEEPEEgwDxFKMEEPEEBADxFCQEEPEEhQDxFKUPJBDxBAYPIPEUJgSI2N2AAAAEyLwotSVOgJefz//8OLhcAAAAA72A+MOf///yuF6AAAAImFwAAAAESJpegAAABBi/REOWdAD45rAQAATYv0Zg8fRAAASItfSEmLHB6DewQAdSyLS0SFyXkai8GNQQHR+APBQYvUhcAPT9BIjUtA6GE0//9MiWM8x0M4/////w+2S1eEyXQUi0MEg/gBdAyD+AR0B8dDBAQAAACLQwSD+AR1H0iDexAAdRBIg3sIAHUJx0MEAQAAAOsR/0NQ6dYAAACD+AEPhc0AAACEyXUMx0MEAgAAAOm9AAAASIvL6NL2//+QSIvL6Mn2//9IjUtA6AAk//+QTIsF2Lo3AE2FwHRhRYtIBEkPv5AcKwAASY2IICsAAEiNDNFEOQl0Oo1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/wUmNiCArAABIjQzBRIkJRYmkwCQrAABm/0EGQf+AGCsAAEiLy/8VoWUGAEhj1kiLR0hIjQzQTGNHQEwrwk6NBMX4////SI1RCOgEGAYA/09A/85Jg+4I/8ZJg8YIO3dAD4ye/v//SItcJEBIi2wkSEiLdCRQSIt8JFhIg8QgQV9BXkFcw8zMzMzMzMzMzMzMzMzMzEiJXCQYSIl0JCBXi0EwTItZKEhjUTSD+AEPhSQBAACLWTyF2w+OHgMAAIt5OEiL8k2Lw0SLz4P/BA+MtQAAAI1H/MHoAv/ARIvQ99hEjQyHQQ+2ALr/AAAAZg9uwA9bwPMPWcHzSA8syDvKD7bBD0LQQQ+2QAFBiBC6/wAAAGYPbsAPW8DzD1nB80gPLMg7yg+2wQ9C0EEPtkACQYhQAbr/AAAAZg9uwA9bwPMPWcHzSA8syDvKD7bBD0LQQQ+2QANBiFACuv8AAABmD27AD1vA8w9ZwfNIDyzIO8oPtsEPQtBBiFADSYPABEmD6gEPhVz///9Fhcl+MUEPtgBNjUABuv8AAABmD27AD1vA8w9ZwfNIDyzIO8oPtsEPQtBB/8lBiFD/RYXJf8//y0wD3oXbD4/5/v//SItcJCBIi3QkKF/DhcAPhf0BAACLWTyF2w+O8gEAAItxOEiJbCQYSIvqTYvLRIvWg/4ED4xkAQAAjUb8wegC/8CL+PfYRI0UhkGLEUG4/wAAAEEPtkEDZg9uwA9bwPMPWcHzSA8swEE7wEQPQsCLwkHB4AjB6BAPtsiLwkQLwcHoCEHB4AgPtshEC8EPtsJBi1EEQcHgCEQLwEEPtkEHRYkBQbj/AAAAZg9uwA9bwPMPWcHzSA8swEE7wEQPQsCLwkHB4AjB6BAPtsiLwkQLwcHoCEHB4AgPtshEC8EPtsJBi1EIQcHgCEQLwEEPtkELRYlBBEG4/wAAAGYPbsAPW8DzD1nB80gPLMBBO8BED0LAi8JBweAIwegQD7bIi8JEC8HB6AhBweAID7bIRAvBD7bCQYtRDEHB4AhEC8BBD7ZBD0WJQQhBuP8AAABmD27AD1vA8w9ZwfNIDyzAQTvARA9CwIvCQcHgCMHoEA+2yIvCRAvBwegIQcHgCA+2yEQLwQ+2wkHB4AhEC8BFiUEMSYPBEEiD7wEPhaz+//9FhdJ+XUEPtkEDQbj/AAAAQYsRTY1JBGYPbsAPW8DzD1nB80gPLMBBO8BED0LAi8JBweAIQf/KwegQD7bIi8JEC8HB6AhBweAID7bIRAvBD7bCQcHgCEQLwEWJQfxFhdJ/o//LTAPdhdsPjx7+//9Ii2wkGEiLXCQgSIt0JChfw8zMzMzMzMzMzMzMzEBWV0FWQVdIg+woi4QkiAAAAEmL+UWL8ESL+kiL8YXAD45/AAAASIlcJFCLXCR4RCvzSIlsJFiL6EyJZCRgRIukJIAAAABMiWwkIESLbCRwi0ckQQ+vxExjwEGNBB4Pr0YcQQPHD69GJEhj0IvDD69HHEgDVihBA8UPr0ckSGPISANPKOh7EgYA/8NIg+0Bdb9Mi2wkIEyLZCRgSItsJFhIi1wkUEiDxChBX0FeX17DSIlcJBBIiWwkGFZXQVZIg+wgRA+3VCRgQYv5D7dCPEiL2kQPt1wkaEyL8UEPt/BFM8BmRIlUJEREA9ZmiXQkQGaJfCRCZkSJXCRGZoXAdQkPt1I4QYvI6wcPt1I4jQwCD7dDPkE7ykGL6kQPt88PQ+lFA8tMjVs6ZoXAdApEi8BBD7cDRAPAZjvWQQ+3wQ+3zmYPQspmQTk7ZolLOA+312ZBD0ITZivpD7dLNEU7wWZBiRNmQQ9DwGaJazxmK8JmOXMwZolDPmYPQnMwZjl7Mg+31mYPQnsyA8pBO8pED7fHZolTMGZED0PRZkSJQzIPt0s2ZkQr0kEDyGZEiVM0QTvJZkQPQ8lmRSvIZkSJSzZBxkZSAItDBIXAdAWD+AN1UMdDBAMAAABEi0NEi0tAQTvIdSn/wUWFwHQNQYvAmSvC0fhBA8DrBbgIAAAAO8EPT8iL0UiNS0Doky3//0hjU0BIi0tISItEJEBIiQTR/0NASItcJEhIi2wkUEiDxCBBXl9ew8zMzMzMzMzMzMzMzEiJXCQISIlsJBBIiXQkGEiJfCQgQVRBVkFXSIPsQEiLBXuYNwBIM8RIiUQkMEiDubACAAAASIvySIv5dQXojjQAADPbOF41D4XkAAAAuVAAAAD/FShfBgBMiw0BtDcATIvATYXJdFtJD7+RHCsAAEmNgSArAABFi1EESI0E0EQ5EHQ0jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiRwrAABID7/BSAVkBQAASY0EwUSJEIlYBGb/QARB/4EUKwAATYXAdCUPV8BBDxEAQQ8RQBBBDxFAIEEPEUAwQQ8RQEBBx0BIAACAP+sDTIvDi4+cAgAASI1UJChMiUQkKI1BAYmHnAIAAItGdEGJSBhIjU9oQYlAEItGPEGJQByLRnBBiUAU6DYb//9Ii2wkKOsWSItueEiF7XUNSGNPaEiLR3BIi2zI+EiL1kiNT3jojX0AAEhjR3hIi7eAAAAASIHGcP///0iNDMBIweEESAPxSDleeHUESIlueItNJESLRSBEO8F1KkH/wIXJdAuLwZkrwtH4A8HrBbgIAAAAQTvASI1NIEQPT8BBi9DosCv//0hjTSBIi0UoSIk0yEiLz/9FIOjJCwAATItmSE2F5HQ/SYvEZkE5HCR0EmYPH0QAAEiNQAL/w2aDOAB19I1DAUhj2EgD20iLy+jz1Pz/TIvDSYvUSIvI6LkOBgBIiUZISIuGgAAAAEiFwHUHSIuHuAIAAEyLQBhNhcB0MEiL1kiLz0H/0ITAdSNIi9bowBQAAP9PeP9NIIB+NQB1C0iLzejcdgAA/09oM8DrEUyLxkiL1UiLz+iXEwAASIvFSItMJDBIM8zot/wFAEiLXCRgSItsJGhIi3QkcEiLfCR4SIPEQEFfQV5BXMPMzMzMzMzMzEiLxFVBVkiNqGj///9IgeyIAQAARA8pSKhMi/FIiVgIRA8oy0iJcBBIi9pMiXjoRA+2egoPKXDYDyl4yEQPKUC4D7ZCCcHgEEHB5whEA/gPtkIIweAYRAP4D7ZCC0QD+EGLz+jo0/z/D7ZLAUiL8A+2E8HiCAPRD7ZLAsHiCAPRD7ZLA8HiCAPRgfoAALxXD4WfAAAAD7ZDBQ+2SwTB4QgDyA+2QwbB4QgDyA+2QwfB4QgDyHV+D7ZDCQ+2UwhIweIISAPQSIm8JLABAAAPtkMKD7Z7C0jB4ghIA8JIiR21szcASMHgCEiDwxBIA8ZIiTWzszcASAP4SIk1sbM3AEiLy0iJPZezNwDowm8AAEg7w3QZSDk9lrM3AHcQSIvISIvY6KlvAABIO8N150iLvCSwAQAASIuFwAAAAEiLnCSgAQAASIXAdCkPKBAPKFgQDyhgIA8oQDAPKGhADyhIUA8ocGAPKHhwRA8ogIAAAADrVw9X0g9X2w8RVCRQxkQkVAEPEVQkcMdEJFgAAAAADyhEJFAPV+QPEVWAx0QkfP//f38PKEwkcA9X7Q8RVZDHRYwAAIA/Dyh1gEUPV8DHRZAAAIA/Dyh9kA8pReDGReQBDyhF4A8pRCRQD1fARA8vyESJfCRQTIu8JIABAAAPKWQkQA8pdYAPKLQkcAEAAA8pfZAPKLwkYAEAAEQPKUWgRA8ohCRQAQAASIl0JEhIi7QkqAEAAA8pVCQgDylcJDAPKWwkYA8pTCRwdgfzRA8RTCRcSIuFyAAAAEiNVCQgSItMJGBIhcBID0XISIlMJGBJi87o+fr//0QPKIwkQAEAAEiBxIgBAABBXl3DzMzMzMxAVVdBVkiD7CBMi7GoAgAASIv6SGOBoAIAAEmNLMZMO/UPhNYAAABIiVwkQEyJfCRQRTP/SIl0JEgPH4AAAAAASYseSDl7GHUETIl7GEiLW2hIhdsPhIcAAABIOXtwdQRMiXtwSDm74BIAAHVJSIs1zK43AEiLxkg73nQKSIkdva43AEiLw/MPEIv0EgAA8w8Qg/ASAADzDxGI9BIAAEyJuOASAADopo39/0g73nQHSIk1iq43AEiLg9AgAABIY4vIIAAASMHhBEgDyEg7wXQRSDk4dQNMiThIg8AQSDvBde9Jg8YITDv1D4VS////TIt8JFBIi3QkSEiLXCRASIPEIEFeX13DzMzMzMzMzMzMzEiJXCQISIlsJBBIiXQkGFdIg+wwSIO5sAIAAABJi/FBi/iL6kiL2XUF6HIuAABFM8lEi8eL1UiLy+hyNAAAi/iD+P91AutpSIX2dA1Mi8aL10iLy+h3AAAAgHtRAHRPTIuDsAIAAIvPgeH//wcASYtAeIsMiEmLQGjB4QxIY9FIwfoMD7dM0AZED7dU0ARED7dM0AJED7cE0EiLUziJTCQoSIvLRIlUJCDokvf//4vHSItcJEBIi2wkSEiLdCRQSIPEMF/DzMzMzMzMzMzMzMxIiVwkCFdIg+wgSYvYSIv56Ls2AABIi9BIhcB1C0iLXCQwSIPEIF/DSIXbdHwPtwBmiQMPt0ICZolDAg+3QgRmiUMED7dCBmaJQwYPt0ICZg9uyA+3Ag9byWYPbsDzD1lPWA9bwPMPWUdU8w8RSwzzDxFDCA+3QgIPt0oGA8gPtwJmD27JD7dKBAPID1vJZg9uwfMPWU9YD1vA8w9ZR1TzDxFLFPMPEUMQSItcJDCwAUiDxCBfw8zMzMzMzMzMzMxIiVwkGFVIjWwkoEiB7GABAABIiwXHkDcASDPESIlFUEiL2UiLSThIhcl0EItDBDlBGHQISIvL6MQrAABIg7uwAgAAAHUISIvL6MIsAACDe3gAD4UNAQAAD1fSSIm8JHgBAAAPEVQkYMZEJGQBM/8PEVWAx0QkaAAAAAAPKEQkYA8pRfDzDxBd/A8RVaDHRYz//39/DyhFgA8pRRAPEVWQx0WgAACAPw8oRaAPKUUwD1fADy/Dx0WcAACAP2bHRfgBAcZF9gEPKE2QDylVwA8pVdAPKVXgDylVAA8pTSAPKVVAcg3zDxAdgHI2APMPEV38Zg9+0ITAdRpMjQUoIzYAuigAAABIjU3A6GJb/P/zDxBd/PMPEFUUSI0V8ZMIAA8ow0iJfCQo8w9eBT1yNgC4hQAAAEiLy2aJRfrzDyzAZg9uyEiNRcAPW8lIiUQkIPMPWNHzDxFVFOiD+f//SIu8JHgBAABIi4uoAgAASGODoAIAAEiNFMFIO8p0Jg8fQABIiwFIi0BoSIXAdQtIg8EISDvKdevrC4tANMHoBCQBiENRgHtRAHUISIvL6EACAADGQ1IBSItNUEgzzOiw9QUASIucJIABAABIgcRgAQAAXcPMzMzMzMzMzMzMzMzMzMxAV0FXSIPsKEyL+kiL+Ug5kbgCAAAPhOkBAABIY0FoSIlsJEhMiXQkIEyLcXBIiVwkQEiJdCRQSY0sxkw79Q+EfgAAAEyJZCRYRTPkDx9AAEmLNkiLTghIhcl0CEiL1ujsGwAARIlmMDPAiEY0TIkmSIteKEhjRiBIjTTDSDvedDNIixNIi4KAAAAASIXAdQxIi4e4AgAASIXAdA9Mi0AgTYXAdAZIi89B/9BIg8MISDvedc1Jg8YITDv1dZNMi2QkWEiLj7ACAABIi8FIhcl0IkiLl7gCAABIhdJ0FkyLQhBNhcB0DUiLz0H/0EiLh7ACAABMib+4AgAATYX/dAVJiw/rB0iNDRkHNgBIiY/AAgAASIXAdBNNhf90DkmLRwhIhcB0BUiLz//QTIt3cEhjR2hJjSzGTDv1dFwPH0QAAEmLBkiLWChIY0AgSI00w0g73nQ6Dx9AAA8fhAAAAAAASIsTSIuCgAAAAEiFwHUHSIuHuAIAAEyLQBhNhcB0BkiLz0H/0EiDwwhIO9510kmDxghMO/V1qUyLd3BIY0doTY08xk0793RIDx+EAAAAAABJizZIi14oSGNGIEiNLMNIO910Iw8fQAAPH4QAAAAAAEyLA0iL1kiLz+iCCgAASIPDCEg73XXpSYPGCE0793XASIt0JFBIi1wkQEiLbCRITIt0JCBIg8QoQV9fw8zMzMxBVEFXSIPsSEiLgbACAADGgLkAAAABTIt5cEhjQWhNjSTHTIlkJGBNO/wPhJkBAABIiVwkaEiJbCRwSIl0JHi+/v8AAEiJfCRATIlsJDhBvf//AABMiXQkMA8pdCQg8w8QNbJvNgBmZg8fhAAAAAAASYsfDyjWSIvL8w8QSxzoLUcAAA+3UzJIi/hmhdJ0KUhjSCBIO9FzFUiLSChED7cEUWZEO8Z0EWZFO8V1C0UzwEiLz+gIMwAAD7dTMGaF0nQpSGNHIEg70HMVSItHKEQPtwRQZkQ7xnQRZkU7xXULRTPASIvP6NYyAABMi3MoSGNDIEmNLMZMO/UPhJoAAABBvP7/AABmZmYPH4QAAAAAAEmLBkiNNeYhNgBIi0hASIXJSA9F8Q+3BmaFwHRZSIPGAg+32A+3BjvYdz4PH0QAAEE73Xc0SGNHIA+300g70HMUSItHKA+3DFBmQTvMdBFmQTvNdQtFM8BIi8/oUDIAAA+3Bv/DO9h2xw+3RgJIg8YEZoXAdatJg8YITDv1dYFMi2QkYL7+/wAASYPHCE07/A+Fyv7//w8odCQgTIt0JDBMi2wkOEiLfCRASIt0JHhIi2wkcEiLXCRoSIPESEFfQVzDzMzMzMzMzMzMzMzMzMxIiVwkGEiJdCQgV0iD7CBIi1lwSGNBaEiJbCQwSIvpSI00w0g73nQ+TIl0JDhFM/ZIizuLTySFyXkai8FBi9aNQQHR+APBSI1PIIXAD0/Q6Hwf//9Ig8MIRIl3IEg73nXPTIt0JDhIi72AAAAASGNFeEiLbCQwSI00wEjB5gRIA/dIO/50X2ZmDx+EAAAAAABIi194i0skRItDIEQ7wXUqQf/Ahcl0C4vBmSvC0fgDwesFuAgAAABBO8BIjUsgRA9PwEGL0OgGH///SGNLIEiLQyhIiTzISIHHkAAAAP9DIEg7/nWrSItcJEBIi3QkSEiDxCBfw8zMzMzMzMzMzMzMQFNVVldBVEiD7FD3AQIAAABMi+G7AgAAALn1AAAAi/sPV8APRPm9GwAAAEmLtCSwAgAASYvMQYUcJA8RRCQ4D0Tdi5bsAAAA6PMuAABIhcB0DkQPtxBED7dYAukRBAAASYO8JLACAAAAdQhJi8zozSUAAEUzyUSLw4vXSYvM6M0rAACL2IP4/3UC62hMjUQkOIvTSYvM6NX3//9BgHwkUQB0UUmLlCSwAgAAi8uB4f//BwBIi0J4SItSaIsMiMHhDExjwUnB+AxCD7dMwgRCD7dEwgZGD7dMwgJGD7cEwkmLVCQ4iUQkKIlMJCBJi8zo7O7//0QPt1QkOIme7AAAAEH2BCQCSYtcJDhEi0sYdGlED7dcJDpBi9JBi8tFhcl0L0GD+QEPhUYDAAAPr0scA8oPr0skSGPRSANTKGbHAv//SGNDHGbHBBD//+khAwAAD69LHAPKD69LJEhj0UgDUyhIxwL/////SGNDHEjHBIL/////6fgCAABMibQkkAAAAEGNentMibwkmAAAAEiNFSyzCABED7d8JDpIi8qJfCQwSI01KLMIAEG+/wAAAEG4/////0WFyQ+E+gAAAEGD+QEPhVQBAABmD28V4Ww2AEGLxw+vQxxIi/5MiawkiAAAAEyL7UEDwg+vQyRMY9hMA1soDx9AAGZmDx+EAAAAAABFM/ZIjUdpSY1LeUyNV/BMO9h3BUk7ynNE80EPbwJBvkAAAABmD2/KZg90wvNBD38D8w9vB2YPdMjzD29HEPNBD39LEPMPb08gZg90wmYPdMrzQQ9/QyDzQQ9/SzBNK9NLjQweQbl6AAAATSvOQb7/AAAADx9AAGYPH4QAAAAAADPAQYA8Ci5IjUkBQQ9ExohB/0mD6QF16EhjQxxIg8d6TAPYSYPtAQ+FU////0yLrCSIAAAA62BBi8dIi/0Pr0McQQPCD69DJExj2EwDWyiQTYvLQbo9AAAADx+AAAAAADPATY1JCIA5LkEPRMBBiUH4M8CAeQEuQQ9EwEiDwQJBiUH8SYPqAXXXSGNDHE2NHINIg+8BdbmLfCQwTYtcJDhBi0sYhckPhMQAAACD+QEPhSABAABFD697HGYPbxVebDYARAP/RQ+veyRNY89NA0soRTPSSI1GaUmNSXlMjUbwTDvIdwVJO8hzSPNBD28AQbpAAAAAZg9vymYPdMjzD28G80EPfwlmD2/KZg90yPMPb0YQ80EPf0kQ8w9vTiBmD3TCZg90yvNBD39BIPNBD39JME0rwUuNDAq6egAAAEkr0jPAQYA8CFhIjUkBQQ9ExohB/0iD6gF16EljQxxIg8Z6TAPISIPtAQ+FY////+tlRQ+vexxEA/9FD697JE1j100DUygPH0AADx+EAAAAAABJi8pBuT0AAAAPH4AAAAAAM8BIjUkIgDpYQQ9EwIlB+DPAgHoBWEEPRMBIg8ICiUH8SYPpAXXZSWNDHE2NFIJIg+0BdbtED7dUJDhED7dcJDpMi7QkkAAAAEyLvCSYAAAAQQ+3wmYPbsAPW8BBD7fD8w9YBWxnNgDzQQ9ZRCRU80EPEUQkXGYPbsAPW8DzD1gFT2c2APNBD1lEJFjzQQ8RRCRgSIPEUEFcX15dW8PMzEyL3EFVSIHskAAAAEiLBT2FNwBIM8RIiUQkWPYBBEyL6Q+FcQIAAEmJWxBNjUOoSYlrGA9XwEmJcyAzwEmJe/BIi7mwAgAADxFEJEBNiWPoTYl72EyLeThJiUO4i5fwAAAADyl0JGDoRPP//4hEJCBED7bAhMB1JEyNTCRAuiIAAABBuCEAAABJi83oUPL//0QPtkQkIImH8AAAAPMPEDWQZjYASY29iAAAAEUz5EiJfCQoQYv0TIl0JHgPH0QAAA+3TCREi8FBK8SZK8LR+Ehj0CvKSIvaQSvMSGPpRYTAD4XfAAAAQYtHGIP4AXVgD7dMJEIPt0QkQEEDzEEPr08cA8hBD69PJEhj+UkDfyiF0n4NTIvCSIvPM9LoWvwFAEiF9n4OTIvGSI0MO7L/6Ef8BQBIhe0PjoQAAABIjQwzTIvFSAPPM9LoLfwFAOtxhcB1cg+3TCRCD7dEJEBBA8xBD69PHAPIQQ+vTyRMY/FNA3cohdJ+EkmL/rj///8ASIvL86tIi3wkKEiF9n4VSY0MlkyLxknB4AK6/////+jX+wUASIXtfh1IjQQzSIvNSY08hrj///8A86tmDx9EAABIi3wkKA+3VCRASP/GD7dMJEJED7ZEJCBBA8yNQQFmD27BZg9u2I1C/wPDD1vAZg9uyI1CAfNBD1lFWAPDQQPEQf/ED1vJD1vb80EPWU1U80EPWV1YD8bJ4fMPWNhmD27AD1vA8w9Z3vNBD1lFVPMPEMsPxsnG8w8QyA/GySfzDxDLD8bJOQ8RD0iDxxAPEUwkKEiJfCQoQYP8IQ+MX/7//w8odCRgTIt8JHBMi3QkeEyLpCSAAAAASIu8JIgAAABIi7QkuAAAAEiLrCSwAAAASIucJKgAAABIi0wkWEgzzOg76QUASIHEkAAAAEFdw8xIiVwkIFVWV0iD7DAz9kmL6EiL2kiL+UE4cDV1HUiLSghIhcl0BejFDwAAM8CJczCIQzRIiTNIiXsIQIh3UrkgAAAAD7dDMmaJRCQox0QkKv3/PwBmiUwkLmaFwHUwSI18JChmhfZ0Dw+31kiLy+hNPAAAhMB1E0iDxwJIjUQkMEg7+HQJD7c369lmiXMyZoN7MAAPt3U6vYUAAABmiXQkIMdEJCImIIUAdT9IjXwkIGaF9nQPD7fWSIvL6AA8AACEwHUTSIPHAkiNRCQmSDv4dAkPtzfr2WaJczBmg3swAHUIZolrMMZDNQFIi1wkaEiDxDBfXl3DzMzMzMzMzMzMSIlcJAhIiXQkEFdIg+wgM/ZIi9pAOHI0dHpMi0ooTYXJdGhMiwU2nTcATYXAdFxJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJcQRm/0EGQf+AGCsAAEmLyf8VBEgGAEyLS0hIiXMoTYXJdHJMiwW4nDcATYXAdF1ND7+YHCsAAEmNkCArAABFi1AESo0U2kQ5EnQ2QY1LAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkSiXIEZv9CBkH/gBgrAABJi8n/FYVHBgBIiXNISItcJDBIi3QkOEiDxCBfw8zMzMzMzMzMzEBWV0FVQVdIgeyYAAAATIt6WEiL8kyL6bouAAAASIvO6Ps5AABIi/hIhcB1I7oO/wAASIvO6OY5AABIi/hIhcB1DkiBxJgAAABBX0FdX17DSYuVsAIAAEiJnCTQAAAAi18oSImsJJAAAACB4///BwBIi0J4TImkJIgAAABMibQkgAAAAA8pfCRwiwyYSItCaPMPEH8Q8w9cfwjB4QxMY8lJi81JwfkM8w9YPeVhNgBGD7dEyAZCD7dEyARFM8mNUAGNFFDo5yEAAPMPEE8Ii9BNi4WwAgAARIvI8w9ZPfJhNgAPV8BBD7dHMIHi//8HAPMPf0QkWEmLSHjzDxBHBPMPWPlNi3BoRTPAweAGixSRg8gCweIMSYvN8w9cPXNhNgBIY+pIi9bzDxFMJEjzDxBPFESJTCRoTI1MJEDzD1/H8w8RfCRQ8w8RTCRUSMH9DIlEJEDzDxFEJETzDxBHDPMPEUQkTOgGNAAATYuFsAIAAEyL4E2LfTgPKHwkcEmLSHhJi3hoixSZweIMSGPaSMH7DDP2RA+3XN8ED7dM3wZFD7dM7gJBD7cE7kQPt0TfAkWNUwEPtxTfiUwkOEmLz0SJXCQwRIlMJChNi89ED6/WRAPQRIlUJCDos+P////Gg/4DfLBBD7dE7gZJi9dFD7dU7gRJi81FD7dM7gJFD7cE7kiLnCTQAAAAiUQkKESJVCQg6Cnk//9Mi7QkgAAAAEmLxEyLpCSIAAAASIusJJAAAABIgcSYAAAAQV9BXV9ew0iJXCQIV0iD7FBIi3lYSIvZD7dXMmaF0nQN6ME3AABMi8BIhcB1ebogAAAASIvL6Kw3AAAzycdEJEj/////g+E/D1fAiUwkIA9XyfMPf0QkKPMPf0wkOEiFwHQH8w8QQATrIPMPEEMU8w9ZBZRfNgDzD1gFnF82APMPLMBmD27AD1vASItPCEyNTCQgRTPA8w8RRCQkSIvT6JMyAABMi8BJi8hIuKOLLrrooosuSCtLOEj36UjB+gNIi8JIweg/SAPQiVNAQYtABIlDEEiLXCRgSIPEUF/DzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0FUQVVBVkFXSIPsUEUz9kiL+oN6ICBMi/lBvP//AABBvf7/AAB2MkiLQigPt1BAZkE71XUNQYvuSI1POEiNX0zrSGZBO9R0EUhr6ixIjU84SAMpSI1fTOsogU9MAAAACEiNX0y6IAAAAEUzwEiLz+icIwAAgSP////3SI1POEiL6EiF7XQEg2UA/YN/IAl2HUiLRygPt1ASZkE71XQwZkE71HQJSGvCLEgDAescgQsAAAAIugkAAABFM8BIi8/oTSMAAIEj////90iFwHVVSIXtdFAPV8DHRCRI//////MPf0QkKEyNTCQgQYPmP/MPEEUED1fJ8w9ZBbNeNgBBgc5AAgAARTPARIl0JCBIi9dJi8/zD39MJDjzDxFEJCToHTEAAEyNXCRQSYtbMEmLazhJi3NASYvjQV9BXkFdQVxfw8zMzMzMzMzMzMzMzMzMzEiLxEiJWAhIiWgQSIlwGFdBVkFXSIHswAAAAA8pcNgPKXjIRA8pQLhEDyjDDyj6TIv6SIvpSIsFdJc3AEiFwHQk94BUKgAAAAEAAHQYD1fJ8w9az2ZID37KSI0N6A42AOi7+P7/SIudsAIAAEiBw8AAAAAPV/YzwA8RdCQgDxF0JDAPEXQkQA8RdCRQDxF0JGAPEXQkcEiJhCSAAAAAx0QkYP////+LO4tTBDv6dQuDwiBIi8voFmYAAIvHmYPiHwPCi8iD4B8rwsH5BUhj0UiLSxBImExr8GhMAzTRQQ8RNkEPEXYQQQ8RdiBBDxF2MA8QRCRgQQ8RRkBBDxF2UPIPEIQkgAAAAPJBDxFGYP8DM/YPV8BmD3PYCGZJD37CTYXSdHJMiwWFljcATYXAdFxFi0gESQ+/kBwrAABJjYggKwAASI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJcQRm/0EGQf+AGCsAAEmLyv8VU0EGAJAPV8BmD3PYCGZJD37BTYXJdHJMiwUBljcATYXAdFxFi1AESQ+/kBwrAABJjYggKwAASI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJcQRm/0EGQf+AGCsAAEmLyf8Vz0AGAJBmD3PeCGZJD37xTYXJdHNMiwWAlTcATYXAdF1Fi1AETQ+/mBwrAABJjZAgKwAASo0U2kQ5EnQ2QY1LAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/0UiBwmQFAABJjRTQRIkSiXIEZv9CBkH/gBgrAABJi8n/FU1ABgCQ80EPEX4U80UPEUYYi4QkAAEAAEGJRlRNiX5YSIuFsAIAAIuIpAAAAEGJTlBMi8ZJi08oSWNHIEyNDMFJO8l0Nw8fQABIiwFIi5CAAAAASIXSdQdIi5W4AgAATANCSEiDwQhJO8l13U2FwHQLSYvI6DC3/P9Ii/BJiXZgSYt/KEljRyBMjTzHSTv/dEAPH4QAAAAAAEiLF0iLmoAAAABIhdt1B0iLnbgCAABMi1MwTYXSdAxMi85Ni8ZIi81B/9JIA3NISIPHCEk7/3XISYvWSIvN6C37//9Ji8ZMjZwkwAAAAEmLWyBJi2soSYtzMEEPKHPwQQ8oe+BFDyhD0EmL40FfQV5fw8zMzMzMzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYSIl8JCBBVEFVQVZBV0yLqbACAABMi/LzDxAl9lk2AEUz5EWLvcAAAAAPH4QAAAAAAEUzyUUzwEUz20GD/wQPjNUBAABJi7XQAAAAQY1v/Ulj/LsCAAAAZmYPH4QAAAAAAEGLw0GL00jB6gWD4B9Ia8hoSIsU1kSL00gD0Uw5clh1S/dCTAAAAAR1QkWF5HUM8w8QQhgPLsN6M3Ux8w8QShQPL8p2E02FyXQL80EPEEEUDy/BdgNMi8oPL9F2D02FwHQHQQ8vSBR2A0yLwkmNQv+D4B+NU/9IweoFSGvIaEiLFNZIA9FMOXJYdUv3QkwAAAAEdUJFheR1DPMPEEIYDy7DejN1MfMPEEoUDy/KdhNNhcl0C/NBDxBBFA8vwXYDTIvKDy/Rdg9NhcB0B0EPL0gUdgNMi8JIi8OL00jB6gWD4B9Ia8hoSIsU1kgD0Uw5clh1S/dCTAAAAAR1QkWF5HUM8w8QQhgPLsN6M3Ux8w8QShQPL8p2E02FyXQL80EPEEEUDy/BdgNMi8oPL9F2D02FwHQHQQ8vSBR2A0yLwo1LAYvBg+EfSGvJaEjB6AVIixTGSAPRTDlyWHVL90JMAAAABHVCRYXkdQzzDxBCGA8uw3ozdTHzDxBKFA8vynYTTYXJdAvzQQ8QQRQPL8F2A0yLyg8v0XYPTYXAdAdBDy9IFHYDTIvCQYPDBIPDBEQ73Q+MSv7//+t/RYX/D46uAAAASYu10AAAAElj/EGLw0GL00jB6gWD4B9Ia8hoSIsU1kgD0Uw5clh1S/dCTAAAAAR1QkiF/3UM8w8QQhgPLsN6M3Ux8w8QShQPL8p2E02FyXQL80EPEEEUDy/BdgNMi8oPL9F2D02FwHQHQQ8vSBR2A0yLwkH/w0U733yPTYXJdClNhcB0VfNBDxBBFA8oyvMPWMoPL8FySPNBDxBAFA8oyvMPWcwPL8F3MU2FwHUxQf/EQYP8Ag+MVP3//zPASItcJChIi2wkMEiLdCQ4SIt8JEBBX0FeQV1BXMNJi8Hr3kmLwOvZzMzMzMzMzMzMzMxIiVwkCEiJbCQQSIl0JBhXQVRBVUFWQVdIg+wgSIsFvZA3AEmL2EyLqbACAABMi+JIi+lIhcB0O/eAVCoAAAABAAB0L4N6IAB0CUiLQihMiwDrB0yNBbbfNQDzDxBLFEiNDTIINgAPWslmSA9+yujd8f7/SIt7OEhjQzBIa/AsSAP3SDv+dBmLVyiD+v90CEiLzej5FQAASIPHLEg7/nXnSYt0JChJY0QkIEyLc2BMjTzGSTv3dEBmDx+EAAAAAABIixZIi7qAAAAASIX/dQdIi724AgAASItHOEiFwHQLTYvOTIvDSIvN/9BMA3dISIPGCEk793XJTItLYDP/TYXJdHVMiwXXjzcATYXAdFxJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJeQRm/0EGQf+AGCsAAEmLyf8VpToGAEiJe2CLU1RJjY3YAAAARTPA6JdM/P9B/4XoAAAAiXsQTItLOE2FyXR6TIsFPY83AEiJezBNhcB0XU0Pv5gcKwAASY2QICsAAEWLUARKjRTaRDkSdDZBjUsBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/RSIHCZAUAAEmNFNBEiRKJegRm/0IGQf+AGCsAAEmLyf8VBjoGAEiJezhIi8voMir8/0iNSyDoKSr8/4FjTAAAAPyBS0wAAAAESItsJFhIi3QkYMdDQP////9IiXtESItcJFBJiTwkSIPEIEFfQV5BXUFcX8PMzMzMzMzMzMzMzMzMzMxIiWwkEEiJdCQYV0iD7CBIi7mwAgAASIvySIvpSIX/dHdIiVwkMDPbOZ/AAAAAfmOLw4vLg+Afhdt5Bo1LH4PoIEiLl9AAAADB+QVMY8FImEhryGhOiwTCSIuFsAIAAEwDwYuIpAAAAEE5SFB/G0k5cFh1FUH3QEwAAAAEdQtIi9ZIi83oB/3////DO5/AAAAAfJ1Ii1wkMEiLbCQ4SIt0JEBIg8QgX8PMzMzMzMzMzEiJXCQISIl0JBBIiXwkGEFWSIPsIEiLubACAAAz20SL8kiL8TmfwAAAAH5rDx9AAIvDi8uD4B+F23kGjUsfg+ggSIuX0AAAAMH5BUxjwUiYSGvIaE6LBMJIi4awAgAATAPBQYtIUEEDzjuIpAAAAH8cQfdATAAAAAR1EkmLUFj2QhAIdQhIi87oU/z////DO5/AAAAAfJlIi1wkMEiLdCQ4SIt8JEBIg8QgQV7DzMzMTIvcQVdIg+xgDxBBKEiJUThmD25KIPMPEBVWUzYADxFEJCBmD25CHA8o2kiJUSgPW8APW8nzD17Q8w9e2fMPEVFU8w8RWVhMi7moAgAASGOBoAIAAA8pdCQwDxBxKEmNBMdIiUQkcEw7+A+EKAEAAEmJWxBmD2/GSYlrGEmLa7hJiXMgSYl78EmLe8BNiWPoZkkPfvRNiWvgZg9z2AhNiXPYZkkPfsVmDx+EAAAAAABJiwdIi0hoSIXJdAqAeQEAD4SaAAAASItwYEhjQFhMjTTGSTv2D4SFAAAADx9EAABIix6DOwB+PkiLQ3hIO8d1NUiLS3BIO811LEk7xXUFSTvMdCIPEXNwSGOLsAAAAEiLg7gAAABIA8kPEXTI8EiLy+h6kf//SIuDuAAAAEhji7AAAABIweEESAPISDvBdBdIOXgIdQhIOSh1Aw8RMEiDwBBIO8F16UiDxghJO/Z1gEmDxwhMO3wkcA+FQf///0yLdCRATItsJEhMi2QkUEiLfCRYSIu0JIgAAABIi6wkgAAAAEiLXCR4Dyh0JDBIg8RgQV/DzMzMzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0FWQVdIg+xASIsFgW83AEgzxEiJRCQwSItpOEiL8blYAAAARYvwRIv6/xVBNgYATIsNGos3AEUzwEiL2E2FyXRdSQ+/kRwrAABJjYkgKwAARYtRBEiNDNFEORF0No1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYkcKwAASA+/yUiBwWQFAABJjQzJRIkRRIlBBGb/QQRB/4EUKwAASIXbdCUPV8AzwA8RAw8RQxAPEUMgDxFDMA8RQ0BIiUNQx0MEAQAAAOsDSYvYi46YAgAAjUEBiYaYAgAAiQtEi0ZEi05AQTvIdSn/wUWFwHQNQYvAmSvC0fhBA8DrBbgIAAAAO8EPT8iL0UiNTkDoPwP//0hjTkBIi0ZISIkcyP9GQEiF7XQExkVXAYtWBEWLzkWLx0iLy+i2xP//SIvTxkZSAEiLzuj3/P//SIvDSItMJDBIM8zox9QFAEiLXCRgSItsJGhIi3QkcEiDxEBBX0FeX8PMzMzMzMzMzMzMzMzMzESJRCQYiVQkEFNVVldBVEFVQVZBV0iD7HhIi9lIi7GwAgAAxoa4AAAAAUyLaTjoPf7//0yL+EEPtkVWQYhHVkiLBYqJNwBIhcB0O/eAVCoAAAABAAB0L0GLRyCJRCQwQYtHHIlEJChBiweJRCQgRYtNIEWLRRxBi1UASI0NLwE2AOi66v7/SIvL6JINAAAz7UiJbCRISIlsJFCJbCRci8VIiUQkYExjZnBFheR+J0GL/LkIAAAARDvhD0z5hf9+FUhjz0jB4QLolKv8/0iJRCRgiXwkXESJZCRYSIXAdBlIi1Z4SIXSdBBNi8RJweACSIvI6D3lBQCQi0ZgiYQkwAAAAIluYIlEJEiLRmSJhCTYAAAAiW5kiUQkTEyLdmhIiW5oSYvuTIl0JFBIi354SGNGcEiNBIdIiUQkQEg7+A+EvQAAAIsHD7rgHg+DnQAAAMHgDEhj6EjB/QxBD7dM7gRJjQTuZoXJdQZmOUgGdH5ED7dABovRTIvPSIvL6M8OAACD+P8PhAkDAABMi4OwAgAAi8iB4f//BwBJi0B4iwyIweEMSGPRSMH6DEmLQGgPt0zQBkQPt0zQBEQPt1TQAkQPtxzQRQ+3RO4CQQ+3FO6JTCQ4RIlMJDBEiVQkKESJXCQgTYvPSYvN6EPR//9Ig8cESDt8JEAPhUj///9Ii2wkUEUz9kyJtpwAAABFi95EObbAAAAAD44PAQAADx9EAABFi8NBg+AfQYvDRYXbeQhBjUMfQYPoIMH4BUhj0EiLjtAAAABJY8BMa8BoSIsE0U6LVAA4SmNEADBIa/gsSQP6TDvXD4SxAAAADx+AAAAAAEGLSiiD+f8PhJAAAABIi5OwAgAAgeH//wcASItCeIsMiMHhDExjyUnB+QxMi0JoQw+3BMhmD27AD1vA8w9ZQ1TzQQ8RQhhDD7dEyAJmD27AD1vA8w9ZQ1jzQQ8RQhxDD7dMyARDD7cEyAPIZg9uwQ9bwPMPWUNU80EPEUIgQw+3TMgGQw+3RMgCA8hmD27BD1vA8w9ZQ1jzQQ8RQiRJg8IsTDvXD4VW////Qf/DRDuewAAAAA+M9v7//0iLy+iO5f//SIvL6Mbg//9EiLa4AAAASIuLqAIAAEhjg6ACAABMjQTBSTvIdC4PH4QAAAAAAEiLEUg5WhB1FPIPEENc8g8RAkiNg4gAAABIiUIISIPBCEk7yHXaSIt8JGBIhf90dkyLBTmGNwBNhcB0YEWLSARJD7+QHCsAAEmNiCArAABIjQzRRDkJdDmNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJCcdBBAAAAABm/0EGQf+AGCsAAEiLz/8VAzEGAJBIhe10d0yLBb6FNwBNhcB0YUWLSARND7+QHCsAAEmNkCArAABKjRTSRDkKdDpBjUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/RSIHCZAUAAEmNFNBEiQrHQgQAAAAAZv9CBkH/gBgrAABIi83/FYcwBgCQSIPEeEFfQV5BXUFcX15dW8NMiwU2hTcATYXAdCNB94BUKgAAAAEAAHQWQYsXSI0NQv01AOiF5v7/TIsFDoU3AEHGR1cBi0ZgiUQkSIuEJMAAAACJRmCLRmSJRCRMi4Qk2AAAAIlGZEiLbmhIiWwkUEyJdmhMi054TYXJdHZFM/ZMiXZwTYXAdF1Fi1AESQ+/kBwrAABIjYpkBQAASY0MyEQ5EXQ2jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRFEiXEEZv9BBkH/gBgrAABJi8n/FZcvBgBMiXZ4QYvUSI1OcOg/SwAASItOeEiLfCRgSIXJdBVIhf90EExjRnBJweACSIvX6JDgBQBJi9VIi8voEff//0SLhCTQAAAAi5QkyAAAAEiLy+gKAAAA6cD9///MzMzMzEiJXCQISIl0JBBXSIPsIEiLsbACAABFi9BEi9pMi8mD+v91CEiLQThEi1gcQYP4/3UISItBOESLUCBFO9N/CUONHBJBi/vrB0ONPBtBi9qLUQiNSv8DjqgAAACLwdH4C8GLyMH5AgvIi8HB+AQLwYvIwfkIC8hEi8FBwfgQRAvBjUr/QYtRDEH/wEE7+EQPTccDjqwAAACLwdH4C8GLyMH5AgvIi8HB+AQLwYvIwfkIC8iLwcH4EAvI/8E72Q9Ny0Q7wnwMRTtBFEGL0EEPT1EURYtBEEE7yHwMQTtJGESLwUUPT0EYQTvTdQVFO8J0CEmLyeg4+f//SItcJDBIi3QkOEiDxCBfw8zMzMzMzMzMSIlcJCBWQVZBV0iD7CCLQgxIi9n/yEyL+kSLwEHR+EQLwE2Lj7ACAABBi8DB+AJBC8CLyMH5BAvIi8HB+AgLwUSL8EHB/hBEC/BBi0cQ/8iLyNH5C8hBjVYBi8HB+AILwYvIwfkEC8iLwcH4CAvBi/DB/hAL8ESNRgFNhckPhKsBAABJi0c4SIXAD4SeAQAAg3gEBA+ElAEAAEGLgagAAAAPV8D/yEiJbCRAi8hIiXwkSNH5C8hMiWQkUEWLoZgAAACLwcH4AgvBi8jB+QQLyIvBwfgIC8GLyMH5EAvIjUEBO8JBi4GsAAAARA9N8f/Ii8jR+QvIi8FBjX4BwfgCC8GLyMH5BAvIi8HB+AgLwYvIwfkQC8iNQQFBO8APTfFFK6GgAAAAZkEPbsyNbgEPW8kPLsF3CQ9XwPMPUcHrCA8owei13wUARYsX8w8swEGD4gH/yIvI0fkLyIvBwfgCC8GLyMH5BAvIi8HB+AgLwYvIwfkQC8iNQQE7/XxSO/hBjUQk/0EPTc5EjUkBQQPBmUH3+TvoRIvARA9NxUWF0nV5QY1A/4vI0fkLyIvBwfgCC8GLyMH5BAvIi8HB+AgLwUSLwEHB+BBEC8BB/8DrSzvoD03ORI1BAUWF0nUoi8HR+AvBi8jB+QILyIvBwfgEC8GLyMH5CAvIRIvBQcH4EEQLwUH/wEGNRCT/QQPAmUH3+Dv4RIvIRA9Nz0yLZCRQSIt8JEhIi2wkQESJC+sCiRNIi8NEiUMESItcJFhIg8QgQV9BXl7DzMzMzMzMzMzMzEiJXCQYSIl0JCBXQVZBV0iD7CBIi/lIi9FIjUwkQOiN/f//SIvP6AUDAABEi0QkREiLz4tUJEDoBPX//0iLz+jMAAAASIufgAAAAEhjR3hIjTTASMHmBEgD80g73nQykEiLg4AAAABIhcB1B0iLh7gCAABMi0AYTYXAdAlIi9NIi89B/9BIgcOQAAAASDvedc9Mi3dwSGNHaE2NPMZNO/d0U0iJbCRIZg8fhAAAAAAASYs2SIteKEhjRiBIjSzDSDvddCMPH0AADx+EAAAAAABMiwNIi9ZIi8/oYuH//0iDwwhIO9116UmDxghNO/d1wEiLbCRISItcJFBIi3QkWEiDxCBBX0FeX8PMzMzMzMzMSIlcJBBXSIPsIEiDubgCAAAASIvZdRDo1BcAAEiL0EiLy+ip1P//SItDOEiFwHQHSIN4KAB1XotDEP/Ii8jR+QvIi8HB+AILwYvIwfkEC8iLQwyL0cH6CAvR/8hEi8KLyEHB+BDR+UQLwgvIQf/Ai8HB+AILwYvIwfkEC8iLwcH4CAvBSIvLi9DB+hAL0P/C6Jvz//+5+AAAAP8VECoGAEyLDel+NwBFM9JIi/hNhcl0XEkPv5EcKwAASY2BICsAAEWLQQRIjQTQRDkAdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmJHCsAAEgPv8FIBWQFAABJjQTBRIkARIlQBGb/QARB/4EUKwAASIX/dDEz0kG4+AAAAEiLz+jX2gUAx4ekAAAA/////8eHkAAAAP////9Ix4fsAAAA/////+sDSYv6SIuDuAIAAEiJu7ACAABIi1AISIXSdAVIi8v/0kiLi6gCAABIY4OgAgAASI0UwUg7ynQoZg8fRAAASIsBSItAaEiFwHULSIPBCEg7ynXr6wuLQDTB6AQkAYhDUUiLy+g2AgAASIvL6M7c//9Ii8voBtj//0iLy+j+1v//SIuLqAIAAEhjg6ACAABMjQTBSTvIdC0PH4AAAAAASIsRSDlaEHUU8g8QQ1xIjYOIAAAA8g8RAkiJQghIg8EISTvIddpIi1wkOEiDxCBfw8zMzMzMzMzMzMzMzMzMzEiJXCQISIlsJBBIiXQkGFdBVkFXSIPsIEyLcXBFM/9IY0FoSIv5SY0sxkw79XRukEmLNkiLTghIhcl0CEiL1ui87v//RIl+MDPAiEY0TIk+SIteKEhjRiBIjTTDSDvedDNIixNIi4KAAAAASIXAdQxIi4e4AgAASIXAdA9Mi0AgTYXAdAZIi89B/9BIg8MISDvedc1Jg8YITDv1dZNIjbewAgAATDm/sAIAAHQvSIuHuAIAAEiNt7ACAABIhcB0HEiLUBBIjbewAgAASIXSdAxIi8//0kiNt7ACAABIi5+wAgAASIXbD4SxAAAASI2L2AAAAOiY5f7/SI2LwAAAAOgMQgAASI2LgAAAAOiA5f7/SI1LcOh35f7/SI1LYOhu5f7/SI1LUOhl5f7/TIsFPnw3AE2FwHRdSQ+/kBwrAABJjYggKwAARYtIBEiNDNFEOQl0No1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkJRIl5BGb/QQZB/4AYKwAASIvL/xULJwYASItcJEBIi2wkSEyJPkiLdCRQSIPEIEFfQV5fw8zMzMzMzMxIiVwkIFVWQVdIg+wwSItpOEUz/0iLmbACAACLRRyLS1SZK8LR+IvwO8EPjuUAAABIiXwkWIXJdAuLwZkrwtH4A8HrBbgIAAAAO8aL/g9P+Dv5D464AAAASGPPSMHhBEyJdCRg6Ned/P9Ii1NYTIvwSIXSD4SLAAAATGNDUEiLyEnB4AToi9cFAEyLS1hNhcl0aUyLBRd7NwBNhcB0XUkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDaNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJEUSJeQRm/0EGQf+AGCsAAEmLyf8V5CUGAEyJc1hMi3QkYIl7VEiLfCRYiXNQSIvLTItLWESLRSCLVRyJdCQg6FEC//9Ji8dMibuUAAAASImDqAAAAEiJg7AAAABIi1wkaEyJfCRQTIl8JFBIg8QwQV9eXcPMSIlcJAhMi4mwAgAAi8Il//8HAEiL2USL2kmLSXiLFIGLwsHgDExjwEmLQWhJwfgMTo0UwE2F0g+EgQAAAA+68h5BgeP//wcATo0EmUGJEEGLgZAAAACLyDPKgcIAABAAgeEAAPD/M8gz0YHiAADwPzPRQYkQ98IAAPA/dRKNggAAEAAzwiUAAPA/M8JBiQCLUwhB/4GcAAAARYmZkAAAAEEPt0oEQQ+3QgYDygPCD6/IQQGJoAAAADPAQYlCBEiLXCQIw8zMzMzMzMzMzMzMzEBTVVZXQVRBVUFWQVdIg+x4Dyl0JGBIiwWjXTcASDPESIlEJFhIi6mwAgAAi9rzDxA1Qj82AEiL+YlUJCCLw4tRCE2L8YuNqAAAAL4DAAAAO8tEiUQkJIlUJDgPTcFmiVwkNIuNrAAAAEaNLAKJhagAAABBO8hBi8BmRIlEJDYPTcGJhawAAACNBBqJRCQokDPJSI1UJEBIiUwkUA9XwA8RRCRASIvNiUQkRESJbCRI6GsG//+DfCRUAEQPt3wkTEQPt2QkUGZEiXwkMGZEiWQkMnV3hfYPhNwAAACAvbgAAAAAD4XPAAAASIufsAIAALoCAAAASIvP6MPq//9mD26DmAAAAEiLz2YPbougAAAAD1vAD1vJ8w9Zxg8vwXYPuv////9Ei8LoVPT//+sQSItXOESLQiCLUhzocu7//4PuAYtEJCgPiUX///+LhbAAAAAPt1QkIANUJDhBA9c7wg9N0IuFtAAAAImVsAAAAA+3VCQkA1QkOEED1DvCD03Q/4WUAAAARA+vbCQoiZW0AAAARAGtmAAAAESLRWSLTWBBO8h1YP/BRYXAdERBi8CZK8LR+EEDwOs8SIsNwXc3AEiFyXQh94FUKgAAAAEAAHQVRItEJCRIjQ0E8DUAi1QkIOgL2f7/uP/////p1wAAALgIAAAAO8EPT8iL0UiNTWDofPD+/0hjVWBIi0QkMEiLTWhIiQTRi3VgjUYBiUVgSIufsAIAAE2F9nQ4i0Ng/8iLyEEzDoHhAADw/zPIQYkOSIuHsAIAAMHpFIHh/wMAAMHhFEwrcHhJwf4CRAvxQYvG62RIY5OQAAAAhdJ5IotTcEiNS3D/wuj1PQAASItDeItTcP/KSGPKTI0EiDPA6xpIi0N4TI0EkIsEkMHgDMH4DImDkAAAAEGLADPGJQAA8P8zxg+66B5BiQDB6BQl/wMAAMHgFAvCSItMJFhIM8zofcEFAA8odCRgSIPEeEFfQV5BXUFcX15dW8PMzMzMzMzMSIlcJAhIiXQkEFdIg+wgi/JIi/mD+v90XovageP//wcASIO5sAIAAAB1BejQ9v//TIuHsAIAAEE7WHB9OkmLQHiLFJiLwjPGqQAA8D91KA+64h5zIkmLQGjB4gxIY8pIwfkMSI0EyEiLXCQwSIt0JDhIg8QgX8NIi1wkMDPASIt0JDhIg8QgX8PMzMzMzMzMSIlcJBhWSIPsIEhj2kiNcSA7Hg+O6gAAAEyNRCQ4x0QkOAAAgL+L0+gzPwAAi04EO9l+I4XJdAuLwZkrwtH4A8HrBbgIAAAAO8OL00iLzg9P0Ohp9P7/TGMGQTvYD46eAAAASIl8JDBBu///AACL+0Er+IP/CHJjSItWCEyNTgiNQ/9IY8hOjRRCSI0ESk070XcFSTvBc0OB5wcAAIB9B//Pg8/4/8eLw0GLyCvHZpBBg8AIRDvAfPcrwUmL+oPAB5mD4gcDwsH4A0hjyEjB4QRI0elBD7fDZvOrSIt8JDBJY8hIO8t9GQ8fhAAAAAAASItGCGZEiRxISP/BSDvLfO+JHkiLXCRASIPEIF7DzMxIiVwkIFVWV0FUQVVBVkFXSIHsoAAAAEiLBRJZNwBIM8RIiYQkiAAAAEiLcVhIi/lMiUQkSA+32kyLbghBgH1QAA+FTgIAAPZGEAQPhUQCAACDfjgASI1OOGaJXCRAdAyL00SLw+hWL/z/i9hmO14wdRqAfjUAdBRIi9dJi83oPdj//0iFwA+FHwIAAEyLdigz0khjRiBEi+JMi39gSY0ExkiJRCRQTDvwD4QJAQAAkEmLNkiLroAAAABIhe11B0mLrbgCAABIi0ZISIXAdCQPtwhmhcl0HGY72XIKZjtYAg+GvAAAAA+3SARIg8AEZoXJdeRIi0wkSE2Lz0iLRUBMi8dIhcl1fkiJVCQwSI1MJFhIiUwkKA9XwEiJVCRYD1fJSYvNx4QkgAAAAP////9Ii9ZmiVwkIPMPf0QkYPMPf0wkcP/QhMB0V4tEJFhBg+QPRA+3TCRAg+ADQcHhBEyLxkULzEiL10HB4QJJi81EC8hEiUwkWEyNTCRY6LAMAADpJgEAAEiJTCQwSYvNSIlUJChIi9ZmiVwkIP/QhMB1XDPSTAN9SEH/xEmDxghMO3QkUA+F+P7///dHTAAAAAgPheQAAACDf0D/dQhIi8/oLdn//w+300iLz//C6BD9//+LRxBIi08ID7fTiQSRSItHKGbHBFD+/+mtAAAASItHWA9XwEyLRCRIDym0JJAAAABIi0go80EPEAhIiwHzDxBQPA8u0HoMdQrzDxAFJDk2AOsJ8w8QRxTzD17CDyjw8w9ZdlgPL/F3DA8o8PMPWXZc8w9d8YB+NgB0E/MPWDWyODYA8w8sxmYPbvAPW/bzD1h2YA+300iLz//C6HH8//9Ii0cID7fL8w8RNIgPKLQkkAAAAOsUg3lA/3UO90FMAAAACHUF6FfY//8zwEiLjCSIAAAASDPM6AW9BQBIi5wk+AAAAEiBxKAAAABBX0FeQV1BXF9eXcPMzMzMzMzMzMzMQFNIg+wwSIsFQ1Y3AEgzxEiJRCQo8w8QQRRIi9kPLwUAOTYAcy73QUwAAAAQdSVFM8Do6fz//0iFwHUv8w8QQxBIi0wkKEgzzOiSvAUASIPEMFvDTI1EJCDHRCQgAAAAAOi6/P//SIXAdBjzDxBABEiLTCQoSDPM6GO8BQBIg8QwW8PzDxBEJCBIi0wkKEgzzOhKvAUASIPEMFvDzMzMzEiJXCQISIlsJBBIiXQkGFdIg+wguagAAABIi9r/FW4cBgBMixVHcTcAM+1Ii/hNhdJ0XEkPv5IcKwAASY2KICsAAEWLQgRIjQzRRDkBdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmKHCsAAEgPv8lIgcFkBQAASY0MykSJAYlpBGb/QQRB/4IUKwAASItzKItTZEiLzuiyBv//hcAPiYMAAABIhf90a02F0nRdTQ+/ihwrAABJjZIgKwAARYtCBEqNFMpEOQJ0NkGNSQG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmKHCsAAEgPv9FIgcJkBQAASY0U0kSJAolqBGb/QgZB/4IYKwAASIvP/xWSGwYASI0Nw+k1AOh+hv3/MsDpVgEAAESLwEiL1kiLz+jZCP//hcAPhYkAAABIhf90cUyLBSVwNwBNhcB0XEkPv5AcKwAASY2IICsAAEWLSARIjQzRRDkJdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJCYlpBGb/QQZB/4AYKwAASIvP/xXzGgYASI0NhOk1AOjfhf3/MsDptwAAAA9X0kiLQ3hIibuIAAAASItIKEiLAfMPEEg8QDhrNXQR8w8QQzwPLsJ6B3UF8w8RSzxMY18kvgABAABMi1cI8w8QHcY1NgAPv8ZDD7ZMEwZDD7ZUEwdHD7ZEEwUPr8hDD7ZEEwRmA9EPv84Pr8FED7/KZkEDwJhBK8FmD27AD1vA8w9e2PMPEZ+gAAAAQDhrNXQj8w8QQzwPLsJ6AnQXDy7KegJ0EPMPXsHzD1nD8w8Rh6AAAACwAUiLXCQwSItsJDhIi3QkQEiDxCBfw8zMzMzMzMzMzMzMzEiJXCQIV0iD7CBMi4qIAAAAM9tIi/pNhckPhIMAAABMiwWqbjcATYXAdFxJD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRGJWQRm/0EGQf+AGCsAAEmLyf8VeBkGAEiJn4gAAABIi1wkMEiDxCBfw0iJmogAAABIi1wkMEiDxCBfw8zMzMzMzMzMzMzMzEiD7ChIi4qIAAAAQQ+30OhsDP//hcAPlcBIg8Qow8zMQFdIg+wwgHo1AEmL+A+FrwAAAEiLgogAAABIiVwkQA8pdCQgTGNQJEyLSAjzDxCwoAAAAPNBD1lwFEG4AAEAAEEPv8BDD7ZUCgYPr9BDD7ZECgdBD7/IZgPQQw+2RAoFD7/aQw+2VAoED6/RZgPCmGYPbsAPW8DzD1nG6EzLBQBmD27LSItcJEAPW8nzDxFHRA9XwPMPWc4PKHQkIA8vyPMPLMFzEGYPbsAPW8APLsF6AnQC/8hmD27AD1vA8w8RR0iwAUiDxDBfw8zMzMzMzEiLxEiJWBhIiUgIVVZXQVRBVUFWQVdIgezwAAAASIuqiAAAAEiL8g+3nCRQAQAASIvNDyl4qIvTRA8pQJhNi+hEDylIiEQPKZB4////RA8pmGj///9EDymgWP///0iJbCRw6CkL//+JRCRgi/iFwA+EygQAAA++VjhBvAEAAADzRQ8QRRjzDxBOcA8ptCTgAAAA80EPEHUUhNJ0BUSL8uskDyjG80EPWcDzD1nBDy8FXDM2AHcMgH42AEG+AgAAAHQDRYv0D75GOUSL+ITAdQNFi/zzD1m1oAAAAEiNRCRYSIlEJEhIjUQkUEiJRCRAD1f/80QPWcFIjYQkOAEAAEiJRCQ4i9dIjYQkUAEAAGZFD27OSIlEJDBIi81FD1vJQQ8owPMPEXwkKPMPWcZFDyjZZkUPbtdFD1vS80QPWdhFDyji8w8RfCQg80QPWeBBDyjTQQ8o3OiFNf//TItFCEhjRSRIY1UoQg+2TAAjQg+2RAAiweAIA8E7+H0ZjQS9AAAAAEhjyEkDyEQPtkQRAQ+2DBHrFY0MhQAAAABJA8hED7ZEEf0PtkwR/LgAAQAAmA+vyGZEA8FBD7/AZg9uwEiLhCRgAQAAD1vA8w9Zxg8otCTgAAAASIXAdA3zDxEAQQ+2xOlZAwAASIusJFgBAABEi4QkUAEAAItEJFDB4waDZQA/CV0A8w8RRQREO8APhCcDAACLlCQ4AQAAi0wkWDvRD4QUAwAASIucJDABAABBK8AryolEJFxBA8ZFM8mNef9Ii8tBA/+NUP9Ei8eJfCRk6Erx//+JRCRog/j/D4TcAgAATIuLsAIAAIvQgeL//wcAQQ8o3EEPKNNJi0l4ixSRSYtJaMHiDExjwotUJGBJwfgMSo0EwUiJRCR4SI1MJFhIiUwkSEiNRCRQSItMJHBIiUQkQEiNhCQ4AQAASIlEJDhIjYQkUAEAAEiJRCQw8w8RfCQo8w8RfCQg6AA0//+LRCRcSIubsAIAAP/IQQPGD6/4SI2LgAAAAIvX6P/j/v9Ii4OIAAAAM9JIi8hMY8dIiUQkUOhwxgUAi0QkYItcJFyLfCRk/8tIi1QkUEED3kiLTCRwRIvDiUQkSESLz/MPEXwkQEUrxvMPEXwkOEUrz/NEDxFkJDBB/8DzRA8RXCQoQf/BiVwkIOgSVv//RTv0fhdIi0wkUESLy0SLx0SJdCQgi9PoNlj//0U7/H4cRIvHRIl8JCBIi3wkUESLy0iLz4vT6Mda///rBUiLfCRQRYX2dQUPV+TrGkGLxEEPKMFBK8bzQQ9YwWYPbuAPW+TzD17gRYX/dQUPV9LrGEUr50EPKMLzQQ9YwmZBD27UD1vS8w9e0EmLRVjzDxAtgi82AEiLSChIiwHzDxBAPA8ux3oHdQUPKM3rCvNBDxBNFPMPXsiAfjYADyjB8w9ZRlDzD1lOVPMPEB0HLzYAdA/zD1jD8w8swGYPbsAPW8CAfjcAdA/zD1jL8w8swWYPbsgPW8lMi0QkePMPWODzQQ8QRURMi82LjCRQAQAA8w9Yw4uUJDgBAADzRQ9ZyIlcJDjzRQ9Z0EiJfCQo8w8swEyJRCQgZg9uwQ9bwGYPbtgPW9vzD1jaDyjV80EPXtHzD1jZZg9uyvMPWcLzQQ9e6vMPWMQPW8nzDxFFCPMPWc3zD1jL8w8RTQxBD7dABAPBSIuMJDABAABmD27AD1vA8w9ZwvMPWMTzDxFFEEEPt0AGTIvGg00AAgPCSYvVZg9uwItEJGgPW8CJRSjzD1nF8w9Yw/MPEUUU6FUDAACwAesCMsBMjZwk8AAAAEmLW1BBDyh74EUPKEPQRQ8oS8BFDyhTsEUPKFugRQ8oY5BJi+NBX0FeQV1BXF9eXcPMzMzMzMxIg+woiw1yZjcAZUiLBCVYAAAAugQAAABIiwTIiwwCOQ1TbzcAfkdIjQ1KbzcA6H2zBQCDPT5vNwD/dTIPV8BIjQ0ybzcADxEFM283AA8RBTxvNwAPEQVFbzcADxEFTm83AA8RBVdvNwDo1rIFAEiNBePaNQBIxwU4bzcAAAAAAEiJBfluNwBIjQWi9f//SIkFA283AEiNBTT4//9IiQX9bjcASI0F5vj//0iJBfduNwBIjQX4+P//SIkF8W43AEiNBbr5//9IiQXzbjcASI0FrG43AEiDxCjDzMzMzMzMzEiJXCQISIlsJBBIiXQkGEiJfCQgQVZIg+wgTGNyMEiL6UiNSjBIi/JJi9FJi9jorS4AAElr/ixIA344i08og/n/D4StAAAASIuVsAIAAIHh//8HAEyLQmhIi0J4iwyIweEMTGPJScH5DEMPtwTIZg9uwA9bwPMPWUVU8w8RRxhDD7dEyAJmD27AD1vA8w9ZRVjzDxFHHEMPt0TIBEMPtwzIA8hmD27BD1vA8w9ZRVTzDxFHIEMPt0TIAkMPt0zIBgPIZg9uwQ9bwPMPWUVY8w8RRySLTkxDD7dUyAZDD7dEyAQPr9AD0TPRgeL///8DM9GJVkxIhdsPhKwAAABIi0ZYD1fASItIKEiLAfMPEEg8Dy7Iegx1CvMPEAUFLDYA6wnzDxBGFPMPXsHzDxBfBA8oyPMPWUtYDy/LdwwPKMjzD1lLXPMPXcsPLsvzDxAlkSs2AHoCdDOAezYADyjR8w9c0/MPWdR0C/MPLMJmD27QD1vSDyjC8w9YRwjzD1hXEPMPEUcI8w8RVxCAezYAdA/zD1jM8w8swWYPbsgPW8nzD1hLYPMPEU8E9gcBdAxIi0U4xkBWAcZFUwGLB0iLzsHoBovYjVAB6PTu//9Ii04Ii0cESItsJDiJBJlIi0YoZkSJNFiLw0iLXCQwmYHi/x8AAAPCSItWWEiLdCRAwfgNTGPAg+AHScH4A0EPtkwQNA+rwUiLx0iLfCRIQYhMEDRIg8QgQV7DzMzMzMzMzMzMTIlMJCBMiUQkGEiJVCQQSIlMJAhTVVZXQVRBVUFWQVdIg+x4TItpOEiL6UyLpCTgAAAATYvwSIu0JOgAAABMi/pFi0UkQQ+3TCQCQQ+vTRxBD7cEJEUPr0UcRYtNGEEPt1wkBkUPt1QkBAPIQQ+vTSRIY/lJA30oQYP5AXVWhdsPhKQAAABMY7Qk+AAAAEGL6k1j+A8fQAAPH4QAAAAAAEyLxUiL1kiLz+hGwAUA/8tJA/ZJA/+F23/mSIusJMAAAABMi7Qk0AAAAEyLvCTIAAAA61ZFhcl1UYXbdE1MY4wk+AAAAE1j2A8fhAAAAAAASIvOSIvXRYvCRYXSdCBmkA+2AUiNUgTB4BhIjUkBDf///wBB/8iJQvxFhcB/4v/LSQPxSQP7hdt/xkmLR1hFi0UcQQ+3TCQC80EPEE5sSIlEJDhIi4Qk2AAAAEiJRCRQQQ+3BCRBD6/IRQ+vRSRIiWwkMEyJdCRATIl8JEgDwUEPr0UkRIlEJGRImEkDRSgPLg1uKTYASIlEJFhBi0UYiUQkYEEPt0QkBIlEJGhBD7dEJAaJRCRsegJ0CkiNTCQw6Nuo//9BD7dMJARJi9VBD7dEJAZFD7dMJAJFD7cEJImEJOgAAACJjCTgAAAASIvNSIPEeEFfQV5BXUFcX15dW+mrrP//zMzMzMzMzMzMzMxAU0iD7CBIi9kPt8pIY0MgSDvIczxIi0MoD7cMSLj+/wAAZjvIdRJIY0NASGvALEgDQzhIg8QgW8O4//8AAGY7yHQOSGvBLEgDQzhIg8QgW8NFM8BIi8voRO3//0iLyEiFwHUMSGNDQEhryCxIA0s4SIvBSIPEIFvDzMzMzMzMzEBTSIPsIEiL2Q+3ykhjQyBIO8hzMkiLQygPtwxIuP7/AABmO8h1CDPASIPEIFvDuP//AABmO8h0DkhrwSxIA0M4SIPEIFvDgUtMAAAACEUzwEiLy+jH7P//gWNM////90iDxCBbw8zMzMzMzMzMzMxIiVwkGFVWV0iD7CBIi3kISIvxSIPBOA+36oM5AHQMi9VEi8XoRxz8/4voSIteKEhjTiBIjTTLSDvedDoPH0AASIsTSIuCgAAAAEiFwHUHSIuHuAIAAEyLSChNhcl0DkQPt8VIi89B/9GEwHUYSIPDCEg73nXKMsBIi1wkUEiDxCBfXl3DSItcJFCwAUiDxCBfXl3DzMzMzMzMzMzMzMzMQFZIgeygAAAADyl0JHAPKXwkYEiLBSZFNwBIM8RIiUQkUPMPWA36JjYAD1fASIvxDy/CSIsJDyjy8w8swWYPbvgPW/92BfMPEHYUSIXJdCDzDxBBFA8ux3oWdRTzDxBBGA8uxnoKdQhIi8HpeQEAAItGGEiNVCRASImcJJgAAABMjQU5PwgASImsJJAAAAC7/////0iLbghIibwkiAAAAEyJtCSAAAAA8w8RfCRETIu1sAIAAPMPEXQkSIlEJECQD7YCSP/CD7bLSDPIwesISI1EJExBMxyISDvQcuNJY47YAAAA99NNi57gAAAATIvJTQPJSYv7SIXJdDYPH0QAAEiL0UjR6kyLwk0DwEI5HMdzF0qNPMdIx8D/////SIPHEEgrwkgDyOsDSIvKSIXJdc9LjQTLSDv4dAQ5H3QkTI1EJDCJXCQwSIvXSMdEJDgAAAAASY2O2AAAAOih2/7/SIv4SItPCEiFyXVO9kYQCHUFOE1QdB4PKN4PKNdIi9ZIi83oecv//0iLyEiFwHUqOEVQdSEPKN6JXCQgDyjXSIvWSIvN6KfH//9IiUcISIvISIXAdQQzwOsQQYuGpAAAAIlBUEiLwUiJDkiLvCSIAAAASIusJJAAAABIi5wkmAAAAEyLtCSAAAAASItMJFBIM8zo2qkFAA8odCRwDyh8JGBIgcSgAAAAXsPMzMzMzMzMSIvESIlYCEiJaBBIiXAgTIlAGFdBVEFVQVZBV0iB7IAAAADzDxAVLSY2AE2L4Q8peLhJi9hEDylAqEQPKUiYRA8pUIhEDylcJCAPKXDIDyjx6Jr9///zRA8QnCTQAAAARTP2TIvoRQ9X0kUPV8BFD1fJD1f/TIv7QLYBSIv78w9ecBTzRA9e3g8odCRwSTvcD4NnAQAAZmYPH4QAAAAAAA++H4mcJNAAAACB+4AAAABzB7gBAAAA6xxNi8RIjYwk0AAAAEiL1+gUFPz/i5wk0AAAAEiYSI0sOIP7IHMSg/sKD4QWAQAAg/sND4TAAAAAQTtdAHMRSYtFCIvL8w8QBIhEDy/QdgsPt9NJi83ozuv//4P7IHRog/sJdGOB+wAwAAB0W/NED1jIQIT2dAVMi/3rJ/aEJNgAAAAC80EPWPlNi/fzRA9Yx3QIRQ8v2EwPQ/dBDyj6RQ8oyoP7P3cQSLkAAAAABlAAiEgPo9lyL42D/8///4P4AXYkQLYB6yJAhPZ0CfNED1jHQQ8o+kCE9vMPWPhIi8dJD0THTIv4QDL2QQ8owfNBD1jAQQ8vw3cOSIv9STvsD4Lk/v//6xBFDy/ZdgpNhfZJi/9JD0X+SDu8JMAAAAB1JU2LxMeEJNAAAAAAAAAASIvXSI2MJNAAAADo6hL8/0iYSAPH6wNIi8cPKHwkYEyNnCSAAAAASYtbMEmLazhJi3NIRQ8oQ9BFDyhLwEUPKFOwRQ8oW6BJi+NBX0FeQV1BXF/DzMzMzMzMSIvESIlYCEiJUBBVVldBVEFVQVZBV0iB7JAAAABIi7wkCAEAAEiL6kiLnCT4AAAATIvxDylwuA8peKgPKPpEDylAmEQPKUiIRA8pVCRARA8o00QPKVwkMEiF/3UWSMfA/////4B8AwEASI1AAXX1SI08GEyLvCQAAQAADyjP8w8QFZIjNgBNhf9Ii8pMD0T/TIm8JAABAADoE/v///NEDxCcJPAAAABFD1fARQ8v2EnHBgAAAABMi+hEDyjPD1f280QPXkgUD5fBSY1GBDP2iIwk8AAAAEk73w+DeQEAAESLvCQgAQAAhMkPhJQAAABIhfZ1J0EPKMNEiXwkKPMPXMZMi89Mi8MPKM9Ii83zDxFEJCDoqPz//0iL8Eg73nJjQQ8vNnYF80EPETYPKMdBDyjw80EPWEYE80EPEUYEQfbHAnUhSDvfcykPH4AAAAAAD7YDPCB0BDwJdQpI/8NIO99y7esNSDvfcwiAOwp1A0j/w0H2xwQPhccAAAAz9ummAAAAD74TSIvriZQk4AAAAIH6gAAAAHMFSP/D6yBMi8dIjYwk4AAAAEiL0+jwEPz/i5Qk4AAAAEhjyEgD2YP6CnUp80EPEAYPKM/zD1/GQQ8o8PNBD1hOBPNBDxEG80EPEU4EQfbHBHVa6zaD+g10MUE7VQBzEUmLRQiLyvMPEASIRA8vwHYISYvN6JHo///zQQ9ZwfMPWMZBDy/CcyIPKPBIi6wk2AAAAEg7nCQAAQAAcxAPtowk8AAAAOmn/v//SIvdQQ8vNnYF80EPETZBDy/wSY1GBHcO80EPEEYEQQ8uwHoKdQjzD1g48w8ROEiLhCQQAQAASIXAdANIiRgPKHwkcEyNnCSQAAAASYtbQEmLxkEPKHPwRQ8oQ9BFDyhLwEUPKFOwRQ8oW6BJi+NBX0FeQV1BXF9eXcPMzMzMzMxAU0iD7GBIi4QkqAAAAEiL2vMPEIQkkAAAAEiL0cdEJFAAAAAASIvLSIlEJEBIi4QkoAAAAEiJRCQ4SIlEJDBIi4QkmAAAAEiJRCQo8w8RRCQg6On8//9Ii8NIg8RgW8NIi8RIiVgQSIloGEiJeCBBVkiB7NAAAABIi5wkEAEAAEmL6Q8pcOhMi/IPKPLzDxAVwyA2AA8ozuhT+P//D7eUJAgBAABIi8hIi/josPb//0yLwEiFwA+EkgIAAIsQ9sICD4SHAgAA8w8QHYUfNgAPV8BIibQk4AAAAIu0JAABAACBzv///wAPKbwksAAAAPbCAUQPKYQkoAAAAA9EtCQAAQAADy/wcgfzD153FOsDDyjzRA8oxg8o/vNFD1lACPNBD1l4EPMPLEUAZg9uwPMPLEUED1vAZg9uyPNED1jA8w9Y+A9byUiF23QYRA8vQwgPh98BAADzDxADDy/HD4fSAQAARA8pjCSQAAAARA8ozvNFD1lIDPNBD1lwFEQPKZQkgAAAAPNED1jJ80UPEFAkRA8pXCRw8w9Y8fNFDxBYIEQPKWQkYPNFDxBgHEQPKWwkUPNFDxBoGEiF2w+E4gAAAPMPECNBDy/gdjAPKMcPKNfzQQ9cwA8oy/MPXNREDyjE8w9e0EEPKMPzQQ9cxfMPXMrzD1nI80QPWOnzDxBTBEEPL9F2LQ8oxg8ozvNBD1zBRA8oyvMPXMrzD17IQQ8owvNBD1zE8w9c2fMPWdjzRA9Y4/MPEFMIDy/6ditBDyjD80EPXPgPKMrzQQ9cxfNBD1zI8w9ezw8o+kQPKNnzRA9Z2PNFD1jd8w8QUwwPL/J2K0EPKMLzQQ9c8Q8oyvNBD1zE80EPXMnzD17ODyjyRA8o0fNED1nQ80UPWNREDy/Oc266BgAAAEG4BAAAAEmLzugKX///SI1EJDCJdCQoTI1MJDhIiUQkIEyNRCRA80QPEVwkMEiNVCRI80QPEVQkNEmLzvNEDxFsJDjzRA8RZCQ88w8RfCRA8w8RdCRE80QPEUQkSPNEDxFMJEzoz1///0QPKGQkYEQPKFwkcEQPKJQkgAAAAEQPKIwkkAAAAEQPKGwkUA8ovCSwAAAASIu0JOAAAABEDyiEJKAAAABMjZwk0AAAAEmLWxhJi2sgSYt7KEEPKHPwSYvjQV7DzMzMTIvcTYlLIEmJUxBJiUsIVkFVQVdIgewgAQAA80EPLAFMi6wkaAEAAEiL8kyL+UEPKXO4RA8pdCRwRA8pfCRgRA8o+mYPbvDzQQ8sQQQPW/ZmRA9u8EUPW/bzDxF0JDBFDy91DA+HbAcAAEmJWxgPV8BJiWvgSYl72EiLvCR4AQAATYlj0E2Jc8hBDyl7qEUPKUOY80QPEIQkgAEAAEUPKUuIRQ8pk3j///9FDymbaP///0QPL8BFDymjWP///0UPKatI////QA+XxUCIrCRoAQAASIX/dShIi4wkcAEAAEjHwP////9mZg8fhAAAAAAAgHwBAQBIjUABdfVIjTwI8w8QFeEcNgBBDyjPSYvP6G30///zQQ8QTQRFDyjPSIucJHABAABBDyjG80EPWMfzDxF0JDzzRA9eSBRMi/APKP4PL8jzRA8RTCRED4a1AAAAi7QkiAEAAEg73w+DnQAAAEyLx7oKAAAATCvDSIvL6GuxBQBAhO10XEiFwIl0JChMi8/zRA8RRCQgTA9FyEyLw0EPKM9Ji8/o9PX//0iL2ED2xgJ1IEg7x3M2Zg8fRAAAD7YDPCB0BDwJdQpI/8NIO99y7esbSDvfcxaAOwp1EUj/w+sMSI1YAUiFwHUDSIvf80EPEEUE80UPWPdBDyjO80EPWM8PL8EPh1r///9Ii7QkSAEAAEiLx0grw0g9ECcAAH5bQITtdVbzQQ8QfQxIi8NBDy/+QQ8o9nY0Dx9EAABIO8dzKkyLx7oKAAAATCvASIvI6JawBQBIhcB0BUj/wOsDSIvH80EPWPcPL/530fMPEHQkMEiL+PMPEHwkPEg73w+E+QQAAIvHK8ONFIUAAAAAjQRAiVQkUI0MAESLwotGEIvRA8GJTCRMSIvOiUQkVOiqW///iwaLjCSIAQAASItuQEyLfkhEi2Y0M/aJRCRID7bBJAGIRCQ0i4QkYAEAAA3///8AiUQkQEg73w+DvAMAAA8fQABmDx+EAAAAAACAvCRoAQAAAA+EpAAAAEiF9nU6QQ8oyIlMJChIi4wkQAEAAA8oxvMPXMdMi89Mi8PzD1zI8w8RTCQgQQ8oz+hd9P//i4wkiAEAAEiL8Eg73nJg80UPWPfzDxF8JDAPKPdFDy91DA+HRAMAADP29sECdSZIO98PgyEDAAAPH0QAAA+2AzwgdAQ8CXUNSP/DSDvfcu3pAQMAAEg73w+D+wIAAIA7Cg+F7wIAAEj/w+nnAgAAD74TiVQkOIH6gAAAAHMFSP/D6xpMi8dIjUwkOEiL0+iqCPz/i1QkOEhjyEgD2YP6IHMsg/oKdR7zRQ9Y9/MPEXwkMA8o90UPL3UMD4esAgAA6YoCAACD+g0PhIECAABJY0YgD7fKSDvIcyJJi0YoD7cMSLj+/wAAZjvIdCC4//8AAGY7yHQGSGvBLOsYRTPASYvO6Fbd//9IhcB1DEljRkBIa8AsSQNGOIsIRQ8owfNED1lABPbBAg+EDQIAAPNFDxBtCEEPKPnzD1l4CEEPKOHzD1lgEEEPKOnzD1loFPMPWP7zD1jmQQ8o8fMPWXAMRA8v7/NBD1j280EPWO4PgsEBAADzQQ8QXQAPL+MPgrIBAACAfCQ0APNEDxBIGPNEDxBQHPNEDxBYIPNEDxBgJA+E5AAAAA8v33Yz8w8QDf8XNgAPKMTzD1zHDyjU8w9c0w8o+/MPXtBBDyjD80EPXMHzD1zK8w9ZyPNED1jJ80EPEF0EDy/edjPzDxANwRc2AA8oxfMPXMYPKNXzD1zTDyjz8w9e0EEPKMTzQQ9cwvMPXMrzD1nI80QPWNFBDy/lditBDyjD8w9c50EPKM3zQQ9cwfMPXM/zD17MQQ8o5UQPKNnzRA9Z2PNFD1jZ80EPEFUMDy/qdilBDyjE8w9c7g8oyvNBD1zC8w9czvMPXs0PKOpEDyjh80QPWeDzRQ9Y4g8v9Q+DqwAAAIuEJGABAAD2wQHzDxF9AA9FRCRAiUUQiUUkiUU4iUVMQY1EJAHzDxF1BPNEDxFNCPNEDxFVDPMPEWUU8w8RdRjzRA8RXRzzRA8RVSDzDxFlKPMPEW0s80QPEV0w80QPEWU08w8RfTzzDxFtQPNEDxFNRPNEDxFlSEiDxVBmQYlHAkGNRCQCZkGJRwRmQYlHCEGNRCQDZkWJJ2ZFiWcGQYPEBGZBiUcKSYPHDPMPEHQkMPNBD1jw80QPEIQkgAEAAPMPEXQkMIuMJIgBAABIO9/zDxB8JDzzRA8QTCRED4JR/P//SIu0JEgBAABIYwZMi8A5RCRIdG+LVCRMS40MwP/IiQZIi0YIKVTImEiLzotGICtEJFApVhCJRiDopFP//0yLhCRYAQAAD7asJGgBAABMi7wkQAEAAPNBDywAZg9u8PNBDyxABA9b9mZED27wRQ9b9vMPEXQkMEUPL3UMD4ay+f//605Ii81IuGdmZmZmZmZmSCtOKEj36UuNDMBIwfoDSIvCSMHoP0gD0IlWIEmL10grVhhI0fqJVhBIi0YIK1QkVAFUyOBIiW5ATIl+SESJZjREDyikJJAAAABEDyicJKAAAABEDyiUJLAAAABEDyiMJMAAAABEDyiEJNAAAAAPKLwk4AAAAEyLtCQAAQAATIukJAgBAABIi7wkEAEAAEiLrCQYAQAASIucJFABAABEDyisJIAAAAAPKLQk8AAAAEQPKHQkcEQPKHwkYEiBxCABAABBX0FdXsPMzMzMzMzMzMxIgeyIAAAASItBOEyL0Q8pdCRwD1fSDyl8JGAPV+1EDylEJFAPV9vzDxBwIA9X5EQPKUwkQA8ozvMPWTVkFDYAD1f/SImUJJAAAABBi8nzD1kNPhQ2AEUPV8BEDyjO8w9ZtCSwAAAA8w9ZjCSwAAAA8w9YtCSUAAAA80QPWIwkkAAAAEWFyXReg+kBdFSD6QF0CYP5AQ+FjQAAAEGD+QJ1Bw9XDegXNgAPKOEPKOnzD1klKhU2AA8o2fMPWR0jFTYADyj58w9ZPQgUNgBEDyjE8w9Z6g8o0fMPWRXlEzYA60dFhcl1Bw9XDaMXNgAPKNkPKMHzD1kd5RQ2AA8o6fMPWS2+EzYADyjh8w9ZJcMTNgBEDyjB80QPWQXGFDYADyj78w9Zwg8o0EEPKMFEiUQkIA8ozvMPWMfzQQ9YyEmLykyNjCSQAAAATI1EJDBIjVQkOPMPEYQkkAAAAEEPKMHzDxGMJJQAAADzD1jDDyjO80QPWM3zD1jM8w9Y8vMPEUQkMPNEDxFMJDjzDxFMJDTzDxF0JDzoBn3//w8odCRwDyh8JGBEDyhEJFBEDyhMJEBIgcSIAAAAw8zMzMzMzMzMQFNVVldIgeyIAAAADyl0JHBBi+hEi0FUSIvxi0lQvwgAAAAPKXwkYEQPKUQkUEQPKUwkQEQPKMtIiVQkMPNED14NLhM2APNED18N1RI2AEEPKMFBDyj58w9ZBYUSNgDzD1k9VRI2APMPXNhEDyjH8w9YfCQ080QPWEQkMA8o8/MPXjXdEjYA8w9Y+/NED1jGDyjG8w9ZBUkSNgDzD1z4QQ8owPMPXMYPKM/zDxFEJDDzD1zO8w8RTCQ0QTvIdSb/wUWFwHQNQYvAmSvC0fhBA8DrAovHO8EPT8iL0UiNTlDo28T+/0iLRCQwSGNWUEiLTljzRA8RRCQw8w8RfCQ0SIkE0YtOUP/BiU5QRItGVEE7yHUm/8FFhcB0DUGLwJkrwtH4QQPA6wKLxzvBD0/Ii9FIjU5Q6IbE/v9Ii0QkMPMPWPZIY1ZQSItOWA8oxvMPXP5IiQTR80EPWMCLTlD/wYlOUESLRlTzDxFEJDDzDxF8JDRBO8h1I//BRYXAdAxBi8CZK8LR+EGNPAA7+Q9Pz4vRSI1OUOglxP7/TGNGUDP/SItWWESLzUiLRCQwSIvO80QPEUwkKIl8JCBKiQTC/0ZQRItGUEiLVljoMVX//w8odCRwDyh8JGBEDyhEJFBEDyhMJECJflBIgcSIAAAAX15dW8PMzMzMzMzMzMzMzMxIi8TzDxFYIFVXQVRBVkiNaLFIgezoAAAARA8pSJhFi+DzRA8QTXdMi/JEDyl0JFBIi/lEDyjzRQ8v8Q+H+AUAAPMPEFoEDyl4uPMPEH1/RA8pQKhFD1fAQQ8u+EQPKWQkcPNEDxBiDPNEDxFkJDTzRA8RdCQ48w8RXXfzDxFdg/NEDxFMJDBMiXjYeih1JkUz/0iNVCQ4RYvIRIl8JChMjUQkMPNEDxFEJCDogHj//+llBQAA8w8QUghBDyjMSIm0JBgBAADzD1zLDym0JNAAAADzDxAy8w9c1kQPKZQkkAAAAEQPKZwkgAAAAPMPWQ3wDzYA80QPEB0nEDYA8w9ZFd8PNgBEDylsJGBEDyl8JEDzD13R80EPXNNEDy/CdgUPV//rBPMPXfrzRA8QPQoQNgBFDyjT80QPXtdBDyjGQQ8oy/MPXMbzRA8RVCQw80EPWcLzD1zIRA8vwXIGRQ8o7+sYQQ8vy3IGRQ9X7esMDyjB6B+nBQBEDyjoQQ8oyUEPKMPzD1zO80EPWcrzD1zBRA8vwHIGRQ8o1+sVQQ8vw3IGRQ9X0usJ6OmmBQBEDyjQ8w9Y90iJnCQQAQAARTP/vggAAABFDy7q80QPX/YPiroAAAAPhbQAAACLT1REi0dQ80QPEXQkOPNEDxFlg0Q7wXUnQf/Ahcl0C4vBmSvC0fgDwesCi8ZBO8BIjU9QRA9PwEGL0Oimwf7/SItEJDhIY1dQSItPWPNEDxF0JDjzRA8QdXfzRA8RdYNIiQTRi09Q/8GJT1BEi0dUQTvIdSb/wUWFwHQNQYvAmSvC0fhBA8DrAovGO8EPT8iL0UiNT1DoS8H+/0hjV1BIi09YSItEJDhIiQTR/0dQ6QoBAABFDy7oenl1d0UPLtd6cXVvQQ8oxPNEDxF0JDjzD1zHx0QkIAYAAABBuQMAAABIjVQkOA8o10iLz/MPEUWD6JBr///zRA8RdCQ4SI1UJDjzRA8QdXcPKMfzQQ9YxsdEJCAJAAAAQbkGAAAADyjXSIvP8w8RRYPoWGv//+mLAAAA8w8QNVMONgBIjVQkOA8ozkSJfCQoQQ8oxPNEDxF0JDgPKN7zQQ9czfMPXMcPKNfzQQ9c2kiLz/MPEUwkIPMPEUWD6Jxr///zRA8RdCQ480QPWO7zRA8QdXfzRA9Y1g8ox0SJfCQo80EPWMYPKNdIjVQkOEiLz0EPKN3zRA8RVCQg8w8RRYPoWGv//w8ox/NBD1gGRA8vyA+GIwIAAPNFDxBuCEEPKMvzDxB0JDBBDyjF80EPXMHzD1nG8w9cyEQPL8FyBkUPKNfrGEEPL8tyBkUPV9LrDA8oweirpAUARA8o0EEPKM1BDyjD8w9cTW/zD1nO8w9cwUQPL8ByBkEPKPfrE0EPL8NyBQ9X9usI6HakBQAPKPBEDy7W80QPXO/zRQ9dzQ+KsAAAAA+FqgAAAESLR1SLT1DzRA8RTCQ480QPEXWDQTvIdSb/wUWFwHQNQYvAmSvC0fhBA8DrAovGO8EPT8iL0UiNT1DoRL/+/0iLRCQ4SGNXUEiLT1jzRA8RTCQ480QPEWWDSIkE0YtPUP/BiU9QRItHVEE7yHUj/8FFhcB0DEGLwJkrwtH4QY00ADvxD0/Oi9FIjU9Q6PK+/v9IY1dQSItPWEiLRCQ4SIkE0f9HUOnmAAAARQ8u0HprdWlBDy73emN1YQ8ox/NEDxFMJDjzQQ9YxsdEJCAMAAAAQbkJAAAASI1UJDgPKNdIi8/zDxFFg+g3af//80QPXOfzRA8RTCQ4RTPJx0QkIAMAAAAPKNdIjVQkOEiLz/NEDxFlg+gKaf//63VBDyjSRIl8JCgPVxVoDzYASI1UJDgPKMfzDxFUJCDzQQ9YxvNEDxFMJDgPKN4PKNcPVx1BDzYASIvP8w8RRYPoVGn///NED1znRIl8JChBDyja80QPEUwkOA8o1/MPEXQkIEiNVCQ4SIvP80QPEWWD6CNp//9Ei0dQRYvMSItXWEiLz+hAXv//RA8ofCRARA8obCRgRA8onCSAAAAARA8olCSQAAAADyi0JNAAAABIi7QkGAEAAEiLnCQQAQAARIl/UEyLvCTgAAAADyi8JMAAAABEDyiEJLAAAABEDyhkJHBEDyiMJKAAAABEDyh0JFBIgcToAAAAQV5BXF9dw8zMzMzMzMzMzMxIiVwkCFVWV0FUQVVBVkFXSIvsSIPsYPMPEEIITIvx8w8QCkiL+vNBDxAQQYvx80EPEFgESYvY80EPEGAMDy/RDyl0JFDzDxB1YA+XwEEPL0AIiEVQ8w8QQgxBD5fFDy9aBA+XwQ8vxEQPtvmITdAPl8JBg/cBRA+24kGD9AGIVUiEwHRAQYvP8w8RVdTB4QRMjUXUQYvE8w8RZdjB4AZIjVXcC8jzDxFN3A+66QjzDxFd4IlMJChJi87zDxF0JCDoC3L//0WE7XRW8w8QRwhMjUXc8w8QSwxIjVXUQcHnBUSLzkHB5AdJi85FC/zzDxFF3PMPEEMIQQ+67wjzDxFN4PMPEEsERIl8JCjzDxF0JCDzDxFF1PMPEU3Y6LBx//9ED7Zl0EWE5HRk8w8QQwhMjUXc8w8QSwRIjVXURA+2fVBEi85Bi8dBD7bNg/EB8w8RRdzzDxADg/ABweEFweAEC8jzDxFN4PMPEE8ED7rpCIlMJChJi87zDxFF1PMPEU3Y8w8RdCQg6ERx///rBUQPtn1QgH1IAHRe8w8QQwhMjUVQ8w8QTwxIjVXcQQ+2zUSLzoPxAUEPtsfB4QeD8AHB4AYLyPMPEUVQ8w8QAw+66QiJTCQoSYvO8w8RTVTzDxBLDPMPEUXc8w8RTeDzDxF0JCDo2XD//0WE/3RMRYTkdEfzDxADTI1FUPMPEEsESI1V3PMPEUVQRIvO8w8QB0mLzvMPEU1U8w8QTwTHRCQoEAAAAPMPEUXc8w8RTeDzDxF0JCDoiHD//0WE7XRORYTkdEnzDxBHCEyNRVDzDxBLBEiNVdzzDxFFUESLzvMPEEMISYvO8w8RTVTzDxBPBMdEJCggAAAA8w8RRdzzDxFN4PMPEXQkIOg1cP//D7ZFSEWE/3RPhMB0S/MPEANMjUVQ8w8QTwxIjVXc8w8RRVBEi87zDxAHSYvO8w8RTVTzDxBLDMdEJChAAAAA8w8RRdzzDxFN4PMPEXQkIOjhb///D7ZFSEWE7XRNhMB0SfMPEEcITI1FSPMPEE8MSI1VUPMPEUVIRIvO8w8QQwhJi87zDxFNTPMPEEsMx0QkKIAAAADzDxFFUPMPEU1U8w8RdCQg6Itv//9Ii5wkoAAAAA8odCRQSIPEYEFfQV5BXUFcX15dw8zMzMzMzMzMzMzMzMzMSIlcJAhXSIPsIA+2EUiL2YD6IA+CtQEAAEyNSQGA+oAPgqUAAABBD7YBRI1CgUiLDatDNwBIi9FFi8hIK9BMA8lIiwWIQzcASP/KTDvIdhlIg8MCTIkNhUM3AEiLw0iLXCQwSIPEIF/DSDsVaEM3AHMcSP/ASIPDAkiJBWBDNwBIi8NIi1wkMEiDxCBfw0WFwHQmDx9AAGYPH4QAAAAAAA+2AkiNUgGIAUj/wUGDwP917kiJDSdDNwBIg8MCSIvDSItcJDBIg8QgX8OA+kAPgqcAAABED7ZBAkiLwkiLDf1CNwBB/8BIweAISIvRSCvQQQ+2AUgr0EWLyEiLBc9CNwBIgcL/PwAATAPJTDvIdhlIg8MDTIkNxUI3AEiLw0iLXCQwSIPEIF/DSDsVqEI3AHMeSP/ASIPDA0iJBaBCNwBIi8NIi1wkMEiDxCBfw2aQD7YCSI1SAYgBSP/BQYPA/3XuSIPDA0iJDXNCNwBIi8NIi1wkMEiDxCBfw0iLDV5CNwCNQuFEi8BIjTwISIsFPUI3AEg7+HcXTDsNKUI3AHMGSI14AesISYvR6KWbBQAPtgNIg8PiSAPYSIk9IEI3AEiLw0iLXCQwSIPEIF/DgPoYD4K1AAAARA+2SQNIi8oPtkMBQf/BSIsV80E3AEjB4QhMi8JIA8gPtkMCSMHhCEwrwUGLyUwrwEgDykiLBb5BNwBJgcD//xcASDvIdhlIg8MESIkNt0E3AEiLw0iLXCQwSIPEIF/DTDsFmkE3AHMgSP/ASIPDBEiJBZJBNwBIi8NIi1wkMEiDxCBfww8fQABBD7YATY1AAYgCSP/CQYPB/3XtSIPDBEiJFWJBNwBIi8NIi1wkMEiDxCBfw4D6EA+CugAAAA+2SQMPtkMBRA+2SwTB4Qj/wUQDyUiLykiLFSxBNwBIweEITIvCSAPID7ZDAkjB4QhMK8FBi8lMK8BIA8pIiwX3QDcASYHA//8PAEg7yHYZSIPDBUiJDfBANwBIi8NIi1wkMEiDxCBfw0w7BdNANwBzHEj/wEiDwwVIiQXLQDcASIvDSItcJDBIg8QgX8NBD7YATY1AAYgCSP/CQYPB/3XtSIPDBUiJFZ9ANwBIi8NIi1wkMEiDxCBfw4D6CHJ4RA+2QwFMjUkCSIsFbEA3AEmBwAH4//9Ii8pIweEITAPBSIsNZEA3AEWLwEmNPAhIO/h3F0w7DTlANwBzBkiNeAHrCEmL0ei1mQUAD7YLD7ZDAUgDw0jB4QhIiT0sQDcASI2ZA/j//0gD2EiLw0iLXCQwSIPEIF/DgPoHdW1ED7ZDAkiNUQMPtkkBSIsF6z83AEjB4QhI/8FMA8FIiw3qPzcASY08CEg7+HcUSDsVwj83AHMGSI14AesF6EGZBQAPtksBD7ZDAkgDw0jB4QhIiT23PzcASI1ZBEgD2EiLw0iLXCQwSIPEIF/DgPoGD4W1AAAARA+2SQQPtkkBQf/BD7ZDAkiLFYI/NwBIweEITIvCSAPID7ZDA0jB4QhMK8FBi8lMK8BIA8pIiwVNPzcASf/ISDvIdhlIg8MFSIkNSj83AEiLw0iLXCQwSIPEIF/DTDsFLT83AHMjSP/ASIPDBUiJBSU/NwBIi8NIi1wkMEiDxCBfww8fgAAAAABBD7YATY1AAYgCSP/CQYPB/3XtSIPDBUiJFfI+NwBIi8NIi1wkMEiDxCBfw4D6BA+FqQAAAA+2SQQPtkMCSIsVzD43AEQPtksFTIvCweEI/8FEA8kPtksBSMHhCEgDyA+2QwNIweEITCvBQYvJTCvASAPKSIsFhj43AEn/yEg7yHYZSIPDBkiJDYM+NwBIi8NIi1wkMEiDxCBfw0w7BWY+NwBzHEj/wEiDwwZIiQVePjcASIvDSItcJDBIg8QgX8NBD7YATY1AAYgCSP/CQYPB/3XtSIkVNj43AEiDwwZIi8NIi1wkMEiDxCBfw8zMzMxIhckPhLkAAABIiVwkCFdIg+wgSIvZSItJCEiFyXQISIvT6Jms//8z/4l7MDPAiEM0SIk7SI1LOOgTpP7/SI1LIOgKpP7/kEyLBeI6NwBNhcB0XEWLSARJD7+QHCsAAEmNiCArAABIjQzRRDkJdDWNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJCYl5BGb/QQZB/4AYKwAASIvL/xWw5QUASItcJDBIg8QgX8PMzMzMzMzMzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0iD7CBIi/FIi1kQSGNBCEiNPMMz7Ug73w+EjQAAAGaQTIsLTYXJdG1MiwUhOjcATYXAdGFFi1AESQ+/kBwrAABJjYggKwAASI0M0UQ5EXQ6jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/BSY2IICsAAEiNDMFEiRFBiazAJCsAAGb/QQZB/4AYKwAASYvJ/xXq5AUASIPDCEg73w+Fdf///0yLThBNhcl0c0yLBZU5NwBNhcB0XUWLUARND7+YHCsAAEmNkCArAABKjRTaRDkSdDZBjUsBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/RSIHCZAUAAEmNFNBEiRKJagRm/0IGQf+AGCsAAEmLyf8VYuQFAJBIi1wkMEiLbCQ4SIt0JEBIg8QgX8PMzMzMSIlcJBhXSIPsIEiL2Yv6i0kEO9EPjgQBAABIiXQkOIXJdAuLwZkrwtH4A8HrBbgIAAAAO8eL9w9P8DvxD47KAAAASGPOSMHhAkiJbCQw6E1b/P9Ii1MISIvoSIXSD4SLAAAATGMDSIvIScHgAugClQUATItLCE2FyXRqTIsFjjg3AE2FwHReSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0N41KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIM8BEiRGJQQRm/0EGQf+AGCsAAEmLyf8VWuMFAEiJawhIi2wkMIlzBEiLdCQ4iTtIi1wkQEiDxCBfw0iLdCQ4iTtIi1wkQEiDxCBfw4k7SItcJEBIg8QgX8PMzMzMzEiJXCQQSIl0JBhXSIPsIEiL2UiL8otJBIs7O/kPhdsAAAD/x4XJdAuLwZkrwtH4A8HrBbgIAAAAO8cPT/g7+Q+OuAAAAEhjx0hryCxIiWwkMOgaWvz/SItTCEiL6EiF0g+EiwAAAEhjC0xrwSxIi8joz5MFAEyLSwhNhcl0akyLBVs3NwBNhcB0XkkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyDPARIkRiUEEZv9BBkH/gBgrAABJi8n/FSfiBQBIiWsISItsJDCJewRIYwMPEAZIa9AsSANTCA8RAg8QThAPEUoQ8g8QRiDyDxFCIItGKEiLdCRAiUIo/wNIi1wkOEiDxCBfw8zMzMzMzMzMSIlcJBBIiXQkGEFWSIPsIEhj8kiL2YtJBE2L8DvxfiOFyXQLi8GZK8LR+APB6wW4CAAAADvGi9ZIi8sPT9Dozbv+/0xjA0E78A+OuwAAAEiJfCQwi/5BK/iD/wRybUiLUwhMjUsIRYsejUb/SGPITo0UgkiNBIpNO9F3BUk7wXNKTTvWdwVJO8ZzQIHnAwAAgH0H/8+Dz/z/x4vGQYvIK8dBg8AERDvAfPcrwUmL+oPAA5mD4gMDwsH4AkhjyEmLw0jB4QRIwekC86tJY9BIO9Z9Hw8fQABmDx+EAAAAAABIi0sIQYsGiQSRSP/CSDvWfO5Ii3wkMIkzSItcJDhIi3QkQEiDxCBBXsOJM0iLXCQ4SIt0JEBIg8QgQV7DzMzMSIlcJBBIiXQkGFdIg+wgSIvZSIv6i0kEizM78Q+F4wAAAP/Ghcl0C4vBmSvC0fgDwesFuAgAAAA7xg9P8DvxD47AAAAASGPGSIlsJDBIjQzASMHhBOi2V/z/SItTCEiL6EiF0g+EjwAAAEhjC0yNBMlIi8hJweAE6GeRBQBMi0sITYXJdGpMiwXzNDcATYXAdF5JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ3jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMgzwESJEYlBBGb/QQZB/4AYKwAASYvJ/xW/3wUASIlrCEiLbCQwiXMESGMDDygHDyhPEEiLdCRASI0MwEiLQwhIA8kPEQTIDyhHIA8RTMgQDyhPMA8RRMggDyhHQA8RTMgwDyhPUA8RRMhADyhHYA8RTMhQDyhPcA8RRMhgDyiHgAAAAA8RTMhwDxGEyIAAAAD/A0iLXCQ4SIPEIF/DzMzMzMzMSIlcJAhIiWwkEEiJdCQYV0FWQVdIg+wgTIvxM+2L/TkpD46xAAAAi/UPH4AAAAAASYteCEiLHB5IhdsPhIgAAABIi8vol2///0iNS0Dozpz+/5BMiwWmMzcATYXAdGFFi0gESQ+/kBwrAABJjYggKwAASI0M0UQ5CXQ6jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/BSY2IICsAAEiNDMFEiQlBiazAJCsAAGb/QQZB/4AYKwAASIvL/xVv3gUA/8dIg8YIQTs+D4xY////TYtOCE2FyXR5SYkuTIsFFTM3AE2FwHRdRYtQBE0Pv5gcKwAASY2QICsAAEqNFNpEORJ0NkGNSwG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv9FIgcJkBQAASY0U0ESJEolqBGb/QgZB/4AYKwAASYvJ/xXi3QUASYluCEiLXCRASItsJEhIi3QkUEiDxCBBX0FeX8PMzMzMzMzMzMzMzMzMSIlcJAhXSIPsIEhj+kiL2Tt5BA+OjwAAAEyLSQhNhcl0c0yLBVcyNwBNhcB0XkkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyDPARIkRiUEEZv9BBkH/gBgrAABJi8n/FSPdBQBIi89IweED6G9U/P9IiUMIiXsESItcJDBIg8QgX8PMzMzMzMzMzMzMzMzMSIlcJBBXSIPsIEhj+kiL2Tt5BA+OuAAAAEiLz0iJdCQwSMHhBegmVPz/SItTCEiL8EiF0g+EiwAAAExjA0iLyEnB4AXo240FAEyLSwhNhcl0akyLBWcxNwBNhcB0XkkPv5AcKwAASY2IICsAAEWLUARIjQzRRDkRdDeNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyDPARIkRiUEEZv9BBkH/gBgrAABJi8n/FTPcBQBIiXMISIt0JDCJewRIi1wkOEiDxCBfw8zMzMxIiXQkIFdBVkFXSIPsIItBBESNeh+ZQYPn4IPiH0iL+QPCwfgFTGPwQYvHmYPiHwPCwfgFSGPwQTv2D46fAQAAi0kMSIlcJEBMiWQkUEUz5DvxD47bAAAAhcl0C4vBmSvC0fgDwesFuAgAAAA7xoveD0/YO9kPjrgAAABIY8tIweEDSIlsJEjo5FL8/0iLVxBIi+hIhdIPhIsAAABMY0cISIvIScHgA+iYjAUATItPEE2FyXRpTIsFJDA3AE2FwHRdSQ+/kBwrAABJjYggKwAARYtQBEiNDNFEORF0No1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkRRIlhBGb/QQZB/4AYKwAASYvJ/xXx2gUASIlvEEiLbCRIiV8MiXcISYveTDv2D42PAAAAuQANAAD/FbPaBQBMiwWMLzcATIvITYXAdGFJD7+AHCsAAEmNkCArAABFi1AESI0UwkQ5EnQ6jUgBuKuqqir36YvCwegfA9CNBFIDwEmNkCArAAAryEgPv8FmQYmIHCsAAEiNFMJEiRJFiaTAJCsAAGb/QgRB/4AUKwAASItHEEyJDNhI/8NIO94PjHH///9Mi2QkUEiLXCRARIl/BEiLdCRYSIPEIEFfQV5fw8zMSIlUJBBMiUQkGEyJTCQgU1ZXSIPsMEiL+kiNdCRgSIvZ6PrK+/9FM8lIiXQkIEyLx0iL00iLCP8VW9sFAEiDxDBfXlvDzMzMzMzMzMzMzMxIiVwkGEiJbCQgVldBVkiB7JAAAABIiwXEEjcASDPESIlEJHBIizV1LjcAM+1Ii/pIi9lIhfZ0CUiLttgAAADrA0iL9fMPEEEwTI1EJEjzD1lBKEiLAroBAAAAiWwkWMdEJFwAAIA/8w8RRCRQ8w8QQTTzD1lBLEiLz0iJbCRI8w8RRCRU/5BgAQAASIsHSI1MJDBIi1Y4QbkEAAAASIlMJChFM8BIi8+JbCQg/1BwhcAPhbcAAADzDxBjIEUzwPMPEGskDyjc8w9YWyjzDxAVXPQ1AEiLz0iLRCQwDyjCDym0JIAAAAAPKPXzD1hzLA8oy/MPXMzzD17BDyjO8w8RAPMPWM1IiWgEDyjFSIloDPMPXMbzD1z18w9e0A8ow/MPEVAU8w9YxEiJaBjzD1zjSIloIEjHQCgAAAA/8w9ezvMPXsTzDxFAMPMPEUg0x0A4AAAAP8dAPAAAgD9IiwdIi1Y4/1B4Dyi0JIAAAABIiwdIi8/HRCREFAAAAIlsJEBIi1Yw/5CIAAAASIsHSI1MJEBIiUwkKEyNThhIjUwkRDPSSIlMJCBBuAEAAABIi8//kJAAAABIiwdFM8lIi1YgQbg5AAAASIvP/5CYAAAASIsHugQAAABIi8//kMAAAABIiwdFM8lIi1YoRTPASIvP/1BYSIsHTI1OODPSQbgBAAAASIvP/1A4SIsHRTPJSItWQEUzwEiLz/9QSEiLB0yNTkgz0kG4AQAAAEiLz/9QUEiLB0UzyUUzwDPSSIvP/5C4AAAASIsHRTPJRTPAM9JIi8//kOABAABIiwdFM8lFM8Az0kiLz/+QAAIAAEiLB0UzyUUzwDPSSIvP/5AoAgAASIsHTI1EJGAPV8BBuf////8PEUQkYEiLVlhIi8//kBgBAABIiwdFM8BIi1ZgSIvP/5AgAQAASIsHSIvPSItWUP+QWAEAAEiLTCRwSDPM6J12BQBMjZwkkAAAAEmLWzBJi2s4SYvjQV5fXsPMzMzMzEBVQVVIjawkuOT//7hIHAAA6AqJBQBIK+BIiwXQDzcASDPESImF6BoAAA9XwEiJTCQwDy9BKEyL6Q+DrAkAAA8vQSwPg6IJAABIiZwkaBwAAEiJvCR4HAAATImkJEAcAABFM+RMibQkOBwAAEyLNT0rNwBNhfZ0CU2LttgAAADrA02L9EiLQUBJi34ISIm0JHAcAABIhcB0LkiLWAhIYwBIjTTDSDvedB4PH4AAAAAASIsLRDlhBHQF6DIKAABIg8MISDvedelJi04YSIXJdBRBi0UMQTlGaH1nSIsB/1AQTYlmGEGLRQxNjU4YSYsOSI2V0BoAAAWIEwAATIml4BoAAEGJRmhFM8DHhdQaAAACAAAAx4XYGgAAAQAAAI0EgMeF3BoAAAAAAQDB4AKJhdAaAABIiwH/UBiFwA+IgggAAEmLTiBIhcl0FEGLRQhBOUZsfWNIiwH/UBBNiWYgQYtFCE2NTiBJiw5IjZXQGgAABRAnAABMiaXgGgAAQYlGbEUzwAPAx4XUGgAAAgAAAImF0BoAAMeF2BoAAAIAAADHhdwaAAAAAAEASIsB/1AYhcAPiAwIAABIiwdIjU2ASYtWGEG5BAAAAEiJTCQoRTPASIvPRIlkJCD/UHCFwA+F4AcAAEiLB0iNTZBJi1YgQbkEAAAASIlMJChFM8BIi89EiWQkIP9QcIXAD4W0BwAASItFkEmLdRhMibwkMBwAAEyLfYAPKbQkIBwAAEiJRCRASWNFEA8pvCQQHAAARA8phCQAHAAARA8pjCTwGwAASI0Exkg78HRcTItkJEBMi+iQSIseSYvPSGNDIEiLUyhMjQSAScHgAuiZhQUATGNDEEmLzEiLUxhNA8DohoUFAEhjQyBIg8YISI0MgEhjQxBNjTyPTY0kREk79XW1TItsJDBFM+RIiwdFM8BJi1YYSIvP/1B4SIsHRTPASYtWIEiLz/9QeDPSSI1NqEG4IBsAAOg2hQUAx0WkEAAAAEyNRajHRaAQAAAASI1VoEiLB0iLz/+QAAMAAEiLB0yNhagAAABIjVWkSIvP/5D4AgAASIsHSI2VKAIAAEiLz/+Q8AIAAEiLB0yNjUgCAABMjYU4AgAASIvPSI2VMAIAAP+Q2AIAAEiLB0yNhUwCAABIjZVQAgAASIvP/5DgAgAASIsHTI2NWAIAADPSQbgBAAAASIvP/5BIAgAASIsHTI2NYAIAADPSQbgBAAAASIvP/5BYAgAAx4WIAgAAAAEAAEyNjYACAADHhYQCAAAAAQAATI2FkAIAAMeFgAIAAAABAABIjZVoAgAASIsHSIvP/5BQAgAASIsHTI2NhAIAAEyNhZAKAABIi89IjZVwAgAA/5BgAgAASIsHTI2NqBoAADPSQbgBAAAASIvP/5BAAgAASIsHTI2NiAIAAEyNhZASAABIi89IjZV4AgAA/5CQAgAASIsHSI2VkBoAAEiLz/+QmAIAAEiLB0yNjbAaAABMjYW8GgAASIvPSI2VmBoAAP+QgAIAAEiLB0iNjbgaAABIiUwkKEyNjaAaAABIjY20GgAAM9JIiUwkIEG4AQAAAEiLz/+QeAIAAEiLB0iNlcAaAABIi8//kHACAABIi9dJi83oTvj//0mLBkGL1EiLDeEmNwBIiUQkYEmLRghIiUQkaEmLRkhIiUQkcEmLRjhIiUQkeEiNRCRgSImBkAwAAE2LRRhJY0UQ80EPEHUg80EPEH0k80UPEEUw80UPEE00SY0EwEiJTCRQQYvMiUwkMIlUJDhMiUQkQEiJRCRITDvAD4R5AQAADx9AAGZmDx+EAAAAAABJizBFi/SDPgAPjjwBAABNi/xEi2QkMGYPH4QAAAAAAEiLXghJA99Ii0MwSIXAdCNIg/j4dRBIi9dJi83of/f//+ngAAAASIvTSIvO/9Dp0wAAAPMPEBPzDxBbCPMPXNbzDxBDBPMPXN7zDxBLDPMPXMfzD1zP80EPWdDzQQ9Z2PNBD1nBDy/T80EPWckPg5MAAAAPL8EPg4oAAADzDyzCTI2F0BoAALoBAAAASIvPiYXQGgAA8w8swImF1BoAAPMPLMOJhdgaAADzDyzBiYXcGgAASIsH/5BoAQAASItDEEiFwHQGSItAEOsESItDGEiJRCRYTI1MJFhIiwcz0kG4AQAAAEiLz/9QQESLTCQ4SIvPRItDJEiLB0UDxEQDSyCLUyj/UGBB/8ZJg8dIRDs2D4zq/v//i0wkMEUz5ItUJDhMi0QkQEiLRCRIA04QSYPACANWIIlMJDCJVCQ4TIlEJEBMO8APhZX+//9Ii0QkUEyNRahIi89MiaCQDAAASIsHi1Wg/5BoAQAASIsHTI2FqAAAAItVpEiLz/+QYAEAAEiLB0iLz0iLlSgCAAD/kFgBAABIi40oAgAARA8ojCTwGwAARA8ohCQAHAAADyi8JBAcAAAPKLQkIBwAAEyLvCQwHAAASIXJdAZIiwH/UBBIiwdMjYU4AgAARIuNSAIAAEiLz0iLlTACAAD/kBgBAABIi40wAgAASIXJdAZIiwH/UBBIiwdIi89Ei4VMAgAASIuVUAIAAP+QIAEAAEiLjVACAABIhcl0BkiLAf9QEEiLB0yNjVgCAAAz0kG4AQAAAEiLz/9QQEiLjVgCAABIhcl0BkiLAf9QEEiLB0yNjWACAAAz0kG4AQAAAEiLz/9QUEiLjWACAABIhcl0BkiLAf9QEEiLB0yNhZACAABEi42AAgAASIvPSIuVaAIAAP9QSEiLjWgCAABIhcl0BkiLAf9QEIuVgAIAAEGL3IXSdCKQi8NIi4zFkAIAAEiFyXQMSIsB/1AQi5WAAgAA/8M72nLfSIsHTI2FkAoAAESLjYQCAABIi89Ii5VwAgAA/1BYSIuNcAIAAEiFyXQGSIsB/1AQSIsHTI2NqBoAADPSQbgBAAAASIvP/1A4SIuNqBoAAEiFyXQGSIsB/1AQSIsHTI2FkBIAAESLjYgCAABIi89Ii5V4AgAA/5C4AAAASIuNeAIAAEiFyXQGSIsB/1AQi5WEAgAAhdJ0LA8fhAAAAAAAQYvESIuMxZAKAABIhcl0DEiLAf9QEIuVhAIAAEH/xEQ74nLcSIsHSIvPi5WQGgAA/5DAAAAASIsHSIvPRIuNsBoAAESLhbwaAABIi5WYGgAA/5CYAAAASIuNmBoAAEiFyXQGSIsB/1AQSIsHSI2NuBoAAEiJTCQoTI2NoBoAAEiNjbQaAAAz0kiJTCQgQbgBAAAASIvP/5CQAAAASIuNoBoAAEiFyXQGSIsB/1AQSIsHSIvPSIuVwBoAAP+QiAAAAEiLjcAaAABIhcl0BkiLAf9QEEiLtCRwHAAASIu8JHgcAABMi6QkQBwAAEiLnCRoHAAATIu0JDgcAABIi43oGgAASDPM6IZsBQBIgcRIHAAAQV1dw8zMzMzMzMzMzMzMQFNIg+wgSIl8JDhIi9lIi3kISIX/D4SYAAAASItPCEiJdCQwSIsB/1AQSIsPSIsB/1AQTIsFZiE3ADP2TYXAdFxJD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJcQRm/0EGQf+AGCsAAEiLz/8VMswFAEiJcxBIiXMISIt0JDCAe1cASIt8JDjHQwQBAAAAdQfHQwQCAAAASIPEIFvDzMzMzMzMzMzMzMzMzMxAVVdBVEFWSI1sJMFIgey4AAAASIsF5gQ3AEgzxEiJRSdIiwWYIDcARTPkSIv5SIXAdAlMi7DYAAAA6wNNi/SLQQRIiZwk6AAAAEiJtCTwAAAAg/gCD4UqAQAASItZKLkQAAAA/xV2ywUATIsFTyA3AEiL8E2FwHRcSQ+/kBwrAABJjYAgKwAARYtIBEiNBNBEOQh0NY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/wUgFZAUAAEmNBMBEiQhEiWAEZv9ABEH/gBQrAABIhfZ0CA9XwA8RBusDSYv0i08cTI1Fx4tHIEiNVd+JReNMi86JTd+NBI0AAAAASMdF8wEAAABJiw5MiWUDx0XnAQAAAMdF6wEAAADHRe8cAAAARIll+8dF/wgAAABIiV3HiUXPRIll00iLAf9QKItF50yNTghJiw5MjUUPTIllH8dFDxwAAABIx0UTBAAAAIlFG0iLAUiLFv9QOEiLRghIiUcQRIlnBEiJdwjpxQAAAIP4Aw+FrAAAAEiLWUhIY0FATIm8JLAAAABMi3kISI00w0g73g+EfQAAAJBED7cLRA+3UwIPt0MERItHJEEDwUQPr0ccSYtOCESJVcuJRdMPt0MGQQPCRIlNx0QPr1ccRIllz4lF18dF2wEAAABIiwFFA9FEiWQkMEQPr1ckTI1Nx0SJRCQoRTPASWPSSANXKEiJVCQgSYsX/5CAAQAASIPDCEg73nWETIu8JLAAAABEiWcE6xCD+AR1C0Q5YVB+BejW/P//SIu0JPAAAABIi5wk6AAAAEiLTSdIM8zoKmkFAEiBxLgAAABBXkFcX13DzMzMzMzMzMzMzMzMQFVBVkFXSI2sJOD+//9IgewgAgAASIsFZAI3AEgzxEiJhRABAABMizUTHjcARTP/TYX2dAlNi7bYAAAA6wNNi/dIiZwkQAIAAEiJtCRIAgAASIm8JFACAABMiaQkWAIAAE05Pg+EoAAAAOjBAwAATIl8JFBIjUQkYEiJRCRITI0ll5w1AESJfCRASI0Fg5w1AESJfCQ4SI0NA5g1AEiJRCQwRTPJTIlkJChFM8C63QIAAEyJfCQg/xWDwQUAhcB4SUmLNkiLTCRgSIsGSIt4YEiLAf9QIEiLTCRgSIvYSIsR/1IYSY1WKEUzyUiJVCQgTIvDSIvQSIvO/9dIi0wkYIXAdERIiwH/UBAywEyLpCRYAgAASIu8JFACAABIi7QkSAIAAEiLnCRAAgAASIuNEAEAAEgzzOjVZwUASIHEIAIAAEFfQV5dw0mLNkiNBdabNQBIiYWwAAAASI0F2Js1AEiJhdAAAABIjQXWmzUASImF8AAAAESJvbgAAABIx4W8AAAAEAAAAEyJvcQAAABEib3MAAAARIm92AAAAEjHhdwAAAAQAAAASMeF5AAAAAgAAABEib3sAAAARIm9+AAAAEjHhfwAAAAcAAAASMeFBAEAABAAAABEib0MAQAASIsGSIt4WEiLAf9QIEiLTCRgSIvYSIsR/1IYSY1WMEG4AwAAAEiJVCQoTIvISI2VsAAAAEiJXCQgSIvO/9dIi0wkYIXASIsBD4Xc/v///1AQSYsOTY1OOEyJfCR4SI1UJGjHRCRoQAAAAEUzwMdEJGwCAAAAx0QkcAQAAADHRCR0AAABAEiLAf9QGEyJfCRQSI1EJGBIiUQkSEiNDQKZNQBEiXwkQEiNBcKaNQBEiXwkOEUzyUiJRCQwRTPATIlkJCi6kQEAAEyJfCQg/xWRvwUAhcAPiFP+//9JizZIi0wkYEiLBkiLeHhIiwH/UCBIi0wkYEiL2EiLEf9SGEmNVkBFM8lIiVQkIEyLw0iL0EiLzv/XSItMJGCFwEiLAQ+FBv7///9QEDPASI1NxTPSiUWkQbjjAAAA6JB3BQBJiw5NjUZYZg9vBVfjNQBIjVWgRIl9oMdFqAEAAADHRawFAAAAZg9/RbDHRcABAAAAxkXED0iLAf+QoAAAAEmLDk2NRlAPV8BMiX2I8w9/RCRwx0QkaAMAAABIjVQkaMdEJGwBAAAAx0WEAQAAAMdFgAEAAABIiwH/kLAAAABmD28FcOI1AE2NRmBJiw5IjVQkaPMPf0QkaMdFhAEAAADHRYABAAAAx0QkfAEAAADHRYgIAAAADxBEJHxEiXwkeA8RRYxIiwH/kKgAAABJiw5NjUZIZg9vDXviNQBIjVQkaA9XwEyJfCR48w9/RYTHRYAIAAAA8w9/TCRoTIl9lEiLAf+QuAAAALAB6eT8///MzMzMzMzMzEiJbCQYV0iD7CBIiwX/GTcAM+1IhcB0CUiLuNgAAADrA0iL/Ug5Lw+EAwEAAEiJXCQwSIuYeA0AAEhjgHANAABIiXQkOEiNNMNIO950GmaQSIsLZoN5VAF1BegR+P//SIPDCEg73nXoSItPSEiLdCQ4SItcJDBIhcl0CkiLAf9QEEiJb0hIi08gSIXJdApIiwH/UBBIiW8gSItPGEiFyXQKSIsB/1AQSIlvGEiLT1hIhcl0CkiLAf9QEEiJb1hIi09gSIXJdApIiwH/UBBIiW9gSItPUEiFyXQKSIsB/1AQSIlvUEiLT0BIhcl0CkiLAf9QEEiJb0BIi084SIXJdApIiwH/UBBIiW84SItPMEiFyXQKSIsB/1AQSIlvMEiLTyhIhcl0CkiLAf9QEEiJbyhIi2wkQEiDxCBfw8zMzMzMSIlcJAhIiXQkEEiJfCQYVUFWQVdIjWwkuUiB7KAAAABIiwXp/DYASDPESIlFP0yLNcMYNwC5gAAAAEiLNccYNwBIiz2IGDcA/xWiwwUATIsFexg3AEUz/0iL2E2FwHRdSQ+/kBwrAABJjYggKwAARYtIBEiNDNFEOQl0No1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkJRIl5BGb/QQRB/4AUKwAASIXbdDIPV8APEQMPEUMQDxFDIA8RQzAPEUNADxFDUA8RQ2APEUNwx0NoiBMAAMdDbBAnAADrA0mL34FPNBgEAABIjQXjljUASImHyAAAAEiNFSWXNQBIiZ/YAAAASIvOQceAiAwAAABAAABBx4CEDAAAAEAAAEyNRS9MiX0vTIl9N0yJfSdIiwb/EIXAdUFIi00vTI1FN0iNFe2WNQBIiwH/UDCFwHUoSItNN0yNRSdIjRX0ljUASIsB/1AwhcB1D0iJM0yJcwhIi0UnSIlDEEiLTS9Ihcl0BkiLAf9QEEiLTTdIhcl0BkiLAf9QEEiLC0iLAf9QCEiLSwhIiwH/UAhIiwULFzcASI0NlAMAAEyJfddMiX3fTIl960iJiDgNAABIjQ1qBQAASImIQA0AAEiNDTwGAABIiYhIDQAASI0NLgcAAEiJiFANAABIjQ3QBwAASImIWA0AAEiNTddMiX0DRIl9C0yJfRfHReccAAAASMdF8wEAAADHRfsgAAAAx0X/AQAAAEjHRQ8BAAAA6J8BAACwAUiLTT9IM8zoQWEFAEyNnCSgAAAASYtbIEmLcyhJi3swSYvjQV9BXl3DzMzMzEiJXCQISIlsJBBIiXQkGEiJfCQgQVZIg+wgSIs9LxY3AEUz9kiF/3QJSIu32AAAAOsDSYv2SIufQCEAAEhjhzghAABIjSzDSDvddBUPH0AASIsL6Nje/f9Ig8MISDvdde/o2vv//0iLThBIhcl0BkiLAf9QEEiLDkiFyXQGSIsB/1AQSItOCEiFyXQGSIsB/1AQgWc05/v//0iNTnBMibfIAAAATIm32AAAAEyJt4QMAABMibeQDAAATIm3QA0AAEyJtzgNAABMibdIDQAATIm3WA0AAEyJt1ANAADoj37+/0yLBWgVNwBNhcB0XUkPv5AcKwAASY2IICsAAEWLSARIjQzRRDkJdDaNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8lIgcFkBQAASY0MyESJCUSJcQRm/0EGQf+AGCsAAEiLzkiLXCQwSItsJDhIi3QkQEiLfCRISIPEIEFeSP8lGsAFAMzMSIlcJBhIiXQkIEFWSIPsIEiLHckUNwBFM/ZIi/FIhdt0CUiLm9gAAADrA0mL3otLdIP5AQ+N8AAAAEiJfCQ4hcl0Hb8BAAAAi8GZK8LR+APBO8cPT/g7+Q+OxwAAAOsFvwgAAABIY8dIiWwkMEiNDMBIweED6PY2/P9Ii1N4SIvoSIXSD4SPAAAASGNLcEyNBMlIi8hJweAD6KZwBQBMi0t4TYXJdGlMiwUyFDcATYXAdF1JD7+QHCsAAEmNiCArAABFi1AESI0M0UQ5EXQ2jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiRFEiXEEZv9BBkH/gBgrAABJi8n/Ff++BQBIiWt4SItsJDCJe3RIi3wkOA8oBg8oThDHQ3ABAAAASItDeEiLXCRADxEADyhGIA8RSBAPKE4wDxFAIPIPEEZASIt0JEgPEUgw8g8RQEBIg8QgQV7DzMxIiVwkEEiJbCQYSIl0JCBXQVZBV0iB7JAAAABIiwWO9zYASDPESImEJIAAAABIizU8EzcAM9tIi+lIhfZ0CUiLttgAAADrA0iL87kQAAAA/xU7vgUATIsFFBM3AEiL+E2FwHRbSQ+/kBwrAABJjYAgKwAARYtIBEiNBNBEOQh0NI1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/wUgFZAUAAEmNBMBEiQiJWARm/0AEQf+AFCsAAEiF/3QJSIkfSIlfCOsDSIv7TIt9YEiJfUhNhf91BEyLfVhIi154SGNGcEiNDMBMjTTLSTvedHNmZg8fhAAAAAAA80gPLEUQSItOEEyLz0iLFkyNRCQwDxADDxBLEA8pRCQwDxBDIIlEJDDzSA8sRRQPKUwkQA8QSzCJRCQ0DylEJFDyDxBDQA8pTCRg8g8RRCRwTIl8JGBIiwH/UFCFwHkJSIPDSEk73nWXSItOEEG4AwAAAEmL10iLAf9QQEiLD0iFyXQ0SIsBTI1MJChMjQVlkTUAM9L/UEhIiw5MjU8ISItUJChFM8BIiwH/UEhIi0wkKEiLAf9QEEiLjCSAAAAASDPM6HhcBQBMjZwkkAAAAEmLWyhJi2swSYtzOEmL40FfQV5fw8zMzMzMzMzMzMzMSIlcJAhIiXQkEFdIg+wgSItZSEiL8UiF2w+EqwAAAEiLC0iFyXQGSIsB/1AQSItLCDP/SIk7SIXJdAZIiwH/UBBMiwU4ETcASIl7CE2FwHRcSQ+/kBwrAABJjYggKwAARYtIBEiNDNFEOQl0NY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkJiXkEZv9BBkH/gBgrAABIi8v/FQK8BQBIiX5ISItcJDBIi3QkOEiDxCBfw0iLXCQwM/9Ii3QkOEiJeUhIg8QgX8NIiVwkGFVWV0iD7FBIiwXN9DYASDPESIlEJEBIiwV+EDcAM+1IiVQkMEiFwHQJSIuw2AAAAOsDSIv1SItZSEiLSwhIhcl0CkiLAf9QEEiJawhIiwtIhcl0e/NMDyxMJDRIiWwkODPSSIsBiWwkKIlsJCDzTA8sRCQw/1BoSIsLTI1MJDhMjQWdjzUAM9JIiwH/UEhIi1QkOEiF0nUcuQIAAAD/FZi8BQBIi8hIjRUWjzUA6Png///rG0iLDkyNSwhFM8BIiwH/UEhIi0wkOEiLAf9QEEiLTCRASDPM6I9aBQBIi5wkgAAAAEiDxFBfXl3DzMzMzMzMzMzMzMzMzMzMSIlcJBBIiXQkGFdIg+xASIsFyvM2AEgzxEiJRCQwSIsdew83AEiL+UiF23QHSIub2AAAAGYPbwVk2DUARTPJSIt3SLoBAAAADxFEJCBIi0sITI1GCEiLAf+QCAEAAPdHBAABAAB1FkiLSwhMjUQkIEiLVghIiwH/kJABAABIi09A6Grj//9Ii0wkMEgzzOjdWQUASItcJFhIi3QkYEiDxEBfw8zMzMzMzMzMzMzMzMxIi0FISIsISIXJdAxIiwFFM8Az0kj/YEDDzMzMzMzMzEiJbCQYVkiD7HBIiwX/8jYASDPESIlEJGhIizWwDjcASIvpSI1MJFj/FYqzBQCFwA+ESgIAAEiNTCRg/xWPswUAhcAPhDcCAABIiZwkgAAAALlQAAAASIm8JIgAAAD/FYy5BQBMiwVlDjcAM9tIi/hNhcB0W0kPv5AcKwAASY2AICsAAEWLSARIjQTQRDkIdDSNSgG4q6qqKvfpi8LB6B8D0I0EUgPAK8hmQYmIHCsAAEgPv8FIBWQFAABJjQTARIkIiVgEZv9ABEH/gBQrAABIhf90GA9XwA8RBw8RRxAPEUcgDxFHMA8RR0DrA0iL+4FONAY4AABIjQV6jTUASImGwAAAADPJSIm+0AAAAEiJL0iLRCRYSIlHIEiLRCRgSIlHGMdHKAsAAABIi7bQAAAA/xWRtwUASMHoEEG5BAAAAA+3yEyNRiy6BBAAIP8VVbIFAIXAdQOJXixIiwVvDTcASIXAdAlIi6jQAAAA6wNIi+tIjbBgDQAAi04Ehcl5GIvBmSvCi9PR+APIhckPT9FIi87oKDYAAEUzyYkeTI0FfA0AADPSM8n/FXq3BQBMiwUbDTcASI0V1Iw1AIhdMEmLgEAhAABIiwhIiwdIiUFgSIlBWEiLD/8VW7YFAOjOMgAASI0Ft4w1AMZHMgFIiUQkMEiNBbeMNQBIiUQkOEiNBbuMNQBIiUQkQEiNBb+MNQBIiUQkSEiNBcOMNQBIiUQkUEiLTNww/xWDsQUASIvwSIXAdQtI/8NIg/sFfOTrLEiNFamMNQBIiXc4SIvO/xUEsQUASI0VrYw1AEiLzkiJR0D/FfCwBQBIiUdISIu8JIgAAACwAUiLnCSAAAAA6wIywEiLTCRoSDPM6BFXBQBIi6wkkAAAAEiDxHBew8zMzEiJXCQISIlsJBBIiXQkGEiJfCQgQVZIg+wgSIsdDww3ADPtSIXbdAlMi7PQAAAA6wNMi/VJiw5IjRWyizUARTPA/xVRtQUAM8n/FXGyBQBIi9BIjQ3PjDUA/xURtgUASIsFygs3AEiLuEAhAABIY4A4IQAASI00x0g7/nQUDx8ASIsP6IjU/f9Ig8cISDv+de9Ji044SIXJdAb/FSCwBQCBYzT4x///TIsFggs3AEiJq8AAAABIiavQAAAASImrSAwAAEiJq1AMAABIiatgDAAASImrcAwAAEiJq3gMAABIiatoDAAASImrWAwAAEiJq6gMAABIiaugDAAASImrmAwAAEiJq8AMAABIiauwDAAASImr0AwAAEiJq8gMAABIiau4DAAASImr2AwAAEiJq+gMAABIiavgDAAASImr8AwAAEiJq/gMAABIiasADQAASImrEA0AAEiJqwgNAABIiasYDQAASImrIA0AAEiJqygNAABIiaswDQAATYXAdFxJD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJaQRm/0EGQf+AGCsAAEmLzkiLXCQwSItsJDhIi3QkQEiLfCRISIPEIEFeSP8larUFAMzMSIPsKPYBIEhjwnQHMsBIg8Qow4P4/w+ETgEAAIB5XAAPhUQBAAC6AH8AAIP4Cg+HHgEAAEyNBfWd+v9Bi4yATGMFAEkDyP/hugF/AAAzyf8Vo7MFAEiLyP8VirMFALABSIPEKMO6hn8AADPJ/xWGswUASIvI/xVtswUAsAFIg8Qow7qEfwAAM8n/FWmzBQBIi8j/FVCzBQCwAUiDxCjDuoV/AAAzyf8VTLMFAEiLyP8VM7MFALABSIPEKMO6g38AADPJ/xUvswUASIvI/xUWswUAsAFIg8Qow7qCfwAAM8n/FRKzBQBIi8j/FfmyBQCwAUiDxCjDuol/AAAzyf8V9bIFAEiLyP8V3LIFALABSIPEKMO6An8AADPJ/xXYsgUASIvI/xW/sgUAsAFIg8Qow7qKfwAAM8n/FbuyBQBIi8j/FaKyBQCwAUiDxCjDuoh/AAAzyf8VnrIFAEiLyP8VhbIFALABSIPEKMMzyf8VdrIFALABSIPEKMMPHwAiYwUAGGIFADViBQBvYgUAUmIFAIxiBQCpYgUAxmIFAONiBQAAYwUAHWMFAMzMzMzMzMzMSIlcJBBIiWwkGFZXQVZIg+xgSIsFp+w2AEgzxEiJRCRQSIuxoAAAAEiL2UiNTCRASIvq/xU/sQUARIvw/xUusgUASIv4SIXAdEhIixZIO8IPhJUAAABIi8j/FSmyBQCFwA+FhAAAAEiLjUABAABIY4U4AQAASI0UwUg7ynQUZpBIiwFIOXhYdGJIg8EISDvKde4z/4v3RYX2D4T5AAAASItMJED/FQayBQBIhcAPhOUAAABIi5VAAQAASGONOAEAAEyNBMpJO9APhMoAAABmkEiLCkg5QVgPhLkAAABIg8IISTvQderprQAAAIC7uwAAAAB0SfcDAAQAAPMPLIvoAAAA8w8sk+wAAACJTCRIiVQkTHUWSI1UJEhIi8//FW6xBQCLVCRMi0wkSP8VWLAFAIC7uwAAAAAPhVX///+DfhAAD4VL////RYX2D4RC////9wMABAAASItEJEBIiUQkSHUTSIsOSI1UJEj/FVixBQBIi0QkSGYPblQkTEiLy2YPbsgPW9IPW8noQ7L7/zP/i/fpCf///4sxgLvlCwAAAEiLk+AAAAAPhLoAAABIjZpQFQAARIsLQY1B/4XAeCFIY8hIa8EcSAOCWBUAAA8fQACDOAR0TUiD6BxIg+kBefGLijQBAAA7znR9RItDBEjHRCQkAQAAAEiJfCQwx0QkIAQAAACJdCQsRTvIdTRBjUkBRYXAdBdBi8CZK8LR+EEDwOsPSIXAdLiLSAzrubgIAAAAO8EPT8iL0UiLy+gAif7/SGMDDxBEJCDyDxBMJDBIa8gcSItDCA8RBAHyDxFMARCJfAEY/wNIi0wkUEgzzOjdUAUATI1cJGBJi1soSYtrMEmL40FeX17DzMzMzMzMzMxIiVwkEEiJfCQYVUiNbCSpSIHsoAAAAEiLBRLqNgBIM8RIiUX/SIu5oAAAAEiL2YB/MgB0LjPAM8mJRfcPV8BIi0dADxFF50iFwHQQTI1F57oBAAAA/9CFwA+UwYhPMcZHMgCDYwT+gH8xAA+ErAUAAEiLR0hIhcAPhJ8FAABIjVXXM8n/0IXAD4WPBQAARA+3RduDSwQBQQ+2wA8ptCSQAAAAD1f2Dym8JIAAAADzDxA9nss1AMDoBEQPKUQkcCQBgLvlCwAAAEQPKUwkYEQPKVQkUHQihMB0BQ8o3+sDD1fbRA+2wLp4AgAASIvL6E2u+/9ED7dF20EPtsDA6AUkAYC75QsAAAB0IoTAdAUPKN/rAw9X20QPtsC6eQIAAEiLy+gZrvv/RA+3RdtBD7fAZsHoDiQBgLvlCwAAAHQihMB0BQ8o3+sDD1fbRA+2wLp6AgAASIvL6OSt+/9ED7dF20EPt8BmwegNJAGAu+ULAAAAdCKEwHQFDyjf6wMPV9tED7bAunsCAABIi8vor637/0QPt0XbQQ+3wGbB6A+Au+ULAAAAdCKEwHQFDyjf6wMPV9tED7bAunwCAABIi8vofK37/0QPt0XbQQ+3wGbB6AwkAYC75QsAAAB0IoTAdAUPKN/rAw9X20QPtsC6fQIAAEiLy+hHrfv/RA+3RdtBD7bAwOgCJAGAu+ULAAAAdCKEwHQFDyjf6wMPV9tED7bAun4CAABIi8voE637/0QPt0XbQQ+2wMDoAyQBgLvlCwAAAHQihMB0BQ8o3+sDD1fbRA+2wLp/AgAASIvL6N+s+/9ED7dF20EPtsAkAYC75QsAAAB0IoTAdAUPKN/rAw9X20QPtsC6gAIAAEiLy+iurPv/RA+3RdtBD7bA0OgkAYC75QsAAAB0IoTAdAUPKN/rAw9X20QPtsC6gQIAAEiLy+h7rPv/RA+3RdtBD7fAZsHoCCQBgLvlCwAAAHQihMB0BQ8o3+sDD1fbRA+2wLqCAgAASIvL6Eas+/9ED7dF22ZBwegJQYDgAYC75QsAAAB0GkWEwHQFDyjf6wMPV9u6gwIAAEiLy+gVrPv/D7ZF3fNEDxAN0Mk1AIPoHmYPbsAPW8DzQQ9ewQ8v8HYFD1fb6wcPKN/zD13Y80QPEAVzyDUAuoQCAABBDy/ASIvLQQ+XwOjKq/v/D7ZF3oPoHmYPbsAPW8DzQQ9ewQ8v8HYFD1fb6wcPKN/zD13YQQ8vwLqFAgAASIvLQQ+XwOiRq/v/RA+3RdtBD7bAwOgGJAGAu+ULAAAAdCKEwHQFDyjf6wMPV9tED7bAuoYCAABIi8voXav7/0QPt0XbQcDoB0GA4AGAu+ULAAAAdBpFhMB0BQ8o3+sDD1fbuocCAABIi8voLav7/w+/Rd/zRA8QDVDJNQAFqR4AAGYPbsAPW8DzQQ9ewQ8v8HYFD1fb6wcPKN/zD13YQQ8vwLqIAgAASIvLQQ+XwOjpqvv/D79F3/NEDxAVyMg1AC2pHgAAZg9uwA9bwPNBD17CDy/wdgUPV9vrBw8o3/MPXdhBDy/AuokCAABIi8tBD5fA6KWq+/8Pv0XhLakeAABmD27AD1vA80EPXsIPL/B2BQ9X2+sHDyjf8w9d2EEPL8C6igIAAEiLy0EPl8Doaqr7/w+/ReEFqR4AAGYPbsAPW8DzQQ9ewQ8v8HYFD1fb6wcPKN/zD13YQQ8vwLqLAgAASIvLQQ+XwOgvqvv/D79F4wWpHgAAZg9uwA9bwPNBD17BDy/wdgUPV9vrBw8o3/MPXdhBDy/AuowCAABIi8tBD5fA6PSp+/8Pv0XjLakeAABmD27AD1vA80EPXsIPL/B2BQ9X2+sHDyjf8w9d2EEPL8C6jQIAAEiLy0EPl8Douan7/w+/ReUtqR4AAGYPbsAPW8DzQQ9ewkQPKFQkUA8v8HYFD1fb6wcPKN/zD13YQQ8vwLqOAgAASIvLQQ+XwOh4qfv/D79F5QWpHgAAZg9uwA9bwPNBD17BRA8oTCRgDy/wdwfzD134Dyj3QQ8vwLqPAgAASIvLDyjeQQ+XwOg5qfv/RA8oRCRwDyi8JIAAAAAPKLQkkAAAAEiLTf9IM8zol0oFAEyNnCSgAAAASYtbGEmLeyBJi+Ndw8zMSIlcJBBVSIvsSIHsgAAAAEiLBdnjNgBIM8RIiUX4D1fASI1V0DPASIvZDxFF0MdF0CgAAAAPEUXgSIlF8P8VhakFAIXAD4SSAQAAi03Ui1XYi0XcK8FmD27Bi03kD1vAZg9uyvMPEUWgZg9uwItF4A9bwCvCi1XoD1vJ8w8RRahmD27Ai0XsD1vAK8HzDxFNpPMPEUWsZg9uyUiLy2YPbsIPW8APW8nzDxFFtGYPbsCLRfAPW8ArwvMPEU2w8w8RRbhmD27AD1vA8w8RRbzoDRgAAA9XyfMPEUXADy/ISIldyA+D9QAAAEiLHcH+NgBIgcNgDQAA9kX0AYsDD4SAAAAAhcB1EUiNVaBIi8voDicAAOnGAAAAi0sEO8F1KkSNQAGFyXQLi8GZK8LR+APB6wW4CAAAAEE7wEiLy0QPT8BBi9DoWCcAAEhjA0iFwH4VSItTCEyNBEBJweAESI1KMOgJXAUASItDCA8QRaAPEE2wDxEADxBFwA8RSBAPEUAg61mLSwQ7wXUqRI1AAYXJdAuLwZkrwtH4A8HrBbgIAAAAQTvASIvLRA9PwEGL0OjtJgAASGMDDxBFoA8QTbBIjQxASItDCEgDyQ8RBMgPEEXADxFMyBAPEUTIIP8DuAEAAABIi034SDPM6JJIBQBIi5wkmAAAAEiBxIAAAABdw8xIiVwkIFdIg+xASIsF3+E2AEgzxEiJRCQ4SIsFkP02AEiJbCRQSIl0JFhIhcB0CUiLuNAAAADrAjP/D1fASI1UJCDzD39EJCBIiw9IjVgwSI2oSAwAAP8V/KYFAItEJCgrRCQgZg9uwItEJCwrRCQkD1vA8w8RQwhmD27AD1vA8w8RQwyAfzAAdGdIiwUf/TYATIl0JGBIhcB0CUiLsNAAAADrAjP2TI2wYA0AAEGLTgSFyXkYi8GZK8Iz0tH4A8iFyQ9P0UmLzujTJQAARTPJQccGAAAAAEyNBSL9//8z0jPJ/xUgpwUATIt0JGDGRjAASI1MJDBIx0QkMAAAAAD/FauhBQBIi0wkMA9XyUiLwQ9XwEgrRxhIi9XzSA8qRyDzSA8qyPMPXsjzDxFLGEiJTxhIi8vo9vP//0iLBW/8NgBIi2wkUIC4QAIAAAB0N4C4jBcAAAB1LrmgAAAA/xWlpQUAZg+64A9yHIC75QsAAAB0Ew9X20UzwLoQAgAASIvL6Hql+/9IiwUj/DYAgLiAAgAAAHQ3gLi8FwAAAHUuuaEAAAD/FV6lBQBmD7rgD3IcgLvlCwAAAHQTD1fbRTPAuhQCAABIi8voM6X7/0iLBdz7NgCAuGACAAAAdDeAuKQXAAAAdS65WwAAAP8VF6UFAGYPuuAPchyAu+ULAAAAdBMPV9tFM8C6EgIAAEiLy+jspPv/SIsFlfs2AIC4oAIAAAB0N4C41BcAAAB1LrlcAAAA/xXQpAUAZg+64A9yHIC75QsAAAB0Ew9X20UzwLoWAgAASIvL6KWk+/+Ae1wASIt0JFh0B7r/////6w1IiwU8+zYAi5AoJgAAOVcodAtIi8uJVyjo9vD//0iLy+gu9f//SItMJDhIM8zo4UUFAEiLXCRoSIPEQF/DzMzMzMzMSMHqEEiD+Q11DWYPuuIIcwa4cwIAAMNIjUH4RA+2wkiNFdqO+v9IPbYAAAAPh5ACAAAPtoQC4HUFAIuMgix0BQBIA8r/4bgAAgAAw7gBAgAAw7gCAgAAw7gDAgAAw7gEAgAAw7gFAgAAw7gGAgAAw7gHAgAAw7gIAgAAw7gJAgAAw7gKAgAAw7gLAgAAw7gMAgAAw7gNAgAAw7gOAgAAw7hfAgAAw7hgAgAAw7hhAgAAw7hiAgAAw7hjAgAAw7hkAgAAw7hlAgAAw7hmAgAAw7hnAgAAw7hoAgAAw7hpAgAAw7hqAgAAw7hrAgAAw7hsAgAAw7htAgAAw7huAgAAw7hvAgAAw7hwAgAAw7hxAgAAw7hyAgAAw7gQAgAAw7gPAgAAw7gRAgAAw7gSAgAAw7gUAgAAw7gTAgAAw7gVAgAAw7gWAgAAw7gXAgAAw7gYAgAAw7gZAgAAw7gaAgAAw7gbAgAAw7gcAgAAw7gdAgAAw7geAgAAw7gfAgAAw7ggAgAAw7ghAgAAw7giAgAAw7gjAgAAw7gkAgAAw7glAgAAw7gmAgAAw7gnAgAAw7goAgAAw7gpAgAAw7gqAgAAw7grAgAAw7gsAgAAw7gtAgAAw7guAgAAw7gvAgAAw7gwAgAAw7gxAgAAw7gyAgAAw7gzAgAAw7g0AgAAw7g1AgAAw7g2AgAAw7g3AgAAw7g4AgAAw7g5AgAAw7g6AgAAw7g7AgAAw7g8AgAAw7g9AgAAw7g+AgAAw7g/AgAAw7hAAgAAw7hBAgAAw7hCAgAAw7hDAgAAw7hEAgAAw7hFAgAAw7hGAgAAw7hHAgAAw7hIAgAAw7hJAgAAw7hKAgAAw7hLAgAAw7hMAgAAw7hNAgAAw7hOAgAAw7hPAgAAw7hQAgAAw7hRAgAAw7hSAgAAw7hTAgAAw7h1AgAAw7h2AgAAw0GNQPSD+Ep3XkiYD7aEAsx2BQCLjIKYdgUASAPK/+G4XgIAAMO4VgIAAMO4WgIAAMO4WwIAAMO4XQIAAMO4dwIAAMO4XAIAAMO4WQIAAMO4VAIAAMO4VQIAAMO4VwIAAMO4WAIAAMMzwMOIcQUARnEFAJRxBQC4cQUAoHEFAJpxBQCOcQUAZHEFAGpxBQB2cQUAcHEFAExxBQBYcQUAUnEFAF5xBQCycQUAfHEFAIJxBQBOcgUAVHIFAFpyBQBgcgUAZnIFAGxyBQBycgUAeHIFAH5yBQCEcgUAinIFAJByBQCWcgUAnHIFAKJyBQCocgUArnIFALRyBQC6cgUAwHIFAMZyBQDMcgUA0nIFANhyBQDecgUA5HIFAOpyBQDwcgUA9nIFAPxyBQACcwUACHMFAA5zBQAUcwUAGnMFACBzBQAqcgUAQnIFAEhyBQC+cQUAxHEFAMpxBQDQcQUA1nEFANxxBQDicQUA6HEFAO5xBQD0cQUABnIFABJyBQAMcgUA+nEFAAByBQAmcwUALHMFADJzBQA4cwUAPnMFAERzBQBKcwUAUHMFAFZzBQBccwUAYnMFAGhzBQBucwUAdHMFAHpzBQCAcwUAhnMFAIxzBQCScwUAmHMFAJ5zBQCkcwUAqnMFALBzBQCscQUApnEFABhyBQAwcgUAHnIFADZyBQAkcgUAPHIFALZzBQC8cwUAF3QFAB10BQDCcwUAAAFsbGwCbGxsbGwDBGxsbGxsbAVsbGxsBgcICQoLDA0ObGxsDxARbBITFBUWFxgZGhtsbGxsbGxsHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2NzhsbDk6Ozw9Pj9AQUJDRGxFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9sbGxsbGxsbGBhbGxsbGxsbGxsbGxsbGxiY2RlZmdoaWxsbGxsbGxsbGxsbGxsbGxsbGxsamxrkOdzBQDtcwUA83MFAPlzBQALdAUAEXQFAOFzBQAFdAUAF3QFAB10BQAjdAUA/3MFACl0BQAAAQwMDAwMDAwMDAwMDAIDDAwMDAwMDAwMDAwEBQYMBwwMDAwMDAwICQoMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAvMzMzMzMzMzMxAVVNWV0FUQVVBVkFXSI1sJOlIgey4AAAADym0JKAAAABIiwX42DYASDPESIlF90iLXX9Ni/lEi/JMiUXnTIvhSIuzoAAAAEiF9g+EbwoAAIH6AAIAAA+HVgcAAA+EKgYAAIP6B3dJD4SVAwAAg/oCD4VJCgAASDlOCA+FPwoAAIN+EAAPhDUKAABIiU3PM/9IjU3HiX3Xx0XHGAAAAMdFywAAAID/FTWeBQDpTQcAAEGB/g8BAAAPhwIKAAAPhKoFAACNQvg9/QAAAA+H7gkAAEiNFQiI+v8PtoQCMIIFAIuMggyCBQBIA8r/4UGNhgD///+p+////0APlMdJgfgAAQAAD4O2CQAAuREAAAD/FSSdBQDzDxA1KLo1AGbB6A+Au+ULAAAAdB2EwHQFDyje6wMPV9tED7bAugAQAABIi8vo6pz7/7kQAAAA/xXnnAUAZsHoD4C75QsAAAB0HYTAdAUPKN7rAw9X20QPtsC6ACAAAEiLy+i1nPv/uRIAAAD/FbKcBQBmwegPgLvlCwAAAHQdhMB0BQ8o3usDD1fbRA+2wLoAQAAASIvL6ICc+/+5WwAAAP8VfZwFAL4AgAAAZoXGdRW5XAAAAP8VaJwFAGaFxnUFRTLA6wNBsAGAu+ULAAAAdBdFhMB0BQ8o3usDD1fbi9ZIi8voM5z7/0iLdedJi9dIi87o1Pf//0SL8D1iAgAAdSBAhP91IEA4u+ULAAB0PA8o3kGwAYvQSIvL6Pyb+//rBUWF9nQlgLvlCwAAAHQcQIT/dAUPKN7rAw9X20QPtsdBi9ZIi8vo0Jv7/4P+EA+FgQAAALmgAAAA/xXEmwUAZsHoD0A6x3UngLvlCwAAAHQeQIT/dAUPKN7rAw9X20QPtse6EAIAAEiLy+iMm/v/uaEAAAD/FYmbBQBmwegPQDrHD4UDCAAAgLvlCwAAAA+E9gcAAECE/3UDD1f2DyjeRA+2x7oUAgAASIvL6Eub+//p1QcAAIP+EQ+FgQAAALmiAAAA/xU6mwUAZsHoD0A6x3UngLvlCwAAAHQeQIT/dAUPKN7rAw9X20QPtse6DwIAAEiLy+gCm/v/uaMAAAD/Ff+aBQBmwegPQDrHD4V5BwAAgLvlCwAAAA+EbAcAAECE/3UDD1f2DyjeRA+2x7oTAgAASIvL6MGa+//pSwcAAIP+Eg+FQgcAALmkAAAA/xWwmgUAZsHoD0A6x3UngLvlCwAAAHQeQIT/dAUPKN7rAw9X20QPtse6EQIAAEiLy+h4mvv/uaUAAAD/FXWaBQBmwegPQDrHD4XvBgAAgLvlCwAAAA+E4gYAAECE/3UDD1f2DyjeRA+2x7oVAgAASIvL6Dea+//pwQYAAEGD/gdIi5PgAAAAQQ+UwEiNulAVAABEiw9BjUH/hcB4IEhjyEhrwRxIA4JYFQAADx8AgzgHdHhIg+gcSIPpAXnxgLoUDAAAAA+UwUE6yA+EbQYAAIC7iQAAAAB0CkGD/gcPhVoGAACLgnQVAAAz2w9XwEiJXbcPEUWniUWv/8CJgnQVAABEiEWzRItHBMdFpwcAAABFO8h1NUGNSQFFhcB0GEGLwJkrwtH4QQPA6xBIhcB0jQ+2SAzrkbgIAAAAO8EPT8iL0UiLz+jUcv7/SGMHDxBFp/IPEE23SGvIHEiLRwgPEQQB8g8RTAEQiVwBGP8H6coFAAAzyf8V25kFAEjB6BBBuQQAAAAPt8hMjUYsugQQACD/FZ+UBQCFwA+FngUAADP/iX4s6ZQFAABJi8z/FdSYBQCFwHQhSItV50iNQv9IPf7/AAAPh3MFAABIi8vojJf7/+lmBQAAi04sSI1F30G/AQAAAEyNRedBvQIAAABEiXwkKDP/SIlEJCBFi81miX3fQYvX/xX0kwUAD7dV30iLi+AAAACF0g+EIAUAAEA4u+ULAAAPhBMFAACLgXQVAABIjZlQFQAAiUWv/8CJgXQVAABEi0MEiwtIiX23x0WnBgAAAESJbauJVbNBO8h1KP/BRYXAdA1Bi8CZK8LR+EEDwOsFuAgAAAA7wQ9PyIvRSIvL6Jdx/v9IYwMPEEWn8g8QTbdIa8gcSItDCA8RBAHyDxFMARCJfAEY/wPpjQQAAGZBg/8BD4WCBAAAi1YoSIvL6Gjk//+EwA+EbwQAALgBAAAA6WcEAABJg/gvD4VbBAAAxkYwAelSBAAAug8BAAD/FaiXBQBJD7rnC0G/AQAAAEkPQsfpNQQAAP8VrpcFALmA////M/9Ii9BBvQIAAABII9G5AFdR/0g70XUGRIlt3+sQi8+4gFdR/0g70A+UwYlN34tOEEGB/gACAACLx0yJZggPlcD/wIlFnzvIdFVBgf4AAgAAx0XHGAAAALgSAAAAx0XLAAAAgEQPRehMiWXPRIltq4l918dFpxgAAABMiWWviX23hcl0CkiNTcf/FbqXBQBIjU2n/xWwlwUAi0WfiUYQQQ+/x4lF70nB7xBBD7/HiUXziwMlAAQAAEGB/gACAAB1E4XAdClIjVXvSYvM/xWHlwUA6xpBgf6gAAAAdRGFwHUNSI1V70mLzP8Vo5cFAEiLg+AAAACLTd+JiHAVAABIi8tmD25V82YPbk3vD1vSD1vJ6IOY+//pDQMAAI2C//3//z3fAAAAD4f8AgAASI0VFoH6/w+2hAJUgwUAi4yCMIMFAEgDyv/hM/9Bgf6jAgAAi8cPlcD/wDlGEA+FyAIAAEw5Zgh1BEiJfgjzDxANX7Q1AEiLyw8o0Yl+EOgZmPv/6aMCAAD/FR6WBQC5gP///zP/SIvQQb0CAAAASCPRuQBXUf9IO9F1BkSJbd/rEIvPuIBXUf9IO9APlMGJTd9Bgf4EAgAAdAxEi/9Bgf4GAgAAdQZBvwEAAABBjYb5/f//qf3///9BjYb1/f//RQ9E/an9////dRVIi0Xni89IwegQZoP4AQ+VwUSNeQP/FVeWBQA5fhR0CEk7xHQRiX4USIXAdQlJi8z/FdyVBQCLRhRBsAGLTd9ED6v4iUYUQYvXSIuD4AAAAImIcBUAAEiLy+jEmPv/6c4BAAD/FUmVBQC5gP///zP/SIvQQb0CAAAASCPRuQBXUf9IO9F1BkSJbd/rEIvPuIBXUf9IO9APlMGJTd9Bgf4FAgAARIv/QQ+Ux0GB/ggCAAB1BUWL/esgQYH+DAIAAHUXSItF50SL/0jB6BBmg/gBQQ+Vx0GDxwOLRhRED7P4iUYUhcB1Ef8VhpUFAEk7xHUG/xV7lAUASIuD4AAAAEUzwItN30GL14mIcBUAAEiLy+gNmPv/6RcBAABJwegQD1fJQQ+/wEiLy2YPbtAPW9LzD14VJ7I1AOgGmvv/6fAAAABJwegQD1fSQQ+/wEiLy2YPbsgPW8kPVw0FtTUA8w9eDfmxNQDo2Jn7/+nCAAAASYvM/xUClAUAhcAPhbEAAABIi03nSMHpCP8VtI8FAIXAdBxIi1XnD7bCZsHgCEjB6ggPt8gPtsJIC8hIiU3ni04sSI1F30G/AQAAAEyNRecz/0SJfCQoQYvXSIlEJCBBuQIAAABmiX3f/xUUjwUAD7dV30iLy+hokvv/QYvH60RBg/gHdTzGRjIB6zaAe1sAdDBBi08MM9JFi0kEQSvJQYtHCEWLB0ErwMdEJDAUAAAAiUwkKEmLzIlEJCD/FamTBQAzwEiLTfdIM8zo4zQFAA8otCSgAAAASIHEuAAAAEFfQV5BXUFcX15bXcMPHwAeewUAen0FAFJ9BQAVfAUAhH0FAKx9BQAMeAUAS3wFAN+BBQAACAgICAgICAgICAgICAgICAgBCAgICAgCCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAUICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAYGBwgGBmaQPH8FABGABQDIgAUA74AFAJ2BBQAdgQUA/n4FAKmBBQDfgQUAAAEAAAEAAAEAAgABAAMICAgICAgICAgIBAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAUICAgICAgICAgICAgICAgICAgICAgICAgICAgGBggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAfMzMzMzMzMzMzMzMxIiVwkGFdIgexQAQAASIsF7Ms2AEgzxEiJhCRAAQAASIM98eo2AAAPt/oPt9l1N0iNDdJnNQD/FVSMBQBIhcB0GUiNFdBnNQBIi8j/FfeLBQBIiQXA6jYA6wdIiwW36jYASIXAdGMz0kiNTCQsQbgQAQAA6LJDBQBBsAPHRCQgHAEAALoCAAAAiVwkJDPJiXwkKP8VIIwFAEGwA7oBAAAASIvI/xUPjAUATIsNaOo2AEiNTCQgTIvAugMAAABB/9EzyYXAD5TBi8FIi4wkQAEAAEgzzOi3MQUASIucJHABAABIgcRQAQAAX8PMzMzMzMxAU0iD7DBIiwUDyzYASDPESIlEJChIi9nHRCQgYAAAALkGAAAAx0QkJGAAAAC6AwAAAOjZ/v//hcAPhJwAAACLDWflNgBlSIsEJVgAAAC6BAAAAEiLBMiLDAI5DbTuNgB+NUiNDavuNgDocjIFAIM9n+42AP91IEiNDfJmNQD/FSyLBQBIjQ2J7jYASIkFdu42AOjdMQUASIsFkuk2AEiFwHUlSIsNXu42AEiFyXQsSI0V4mY1AP8VnIoFAEiJBW3pNgBIhcB0E0yNTCQkM9JMjUQkIEiLy//Q6zozyf8VZY8FAEiLyLpYAAAASIvY/xXsiQUAuloAAABIi8uJRCQg/xXaiQUASIvTM8mJRCQk/xW7jgUAi0QkIA9XwPNIDyrA8w9eBausNQBIi0wkKEgzzOhqMAUASIPEMFvDzMzMzEiJXCQQSIl0JBhXSIHskAAAAEiLBbfJNgBIM8RIiYQkgAAAAEiL+bkgAAAA/xV+kAUATIsFV+U2ADP2SIvYTYXAdFxJD7+QHCsAAEmNiCArAABFi0gESI0M0UQ5CXQ1jUoBuKuqqir36YvCwegfA9CNBFIDwCvIZkGJiBwrAABID7/JSIHBZAUAAEmNDMhEiQmJcQRm/0EEQf+AFCsAAEiF23QRSIlzCEiJM0CIcxBIiXMU6wNIi96LTwS6AADPAPbBCEiJX1C4AAAAgA9EwvbBEIlDFLoAAAQAuIAAAAAPRMKJQxgPuuEKcwaDyAiJQxhIi0c4SIXAdAZIi0hY6wNIi85IiUsIRTPA8w8QRwhIjUwkcPMPEE8M8w8swPMPWEcQiUQkcPMPLMHzD1hPFIlEJHTzDyzAiUQkePMPLMGJRCR8RItLGItTFP8ViI0FADPJ/xXIigUARItMJHSLVCRwRItEJHyLTCR4RSvBSIl0JFgrykiJRCRQSItDCEiJdCRISIlEJEBEiUQkOEyNBd1kNQCJTCQwi0sYRIlMJChEi0sUiVQkIEiNFdpkNQD/FSyOBQBMiwXV4zYASI0VjmM1AEiJA8ZDEAFAiHdqSIsDSIlHYEiJR1hIiwv/FReNBQBIi4wkgAAAAEgzzOhvLgUATI2cJJAAAABJi1sYSYtzIEmL41/DzMzMzMzMzMzMzEiJbCQQSIl0JBhIiXwkIEFWSIPsIEiLBWTjNgAz7UiL8UiFwHQJTIuw0AAAAOsDTIv1SIt5UEiF/w+EuQAAAEiJXCQwSIsf/xVTjQUASDvDSItcJDB1D/8VQ4wFAEmLDv8V2owFAEiLD0iFyXQMQDhvEHQG/xV2jAUATIsF/+I2AEiJL02FwHRcSQ+/kBwrAABJjYggKwAARYtIBEiNDNFEOQl0NY1KAbirqqoq9+mLwsHoHwPQjQRSA8AryGZBiYgcKwAASA+/yUiBwWQFAABJjQzIRIkJiWkEZv9BBkH/gBgrAABIi8//FcqNBQBIiW5YSIluUOsISIlpWEiJaVBIi2wkOEiLdCRASIt8JEhIg8QgQV7DzMzMzMzMzMzMzEiJXCQIV0iD7CBIi1lQSIv5SIN7CAB0EUiLC0UzwLr4/////xXPiwUA9kcEILoIAAAASIsLdQW6BQAAAP8VRowFAEyLQwhNhcB0DkiLC7r4/////xWfiwUASItcJDBIg8QgX8PMzMzMzMzMzMzMzMxAU1ZXSIPsYEiLBSHGNgBIM8RIiUQkUEyLQTgz/0iLWVBIi/FNhcB0Bk2LQFjrA0yLx0w7Qwh0EkiLC7r4////TIlDCP8VPosFAItWBLgAAM8A9sIIuQAABABBuAAAAIBED0TA9sIQuIAAAAAPRMGLyIPJCIHiAAQAAA9EyEQ5QxR1CTlLGA+EBQEAAEiJrCSIAAAAi2sYTIm0JJAAAACD5QhEi/FBg+YIQTvudAqF0kAPlcdIg8f+iUsYuvD///9IiwtEiUMU/xXTigUARItDGLrs////SIsL/xXBigUA8w8QRghIjUwkQPMPEE4MRTPARItLGItTFPMPLMDzD1hGEIlEJEDzDyzB8w9YThSJRCRE8w8swIlEJEjzDyzBiUQkTP8VEIoFAESLVCRMuDAAAABEi0wkREG7NAAAAESLRCRAQTvuSIsLSIvXRA9F2ItEJEhEiVwkMEUr0UErwESJVCQoiUQkIP8VC4oFAEiLC7oIAAAA/xWdigUATIu0JJAAAABIi6wkiAAAAGbHRmkBAUiLTCRQSDPM6CIrBQBIg8RgX15bw8zMzMzMzMzMzMxAU0iD7DBIiwVzxDYASDPESIlEJChIi9kzwEiLSlBIjVQkIEiJRCQgSIsJ/xUfigUAZg9uRCQgSIvDZg9uTCQkD1vAD1vJ8w8RA/MPEUsESItMJChIM8zotCoFAEiDxDBbw8zMzMzMzMzMzMzMzMzMSIlcJBhIiXQkIFdIg+xgSIsF+sM2AEgzxEiJRCRY9kEEBEiLcVBIiVQkQPMPLFQkQPMPLEQkRIlUJEiJVCRQiUQkTIlEJFR0IkiLDrrw/////xWxiAUASIsOuuz///+JRhT/FaCIBQCJRhhEi04YSI1MJEiLVhRFM8D/FZiIBQBEi0wkTDPARItEJEgz0kiLDsdEJDAVAAAAiUQkKIlEJCD/FbGIBQBIi0wkWEgzzOjsKQUATI1cJGBJi1sgSYtzKEmL41/DzMzMzMzMzMzMzEBTSIPsQEiLBTPDNgBIM8RIiUQkMEiL2UiLSlBIjVQkIEiLCf8VfogFAItMJChIi8MrTCQgZg9uwYtMJCwrTCQkD1vA8w8RA2YPbsEPW8DzDxFDBEiLTCQwSDPM6G8pBQBIg8RAW8PMzMzMzMzMzMxIiVwkGEiJdCQgV0iD7GBIiwW6wjYASDPESIlEJFhIi3FQM8D2QQQESIlUJEBIiUQkSPMPLEQkQIlEJFDzDyxEJESJRCRUdCJIiw668P////8VcocFAEiLDrrs////iUYU/xVhhwUAiUYYRItOGEiNTCRIi1YURTPA/xVZhwUAi1QkVEUzyStUJExFM8CLRCRQK0QkSEiLDsdEJDAWAAAAiVQkKDPSiUQkIP8VaIcFAEiLTCRYSDPM6KMoBQBMjVwkYEmLWyBJi3MoSYvjX8PM diff --git a/IDA/project/docs/input/files/ef_cheeto_text_chunk3of4.b64 b/IDA/project/docs/input/files/ef_cheeto_text_chunk3of4.b64 new file mode 100644 index 0000000..e902f0f --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_text_chunk3of4.b64 @@ -0,0 +1,7 @@ +# EF-Cheeto .text section — chunk 3/4 +# RVA range: 0x58E40–0x84D60 +# Size: 180,000 bytes / ~60,000 tokens +# ImageBase: 0x180000000 VA = 0x0180058E40 +# To decode: import base64; data = base64.b64decode(open(this).read().split('\n',6)[-1]) + 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 diff --git a/IDA/project/docs/input/files/ef_cheeto_text_chunk4of4.b64 b/IDA/project/docs/input/files/ef_cheeto_text_chunk4of4.b64 new file mode 100644 index 0000000..f1c7a77 --- /dev/null +++ b/IDA/project/docs/input/files/ef_cheeto_text_chunk4of4.b64 @@ -0,0 +1,7 @@ +# EF-Cheeto .text section — chunk 4/4 +# RVA range: 0x84D60–0xB0200 +# Size: 177,312 bytes / ~59,104 tokens +# ImageBase: 0x180000000 VA = 0x0180084D60 +# To decode: import base64; data = base64.b64decode(open(this).read().split('\n',6)[-1]) + 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 diff --git a/IDA/project/docs/input/files2/ef_cheeto_feed_1_analysis.md b/IDA/project/docs/input/files2/ef_cheeto_feed_1_analysis.md new file mode 100644 index 0000000..8db0eca --- /dev/null +++ b/IDA/project/docs/input/files2/ef_cheeto_feed_1_analysis.md @@ -0,0 +1,3963 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 1/3 +# Feed ALL THREE PARTS before asking reconstruction questions. +# Part 1: Orientation + Full Analysis (prose, pseudocode, tables) + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed +# Part 2: Reconstruction Header (structs, addresses, constants) +# Part 3: Machine Code (hex dumps + raw binary sections) + +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +ANALYSIS DOCUMENT — All 29 Chapters +================================================================================ + +EF-Cheeto.dll (unityexplorer.dll) +Complete Reverse Engineering Report — Final Consolidated Edition +24 Chapters · 11 Registered Modules · Complete Static Reconstruction +February 27, 2026 +# 1. Executive Summary +This document is the complete consolidated reverse engineering analysis of EF-Cheeto.dll (distributed as unityexplorer.dll), spanning twenty-five chapters. It covers all subsystems from infrastructure (thread enumeration, anti-debug, shader compilation, config I/O) through the hook engine, eleven registered cheat modules, the ModuleManager dispatch architecture, GABypass IL2CPP resolver, JSON config schema, and analyses added in later passes: ESPModule Render/Update implementation (Ch. 22), DamageHack ghost feature analysis (Ch. 23), SetDither RenderOverlay body (Ch. 12.5.1), and the Sidebar/Main Panel rendering function (Ch. 25). +IAT base is RVA 0xB1000 (file raw offset 0xAF600). The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows. The binary is fully reverse engineered with no significant undocumented regions remaining. +# 2. Corrected IAT Address Map +Previous analysis used incorrect IAT RVAs derived from objdump -p output. The correct IAT base is RVA 0xB1000 (file raw offset 0xAF600), not the 0x3C2xxx addresses previously listed. The following table gives the correct IAT RVAs and all call sites. +Function +IAT RVA +DLL +Call Sites (VA) +SuspendThread +0xB1050 +KERNEL32.dll +0x1800A9861 +ResumeThread +0xB1058 +KERNEL32.dll +0x1800A9964 (×37 total) +GetThreadContext +0xB1068 +KERNEL32.dll +0x1800A988B +SetThreadContext +0xB1078 +KERNEL32.dll +0x1800A993C +CreateToolhelp32Snapshot +0xB1160 +KERNEL32.dll +0x1800A970B +Thread32First +0xB11B0 +KERNEL32.dll +0x1800A972F +Thread32Next +0xB11A8 +KERNEL32.dll +0x1800A97DD +OpenThread +0xB11D0 +KERNEL32.dll +0x1800A9849 (×38 total) +VirtualProtect +0xB1288 +KERNEL32.dll +0x1800A9AFC, 0x1800A9B6C +FlushInstructionCache +0xB1070 +KERNEL32.dll +0x1800A9B81 +GetCurrentProcess +0xB1270 +KERNEL32.dll +0x1800A9B72 +IsDebuggerPresent +0xB11E8 +KERNEL32.dll +0x1800AC67B +SetUnhandledExceptionFilter +0xB1200 +KERNEL32.dll +0x1800AC698 +UnhandledExceptionFilter +0xB1208 +KERNEL32.dll +0x1800AC6A3 +IsProcessorFeaturePresent +0xB11F0 +KERNEL32.dll +0x1800AC5A2 +TerminateProcess +0xB11F8 +KERNEL32.dll +0x1800AC628 (via int 29h) +D3DCompile +0xB1000 +D3DCOMPILER_47 +0x180054E77, 0x180055069 +_wfopen +0xB1888 +CRT +0x180011F93 +fwrite +0xB1868 +CRT +0x18000EA1B, 0x1800170D6, 0x18003033B, 0x18003076D +fread +0xB1870 +CRT +(called via 0x180011EA0 helper) +fclose +0xB1878 +CRT +0x1800170DF, 0x180030776 +SetWindowDisplayAffinity +0xB1460 +USER32.dll +0x18008B48F +LoadLibraryA +0xB10E0 +KERNEL32.dll +0x180055F57, 0x1800585AE (×4) +GetProcAddress +0xB1088 +KERNEL32.dll +0x180055F7E, 0x180055F92 (×7) +VirtualAlloc +0xB11A0 +KERNEL32.dll +0x1800AA566, 0x1800AA607 +VirtualFree +0xB1278 +KERNEL32.dll +0x180081D5B, 0x1800AA6E1 +# 3. Thread Enumeration and Suspension +Thread enumeration serves a critical role in safe hook installation: the cheat must suspend all Unity render/game threads before patching code bytes, then resume them after patching, to prevent race conditions. This subsystem uses two cooperating functions. +## 3.1 Thread Collection Function (0x1800A96B0–0x1800A9A1C) +This function collects all thread IDs for the current process using a Toolhelp32 snapshot, filtering out the calling thread and storing results in a caller-provided vector. The function signature is: +int CollectProcessThreads( +DWORD* out_vec, // RCX: vector { begin, end, capacity } +DWORD current_pid, // RDX: passed to CreateToolhelp32Snapshot +DWORD current_tid // R8d: thread to exclude (caller's thread) +Key sequence: +// 0x1800A96B0: Prologue, save RSI/RDI/RBX/R12-R15, allocate 0x530 bytes stack +// 0x1800A96E7: xor ebx, ebx (thread count = 0) +// 0x1800A96F8: mov [rcx], rbx; mov [rcx+8], rbx (init empty vector) +// 0x1800A9701: lea ecx, [rbx+4] = TH32CS_SNAPTHREAD = 4 +// 0x1800A970B: call [IAT:CreateToolhelp32Snapshot](dwFlags=4, pid=r15) +// 0x1800A9711: mov r14, rax (hSnapshot = result) +// 0x1800A9714: cmp rax, -1 → je fail (INVALID_HANDLE_VALUE) +// 0x1800A971E: lea r12d, [rbx+0x1C] (sizeof THREADENTRY32 = 28) +// 0x1800A9725: lea rdx, [rsp+0x30] (THREADENTRY32 buffer) +// 0x1800A972A: mov [rsp+0x30], r12d (te32.dwSize = 28) +// 0x1800A972F: call [IAT:Thread32First](hSnapshot, &te32) +// --- LOOP --- +// 0x1800A9740: cmp [rsp+0x30], 0x10 (check th32OwnerProcessID offset) +// 0x1800A974B: call [IAT:GetCurrentProcessId] +// 0x1800A9751: cmp [rsp+0x3C], eax (te32.th32OwnerProcessID == GetCurrentProcessId?) +// 0x1800A9755: jne skip (skip threads not in our process) +// 0x1800A9757: call [IAT:GetCurrentThreadId] +// 0x1800A975D: cmp [rsp+0x38], eax (te32.th32ThreadID == calling thread?) +// 0x1800A9761: je skip (exclude caller's thread) +// 0x1800A9763: mov rdx, [rdi] (vector data pointer) +// 0x1800A9778: call [IAT:VirtualAlloc] or HeapReAlloc if needed +// 0x1800A97CA: mov [rdx+rcx*4], eax (store thread ID) +// 0x1800A97CD: incl [rdi+0xC] (vector count++) +// 0x1800A97DD: call [IAT:Thread32Next](hSnapshot, &te32) +// 0x1800A97E3: test eax, eax → jne loop +// 0x1800A97EB: call [IAT:GetLastError] → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0x1800A9815: call [IAT:CloseHandle](hSnapshot) +Return value: 0 on success (ESI = 0 → je path), 9 on error (EBX = 9 → mov eax, 9). +## 3.2 Thread Suspend/Resume Function (0x1800A9A20–0x1800A9A98) +Iterates the thread ID vector and either suspends or resumes each thread. Called before and after code patching. +void SuspendOrResumeThreads(DWORD* id_vector, int action) { +// action: 0 = resume, 1 = suspend +for (int i = 0; i < id_vector->count; i++) { +DWORD tid = id_vector->data[i]; +if (tid == 0) continue; +HANDLE hThread = OpenThread(0x5A, FALSE, tid); // THREAD_SUSPEND+CONTEXT +if (!hThread) continue; +if (action == 0) ResumeThread(hThread); +else SuspendThread(hThread); +CloseHandle(hThread); +} +// free id_vector->data via HeapFree +} +## 3.3 Code Patcher (0x1800A9A9C–0x1800A9BC3) +Writes trampoline/hook bytes at a target address with full thread-safety. Called from SkillHack and other modules during hook installation. +int PatchCode(int hook_index, int is_jmp) { +// Lookup hook entry: base = g_hookTable[hook_index * 0x38] +void* target = hook_entry->target_va; +void* jump_dest = hook_entry->callback; // or target-5 if is_short_jmp +DWORD old_protect; +// First VirtualProtect: make target page EXECUTE_READWRITE (0x40) +VirtualProtect(target, patch_size, PAGE_EXECUTE_READWRITE, &old_protect); +if (is_jmp) { +// Write E9 JMP rel32 +*(BYTE*)target = 0xE9; +*(DWORD*)(target+1) = (DWORD)jump_dest - (DWORD)target - 5; +if (hook_entry->flags & 1) +*(WORD*)orig_ptr = 0xF9EB; // short jmp back +} else { +// Copy original bytes (stub) +*(DWORD*)target = hook_entry->orig_bytes_dword; +if (hook_entry->flags & 1) { +*(WORD*)(target+4) = hook_entry->orig_word; +*(BYTE*)(target+6) = hook_entry->orig_byte; +} else { +*(BYTE*)(target+4) = hook_entry->orig_byte; +} +} +// Second VirtualProtect: restore original protection +VirtualProtect(target, patch_size, old_protect, &old_protect); +FlushInstructionCache(GetCurrentProcess(), target, patch_size); +// Update flags: toggle enable/jmp bits in hook_entry->flags +return 0; // success +} +# 4. Anti-Debug and Exception Handling +The binary contains two related security functions: a structured exception handler setup that uses IsDebuggerPresent, and a stack security cookie verifier. +## 4.1 Exception Handler Setup (0x1800AC580–0x1800AC6CA) +This function is the C runtime __security_check_cookie and SEH initializer. It is called during DLL initialization (DllMain) and during first-chance exception dispatching. +// 0x1800AC580: CRT security init function +// ecx = fault code (passed in from caller) +// Check IsProcessorFeaturePresent(0x17 = PF_FASTFAIL_AVAILABLE) +call [IAT:IsProcessorFeaturePresent](0x17) +test eax, eax +je skip_int29 +int 29h // Fast fail - terminate without SEH if supported +skip_int29: +call sub_1800AC574 // __security_check_cookie helper +// Set up EXCEPTION_RECORD and CONTEXT for RtlCaptureContext +call RtlCaptureContext // [IAT:0xB1220] +call RtlLookupFunctionEntry // [IAT:0xB1218] - find handler +call RtlVirtualUnwind // [IAT:0xB1210] - unwind frame +// Build EXCEPTION_RECORD: +movl [rsp+50h], 0x40000015 // ExceptionCode = STATUS_FATAL_APP_EXIT +movl [rsp+54h], 1 // ExceptionFlags = EXCEPTION_NONCONTINUABLE +call [IAT:IsDebuggerPresent] // 0x1800AC67B +mov ebx, eax // save result +call [IAT:SetUnhandledExceptionFilter](NULL) // remove any handler +call [IAT:UnhandledExceptionFilter](&record) +test eax, eax +jne done +cmp ebx, 1 // was debugger present? +je done +lea ecx, [eax+3] +call __report_gsfailure // terminate +Note: IsDebuggerPresent is NOT used as an anti-cheat measure; it is part of the MSVC CRT __security_check_cookie fast-fail path. The binary does not actively attempt to detect or evade debuggers — it simply invokes standard MSVC security cookie failure reporting. +## 4.2 Security Canary Verifier (0x1800AC6CC–0x1800AC77B) +This is the standard MSVC __security_check_cookie function. It compares the stack cookie against a magic constant, then triggers a fast-fail if mismatch is detected. +// 0x1800AC6CC: __security_check_cookie +// rcx = stack cookie value to verify +mov rax, [__security_cookie] // load expected cookie (initialized at startup) +mov rbx, 0x2B992DDFA232 // partial expected value (lower 48 bits) +cmp rax, rbx +jne fail // mismatch → security violation +// Derive additional check from: +// GetSystemTimeAsFileTime, GetCurrentThreadId, GetCurrentProcessId, +// QueryPerformanceCounter, combined via XOR and shift +call [IAT:GetSystemTimeAsFileTime] +call [IAT:GetCurrentThreadId] +xor -0x10(%rbp), rax +call [IAT:GetCurrentProcessId] +xor -0x10(%rbp), rax +call [IAT:QueryPerformanceCounter] +// ... XOR operations combining all values +// Mask to 0xFFFFFFFFFFFF (48 bits) +// Compare with stored cookie — mismatch → crash +// This is 100% MSVC runtime security, NOT an anti-cheat check +# 5. HLSL Shader Compilation (D3DCompile) +The cheat overlay uses two shaders compiled at runtime via D3DCompile from D3DCOMPILER_47.dll. Both shaders are the standard ImGui Direct3D11 backend shaders embedded verbatim in .rdata. They are compiled in the D3D11 initialization function (0x180054DC0–0x1800551E8) which is called during the Present hook setup. +## 5.1 Vertex Shader +// Source at RVA 0x3AE660, length = 0x2DD (733 bytes) +// Compilation: D3DCompile(src, 0x2DD, NULL, NULL, NULL, "main", "vs_4_0", 0, 0, ...) +cbuffer vertexBuffer : register(b0) { +float4x4 ProjectionMatrix; +}; +struct VS_INPUT { +float2 pos : POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +PS_INPUT main(VS_INPUT input) { +PS_INPUT output; +output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +output.col = input.col; +output.uv = input.uv; +return output; +} +## 5.2 Pixel Shader +// Source at RVA 0x3AE940, length = 0x191 (401 bytes) +// Compilation: D3DCompile(src, 0x191, NULL, NULL, NULL, "main", "ps_4_0", 0, 0, ...) +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +sampler sampler0; +Texture2D texture0; +float4 main(PS_INPUT input) : SV_Target { +float4 out_col = input.col * texture0.Sample(sampler0, input.uv); +return out_col; +} +## 5.3 Shader Initialization Sequence (0x180054DC0) +// Prologue: save R14-R15, allocate 0x220 stack +// Load g_D3DState from [g_Config+0xD8] into R14 +// Check if already initialized: cmp (*r14), null +je skip_init +// Call sub_0x1800551F0 (create vertex/index buffers) +// === Compile Vertex Shader === +lea rcx, [rip+0x1803AE660] // HLSL source ptr +mov edx, 0x2DD // source length +xor r8d, r8d // pSourceName = NULL +xor r9d, r9d // pDefines = NULL +mov [rsp+20h], r15 // pInclude = NULL +lea rax, [0x1803AEADC] // 'main' string +mov [rsp+28h], r12 // pInclude (NULL) +mov [rsp+30h], rax // pEntrypoint = 'main' +lea rax, [0x1803AEAD4] // 'vs_4_0' +mov [rsp+38h], r15d // Flags1 = 0 +mov [rsp+40h], r15d // Flags2 = 0 +mov [rsp+48h], &ppVSCode // output blob ptr +mov [rsp+50h], r15 // ppErrorBlob = NULL +call [IAT:D3DCompile] +js fail +// Get VS blob pointer, call ID3DBlob::GetBufferPointer/GetBufferSize +// Then: call ID3D11Device::CreateVertexShader via vtable slot[0x20/8] +// Create input layout via vtable slot[0x58/8] +// Create constant buffer (ProjectionMatrix) via vtable slot[0x60/8] +// === Compile Pixel Shader === +lea rcx, [rip+0x1803AE940] // PS HLSL source +mov edx, 0x191 // PS source length +// ... same parameters pattern ... +// pEntrypoint = 'main', target = 'ps_4_0' +call [IAT:D3DCompile] +js fail +// Create pixel shader via vtable slot[0x78/8] (CreatePixelShader) +// Create sampler state via vtable slot[0x78/8] on device +// Create blend state (alpha blending) with blend ops +// Create depth stencil state +// Create rasterizer state +# 6. Configuration File I/O +Configuration is read and written using a helper function (0x180011EA0) that converts UTF-8 paths to wide-char then calls _wfopen. Callers pass different file mode strings ('rb' for read, 'wt' for write) to the same function. +## 6.1 File Open Helper (0x180011EA0–0x180012043) +FILE* OpenConfigFile(const char* path_utf8, const char* mode_utf8) { +// rcx = path_utf8, rdx = mode_utf8 +// Get length of path: MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0) +int path_len = MultiByteToWideChar(0xFDE9, 0, path, -1, NULL, 0); // CP_UTF8=65001=0xFDE9 +// Get length of mode string +int mode_len = MultiByteToWideChar(0xFDE9, 0, mode, -1, NULL, 0); +// Allocate wide char buffer (stack if small enough, heap if > 0x104 chars) +if (path_len + mode_len > 0x104) +wbuf = malloc((path_len + mode_len) * 2); +else +wbuf = alloca((path_len + mode_len) * 2); +wchar_t* wpath = wbuf; +wchar_t* wmode = wbuf + path_len; +// Convert path to wide +MultiByteToWideChar(0xFDE9, 0, path, -1, wpath, path_len); +// Convert mode to wide +MultiByteToWideChar(0xFDE9, 0, mode, -1, wmode, mode_len); +// Open file +FILE* fp = _wfopen(wpath, wmode); +if (heap_buf) free(heap_buf); +return fp; +} +## 6.2 Config File Mode Strings +Two mode strings are stored in .rdata at consecutive addresses: +RVA +String +Usage +0x3AD590 +'rb' +Config READ - binary read mode +0x3AD594 +'wt' +Config WRITE - text write mode (ImGui ini) +## 6.3 Config Read Callers +The config file open helper is called from two read contexts and two write contexts: +Caller VA +Func Range +Mode +Data Source / Purpose +0x1800170B9 +0x17078-0x172CA +'wt' +Serialize ImGui window positions/sizes to ini file (ImGui_ImplDX11 save) +0x180030750 +0x30620-0x307A0 +'wt' +Write g_Config state to JSON file on module disable/exit +(via fread) +0x302D2-0x30348 +'rb' +Read JSON config on startup, populate g_Config fields +0x18000EA1B +0xE9F4-0xEA33 +n/a +fwrite to stdout/console (debug output, size=1) +## 6.4 Config Write Function (0x180030620) +void SaveConfig(ConfigState* state) { +// Check state->enabled_flag [rbx+0x2900] +// Load state->file_path pointer [rbx+0x50] +// Call sub_0x180030A90 (build file path string) +// Call OpenConfigFile(path, 'wt') → returns FILE* fp +// Serialize config to string via sub_0x180012050 +// fwrite(config_string, 1, string_length, fp) +// fclose(fp) +// Also handles periodic auto-save: +// xmm0 = [rbx+0x2904] (auto-save timer) +// if (timer > 0) { timer -= delta_time } +// When timer expires: rebuild path, re-open, write again +} +# 7. WndProc Handler and Hotkey Dispatch +The WndProc callback is registered at VA 0x1800826A0 during window class creation (RegisterClassExW). It is the Win32 message handler for the overlay window and handles three specific messages before deferring all others to ImGui's built-in handler. +## 7.1 WndProc Function (0x1800826A0) +Signature: LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// Step 1: Pass ALL messages to ImGui first +if (g_ImGuiCtx != NULL) { +// ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam) +// [rsp+0x20] = g_ImGuiCtx+0x30 +LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +if (r != 0) return 1; // ImGui consumed the message +} +switch (msg) { +case WM_DESTROY (0x0002): +PostQuitMessage(0); +return 0; +case WM_SIZE (0x0005): +// Ignore minimize (SIZE_MINIMIZED = 1) +if (g_pSwapChain != NULL && wParam != 1) { +// Free existing render target +if (g_pRenderTargetView) { +g_pRenderTargetView->Release(); // vtable[0x10] +g_pRenderTargetView = NULL; +} +// Resize swap chain buffers +// pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), 0, 0) +g_pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), +DXGI_FORMAT_UNKNOWN, 0); // vtable[0x68] +// Recreate D3D11 resources (render target, shaders, etc.) +HookInstall(); // 0x1800825B0 +} +return 0; +case WM_SYSCOMMAND (0x0112): +// Suppress SC_KEYMENU (ALT key activating system menu) +if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +break; +default: +// Forward to DefWindowProcW via ImGui_ImplWin32_WndProcHandler +return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +} +return 0; +} +## 7.2 Message Dispatch Table +WM_ Code +Value +Action +Notes +WM_DESTROY +0x0002 +PostQuitMessage(0) +Triggers clean shutdown of message loop +WM_SIZE +0x0005 +ResizeBuffers + HookInstall() recreate +Skipped if wParam==SIZE_MINIMIZED(1) +WM_SYSCOMMAND +0x0112 +Return 0 if SC_KEYMENU (0xF100) +Suppresses ALT-key menu flash on overlay +(all others) +- +Defer to ImGui_ImplWin32_WndProcHandler +ImGui handles mouse/keyboard/focus/IME +## 7.3 F12 Hotkey — Panel Toggle +The overlay panel toggle is NOT processed inside WndProc. It is polled via GetAsyncKeyState in the per-frame Present hook loop at VA 0x18008301A, which is part of the ModuleManager main render function (0x180082FC0). +// Inside ModuleManager render loop (0x180082FC0), called each Present() frame: +// Poll F12 key (VK_F12 = 0x7B) +SHORT keyState = GetAsyncKeyState(0x7B); // VK_F12 +if (keyState & 0x1) { +// Key was pressed since last call — toggle panel visibility +// Static init guard pattern (MSVC thread-safe static) +// g_showPanel (.data+0x245C) = !g_showPanel +g_Config.show_panel ^= 1; // [.data+0x245C] toggle +} +// Banner string shown in game window title / tray when panel is hidden: +// 'EF - Cheeto Press F12 to show panel' (RVA 0x3AF258) +Address +Description +0x18008301A +GetAsyncKeyState(VK_F12=0x7B) call — panel toggle poll +.data+0x245C +g_showPanel flag (BYTE): 0=hidden, 1=visible +RVA 0x3AF258 +Banner string 'EF - Cheeto ... Press F12 to show panel' +0x1800826A0 +WndProc callback registered via RegisterClassExW +0x180057720 +ImGui_ImplWin32_WndProcHandler (handles all ImGui keyboard/mouse) +0x1800825B0 +HookInstall / D3D11 resource recreation (called on WM_SIZE) +## 7.4 Module Hotkeys +A dedicated hotkey error handler exists at 0x1800AECE0, referenced by the string '[ERROR] Failed to process hotkeys for module'. This function is an exception handler — it is called if a module's hotkey processing throws. Individual module hotkey configurations are stored in the per-module state structs and dispatched by the ModuleManager loop, not in WndProc. +# 8. Hook Manager Internals +The hook manager is a global singleton initialized lazily via an MSVC thread-safe static at 0x180081B00. It manages a flat array of hook entries, a hash table for fast lookup by target address, and a spinlock for thread safety. All four hook API functions (CreateHook, RemoveHook, EnableHook, GetHookInfo) acquire the spinlock at entry and release it on every exit path. +## 8.1 Singleton Memory Layout +The singleton is stored at .data+0x2470 (VA 0x1803C7470). The structure is 0x90 bytes, zero-initialized on first call. +Offset +Type +Field +Description ++0x00 +QWORD* +hook_array +Pointer to flat array of hook entries (0x38 bytes each) ++0x08 +DWORD +hook_capacity +Allocated slot count for hook_array ++0x0C +DWORD +hook_count +Number of active hooks currently installed ++0x10 +QWORD* +hash_buckets +Pointer to hash table bucket array (linked list heads) ++0x18 +DWORD +bucket_count +Number of hash buckets (power of 2, initial=8) ++0x1C +DWORD +bucket_mask +hash_mod mask = bucket_count*2 - 1 ++0x20 +QWORD* +free_list_head +Head of freed/recycled hook slot free list ++0x28 +float +load_factor +Hash table load factor threshold (0x3f800000 = 1.0f) ++0x30 +BYTE +initialized +Set to 0 after init, prevents double-init +.data+0x1E88 +DWORD +spinlock +Global spinlock DWORD; 0=free, 1=held +## 8.2 Hook Entry Structure (0x38 bytes) +Each entry in the hook_array is 0x38 bytes. The hook array grows dynamically; initial capacity is 0x80 slots allocated via the IAllocator at .data+0x1E90. +Offset +Type +Field +Description ++0x00 +QWORD +target_va +Virtual address of the hooked IL2CPP function ++0x08 +QWORD +callback_va +Virtual address of the replacement/detour function ++0x10 +QWORD +trampoline_va +VirtualAlloc'd trampoline (original bytes + JMP back) ++0x18 +DWORD +orig_bytes_0_3 +Saved original 4 bytes at target (for restore) ++0x1C +WORD +orig_bytes_4_5 +Saved original bytes 4–5 at target ++0x1E +BYTE +orig_byte_6 +Saved original byte 6 at target ++0x20 +BYTE +flags +Bit 0: has_far_jmp (6-byte JMP); Bit 1: enabled; Bit 2: suspended ++0x24 +DWORD +flags2 +Lower nibble: hook type (0=near JMP, 1=far) ++0x28 +QWORD +hash_next +Next entry pointer in hash chain (for collision chaining) ++0x30 +QWORD +reserved +Padding / future use +## 8.3 Spinlock (0x1800A9C88) +All four hook API functions call the spinlock acquire function at 0x1800A9C88 on entry. Release is done inline via XCHG [.data+0x1E88], 0 at the end of each function. +// Spinlock acquire — 0x1800A9C88 +// Uses LOCK CMPXCHG on .data+0x1E88 (global DWORD spinlock) +void AcquireSpinlock() { +DWORD backoff = 0; +while (true) { +DWORD expected = 0; +// LOCK CMPXCHG [.data+0x1E88], 1 +if (InterlockedCompareExchange(&g_spinlock, 1, 0) == 0) +return; // acquired +// Exponential backoff: if backoff < 32, SwitchToThread(0); else Sleep(1) +backoff += 1; +if (backoff < 32) +SwitchToThread(); // IAT 0x1800B1148 +else +Sleep(1); +} +} +// Spinlock release — inline in all callers +// XCHG [.data+0x1E88], ebx (where ebx=0, atomic store 0) +## 8.4 CreateHook (0x1800A9CC8) +Installs a new hook. Takes target VA (rcx), callback VA (rdx), and optional out_trampoline pointer (r8). Returns 0 on success, error code otherwise. +// CreateHook(void* target, void* callback, void** out_trampoline) -> int +// RVA 0x0A9CC8 +int CreateHook(void* target, void* callback, void** out_trampoline) { +AcquireSpinlock(); // 0x1800A9C88 +// Validate hook manager initialized +if (g_hookMgr.allocator == NULL) return 2; // MH_ERROR_NOT_INITIALIZED +// Validate target and callback are executable +if (!IsExecutable(target)) return 7; // MH_ERROR_NOT_EXECUTABLE +if (!IsExecutable(callback)) return 7; +// Check if hook already exists for this target +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +if (i == -1) continue; +return 3; // MH_ERROR_ALREADY_CREATED +} +} +// Allocate a trampoline buffer near the target +TrampolineSlot* slot = AllocTrampolineSlot(target); // 0x1800A960C +if (!slot) return 9; // MH_ERROR_MEMORY_ALLOC +// Build trampoline: copy prologue bytes + write JMP back +HookEntry entry = {}; +if (!BuildTrampoline(target, callback, slot, &entry)) return 8; +// Fill hook entry fields +entry.target_va = target; // [r8+0x00] +entry.callback_va = callback; // [r8+0x08] (from [rsp+0x28]) +entry.trampoline_va = slot->code; // [r8+0x10] +// Save original bytes for unhook restore +if (entry.flags & 1) { // far JMP (6-byte) +entry.orig_bytes_0_3 = *(DWORD*)(target - 5); +entry.orig_bytes_4_5 = *(WORD*) (target - 1); +entry.orig_byte_6 = *(BYTE*) (target + 1); +} else { // near JMP (5-byte) +entry.orig_bytes_0_3 = *(DWORD*)target; +entry.orig_byte_6 = *(BYTE*)(target + 4); +} +if (out_trampoline) *out_trampoline = slot->code; +ReleaseSpinlock(); // XCHG [.data+0x1E88], 0 +return 0; // MH_OK +} +## 8.5 RemoveHook (0x1800A9E8C) +Removes an installed hook by target address. If the hook is enabled, it is disabled first (original bytes restored). The entry is removed from the array by swapping with the last element. The array is shrunk by half if utilization drops below 50% and count > 0x20. +// RemoveHook(void* target) -> int +// RVA 0x0A9E8C +int RemoveHook(void* target) { +AcquireSpinlock(); +if (g_hookMgr.allocator == NULL) return 2; +// Linear search for target in hook array (stride 0x38) +int idx = -1; +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +idx = i; break; +} +} +if (idx == -1) return 4; // MH_ERROR_NOT_CREATED +HookEntry* entry = &g_hookMgr.hook_array[idx]; +// If hook is currently enabled, disable it first (restore original bytes) +if (entry->flags & 0x2) { +GetHookInfo(idx, 0, ...); // 0x1800A96B0 +EnableHook(idx, 0); // 0x1800A9A9C — restore original bytes +SuspendOtherThreads(...); // 0x1800A9A20 — thread safety +} +// Free trampoline memory +FreeSlot(entry->trampoline_va); // 0x1800AA684 +// Compact array: move last entry into freed slot +int last = g_hookMgr.hook_count - 1; +if (idx < last) { +// memmove: copy 0x38 bytes from hook_array[last] to hook_array[idx] +// (3x movups xmm0 + movsd for full 0x38-byte copy) +hook_array[idx] = hook_array[last]; +} +g_hookMgr.hook_count--; +// Shrink array if count <= capacity/2 and count > 0x20 +if (g_hookMgr.hook_capacity / 2 >= 0x20 && +g_hookMgr.hook_count <= g_hookMgr.hook_capacity / 2) { +realloc(hook_array, (capacity/2) * 0x38); +g_hookMgr.hook_capacity /= 2; +} +ReleaseSpinlock(); +return 0; +} +## 8.6 EnableHook / PatchCode (0x1800A9A9C) +Patches or unpatches the target function's first bytes. Suspends all other threads during the write using VirtualProtect + WriteProcessMemory, then resumes them. Handles both near (5-byte E9 JMP) and far (6-byte FF25 indirect JMP) hook types. +// EnableHook(int hook_idx, BOOL enable) -> int +// RVA 0x0A9A9C +int EnableHook(int hook_idx, BOOL enable) { +HookEntry* e = &g_hookMgr.hook_array[hook_idx * 0x38]; +// Determine patch target and size +BOOL far_jmp = e->flags & 0x1; // bit 0: uses 6-byte far JMP +void* patch_target = far_jmp ? (e->target_va - 5) : e->target_va; +SIZE_T patch_size = far_jmp ? 7 : 5; // [rcx*2 + 5] +// VirtualProtect(patch_target, patch_size, PAGE_EXECUTE_READWRITE, &old) +VirtualProtect(patch_target, patch_size, 0x40, &old_protect); +if (enable) { +// Write JMP hook: +*(BYTE*)patch_target = 0xE9; // near JMP opcode +*(DWORD*)(patch_target+1) = +(DWORD)(e->callback_va - (QWORD)patch_target - 5); +if (far_jmp) { +// Also patch 2 bytes before target_va with short JMP back +*(WORD*)(e->target_va) = 0xF9EB; // JMP -5 (back to patch_target) +} +} else { +// Restore original bytes +*(DWORD*)patch_target = e->orig_bytes_0_3; +if (far_jmp) { +*(WORD*) (patch_target+4) = e->orig_bytes_4_5; +*(BYTE*) (patch_target+6) = e->orig_byte_6; +} else { +*(BYTE*) (patch_target+4) = (BYTE)e->orig_bytes_4_5; +} +} +// Restore page protection +VirtualProtect(patch_target, patch_size, old_protect, &old_protect); +// Flush instruction cache +FlushInstructionCache(GetCurrentProcess(), patch_target, patch_size); +// Update flags: set/clear enabled bit (bit 1) and suspended bit (bit 2) +// Bit manipulation: (enable<<2) XOR flags, AND 0x2, XOR flags, XOR enable_bit +e->flags = (e->flags & ~0x6) | ((enable ? 0x2 : 0x0)); +return 0; // MH_OK +} +## 8.7 FNV-1a Hash Implementation +The hash table uses FNV-1a (Fowler–Noll–Vo) 64-bit hashing to map target VA pointers to hash bucket indices. The compiler has unrolled the byte loop into 8 sequential XOR+MUL pairs operating on each byte of the 8-byte pointer. +// FNV-1a 64-bit hash of a pointer value (unrolled, 0x18008D555) +// r11 = target_va (8 bytes to hash) +// r10 = FNV prime = 0x00000100000001B3 +// r9 = FNV offset = 0xCBF29CE484222325 (init value) +uint64_t FNV1a_64(uint64_t target_va) { +uint64_t hash = 0xCBF29CE484222325ULL; // FNV offset basis +uint64_t prime = 0x00000100000001B3ULL; // FNV prime +// Byte 0 (bits 0-7) +hash ^= (uint8_t)(target_va >> 0); hash *= prime; +// Byte 1 (bits 8-15) +hash ^= (uint8_t)(target_va >> 8); hash *= prime; +// Byte 2 (bits 16-23) +hash ^= (uint8_t)(target_va >> 16); hash *= prime; +// Byte 3 (bits 24-31) +hash ^= (uint8_t)(target_va >> 24); hash *= prime; +// Byte 4 (bits 32-39) +hash ^= (uint8_t)(target_va >> 32); hash *= prime; +// Byte 5 (bits 40-47) +hash ^= (uint8_t)(target_va >> 40); hash *= prime; +// Byte 6 (bits 48-55) +hash ^= (uint8_t)(target_va >> 48); hash *= prime; +// Byte 7 (bits 56-63) +hash ^= (uint8_t)(target_va >> 56); hash *= prime; +// Map to bucket index +uint64_t bucket_idx = hash & bucket_mask; // [r8+0x48] +bucket_idx += bucket_idx; // *2 for pointer-sized bucket entries +return bucket_idx; +} +// Bucket lookup in hash chain: +// head = hash_buckets[bucket_idx] // [rcx + r9*8 + 0x00] +// sentinel = hash_buckets[bucket_idx + 1] // [rcx + r9*8 + 0x08] +// while (node != sentinel): +// if node->target_va == target: return node +// node = node->hash_next +## 8.8 Hook Manager Key Addresses +Address +Function / Field +Notes +0x1800A9C88 +AcquireSpinlock() +LOCK CMPXCHG loop with SwitchToThread/Sleep backoff +0x1800A9CC8 +CreateHook(target, cb, tramp) +Validates, searches array, builds trampoline, patches +0x1800A9E8C +RemoveHook(target) +Finds by linear search, disables if live, frees trampoline, compacts +0x1800A9A9C +EnableHook(idx, enable) +VirtualProtect + write JMP/restore + FlushInstructionCache +0x1800A96B0 +GetHookInfo(idx, ...) +Reads hook entry fields into caller-supplied buffer +0x1800A960C +AllocTrampolineSlot(target) +Finds or allocates VirtualAlloc page near target +0x1800AA684 +FreeTrampolineSlot(tramp) +Returns slot to free list +.data+0x1E88 +g_spinlock (DWORD) +Global spinlock; acquired via CMPXCHG, released via XCHG +.data+0x1E90 +g_allocator (QWORD*) +IAllocator vtable pointer used by hook manager +.data+0x2470 +g_hookMgr (struct, 0x90B) +Hook manager singleton base address +.data+0x2480 +hook_array (QWORD*) +Flat array of 0x38-byte hook entries +.data+0x27E0 +hook_array (mirror ptr) +Second reference to hook_array base +.data+0x27EC +hook_count (DWORD) +Number of currently installed hooks +0x18008D555 +FNV-1a hash body +Unrolled 8-byte XOR/MUL loop, prime=0x100000001B3 +# 9. ESPModule State Layout and Color Table Defaults +The ESPModule state struct is stored at .data+0x1F70 (VA 0x1803C6F70). It is initialized by the lazy singleton at 0x180083E00, which zero-initializes all fields, sets the module name, wires up both vtable pointers, writes boolean defaults for the eight display flags, and loads 12 RGBA color slots from .rdata constants via MOVDQA into 16-byte-aligned slots starting at state+0x40. +## 9.1 ESPModule State Struct Layout +Offset +Type +Field +Default ++0x00 +QWORD* +vtable[0] (init thunk) +0x1803AF9E0 ++0x08 +str* +module_name (std::string) +'ESPModule' ++0x28 +BYTE +enabled +0 (off) ++0x30 +DWORD +max_dist +0x12C = 300 (integer) ++0x34 +BYTE +show_monsters +1 (true) ++0x35 +BYTE +show_npc +1 (true) ++0x36 +BYTE +show_friendly +1 (true) ++0x37 +BYTE +show_puzzles +1 (true) ++0x38 +BYTE +show_all +0 (false) ++0x39 +BYTE +show_distance +1 (true) ++0x3A +BYTE +show_name +1 (true) ++0x3B +BYTE +show_type +0 (false) ++0x3C +DWORD +(alignment padding) +- ++0x40 +float[4] +color[0] RGBA +see table below ++0x50 +float[4] +color[1] RGBA +see table below ++0x60 +float[4] +color[2] RGBA +see table below ++0x70 +float[4] +color[3] RGBA +see table below ++0x80 +float[4] +color[4] RGBA +see table below ++0x90 +float[4] +color[5] RGBA +see table below ++0xA0 +float[4] +color[6] RGBA +see table below ++0xB0 +float[4] +color[7] RGBA +see table below ++0xC0 +float[4] +color[8] RGBA +see table below ++0xD0 +float[4] +color[9] RGBA +see table below ++0xE0 +float[4] +color[10] RGBA +see table below ++0xF0 +float[4] +color[11] RGBA +see table below +## 9.2 Color Table Defaults (12 slots × 16 bytes) +Each slot is a 128-bit XMMWORD (4× IEEE 754 float, little-endian order R, G, B, A). Values are loaded from .rdata constants at init time via MOVDQA. The color slot-to-entity-type mapping follows the order the show_* flags were written in the initializer. +Slot +State Offset +.rdata RVA +R +G +B +A +Color Name +Entity Type +0 ++0x40 +0x3B3510 +1.000 +0.000 +0.000 +1.000 +Red +Monsters / Enemies +1 ++0x50 +0x3B3520 +1.000 +0.647 +0.000 +1.000 +Orange +NPC +2 ++0x60 +0x3B3540 +1.000 +1.000 +0.000 +1.000 +Yellow +Friendly +3 ++0x70 +0x3B3530 +0.000 +1.000 +0.000 +1.000 +Green +Puzzles +4 ++0x80 +0x3B3590 +0.000 +0.000 +1.000 +1.000 +Blue +(spare/all) +5 ++0x90 +0x3B35A0 +0.000 +1.000 +1.000 +1.000 +Cyan +(spare) +6 ++0xA0 +0x3B3580 +0.580 +0.000 +0.827 +1.000 +Purple +(spare) +7 ++0xB0 +0x3B35B0 +1.000 +1.000 +1.000 +1.000 +White +(spare) +8 ++0xC0 +0x3B3560 +1.000 +0.078 +0.576 +1.000 +Hot Pink +(spare) +9 ++0xD0 +0x3B3570 +1.000 +0.753 +0.796 +1.000 +Light Pink +(spare) +10 ++0xE0 +0x3B3500 +0.000 +0.000 +0.000 +1.000 +Black +(spare) +11 ++0xF0 +0x3B3550 +0.502 +0.502 +0.502 +1.000 +Gray +(spare) +All 12 slots have alpha fixed at 1.000 (fully opaque). Slots 0–3 correspond to the four named entity types controlled by show_monsters / show_npc / show_friendly / show_puzzles flags. Slots 4–11 are spare palette entries available for future entity categories; the ImGui color picker in ESPModule::Render exposes all 12 via '##Foreground' color edit widgets. +## 9.3 Show Flag Default Summary +Flag +Offset +Default +Notes +show_monsters ++0x34 +1 (ON) +Draws boxes/labels for monster entities +show_npc ++0x35 +1 (ON) +Draws boxes/labels for NPC entities +show_friendly ++0x36 +1 (ON) +Draws boxes/labels for friendly entities +show_puzzles ++0x37 +1 (ON) +Draws boxes/labels for puzzle objects +show_all ++0x38 +0 (OFF) +Override: draw all entity types regardless of flags above +show_distance ++0x39 +1 (ON) +Appends distance string to entity label +show_name ++0x3A +1 (ON) +Appends entity name string to label +show_type ++0x3B +0 (OFF) +Appends entity type string to label +max_dist ++0x30 +300 +Integer cutoff distance; entities beyond this are not drawn +# 10. SkillHack Hook Callbacks +SkillHack installs up to six IL2CPP hooks across five callback functions. The hooks intercept game methods that govern skill cooldowns, skill availability checks, and skill costs. All five callbacks share the same guard pattern: call SkillHack singleton init (0x180081300), check enabled flag at [singleton+0x28], and either return the bypass value immediately or fall through to the original method via the hook manager's trampoline dispatcher (0x18008FF00). +## 10.1 Hook Installation Map +SkillHack::Render (0x18008D1F0) installs hooks in two stages. Three hooks are installed directly via the hook-installer wrapper (0x18008D8A0). Three more are installed by dedicated patch functions called from Render. All six use the same FNV-1a hash lookup pattern and CreateHook call. +Hook # +Target Ptr +Callback VA +Patch Function +Installed By +1 +[g_Config+0x1E60] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +2 +[g_Config+0x1E68] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +3 +[g_Config+0x1E50] +0x18008D500 (float 100.0) +0x18008E220 +Render → 8E220 → CreateHook +4 +[g_Config+0x1E58] +0x18008D640 (bool true) +0x18008EBC0 +Render → 8EBC0 → CreateHook +5 +[g_Config+0x1E40] +0x18008D780 (void return) +0x18008F560 +Render → 8F560 → CreateHook +6 +[g_Config+0x1E48] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 (tail) +The g_Config IL2CPP function pointer slots are populated at runtime from IL2CPP metadata. Their contents are zero/garbage in the static binary on disk. +## 10.2 Generic Dispatcher — 0x18008D4B0 +Used for hooks 1, 2, and 6. When the skill hack is enabled, returns BOOL true (1) immediately to the caller, bypassing any skill gate check. When disabled, passes through to the original IL2CPP function via the trampoline. +// Generic dispatcher callback — 0x18008D4B0 +// Used for: hooks on [g_Config+0x1E60], [g_Config+0x1E68], [g_Config+0x1E48] +// Return type: BOOL (BYTE in al) +BOOL Callback_Dispatcher(void* self, void* arg) { +// Get SkillHack singleton (lazy init, 0x180081300) +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { // [singleton+0x28] != 0 +return 1; // bypass — skill check always passes +} +// Disabled: look up original function via FNV-1a hash and call trampoline +// HookManager::GetOriginal(hookMgr, this_callback_va, self, arg) +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +return CallOriginal(hookMgr, /*callback=*/0x18008D4B0, self, arg); // → 0x18008FF00 +} +## 10.3 Variant 1: Float Return — 0x18008D500 +Installed by patch function 0x18008E220 on the target at [g_Config+0x1E50]. Intercepts a method that returns a float — most likely GetCooldownPercent() or GetCooldownRemaining(). Returns 100.0 when enabled, indicating the skill is fully cooled down / available. +// Cooldown bypass callback — 0x18008D500 +// Installed on: [g_Config+0x1E50] (via patch fn 0x18008E220) +// Return type: float (xmm0) +float Callback_CooldownBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +// movss xmm0, [rip+0x325de5] -> RVA 0x3B3308 = 100.0f +return 100.0f; // skill cooldown = 100% complete (fully ready) +} +// Hash self VA via FNV-1a, look up hook entry, call original via trampoline +auto* hookMgr = HookManager_GetSingleton(); +return CallOriginal_Float(hookMgr, /*callback=*/0x18008D500, self, arg); +} +// Note: 0x42C80000 = 100.0 IEEE 754 single-precision (confirmed from .rdata RVA 0x3B3308) +// The prior volume summary incorrectly stated this returns 0.0. +## 10.4 Variant 2: Bool True — 0x18008D640 +Installed by patch function 0x18008EBC0 on the target at [g_Config+0x1E58]. Intercepts a method that returns a boolean — most likely IsSkillAvailable() or CanUseSkill(). When enabled, always returns true (1). When disabled, the hash lookup falls through: if the original function is found in the hook table, it is called via tail JMP; otherwise, returns false (0) as a safe default. +// Skill availability bypass callback — 0x18008D640 +// Installed on: [g_Config+0x1E58] (via patch fn 0x18008EBC0) +// Return type: BOOL (BYTE in al) +BOOL Callback_SkillAvailable(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return 1; // skill is always available +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D640); +if (original != NULL) { +// rex.WB JMP r8 — tail call to original +return original(self, arg); +} +// Hash miss — safe fallback +return 0; // xor al,al (0x18008D770) +} +## 10.5 Variant 3: Void Early Return — 0x18008D780 +Installed by patch function 0x18008F560 on the target at [g_Config+0x1E40]. Intercepts a void method — most likely ApplySkillCost() or DeductMana(). When enabled, returns immediately without executing the function body, discarding the cost deduction entirely. When disabled, the hash lookup finds the original and tail-calls it. +// Skill cost bypass callback — 0x18008D780 +// Installed on: [g_Config+0x1E40] (via patch fn 0x18008F560) +// Return type: void +void Callback_SkillCostBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return; // jne 0x18008D894 — skip to ret immediately +// Original cost deduction never executes +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D780); +if (original != NULL) { +// call r8 — call original, then return +original(self, arg); // 0x18008D891: call r8 +} +// If hash miss: no-op (safe for void) +} +## 10.6 Common Trampoline Dispatcher — 0x18008FF00 +When any callback is disabled and needs to call the original IL2CPP method, it calls 0x18008FF00. This function computes the FNV-1a hash of the callback's own VA, looks up the corresponding hook entry's trampoline_va field (+0x18), and tail-jumps to it. It is effectively the 'call original' helper shared by all SkillHack callbacks. +// CallOriginal trampoline dispatcher — 0x18008FF00 +// rcx = hookMgr, rdx = callback_va (used as hash key), r8 = self, r9 = arg +void* CallOriginal(HookManager* mgr, void* callback_va, void* self, void* arg) { +// FNV-1a hash of callback_va -> bucket index +uint64_t hash = FNV1a_64(callback_va); // same unrolled loop as 0x18008D555 +uint64_t bucket_idx = hash & mgr->bucket_mask; +// Walk hash chain to find entry where entry->callback_va == callback_va +HookEntry* entry = FindInHashChain(mgr, bucket_idx, callback_va); +if (entry && entry->trampoline_va) { +// Tail jump to trampoline (original bytes + JMP back) +JMP entry->trampoline_va; // rex.WB jmp r8 +} +// If no entry found: return NULL / no-op +} +## 10.7 Callback Summary Table +VA +Name +Return Type +Enabled Value +Disabled Behavior +Game Method (inferred) +0x18008D4B0 +Dispatcher +BOOL +1 (true) +Call original via 0x8FF00 +Skill gate / permission check +0x18008D500 +CooldownBypass +float +100.0f +Call original via FNV hash + trampoline +GetCooldownPercent / GetCooldownRemaining +0x18008D640 +SkillAvailable +BOOL +1 (true) +Original via tail JMP, or return 0 +IsSkillAvailable / CanUseSkill +0x18008D780 +SkillCostBypass +void +early ret +Original via call r8, or no-op +ApplySkillCost / DeductMana +# 11. DLL Injection Strings — testyip / gatmp.tmp / EF-Cheeto.dll +Three std::string objects are statically pre-initialised in .data and used during the loader's startup sequence. They are not classic injection strings in the sense of being written to a remote process; they are module-path substrings used by the self-presence scanner to confirm that the cheat DLL (or its temp-file loader copy) is already mapped into the target Unity process before the IL2CPP domain is attached. +## 11.1 String Object Layout in .data +All three are MSVC SSO (small-string-optimised) std::string objects with the inline buffer variant active (length ≤ 15, so no heap allocation). Each occupies 24 bytes: 8-byte inline buffer, 8-byte _Mysize, 8-byte _Myres. +String +.data offset (base) +Inline buf offset +Length +Capacity +Content +testyip ++0x308 ++0x318 +7 +15 (0x0F) +testyip\0 (7 bytes) +gatmp.tmp ++0x328 ++0x338 +9 +15 (0x0F) +gatmp.tmp\0 (9 bytes) +EF-Cheeto.dll ++0x348 ++0x358 +13 +15 (0x0F) +EF-Cheeto.dll\0 (13 bytes) +The _Mysize field for testyip reads as zero in the static binary image because the std::string was zero-initialised before the inline buffer was written — the buffer bytes are present but the constructor has not run. At runtime MSVC CRT initialises the object before DllMain executes. +## 11.2 Module Path Scanner — 0x18008B650 +The function at 0x18008B650 receives a process handle (rcx), a pointer array of HMODULE values (rdx), and a count output pointer (r8). For each module handle it calls GetModuleFileNameExW (IAT 0x1800B1168) to obtain the full path as a wide string, then uses the UTF-8→wide converter at 0x18008B4E0 (wrapping MultiByteToWideChar with CP_UTF8 = 0xFDE9) to convert the two search strings, and searches each path with wcsstr. It returns the zero-based array index of the first matching module, or -1 if not found. +// ModulePathScanner — 0x18008B650 +// Scans a process's loaded module list for paths containing known substrings. +// rcx = hProcess rdx = HMODULE[] r8 = DWORD* count_out r9 = extra_arg +int ModulePathScanner(HANDLE hProcess, HMODULE* modules, DWORD* count, void* extra) { +DWORD module_count = *count >> 3; // [rsi] >> 3 = byte-count / sizeof(HMODULE) +if (module_count == 0) return 0; +// Convert search strings from UTF-8 std::string to std::wstring +// 0x18008B4E0: MultiByteToWideChar(CP_UTF8=0xFDE9, 0, src, len, dst, dst_cap) +std::wstring w_gatmp = Utf8ToWide("gatmp.tmp"); // .data+0x338 +std::wstring w_efdll = Utf8ToWide("EF-Cheeto.dll"); // .data+0x358 +int found_count = 0; +for (DWORD i = 0; i < module_count; i++) { +WCHAR path[0x104] = {}; +// GetModuleFileNameExW(hProcess, modules[i], path, 0x104) +if (!GetModuleFileNameExW(hProcess, modules[i], path, 0x104)) +continue; // skip on failure → je 0x18008BA41 +// Convert wide path to std::wstring for wcsstr search +std::wstring wpath = WideToString(path); // 0x18000EB10 +// Search for 'gatmp.tmp' in the path +const wchar_t* pos_gatmp = wcsstr(wpath.c_str(), w_gatmp.c_str()); +// 0x1800AB6A0: custom wcsstr returning iterator, -1 if not found +intptr_t idx_gatmp = (pos_gatmp ? (pos_gatmp - wpath.c_str()) : -1); +if (idx_gatmp == -1) { +// Search for 'EF-Cheeto.dll' in the path instead → 0x18008B937 +const wchar_t* pos_ef = wcsstr(wpath.c_str(), w_efdll.c_str()); +intptr_t idx_ef = (pos_ef ? (pos_ef - wpath.c_str()) : -1); +if (idx_ef != -1) { +// Found — store module handle and record match +modules[found_count] = modules[i]; // compact in-place +found_count++; +} +// else: neither string found, skip module +} else { +// gatmp.tmp match — store module handle +modules[found_count] = modules[i]; +found_count++; +} +} +*count = (found_count * 8); // write back as byte count +return ; // propagates from call r10 (original fn) +} +## 11.3 Hook Installer Wrapper — 0x18008BAF0 +Called at 0x1800A93CC during the main startup sequence (0x1800A9190), after FindWindow('UnityWndClass') confirms the game window exists. Receives the IL2CPP method pointer for a function to hook (rcx = r14 from [IAT+0x7DA4] = EnumProcessModules or similar resolved pointer). Calls CreateHook (0x1800A9CC8) with 0x18008B650 as the callback, handling error codes with log messages 'Failed to remove existing hook: {}' (0x1803AFB30) and 'Failed to create new hook: {}' (0x1803AFB90). +// HookInstallerWrapper — 0x18008BAF0 +// Installs ModulePathScanner (0x18008B650) as hook on a target IL2CPP function. +// Called from main startup (0x1800A9190) once game window is found. +void HookInstallerWrapper(void* target_fn) { +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +// Check if hook already exists — RemoveHook first if so +if (FindExistingHook(hookMgr, target_fn)) { +int rc = RemoveHook(target_fn); // 0x1800A9E8C +if (rc != 0) { +Log("Failed to remove existing hook: {}", FormatError(rc)); // 0x1803AFB30 +return; +} +} +// Install new hook with ModulePathScanner as callback +void* trampoline = nullptr; +int rc = CreateHook(target_fn, /*cb=*/0x18008B650, &trampoline); // 0x1800A9CC8 +if (rc != 0) { +Log("Failed to create new hook: {}", FormatError(rc)); // 0x1803AFB90 +return; +} +// trampoline stored at [rbp-0x1] for later EnableHook call +} +## 11.4 Startup Sequence Context — 0x1800A9190 +The main DLL startup function at 0x1800A9190 establishes the console, hooks the module scanner, then proceeds to IL2CPP domain attachment. The three injection strings serve as the identity check: if neither 'gatmp.tmp' nor 'EF-Cheeto.dll' appears in any loaded module's path, the scanner returns no matches and the cheat does not proceed. +Step +Address +Action +1 +0x1800A91CE +AllocConsole — create 'il2cpp Game Console' window +2 +0x1800A9267 +SetConsoleCP(0xFDE9) — set UTF-8 code page +3 +0x1800A92F7 +FindWindowA(NULL, 'UnityWndClass') — poll until game window present +4 +0x1800A93CC +HookInstallerWrapper(EnumProcessModules) — install module scanner +5 +0x1800A93E6 +Log 'Initializing..' — source: E:\\git\\Endfield_Cheeto\\user\\main.cpp:53 +6 +0x1800A942F +Call [g_Config+0x1E80] — IL2CPP domain resolver +7 +0x1800A945A +Log 'IL2CPP Domain Found: ' if domain non-null +8 +0x1800A94C4 +Log 'IL2CPP Thread Attached Successfully: ' on attach +9 +0x1800A9506 +Error branch: Log ‘Failed to Attach IL2CPP Thread!’ (source: main.cpp) +10 +0x1800A9545 +Error branch: Log ‘IL2CPP Domain Not Found!’ (source: main.cpp) if domain is null +11 +0x1800A959F +Success path: Log ‘Initialized’ (source: main.cpp); function returns +Console initialisation detail (steps 1–2): AllocConsole (IAT[0xB1108]) allocates the console window. Three freopen_s calls (IAT[0xB1878]) redirect stdin, stdout, and stderr to CONIN$ and CONOUT$. SetConsoleOutputCP(0xFDE9) sets the UTF-8 code page. GetConsoleMode (IAT[0xB1120]) reads the current output mode flags and SetConsoleMode (IAT[0xB1128]) adds ENABLE_VIRTUAL_TERMINAL_PROCESSING for ANSI colour support. SetConsoleTitleA (IAT[0xB12A0]) sets the window caption to ‘il2cpp Game Console’. The overlay window thread is then launched (call 0x1800827A0) at step 12 (see Ch. 29), running independently of the IL2CPP attach sequence. +The source path 'E:\\git\\Endfield_Cheeto\\user\\main.cpp' (RVA 0x3B3148) confirms the project name and local build directory. 'Endfield_Cheeto' matches the cheat's internal identity; the published DLL name 'EF-Cheeto.dll' abbreviates this. +## 11.5 Injection String Summary +String +.data VA +Role +Search context +testyip +0x1803C5318 +Alternate temp-file loader name +wcsstr scan against each loaded module's full path +gatmp.tmp +0x1803C5338 +Primary temp-file loader name +wcsstr scan — match means loader copy is present +EF-Cheeto.dll +0x1803C5358 +Published DLL name +wcsstr fallback if gatmp.tmp not found in path +The naming pattern indicates a two-stage loader: the cheat is first written as a temp file (gatmp.tmp or testyip) via a dropper, then optionally renamed or loaded directly as EF-Cheeto.dll. The module path scanner confirms whichever form is loaded before proceeding with IL2CPP hooking. +# 12. Module Render() and Update() Implementations +Each module exposes two callable entry points registered with ModuleManager: a Render() function that draws the ImGui tab panel and handles one-shot toggle/config writes, and an Update() callback (stored as a .rdata function pointer) that runs the per-frame game-state mutation. SetDither and the SkillHack 'Free Skill' tab share a no-op stub at 0x18008/3DC0 whose entire job is to free a string and optionally call operator delete on the module object — meaning those two tabs perform all their work at Render time, not per-frame. The seven implementations are documented below. +## 12.1 Shared g_Config Panel-Width Sequence +All modules that expand their ImGui tab panel write an identical five-instruction sequence at panel-open and invert it at panel-close. This sequence adjusts the panel scroll region width in the global config object g_Config ([.data+0x1c00]). The fields involved are: +Field +g_Config offset +Role +panel_ptr ++0x15D8 +Pointer to the active ImGui panel/window struct +scroll_step ++0x0E0C +Per-frame scroll delta (float, typically a small positive value) +scroll_accum ++0x194 +Accumulated horizontal scroll position (float) +scroll_base ++0x58 +Base horizontal offset for child panels (float) +scroll_total ++0x198 +Total scroll range (float) +panel_width ++0x150 +Rendered panel content width (float, written each frame) +// Panel-open sequence (addss — widens panel each frame module is visible) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; // mark panel as active/dirty +rax = g_Config->panel_ptr; +xmm0 = g_Config->scroll_step; // [g_Config+0x0E0C] +xmm0 += rax->scroll_accum; // [panel+0x194] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; // [panel+0x58] +xmm0 += rax->scroll_total; // [panel+0x198] +rax->panel_width = xmm0; // [panel+0x150] — expand +// Panel-close sequence (subss — narrows panel each frame module is hidden) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; +rax = g_Config->panel_ptr; +xmm0 = rax->scroll_accum; // [panel+0x194] +xmm0 -= g_Config->scroll_step; // [g_Config+0x0E0C] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; +xmm0 += rax->scroll_total; +rax->panel_width = xmm0; // shrink +This pattern appears verbatim in every module's Render body and is not repeated in the per-module pseudocode below — it is implied by 'panel-open sequence' and 'panel-close sequence'. +## 12.2 NoClip +Function +RVA +Role +NoClip::RegisterTab +0x180081300 +One-time tab registration (Render stub #1) +NoClip::Render +0x1800813D0 +ImGui tab panel — checkbox + Move Speed slider +NoClip::Update +0x180089B50 +Per-frame: CharacterController.enabled toggle + speed slider +NoClip::Update stub +0x180089B00 +Tab-manager destructor/cleanup wrapper +NoClip disables/re-enables the Unity CharacterController component on matching entities each frame. When enabled the controller's collision is suppressed, allowing the player to pass through geometry. A Move Speed integer slider ([module+0x30], range 1–10, step 1) controls movement rate while noclip is active. +// NoClip::Render RVA 0x1800813D0 +// rcx = NoClip* this +void NoClip::Render() { +// Panel-open sequence (g_Config+0x1c00, +0x15D8/0xE0C/0x194/0x58/0x198/0x150) +std::string title = MakeString("NoClip", 6); // 0x18000FCB0 +std::string tmp; +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &title); // 0x18009D7D0 +// resolve std::string to char* via SSO check (cmp [rax+0x18], 0xF) +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 — returns true if clicked +// free tmp, title +if (!clicked) { panel-close sequence; return; } +// Panel-open sequence +// second tab header: 'ON / OFF' +bool on_off_clicked = TabManager_BeginTab([.data+0x27B0], &tmp, &title); +// resolve buf, call 0x180085320 (CheckboxToggle) with &this->enabled [+0x28] +// CheckboxToggle: if edx (new_val) != *rdx (current), flip and update +// Panel-open/close based on [this+0x28] +if ([this+0x28] enabled) { +// 'Move Speed' DragInt slider: [this+0x30], range [1,10], step 1, format '%d' +// 0x180066750 — ImGui::DragInt4-variant +panel-open sequence; +} else { +panel-close sequence; +} +} +// NoClip::Update RVA 0x180089B50 +// Called per-frame by ModuleManager hook +void NoClip::Update() { +// Same 'NoClip' tab header + ON/OFF checkbox pattern as Render +if (!clicked) return; +panel-open sequence (if enabled) +'Move Speed' DragInt slider — same as Render, writes [this+0x30] +// Entity iterator loop (0x180089DC0) +bool noclip_on = [this+0x28]; +void* entity_mgr = g_Config->GetEntityManager(); // [g_Config+0x1D28] — IL2CPP call +if (!entity_mgr) return; +void* list = entity_mgr->GetComponentList(); // [entity_mgr+0x10]->field_0x10 +int count = list->count; // [list+0x20] +void** arr = list->items; // [list+0x10][+0x10] +arr += 0x20; // skip header slots +for (int i = 0; i < count; i++, arr++) { +void* component = *arr; +if (!component) continue; +void* ctrl = GetCharacterController(component); // [g_Config+0x1E20] IL2CPP call +if (!ctrl) continue; +// CharacterController.set_enabled(!noclip_on, 0) +// [g_Config+0x1E08]: IL2CPP setter — dl = !noclip_on, r8d = 0 +bool enable_cc = !noclip_on; +SetEnabled(ctrl, enable_cc, 0); // 0x1803C6E08 +} +// Move Speed DragInt — panel sequence at close +} +## 12.3 FreeCam +Function +RVA +Role +FreeCam::RegisterFpsTab +0x1800814C0 +Registers FPS Monitor overlay tab +FreeCam::RegisterMainTab +0x180081590 +Registers FreeCam main tab (0xD8-byte zeroed state) +FreeCam::FpsUpdate stub +0x180087150 +FPS overlay destructor wrapper; tab cleanup +FreeCam::Update +0x1800871A0 +Per-frame: camera override, WASD+mouse input, speed sliders +FreeCam overrides the game camera's transform each frame when enabled. RegisterMainTab zeroes a 0xD8-byte state block in .data ([.data+0x2200]) and writes hard-coded default key bindings (0x44415357 = 'WASD', 0x6D6BA220, 0x2725, 0x60) and clears floats for pitch/yaw/roll/FOV accumulators. It also clears an 8-byte 'active camera' pointer and related state. Move Speed defaults to 30.0f (0x41F00000 IEEE 754), step 0.1f (0x3DCCCCCD). Look Sensitivity defaults to 100.0f (0x42C80000), step 0.1f (0x3DCCCCCD). Roll Speed ([this+0x34]) and FOV Speed ([this+0x38]) have dedicated sliders with format '%.3f'. +// FreeCam::RegisterMainTab RVA 0x180081590 +// Runs once at DLL init; zeroes FreeCam state block and writes defaults +void FreeCam::RegisterMainTab() { +// Zero [.data+0x2200] block (0xD8 bytes via memset-like call 0x1800AC86A) +std::string tab = MakeString("FreeCam", 7); +// register tab with TabManager (0x18000F7D0), clear active flag, free strings +// Write update fn ptr: [.data+0x2200] = 0x1803AFE10 → FreeCam::Update +// Write default key bindings to [.data+0x2230..0x225E]: +// movdqa [+0x2230] = [0x1803B34F0] (key config block 1) +// movdqa [+0x2240] = [0x1803B35C0] (key config block 2) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier default) +// [+0x2254] = 0x44415357 ('WASD' key code mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind) +// [+0x225E] = 0x60 (backtick key code) +// Zero floats: pitch/yaw/roll/FOV [+0x2260..0x22A8], camera ptr [+0x22B0..0x22D0] +} +// FreeCam::Update RVA 0x1800871A0 +void FreeCam::Update() { +std::string hdr = MakeString("Free Camera", 11); +bool open = TabManager_BeginTab(&tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// ON/OFF checkbox → [this+0x28] +bool on_off = TabManager_BeginTab(...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 +if (!this->enabled) { +// Disable camera override: clear active cam ptr [this+0x70] and [this+0x68] +// [g_Config+0x1DB8]: IL2CPP Camera.set_enabled(false/true calls) +Camera_SetEnabled([this+0x70], false, 0); // 0x1803C6DB8 +Camera_SetEnabled([this+0x68], true, 0); +[this+0xB8] = 0; // clear 'cam override active' flag +panel-close sequence; +return; +} +// Move Speed float slider: [this+0x30], max 500.0f, min 0.1f, fmt '%.3f' +// 0x180065570 — ImGui::SliderFloat8 variant (8 = DragFloat with extra params) +// [rsp+0x40]=500.0f (max), [rsp+0x48]=0.1f (min), xmm3=step +// Roll Speed float slider: [this+0x34], max 100.0f (0x42C80000), min 0.1f +// Look Sensitivity float slider: [this+0x38]? (identified from 'FOV Speed' string) +// (Three consecutive float sliders: Move Speed, Roll Speed, FOV Speed) +// Key input + camera transform written via IL2CPP calls on camera component +// (Camera.get_main, Transform.set_position, Transform.set_rotation via vtable) +} +## 12.4 FpsUnlocker +Function +RVA +Role +FpsUnlocker::RegisterTab +0x180081730 +Registers 'Fps Unlocker' tab; writes default fps=300 ([.data+0x21E8]) +FpsUnlocker::Render +0x180085B90 +ImGui panel: checkbox + Fps Value DragInt, calls Application.targetFrameRate +FpsUnlocker::Update stub +0x180085B40 +Tab destructor/cleanup wrapper; cleanup size 0x38 +FpsUnlocker calls the IL2CPP Application.set_targetFrameRate setter ([.data+0x1D48]) on every Render call (not per-frame Update). When the checkbox is off, it passes 60 (0x3C) as the frame rate. When on, it passes [this+0x30] — the user's chosen value. A Fps Value DragInt slider ([this+0x30], max 500, min 30, step 1, format '%d') is displayed in a second tab header. RegisterTab writes a default of 300 (0x12C) to the .data slot backing [this+0x30]. +// FpsUnlocker::Render RVA 0x180085B90 +void FpsUnlocker::Render() { +std::string hdr = MakeString("Fps Unlocker", 12); +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// First action on open: call Application.set_targetFrameRate +// (regardless of enabled state — immediate effect) +int fps_val = this->enabled ? this->fps_target : 60; +Application_SetTargetFrameRate(fps_val); // [.data+0x1D48] IL2CPP +// ON/OFF checkbox → CheckboxToggle([this+0x28]) +if (this->enabled) { +panel-open sequence; +// 'Fps Value' DragInt: [this+0x30], max=500, min=30, step=1, fmt='%d' +// 0x180065570 ImGui::DragInt variant +// On each interaction: call Application.set_targetFrameRate([this+0x30]) +// ... then subss panel-close sequence +} else { +// panel-close sequences x2 (one per BeginTab call) +} +} +## 12.5 SetDither +Function +RVA +Role +SetDither::RegisterTab +0x180081810 +Registers 'SetDither' tab; stores update ptr 0x1803B01B0 → stub 0x180083DC0 +SetDither::Render +0x180081810 +Identical to RegisterTab (same address — no separate Render body) +SetDither::Update +0x180083DC0 +No-op stub: frees string [this+0x8], optionally operator delete(this, 0x30) +SetDither is the simplest module. Its registration function and Render body coincide at the same RVA — the 'tab' it registers has no interactive widgets beyond the standard tab header registration. The stored update pointer leads to the shared no-op stub at 0x180083DC0. The stub frees a std::string at [rcx+0x8] then, if the dirty bit (bl & 1) is set, calls operator delete on the module pointer with size 0x30. There is no per-frame game-state write associated with SetDither in this binary; the feature is either not yet implemented or was stripped before release. +// SetDither::RegisterTab / Render RVA 0x180081810 +void SetDither::RegisterTab() { +std::string hdr = MakeString("SetDither", 9); +// Register tab with TabManager (0x18000F7D0) +// Write update fn ptr: [.data+0x2180] = 0x1803B01B0 → 0x180083DC0 (stub) +// Cleanup string, return [.data+0x2180] +} +// Shared no-op Update stub RVA 0x180083DC0 +// Used by SetDither, FreeCam FPS overlay, and SkillHack 'Free Skill' tab +void* NoOpUpdateStub(void* this_ptr, BOOL dirty) { +std::string& s = *(std::string*)((char*)this_ptr + 8); +std::string_destroy(&s); // 0x18000FA60 +if (dirty & 1) { +operator_delete(this_ptr, 0x30); // 0x1800AB758 +} +return this_ptr; +} +## 12.5.1 SetDither::RenderOverlay (RVA 0x8C4A0) +SetDither::RenderOverlay is a separate callable entry point distinct from RegisterTab. It is invoked by the ModuleManager render loop on every Present() frame. The function (0x8C4A0–0x8C70D, 621 bytes) draws the “Set Dither” (i18n key RVA 0x3B0198) panel inside the main cheat overlay. Its control flow follows the standard module pattern: +// SetDither::RenderOverlay RVA 0x18008C4A0 +void SetDither::RenderOverlay(SetDither* this) { +// Tab guard: i18n lookup for "Set Dither" key (RVA 0x3B0198, 10 chars) +std::string tabName = i18n_lookup("Set Dither"); // 0x18000FCB0 +bool open = TabManager_BeginTab(tabName, g_locale); // 0x18009D7D0 +if (!open) { string_destroy(tabName); return; } +// Panel-open: addss [g_Config+0x15D8]+0x194 with [g_Config+0xE0C] +g_Config->panel_state->height += g_Config->dither_panel_height; // expand +// "ON / OFF" toggle bound to [this+0x28] (dither_enabled BOOL) +std::string label = i18n_lookup("ON / OFF"); // RVA 0x3AF848, 8 chars +DitherToggle(label, &this->dither_enabled); // 0x180085320 (rcx=label, rdx=&[rsi+0x28]) +// Panel-close: subss restores height +g_Config->panel_state->height -= g_Config->dither_panel_height; +} +The singleton state block for SetDither is accessed via [g_Config+0x15D8] (pointer to the active game state node at runtime). The field [this+0x28] is the dither_enabled BOOL; the DitherToggle helper at 0x180085320 is the same ImGui toggle helper used by other modules. The “ON / OFF” i18n label at RVA 0x3AF848 distinguishes this from the other modules which use a module-name toggle pattern. +## 12.6 PlayerProfile +Function +RVA +Role +PlayerProfile::RegisterTab +0x1800818E0 +Registers tab, zeroes two std::string fields, stores IL2CPP find fn ptrs +PlayerProfile::Render +0x1800818E0 +Same RVA — tab registration IS the render registration +PlayerProfile::Update +0x18008A4F0 +Per-frame: UI node traversal, SetText on two TMP labels, Name Changer input +PlayerProfile::Update stub +0x18008A4A0 +Destructor wrapper: frees [this+0x50], [this+0x30], [this+0x8], delete(0x78) +PlayerProfile resolves two Unity UI node paths each frame when enabled. The first path '/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text' (RVA 0x3AFED0, len 0x2F) finds the UID display TextMeshProUGUI component and overwrites its text with the content of [this+0x30] (an internal std::wstring). The second path '/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName' (RVA 0x3AFFD0, len 0x8D) finds the name label and overwrites it with [this+0x50]. A 'UID text' input box and a 'Name text' input box are shown in the panel. A 'Name changer' checkbox ([this+0x70]) enables the ManagerName write. RegisterTab zeroes both std::string fields via 0x18000FFF0 (wstring init) and stores find-by-path and get-component IL2CPP function pointers. +// PlayerProfile::Update RVA 0x18008A4F0 +void PlayerProfile::Update() { +std::string hdr = MakeString("PlayerProfile", 13); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +CheckboxToggle(&this->enabled, ...); // ON/OFF → [this+0x28] +if (this->enabled) { +// Resolve UID text node +std::string path1 = "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text"; +void* uid_node = IL2CPP_FindByPath(path1); // 0x18009BCB0 +if (uid_node) { +// Get TextMeshProUGUI component +void* tmp_comp = GetComponent(uid_node, "TextMeshProUGUI"); +if (tmp_comp) { +// SetText(tmp_comp, 0, this->uid_wstring) — [g_Config+0x1E28] +SetText(tmp_comp, 0, &this->uid_str); // 0x1803C6E28 +} +} +// Resolve second name node (for first name label) +// Same pattern: path → find → GetComponent → SetText +// 'UID text' InputText: writes [this+0x30] (displayed uid string) +// call 0x18008AC20 — InputText_wstring wrapper +// 'Name text' InputText: writes [this+0x50] (player name buffer) +// 'Name changer' checkbox → [this+0x70] +if (this->name_changer_enabled) { // [this+0x70] +// Resolve ManagerName node via long world path +void* name_node = IL2CPP_FindByPath( +"/UINode/WorldUIRoot/WatchPanel/.../ManagerName"); +if (name_node) { +void* tmp_comp = GetComponent(name_node, "TextMeshProUGUI"); +if (tmp_comp) { +SetText(tmp_comp, 0, &this->name_str); // [this+0x50] wstring +} +} +} +} +panel-close sequence; +} +## 12.7 Vacuum +Function +RVA +Role +Vacuum::RegisterTab +0x180081A20 +Registers 'Vacuum' tab, stores update fn ptr 0x1803B0680 → 0x180085B40 stub +Vacuum::Render +0x180093CA0 +ImGui panel: 'Vacuum' checkbox + 'Monster' sub-checkbox; panel-width logic +Vacuum::PhysicsLoop +0x180093F10 +Per-frame Rigidbody.AddForce attraction loop over entity list +Vacuum::Update stub +0x180085B40 +Destructor wrapper: frees [this+0x8], optionally delete(0x38) +Vacuum renders two checkboxes: 'Vacuum' ([this+0x28]) and 'Monster' ([this+0x30]). The physics loop at 0x180093F10 runs each frame when any vacuum flag is active. It obtains the camera's position via IL2CPP (Camera.main → transform → position), then iterates all rigidbody entities and applies an AddForce call that pulls each toward the camera origin. The force vector is computed per-entity as: forceX = (entity.x × attractStrength) + camera.x, forceY similarly, forceZ similarly, where attractStrength (xmm8) is loaded from [.rdata+0x1803B32B4] — a compile-time constant. The 'Monster' flag controls whether monster-type entities are included in the iteration. +// Vacuum::Render RVA 0x180093CA0 +void Vacuum::Render() { +std::string hdr = MakeString("Vacuum", 6); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// 'Vacuum' checkbox: CheckboxToggle(&this->vacuum_on [+0x28]) +// 'Monster' checkbox: CheckboxToggle(&this->monster_on [+0x30]) +// — Monster sub-checkbox uses panel-open/subss sequence at 0x180093EAC +} +// Vacuum::PhysicsLoop RVA 0x180093F10 (called from physics hook each frame) +// rcx = Vacuum* this, xmm1 = attract_vector, r8 = entity_array +void Vacuum::PhysicsLoop(void* this_ptr, vec3 attract_vec, void** entities) { +if (!this->vacuum_on) return; // [this+0x30] +// Get camera position +void* cam_mgr = g_Config->GetCameraManager(); // [g_Config+0x1D28] +if (!cam_mgr) return; +void* main_cam = cam_mgr->GetMainCamera(); // [g_Config+0x1CF0] +void* cam_rb = main_cam->GetRigidbody(); // [g_Config+0x1D60] +void* cam_pos = cam_rb->GetPosition(0); // [g_Config+0x1DC8] +// cam_pos struct: {double x, double y, int z_int, ...} +double cam_x = cam_pos->x; +double cam_y = cam_pos->y; +int cam_z = cam_pos->z_int; +float attract = *(float*)0x1803B32B4; // compile-time attraction constant +// Iterate entity array (from Vacuum::Update inner call 0x180094000) +for each entity in entities { +if (!entity) continue; +void* rb = GetRigidbody(entity); // [g_Config+0x1DF8] +if (!rb) continue; +vec3 pos = rb->GetPosition(0); // [g_Config+0x1D18] +vec3 force; +// Get entity world position +void* rb2 = GetEntityRoot(entity); // [g_Config+0x1D60] +vec3 rb2pos = rb2->GetWorldPos(0); // [g_Config+0x1DC8] +vec3 rb2pos2 = rb2->GetAltPos(0); // [g_Config+0x1DA8] +vec3 rb3pos = rb2->GetFwd(0); // [g_Config+0x1D90] +// force = attract * rb3pos + camera_pos (component-wise) +force.x = rb3pos.x * attract + cam_x; +force.y = rb3pos.y * attract + cam_y_component; +force.z = rb3pos.z * attract + cam_z_component; +// Rigidbody.AddForce(rb, &force, ForceMode=0) [g_Config+0x1E00] +AddForce(rb, &force, 0); +} +} +## 12.8 SkillHack::Render — Complete Panel Body +Function +RVA +Role +SkillHack::Render +0x18008D1F0 +Hook installer entry: installs six IL2CPP hooks, then falls to panel fn +SkillHack::RenderPanel +0x18008D240 +ImGui panel: 'Free Skill' checkbox + ON/OFF toggle + panel-width sequence +SkillHack::Update +0x180083DC0 +No-op stub (shared with SetDither — no per-frame game write) +SkillHack::Dispatcher +0x18008D4B0 +BOOL hook callback: returns 1 when [SkillHack+0x28] is set +SkillHack::CooldownBypass +0x18008D500 +float hook callback: returns 100.0f when enabled +SkillHack::AvailBypass +0x18008D640 +BOOL hook callback: returns 1 when enabled +SkillHack::CostBypass +0x18008D780 +void hook callback: early-return (skip cost deduction) when enabled +SkillHack::Render at 0x18008D1F0 is a pure hook-installation function — it does not itself draw any ImGui widgets. It installs the six IL2CPP hooks (documented in Section 10) and then tail-jumps to 0x18008D8A0 (the CreateHook wrapper / EnableHook dispatcher). The actual ImGui panel rendering is at 0x18008D240, referenced via the .rdata tab-callback pointer chain. That panel body contains the standard 'SkillHack'/'Free Skill' tab header pair followed by the ON/OFF checkbox and the full panel-width sequence. +// SkillHack::Render RVA 0x18008D1F0 — hook installer, NOT the ImGui panel +void SkillHack::Render() { +// Install hooks on six IL2CPP function pointers (see Section 10) +InstallHook(g_Config->il2cpp_fn[0x1E60], &Dispatcher); // 0x18008D8A0 +InstallHook(g_Config->il2cpp_fn[0x1E68], &Dispatcher); +InstallHook_CooldownBypass(); // 0x18008E220 → 0x18008D500 +InstallHook_AvailBypass(); // 0x18008EBC0 → 0x18008D640 +InstallHook_CostBypass(); // 0x18008F560 → 0x18008D780 +InstallHook(g_Config->il2cpp_fn[0x1E48], &Dispatcher); // tail jmp +} +// SkillHack::RenderPanel RVA 0x18008D240 — actual ImGui panel +void SkillHack::RenderPanel() { +// Tab header: 'Free Skill' (10 chars) via TabManager_BeginTab +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// Second tab: 'ON / OFF' +bool on_off = TabManager_BeginTab(..., &tmp_str, ...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 → [this+0x28] +if (this->enabled) { +panel-open sequence; // addss path +// (no additional sliders or sub-widgets beyond the toggle) +} else { +panel-close sequence; // subss path +} +// All six hook callbacks read [SkillHack_singleton+0x28] at call time +// — no deferred write needed here +} +## 12.9 Module Render/Update Address Summary +Module +RegisterTab RVA +Render RVA +Update RVA +Update type +Key field offsets +NoClip +0x181300 +0x1813D0 +0x189B50 +Per-frame entity loop +[+0x28] enabled, [+0x30] move_speed (int) +FreeCam +0x181590 +0x1871A0 +0x1871A0 +Per-frame camera override +[+0x28] enabled, [+0x30] move_speed (float), [+0x34] roll_spd, [+0x38] fov_spd, [+0x68/70] cam ptrs +FpsUnlocker +0x181730 +0x185B90 +stub/none +Render-time only +[+0x28] enabled, [+0x30] fps_target (int, default 300) +SetDither +0x181810 +0x181810 +stub/none +No-op +[+0x28] enabled (unused) +PlayerProfile +0x1818E0 +0x18A4F0 +0x18A4F0 +Per-frame UI path walk +[+0x28] enabled, [+0x30] uid_str, [+0x50] name_str, [+0x70] name_changer +Vacuum +0x181A20 +0x193CA0 +0x193F10 +Per-frame AddForce loop +[+0x28] vacuum_on, [+0x30] monster_on +SkillHack +N/A +0x18D1F0 +stub/none +No-op (hook callbacks handle IL2CPP) +[+0x28] enabled (read by all 6 callbacks) +# 13. Gap Closure Status +Gap +Status +Volume Resolved +Notes +Module Update() bodies +COMPLETE +Ch. 22 +ESPModule::Update completed in Ch. 22; all others in Ch. 12 +Module Render() bodies +COMPLETE +Ch. 22 +ESPModule::RenderOverlay completed in Ch. 22; all others in Ch. 12 +ModuleManager main loop +COMPLETE +Ch. 15 +Present hook + module dispatch; see Ch. 15 +GABypass IL2CPP patching +COMPLETE +Ch. 18 +71 function pointers patched; see Ch. 18 +Config file I/O +COMPLETE +Ch. 6 +UTF-8→wide→_wfopen, 'rb'/'wt' +DLL injection (testyip/gatmp) +COMPLETE +Ch. 11 +Temp file injection pattern; see Ch. 11 +Thread enumeration +COMPLETE +Ch. 3 +Toolhelp32 snapshot loop; see Ch. 3 +Anti-debug checks +COMPLETE +Ch. 4 +MSVC CRT only, no active anti-debug; see Ch. 4 +Shader compilation +COMPLETE +Ch. 5 +Two ImGui HLSL shaders, vs/ps 4_0 +SetWindowDisplayAffinity +COMPLETE +Ch. 21 +PreventScreenshot registered module; full analysis in Ch. 21 +ImGui integration +COMPLETE +Ch. 12 +Win32+D3D11 backends; see Ch. 12. Overlay window init (DPI, CreateWindowExW, D3D11CreateDeviceAndSwapChain, message loop, FindGameWindow, GetOverlayRect) see Ch. 29 +Exception handling +COMPLETE +Ch. 4 +MSVC __security_check_cookie; see Ch. 4 +JSON parsing +COMPLETE +Ch. 19 +Full schema, save/load path, and IAT traced; see Ch. 19 +# 14. Definitive Function Address Table +Complete map of all significant functions identified across all twenty-five chapters: +Function / Purpose +VA Start +VA End +Key Operations +DllMain +0x180001000 +- +Entry point, spawns loader thread +LoaderThread +0x180005000 +- +Init IL2CPP, create window, Present hook +ModuleManager::RegisterAll +0x18009AE00 +- +11 modules registered via stubs +ModuleManager::MainLoop +0x180082000 +0x180082300 +Present hook, ImGui render loop +D3D11Init (shaders) +0x180054DC0 +0x1800551E8 +2× D3DCompile, create D3D resources +ImGui Win32+D3D11 Setup +0x180082500 +- +Backend init, WndProc subclass +CollectProcessThreads +0x1800A96B0 +0x1800A9A1C +Toolhelp32 thread enumeration +SuspendOrResumeThreads +0x1800A9A20 +0x1800A9A98 +OpenThread + Suspend/Resume +PatchCode +0x1800A9A9C +0x1800A9BC3 +VirtualProtect + write hook bytes +HookManager::Install +0x1800A9CC8 +- +Alloc trampoline + FNV hash +HookManager::Remove +0x1800A9E8C +- +Remove and restore bytes +HookManager::Enable +0x1800A9A9C +- +Toggle enabled bit + patch +GABypass::Init +0x18009D1E0 +- +71 IL2CPP stubs patched +OpenConfigFile +0x180011EA0 +0x180012043 +_wfopen(UTF8→wide path, mode) +SaveConfig +0x180030620 +0x1800307A0 +fwrite JSON config to disk +ReadConfig +0x1800302D2 +0x180030348 +fread JSON config from disk +ImGuiSaveIni +0x180017078 +0x1800172CA +fwrite ImGui window layout +__security_init +0x1800AC580 +0x1800AC6CA +CRT SEH + IsDebuggerPresent +__security_check_cookie +0x1800AC6CC +0x1800AC77B +Stack canary: magic 0x2B992DDFA232 +NoClip::Render +0x180089B40 +- +CharacterController enable toggle +SkillHack::Render +0x18008D1F0 +- +IL2CPP hook installer +FreeCam::Render +0x180087150 +- +CinemachineBrain override +FpsUnlocker::Render +0x180085B80 +- +Application.targetFrameRate +SetDither::Render +0x18008C490 +- +Graphics dither toggle +PlayerProfile::Render +0x18008A4A0 +- +Unity UI text manipulation +Vacuum::Render +0x180093C90 +- +Monster item collection +ESPModule::Render +0x180083F60 +- +See Ch. 22 (§22.1) +DamageHack (ghost) +N/A (no code) +- +Ghost feature — no code; see Ch. 23 +PreventScreenshot +0x18008B490 +- +SetWindowDisplayAffinity +ESPModule::DrawOverlay +0x180083000 +- +See Ch. 22 (§22.2) +WndProc +0x1800826A0 +- +Win32 message + WM_SIZE/DESTROY handler; see Ch. 7 +SkillHack::Dispatcher +0x18008D4B0 +- +Generic hook dispatcher (2 hooks); see Ch. 10 +SkillHack::FloatReturn +0x18008D500 +- +Hook cb: return 100.0f (float skills); see Ch. 10 +SkillHack::BoolTrue +0x18008D640 +- +Hook cb: return true (bool checks); see Ch. 10 +SkillHack::VoidReturn +0x18008D780 +- +Hook cb: early void return; see Ch. 10 +SkillHack::TrampolineDispatch +0x18008FF00 +- +Common trampoline dispatcher; see Ch. 10 +ModuleManager::Init +0x18009AC10 +- +Construct + register all modules; see Ch. 15 +ModuleManager::DispatchRender +0x18009AE80 +- +Per-frame Render() dispatch loop; see Ch. 15 +ModuleManager::DispatchHotkeys +0x18009AEF0 +- +Per-frame hotkey dispatch; see Ch. 15 +ModuleManager::DispatchRegInit +0x18009AF60 +- +Registrar init dispatcher; see Ch. 15 +ModuleManager::PresentHook +0x180082F00 +- +D3D11 Present hook; calls Render+Hotkey loops; see Ch. 15 +ModulePathScanner +0x18008B650 +- +Scans loaded modules for testyip/gatmp/EF-Cheeto; see Ch. 11 +HookInstallerWrapper +0x18008BAF0 +- +Wraps CreateHook; validates target ptr; see Ch. 11 +StartupSequence +0x1800A9190 +- +DLL loader startup context; see Ch. 11 +ESPModule::Init +0x180083E00 +- +Lazy singleton init; sets color defaults; see Ch. 9 +ESPModule::RenderOverlay +0x180083FA0 +0x18008499E +ImGui ESP panel (full); see Ch. 22 +ESPModule::Update +0x180084A00 +0x1800852A5 +Entity label draw loop; see Ch. 22 +FPSModule::Initialize +0x1800814C0 +- +once_flag guarded init; see Ch. 20 +FPSModule::RenderOverlay +0x180085700 +0x180085900 +FPS panel + overlay counter; see Ch. 20 +PreventScreenshot::Initialize +0x18008AD70 +- +once_flag guarded init; see Ch. 21 +PreventScreenshot::Render +0x18008AE60 +- +ImGui checkbox; see Ch. 21 +PreventScreenshot::Update +0x18008AFC0 +- +SetWindowDisplayAffinity dispatch; see Ch. 21 +PreventScreenshot::OsCheck +0x18008B220 +- +Win10 build check + affinity call; see Ch. 21 +UnityExplorer::RegisterTab +0x180090060 +- +Tab init, scene hierarchy setup; see Ch. 16 +UnityExplorer::Render +0x180090250 +- +Per-frame scene inspector; see Ch. 16 +UnityExplorer::RefreshScenes +0x180090D40 +- +Scene list refresh helper; see Ch. 16 +HookManager::Spinlock +0x1800A9C88 +- +Spinlock acquire/release; see Ch. 8 +WideToString +0x18000EB10 +- +UTF-8 path to wstring for wcsstr; see Ch. 11 +FreeCam::RegisterTab +0x18000F7D0 +- +Registers FreeCam main tab; see Ch. 12 +BaseModule::Dtor +0x18000FA60 +- +Shared dtor: destroy name string + optional delete; see Ch. 12 +NoClip::RegisterTab +0x18000FCB0 +- +Registers NoClip tab; stores update fn ptr; see Ch. 12 +ManagerName::Init +0x18000FFF0 +- +Zeroes std::string fields for ModuleManager name; see Ch. 15 +ConfigSerialize +0x180012050 +- +Serialize config struct to string for fwrite; see Ch. 6 +ImGui::EndFrame +0x18001C2D0 +- +D3D11/ImGui frame boundary EndFrame call; see Ch. 15 +BuildFilePath +0x180030A90 +- +Build config file path string from state+0x50; see Ch. 6 +D3D11::CreateBuffers +0x1800551F0 +- +Create vertex/index buffers post shader compile; see Ch. 5 +ImGui_ImplWin32_WndProcHandler +0x180057720 +- +ImGui Win32 WndProc message handler; see Ch. 7 +FreeCam::SliderFloat +0x180065570 +- +Move Speed SliderFloat (max 500.0f); see Ch. 12 +FreeCam::DragInt +0x180066750 +- +Move Speed DragInt (range 1-10); see Ch. 12 +TabManager::BeginTab +0x180070820 +- +ImGui tab begin + toggle helper; see Ch. 12 +ImGui::Selectable +0x1800708D0 +- +Preset selector; Per-Config preset writer dispatch; see Ch. 17 +SkillHack::GetSingleton +0x180081300 +- +Lazy once_flag singleton init for SkillHack; see Ch. 10 +NoClip::Render +0x1800813D0 +- +ImGui panel: checkbox + Move Speed slider; see Ch. 12 +FPSModule::RegisterTab +0x180081590 +- +Registers FPS Monitor overlay tab; see Ch. 20 +FpsUnlocker::RegisterTab +0x180081730 +- +Registers Fps Unlocker tab; see Ch. 12 +SetDither::RegisterTab +0x180081810 +- +Registers SetDither tab; stores update ptr; see Ch. 12 +PlayerProfile::RegisterTab +0x1800818E0 +- +Registers PlayerProfile tab; see Ch. 12 +Vacuum::RegisterTab +0x180081A20 +- +Registers Vacuum tab; stores update fn ptr; see Ch. 12 +HookManager::GetSingleton +0x180081B00 +- +Thread-safe static singleton init for HookManager; see Ch. 8 +NoOpUpdateStub +0x180083DC0 +- +Shared no-op Update stub (SetDither, SkillHack free); see Ch. 12 +ESPModule::CheckboxToggle +0x180085320 +- +Toggle checkbox helper used in ESPModule panel; see Ch. 22 +NoClip::EntityIterator +0x180089DC0 +- +Entity iterator loop inner call; see Ch. 12 +InputText::WString +0x18008AC20 +- +ImGui InputText wrapper for wstring fields; see Ch. 12 +SkillHack::InstallHooks +0x18008D8A0 +- +Installs 3 hooks via HookInstallerWrapper; see Ch. 10 +SkillHack::PatchFloat +0x18008E220 +- +Installs FloatReturn hook on [g_Config+0x1E50]; see Ch. 10 +SkillHack::PatchBool +0x18008EBC0 +- +Installs BoolTrue hook on [g_Config+0x1E58]; see Ch. 10 +SkillHack::PatchVoid +0x18008F560 +- +Installs VoidReturn hook on [g_Config+0x1E40]; see Ch. 10 +UnityExplorer::GuardReturn +0x1800901D8 +- +Early return after once_flag sealed; see Ch. 16 +ImGui::Begin +0x1800937D0 +- +ImGui::Begin wrapper (Unity Explorer Window); see Ch. 16 +UnityExplorer::AutoRefresh +0x180093B10 +- +Auto-refresh timer check for scene list; see Ch. 16 +Vacuum::PhysicsLoop +0x180093F10 +- +Per-frame entity attraction physics loop; see Ch. 12 +PlayerProfile::FindUINode +0x18009BCB0 +- +IL2CPP_FindByPath for UI text/UID node; see Ch. 12 +TabManager::BeginTabFull +0x18009D7D0 +- +Full BeginTab with state+title resolution; see Ch. 12 +HookManager::FreeSlot +0x1800AA684 +- +Free trampoline + compact hook array; see Ch. 8 +WideStr::wcsstr +0x1800AB6A0 +- +Custom wcsstr for wide path scanning; see Ch. 11 +WideStr::Dtor +0x1800AB758 +- +wstring destructor in path scanner; see Ch. 11 +HotkeyErrorHandler +0x1800AECE0 +- +Hotkey error handler, logs '[hotkey error]'; see Ch. 7 +std::once_flag::Execute +0x1800AFF60 +- +MSVC once_flag _Execute_once; used by UnityExplorer; see Ch. 16 +D3D11::Reinit +0x1800825B0 +- +Recreate D3D11 render target+shaders on WM_SIZE; see Ch. 7 +ModuleManager::RenderFrame +0x180082FC0 +- +ImGui NewFrame + per-module Render dispatch; see Ch. 15 +FpsUnlocker::UpdateStub +0x180085B40 +- +Tab destructor/cleanup wrapper for FpsUnlocker; see Ch. 12 +FpsUnlocker::Render +0x180085B90 +- +ImGui panel: FPS cap checkbox + DragInt; see Ch. 12 +FreeCam::Update +0x1800871A0 +- +Per-frame: CinemachineBrain camera override; see Ch. 12 +NoClip::UpdateStub +0x180089B00 +- +Tab destructor/cleanup wrapper for NoClip; see Ch. 12 +NoClip::Update +0x180089B50 +- +Per-frame: CharacterController.enabled toggle; see Ch. 12 +PlayerProfile::Update +0x18008A4F0 +- +Per-frame: UI node traversal + text injection; see Ch. 12 +UTF8ToWide +0x18008B4E0 +- +MultiByteToWideChar wrapper for path conversion; see Ch. 11 +ModulePathScanner::EFSearch +0x18008B937 +- +wcsstr branch: search for EF-Cheeto.dll in path; see Ch. 11 +SkillHack::RenderPanel +0x18008D240 +- +ImGui panel body after hook install; see Ch. 10 +Vacuum::Render +0x180093CA0 +- +ImGui panel: Vacuum checkbox + monster sub-checkbox; see Ch. 12 +Vacuum::EntityIterator +0x180094000 +- +Inner entity array iteration for item vacuum; see Ch. 12 +HookManager::AllocTrampoline +0x1800A960C +- +Allocate trampoline slot near target VA; see Ch. 8 +UnityExplorer::MemsetBlock +0x1800AC86A +- +Memset 0xD8 bytes at [.data+0x2200] during init; see Ch. 16 +# 15. ModuleManager Dispatch Architecture +Source file: E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp (string at RVA 0x3B0BC0). The ModuleManager is the central runtime controller responsible for: (1) maintaining the registrar list, (2) constructing module instances during Init, (3) dispatching per-frame Render calls from the D3D11 Present hook, and (4) dispatching per-frame hotkey processing. +## 15.1 Key Data Structures +ModuleManager object layout (rcx in all dispatch calls): +struct ModuleManager { +BaseModule** instances_begin; // [+0x00] begin ptr (vector) +BaseModule** instances_end; // [+0x08] end ptr +BaseModule** instances_cap; // [+0x10] capacity ptr +bool initialized; // [+0x18] set to 1 after Init() completes +// [+0x19..+0x1F] padding +// [+0x20..+0x57] registrar list (vector — 0x60-byte stride elements) +}; +Global singleton pointers in .data: +[.data+0x23B8] ModuleManager.instances_begin (registrar slots array begin) +[.data+0x23C0] ModuleManager.instances_end +[.data+0x23C8] ModuleManager.instances_cap +[.data+0x2398] ModuleManager object ptr (passed as rcx to dispatch loops) +[.data+0x23A8] secondary ptr (capacity end) +BaseModule vtable layout (confirmed from factory stubs at 0x9B660–0x9B7A0 and dispatch call sites): +Slot +Offset +Description +Notes +[0] ++0x00 +copy-ctor/factory() +placement-new style ctor; writes vtable ptr, returns this +[1] ++0x08 +copy-ctor/factory() +same as [0] +[2] ++0x10 +Init()/RegisterTab() +jmp stub -> actual RegisterTab fn for the module +[3] ++0x18 +Render() +per-frame UI + game-state dispatch — called by Present hook loop +[4] ++0x20 +~BaseModule() +destructor: frees name string, conditional operator delete +[5] ++0x28 +getNamePtr() +returns &this->name_string (this+0x08) +[6] ++0x30 +onHotkey() +pure virtual (value = 1 sentinel); not implemented in any module +[7] ++0x38 +getLinkedModuleFactory() +returns factory ptr for a paired module (e.g. FpsOverlay) +BaseModule instance layout (from dispatch loop field access and RegisterTab writes): +struct BaseModule { +void* vtable; // [+0x00] +std::string name; // [+0x08] SSO string (24 bytes) +std::string tab_name; // [+0x20] secondary name / tab label +bool enabled; // [+0x28] ON/OFF flag — checked by dispatch loops +// [+0x29..+0x2F] padding +// [+0x30..] module-specific fields (move_speed, fps_target, etc.) +}; +## 15.2 Registrar Lambda Registration (startup) +During DLL initialization (before ModuleManager::Init is called), ten registrar lambdas fire. Each calls ModuleManager::AddRegistrar (RVA 0x9B2C0) passing the module name string and a factory std::function. The registrar slots are pushed into the vector at [.data+0x23B8] with stride 0x60 bytes per slot. Registration order (determined from code order in .text): +Order +Module Name +Registrar code RVA +Factory .rdata RVA +vtable RVA +1 +SetDither +0x001C41 +0x3B0D58 +0x3B0D58 +2 +FreeCam (fps) +0x001C80 +0x3B0E70 +0x3B0E70 +3 +SkillHack +0x001D50 +0x3B0EE0 +0x3B0EE0 +4 +PlayerProfile +0x001E20 +0x3B0D90 +0x3B0D90 +5 +NoClip +0x001EF0 +0x3B0DC8 +0x3B0DC8 +6 +Vacuum +0x001FC0 +0x3B0E38 +0x3B0E38 +7 +UnityExplorer +0x002090 +0x3B0D28 +— +8 +FpsUnlocker +0x001B80 +0x3B0E00 +0x3B0E00 +9 +FreeCam (main) +0x001AB0 +0x3B0E70 +0x3B0E70 +10 +ESPModule +0x001980 +— +— +ModuleManager::AddRegistrar (RVA 0x9B2C0) logic: constructs a std::string from the name argument, calls 0x18000F7D0 (TabManager::RegisterTab), then appends the registrar's std::function wrapper to the instances array. If the vector is full it calls the grow helper at 0x9B3C0. +## 15.3 ModuleManager::Init (RVA 0x9AC10) +Called once from startup sequence (RVA 0xA9190). Guards against double-init via [rcx+0x18] flag. Log messages: 'Initializing ModuleManager' (0x3B0C08) and 'ModuleManager initialization complete' (0x3B0C60). Asserts at source lines 34 and 52 reference ModuleManager.cpp. +Init body: +void ModuleManager::Init(ModuleManager* self) { +if (self->initialized) { +Log('[WARNING] ModuleManager already initialized'); +return; +} +Log('Initializing ModuleManager'); +// Assert (line 34 in ModuleManager.cpp) +// Move instances_begin ptr to match registrar list +rsi = &self->instances_begin; +if (self->instances_begin != self->instances_end) +*rsi = self->instances_begin; +// Wait for std::once_flag at [.data+0x23D0] +// (once_flag guards module instance allocation) +// Iterate registrar array ([.data+0x23B8]..[.data+0x23C0]) +// stride = 0x60 bytes per registrar slot +for (rbx = registrars_begin; rbx < registrars_end; rbx += 0x60) { +std::function* factory = rbx->invoke_ptr; // [rbx+0x58] +BaseModule* mod = factory->operator()(); // vtable[+0x10]() +// Append to instances list +*instances_end = mod; +instances_end += 0x8; +// (grow vector if needed via 0x9B0D0) +// Call vtable[+0x8] on module = getName() +const char* name = mod->vtable[+0x8](mod); +// Log 'Module {name} initialized' +// Log formatted assert (line 45 in ModuleManager.cpp) +assert_log(mod->name, ModuleManager_cpp, line=45); +} +self->initialized = true; +Log('ModuleManager initialization complete'); +// Assert (line 52 in ModuleManager.cpp) +} +## 15.4 Per-Frame Dispatch Loops +Three dispatch functions iterate the instances array each frame. All share the same structure: guard on initialized flag, pointer-chase loop over [begin..end], null check, enabled flag check at [module+0x28], then vtable call. +Dispatch Loop 1 — ModuleManager::DispatchRender (RVA 0x9AE80): +// Called from Present hook with rcx = &ModuleManager (at [.data+0x2398]) +void ModuleManager::DispatchRender(ModuleManager* self) { +if (!self->initialized) return; +BaseModule** it = self->instances_begin; +BaseModule** end = self->instances_end; +while (it != end) { +BaseModule* mod = *it; +if (mod && mod->enabled) // [mod+0x28] != 0 +mod->vtable[0x18](mod); // Render() +it++; +} +} +Dispatch Loop 2 — ModuleManager::DispatchHotkeys (RVA 0x9AEF0): +void ModuleManager::DispatchHotkeys(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod && mod->enabled) +mod->vtable[0x30](mod); // onHotkey() — pure virtual, no-op for all current modules +} +} +Dispatch Loop 3 — ModuleManager::DispatchRegistrarInit (RVA 0x9AF60): +// Called at 0x180083348 — initializes ImGui panel layout after first Present +void ModuleManager::DispatchRegistrarInit(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod) +mod->vtable[0x38](mod); // getLinkedModuleFactory() — installs linked tab +} +// After loop: copy default panel config block +// movups xmm0, [.data+0x1F08]; movups [.data+0x1F28], xmm0 +// movups xmm1, [.data+0x1F18]; movups [.data+0x1F38], xmm1 +// (16-byte config copy for initial panel state) +} +15.4.1 Exception Handling in Dispatch Loops +The pseudocode above omits the C++ exception-handling wrappers that the compiler generated around each vtable call. Each dispatch loop body is actually enclosed in a __try/__except block; the MSVC runtime (__CxxFrameHandler4, thunk table at RVA 0xAC840, imported from VCRUNTIME140.dll) is registered as the Structured Exception Handler via the .pdata unwind tables. If a module's virtual method throws, the runtime calls one of three catch-handler functions: 0xAEBC0 logs “[ERROR] Failed to update module ‘’” (associated with DispatchRender / Update), 0xAEC50 logs “[ERROR] Failed to render overlay for module ‘’”, and 0xAECE0 logs “[ERROR] Failed to process hotkeys for module ‘’”. All three handlers call the shared logging helper at 0x18000FDA0 (Log/Print) and then resume normally rather than propagating the exception, so a single misbehaving module cannot crash the entire frame. +## 15.5 Present Hook Call Site (RVA 0x082F00) +The Present hook callback contains all three dispatch calls plus the ImGui frame boundary calls. Relevant excerpt (from context around RVA 0x083386): +// 1. DispatchRegistrarInit (once_flag guarded) — installs linked tabs +rcx = &ModuleManager; // [.data+0x2398] +call ModuleManager::DispatchRegistrarInit; // 0x18009AF60 +// 2. DispatchRender — calls Render() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchRender; // 0x18009AE80 +// 3. DispatchHotkeys — calls onHotkey() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchHotkeys; // 0x18009AEF0 +// 4. Continue to D3D11 frame boundary / ImGui EndFrame +call 0x18001C2D0; +## 15.6 Per-Module vtable[+0x10] and vtable[+0x18] Resolved Targets +vtable[+0x10] = Init/RegisterTab (called once during ModuleManager::Init). vtable[+0x18] = Render (called every frame from DispatchRender). +Module +vtable RVA +vtable[+0x10] target +vtable[+0x18] target +Notes +Vacuum +0x3B0E38 +0x090060 (RegisterTab) +0x09B640 -> [.data+0x05D0] fn ptr +NoClip +0x3B0DC8 +0x081A20 (RegisterTab) +0x09B670 -> [.data+0x06D0] fn ptr +PlayerProfile +0x3B0D90 +0x0813D0 (RegisterTab) +0x09B6A0 -> [.data+0x0580] fn ptr +SkillHack +0x3B0EE0 +0x0818E0 (RegisterTab) +0x09B6D0 -> [.data+0x0770] fn ptr +hook installer +FreeCam +0x3B0E70 +0x081300 (RegisterTab) +0x09B700 -> [.data+0x07D0] fn ptr +SetDither +0x3B0D58 +0x081590 (RegisterTab) +0x09B730 -> [.data+0x0630] fn ptr +no-op +FpsOverlay +0x3B0E00 +0x081810 (RegisterTab) +0x09B760 -> [.data+0x0530] fn ptr +overlay +Note: vtable[+0x18] for each module returns a .data block ptr via a 2-instruction lea/ret stub. This stub serves as the state block accessor used during object cleanup. The actual Render dispatch uses this indirection: the stub returns the module's .data state block, which at offset [+0x00] stores a direct fn ptr to the Render/Update function installed by RegisterTab. The dispatch loop calls the stub (vtable[+0x18]) to get this function pointer, then calls through it. +## 15.7 ModuleManager Log Strings +String +RVA +Context +'[WARNING] ModuleManager already initialized' +0x3B0B88 +Init guard +'Initializing ModuleManager' +0x3B0C08 +Init begin +'Module {} initialized' +0x3B0C48 +Per-module Init success +'ModuleManager initialization complete' +0x3B0C60 +Init end +'Failed to initialize module {}' +0x3B0C28 +Init error handler +'[ERROR] Failed to update module ' +0x3B0C90 +Update error handler +'[ERROR] Failed to render overlay for module ' +0x3B0CB8 +Render error handler +'[ERROR] Failed to process hotkeys for module ' +0x3B0CE8 +Hotkey error handler +ModuleManager.cpp source path +0x3B0BC0 +Assert source file string +# 16. UnityExplorerModule +UnityExplorerModule is a fully implemented, live developer-tool module embedded inside the cheat. It is registered as the final entry in the module list (registration code at RVA 0x002090) and shares the Vacuum vtable (0x3B0E38), inheriting its factory and base dispatch structure. Its RegisterTab function is at RVA 0x090060, its per-frame Update stub points to the shared no-op destructor at RVA 0x083DC0 (same stub as SetDither and SkillHack). The module is not a stub — it contains a complete ImGui-based runtime Unity scene hierarchy browser and component inspector. +## 16.1 Registration and Vtable +The registrar lambda at RVA 0x002090 stores Vacuum's vtable pointer (0x1803B0E38) as the factory and passes the string 'UnityExplorerModule' (RVA 0x3B0D28) to ModuleManager::AddRegistrar. This means during ModuleManager::Init, calling vtable[+0x10] on UnityExplorerModule's registrar invokes Vacuum's RegisterTab stub (RVA 0x9B650), which resolves via jmp to UnityExplorerModule::RegisterTab at RVA 0x090060. The vtable[+0x18] dispatch slot returns [.data+0x2610] — the module's state block — and the per-frame render fn ptr is written there during RegisterTab. +Registration: RVA 0x002090 (AddRegistrar call; factory = Vacuum vtable 0x3B0E38) +RegisterTab: RVA 0x090060 (init; registers tab 'Unity Explorer', zeroes state) +Render: RVA 0x090250 (per-frame ImGui scene/inspector panel) +Update stub: RVA 0x083DC0 (shared no-op; frees string, optional delete) +State block: [.data+0x2610] (0x190 bytes, zero-filled by memset at 0x0900BC) +Tab name: 'Unity Explorer' (string RVA 0x3B02D0) +Window title: 'Unity Explorer Window' (RVA 0x3B02E0) +## 16.2 RegisterTab (RVA 0x090060) +RegisterTab is guarded by a std::once_flag at [.data+0x260C]. On first call it: (1) zero-fills the 0x190-byte state block at [.data+0x2610] via memset (0x1800AC86A); (2) constructs the tab name std::string 'Unity Explorer' and calls TabManager::RegisterTab (0x18000F7D0) to register the ImGui tab at [.data+0x2618]; (3) writes the Update fn ptr (0x1803AFA38 → RVA 0x083DC0, shared no-op stub) to [.data+0x2610]; (4) zeroes all state fields (scene list vector, selected index, refresh flags, auto-refresh bool, interval float, search filter buffer, component list, inspector string); (5) calls std::once_flag::_Execute_once (0x1800AFF60) to seal the guard. On subsequent calls the already-initialized guard causes an early return at 0x1800901D8. +Key state fields initialized during RegisterTab: +[.data+0x2610] update_fn_ptr = 0x083DC0 (no-op stub) +[.data+0x2618] tab_string = 'Unity Explorer' (std::string) +[.data+0x2638] enabled = 0 (bool, OFF by default) +[.data+0x2640] auto_refresh = 0 (bool) +[.data+0x2644] refresh_interval = 3.0f (0x40400000) +[.data+0x2648] scene_list_begin = 0 (ptr, vector) +[.data+0x2650] scene_list_end = 0 +[.data+0x2660] scene_list_cap = 0 +[.data+0x2670] selected_scene_idx = 0 +[.data+0x2680] selected_obj_idx = 0 +[.data+0x2684] search_filter[0x100] = 0 (char buffer) +[.data+0x2784] inspector_active = 0 (bool) +[.data+0x2788] inspected_obj_ptr = 0 +[.data+0x2790] inspected_obj_name = 0 (std::string) +## 16.3 Render / Per-Frame Logic (RVA 0x090250) +The Render function checks enabled ([this+0x28]) and a secondary active flag ([this+0x30]) before drawing. When both are set it calls ImGui::Begin with 'Unity Explorer Window' (RVA 0x3B02E0, via jmp to 0x1800937D0 = ImGui::Begin wrapper). The main function body at RVA 0x0902E0 is a substantial per-frame function that draws the complete inspector UI. +Scene panel logic: +// Check scene list (vector at [this+0x58]..[this+0x60]) +if (scene_list is empty) { +ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +} else { +ImGui::Text("Select Scene:"); +ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +if (combo changed) { LoadScene(selected_scene_idx); } +} +// Writes g_Config->overlay_flags |= 1 and g_Config->overlay_scale = 300.0f +// (at [g_Config+0x1F78] and [g_Config+0x1F90]) when scene panel is active +Auto-refresh logic (RVA 0x090250): +if (enabled && auto_refresh) { +now = GetTime(); // 0x180093B10 +elapsed = now - last_refresh_time; +max_entries = (float)refresh_interval * SCALE_CONST; +if (elapsed_entries >= max_entries) { +RefreshScenes(this); // 0x180090D40 +last_refresh_time = now; +} +} +GameObject hierarchy panel (drawn when a scene is selected): +// Search filter input: ##SearchFilter — writes to search_filter[0x100] buffer +// GameObject list: iterates [this+0x40]..[this+0x48] (vector) +// Per entry: prints '[namespace]: ' prefix + name +// 'Ins##' button beside each entry -> inspect that object +// If list empty: Text('No GameObjects found in this scene.') +// 'DontDestroyOnLoad' section: special scene with fallback text if not found +Inspector panel (when an object is selected via 'Ins' button): +// 'No GameObject selected.' if none +// Otherwise shows: +// 'Active' checkbox (calls GameObject.SetActive via IL2CPP) +// Transform section: Position, Local Position, Rotation, Scale (float3 inputs) +// 'Components' section: 'GameObject Class: %s.%s' +// 'All Components:' list via IL2CPP GetComponents(UnityEngine.Component) +// Per component: '%s.%s' (namespace.classname) +// On fetch failure: 'Unknown Component' or 'Unable to get GameObject class information.' +## 16.4 Complete String Inventory +String +RVA +Usage +'UnityExplorerModule' +0x3B0D28 +Module name (registrar) +'Unity Explorer' +0x3B02D0 +Tab label; ImGui::Begin title +'Unity Explorer Window' +0x3B02E0 +ImGui window title string +'Search Filter:' +0x3B02F8 +Label above search input +'##SearchFilter' +0x3B0308 +ImGui InputText widget ID +'Inspector' +0x3B0318 +Inspector sub-panel label +'GameObjectHierarchy' +0x3B0328 +Hierarchy sub-panel label +'No scenes loaded. Click Refresh...' +0x3B0340 +Empty scene list message +'Scene: ' +0x3B0390 +Scene prefix label +'No GameObjects found in this scene.' +0x3B0398 +Empty hierarchy message +'DontDestroyOnLoad' +0x3B03C0 +Special DDOL scene label +'DontDestroyOnLoad (Not Found)' +0x3B03D8 +DDOL fallback label +'Refresh' +0x3B03F8 +Refresh button label +'Auto Refresh' +0x3B0400 +Auto-refresh checkbox +'Interval (s)' +0x3B0410 +Refresh interval slider label +'Scenes found: %d' +0x3B0420 +Scene count display +"No scenes available. Click 'Refresh Scenes' to load." +0x3B0438 +No-scenes message +'Select Scene:' +0x3B0470 +Scene selector label +'Select Scene' +0x3B0480 +Combo default text +'##SceneCombo' +0x3B0490 +ImGui Combo widget ID +']: ' +0x3B04A0 +Object list entry separator +'Ins##' +0x3B04A8 +Inspect button label prefix +'No GameObject selected.' +0x3B04B8 +Inspector empty state +"Click 'Ins' button..." +0x3B04D0 +Inspector hint text +'Active' +0x3B0508 +Active checkbox label +'Transform' +0x3B0510 +Transform section header +'Position' +0x3B0520 +Position field label +'Local Position' +0x3B0530 +Local position field label +'Rotation' +0x3B0540 +Rotation field label +'Scale' +0x3B054C +Scale field label +'No Transform component found.' +0x3B0558 +Transform fallback message +'Components' +0x3B0578 +Components section header +'GameObject Class: %s.%s' +0x3B0588 +Class display format +'All Components:' +0x3B05A0 +Component list header +'UnityEngine.Component, UnityEngine.CoreModule' +0x3B05B0 +IL2CPP type name for GetComponents +'%s.%s' +0x3B05E0 +Component name format +'Unknown Component' +0x3B05E8 +Component fallback name +'No components found or failed to get components.' +0x3B0600 +Component fetch failure +'Unable to get GameObject class information.' +0x3B0638 +Class info failure +## 16.5 Assessment +UnityExplorerModule is a developer/debug tool that was purpose-built alongside the cheat modules and registered in the same module system. It provides a runtime Unity scene browser — listing loaded scenes, displaying the active GameObject hierarchy with a search filter, and offering a per-object inspector showing Transform (position, rotation, scale), active state, and all attached components retrieved via IL2CPP reflection (GetComponents with 'UnityEngine.Component, UnityEngine.CoreModule' as the type argument). +The module is enabled by the same ON/OFF flag ([module+0x28]) as all other modules and is rendered every frame from the same DispatchRender loop. Its auto-refresh timer (default 3.0s interval, bool at [.data+0x2640], float at [.data+0x2644]) periodically re-enumerates loaded scenes via RefreshScenes (RVA 0x090D40). The g_Config writes inside Render ([g_Config+0x1F78] |= 1, [g_Config+0x1F90] = 300.0f) activate the overlay resize logic while the explorer window is open. +This is the probable origin of the DLL's filename 'unityexplorer.dll' — the binary was named after this embedded developer tool to serve as cover, making the file appear to be a legitimate Unity debugging utility rather than a game cheat. +# 17. Per-Config-Preset Writers +The cheat implements four named configuration presets that write distinct sets of skill-timing and distance-threshold constants into g_Config at runtime. These are not game-version or region variants as originally suspected; they are user-selectable combat automation profiles, each named after a science-fiction reference. The active preset name string is stored at [.data+0x00E0] and the integer index at [.data+0x00EC]. On startup the Settings tab reads both the current theme name and the default preset indicator from the config JSON, compares the theme string against each preset name via ImGui::Selectable (0x1800708D0), and calls the matching writer directly — all four calls reside in a single function at RVA 0x09A4F0. +## 17.1 Dispatch Mechanism +The dispatch logic is in the Settings tab render function at RVA 0x09A4F0. It reads the saved preset name string from the JSON config object (keyed 'Default', 'Evangelion Unit 01', 'Evangelion Unit 02', or 'Matrix'), compares via ImGui::Selectable, stores the matched preset name pointer to [.data+0x00E0], writes the index integer (0–3) to [.data+0x00EC], then calls the corresponding writer immediately. On subsequent frames the startup code at 0x082F02 reads [.data+0x00EC] and re-routes to the same writer if the selection changes: +// RVA 0x082F00 version dispatch +ecx = g_Config->preset_index; // [.data+0x00EC] +switch (ecx) { +case 0: WriterDefault(); // RVA 0x0941F0 +case 1: WriterEvangelionUnit01(); // RVA 0x094890 +case 2: WriterEvangelionUnit02(); // RVA 0x096770 +case 3: WriterMatrix(); // RVA 0x098650 +} +## 17.2 Preset Summary +Preset name +Index +Writer RVA +Write count +g_Config range +'Default' +0 +0x0941F0 +168 +0xDA4 – 0x12A4 +'Evangelion Unit 01' +1 +0x094890 +23 +0xD9C – 0xEBE +'Evangelion Unit 02' +2 +0x096770 +23 +0xD9C – 0xEBE +'Matrix' +3 +0x098650 +13 +0xD9C – 0xE14 +'Default' is the master preset and the only one that writes the full skill-timing table (g_Config offsets 0xEC8–0x12A4). The three non-default presets are thin overlays that write only the distance-threshold and encounter-tuning floats at offsets 0xD9C–0xEBE, leaving the skill-timing table zeroed for their entries. When any non-default preset is active the skill-timing table fields written by Default remain at their last-written values (the table is not re-zeroed between preset switches). +## 17.3 g_Config Field Semantics +The written offsets cluster into two functional groups identified by value range and stride pattern. +Distance / encounter thresholds (offsets 0xD9C–0xE30) — written by all four presets. Values are floats in the range 0.0–21.0, representing game-unit distances. Groups of four consecutive dwords repeat the stride [min_x, min_y, range, limit] observed in ESP module configuration. Example values across presets: +g_Config offset +Default +EvaUnit01 +EvaUnit02 +Matrix +Semantic +0x0D9C +0.0 +1.0 +1.0 +1.0 +Encounter active flag / base threshold +0x0DA0 +0.0 +0.60 +0.60 +0.50 +Approach multiplier +0x0DA4 +10.0 +10.0 +10.0 +8.0 +Max detect range (units) +0x0DA8 +10.0 +10.0 +10.0 +8.0 +Max engage range (units) +0x0DAC +8.0 +4.0 +4.0 +0.0 +Attack range (units) +0x0DB0 +0.0 +0.0 +0.0 +1.0 +Reserved / extra trigger flag +0x0DDC +8.0 +6.0 +6.0 +5.0 +Secondary range A +0x0DE0 +6.0 +4.0 +4.0 +3.0 +Secondary range B +0x0E0C +21.0 +0.0 +0.0 +0.0 +Max AoE range (Default only) +0x0E14 +15.0 +14.0 +14.0 +12.0 +Long-range threshold +Skill timing table (offsets 0xEC8–0x12A4) — written only by the Default preset (168 entries, all zero in the other three presets). Values are floats in the range 0.02–1.0 organized in repeating groups of four dwords: [min_time, max_time, window_end, confidence]. This matches the SkillHack timing parameters documented in Section 8. Each group of four corresponds to one skill slot. The table spans approximately 40 skill slots covering offsets 0xEC8 through 0x1144, with an additional small block at 0x1298–0x12A4. Example timing entries from Default: +// g_Config[0xEC8..0xED7]: Skill slot 0 timing (Default) +[0xEC8] min_time = 0.85f +[0xECC] max_time = 0.85f +[0xED0] win_end = 0.85f +[0xED4] confidence= 1.00f +// g_Config[0xED8..0xEE7]: Skill slot 1 timing (Default) +[0xED8] min_time = 0.50f +[0xEDC] max_time = 0.50f +[0xEE0] win_end = 0.50f +[0xEE4] confidence= 1.00f +// g_Config[0xEE8..0xEF7]: Skill slot 2 timing (Default) +[0xEE8] min_time = 0.05f +[0xEEC] max_time = 0.05f +[0xEF0] win_end = 0.07f +[0xEF4] confidence= 0.90f +// ... continues through ~40 skill slots to 0x1144 +// g_Config[0x1298..0x12A7]: final 4-entry block +[0x1298] min_time = 0.05f +[0x129C] max_time = 0.05f +[0x12A0] win_end = 0.07f +[0x12A4] confidence= 0.73f +## 17.4 Preset Behavioral Differences +The three non-default presets represent incrementally more conservative tuning. 'Evangelion Unit 01' and 'Evangelion Unit 02' are nearly identical — both reduce attack range from 8.0 to 4.0, reduce long-range threshold from 15.0 to 14.0, and set the secondary detection distance lower than Default. The only distinction between the two Evangelion presets is a small float difference at offset 0xDC0/0xDC4 (both 0.50 in Unit 01 vs. both 0.50 in Unit 02 — functionally identical in the parsed output; any distinction would be in fields that were not written by the respective functions and thus retained from previous state). 'Matrix' is the most conservative preset: it lowers attack range to 0.0 (disabling direct attack trigger), cuts max detect range to 8.0, reduces the long-range threshold to 12.0, and sets the extra trigger flag at 0xDB0 to 1.0, suggesting it relies on a different trigger path. +The 'Default' preset is by definition the most aggressive: it provides the only non-zero skill timing table and the widest detection ranges. This is consistent with the binary having version_index = 1 hardcoded at .data+0x00EC at static-init time, meaning 'Evangelion Unit 01' loads on first launch before the user selects a preset from the Settings tab. +## 17.5 Preset Name Strings +String +RVA +Role +'Default' +0x3B06F8 (via 0x3B0AF8) +Preset name, ImGui label, JSON key; also theme name for Default +'Evangelion Unit 01' +0x3B06D0 (via 0x3B0AD4+) +Preset name and JSON key for index 1 +'Evangelion Unit 02' +0x3B0AE0 +Preset name and JSON key for index 2 +'Matrix' +0x3B0B10 +Preset name and JSON key for index 3 +'Theme' +0x3B0AD4 +JSON field name for preset selection +'zh_cn' +0x3B10E8 +Locale string; passed to string-construct at 0x9D8A4 (ecx==1 branch) +'en' +0x3B2020 +Locale string; passed to string-construct at 0x9D890 (ecx==0/2 branch) +The 'zh_cn' and 'en' locale strings at 0x3B10E8 and 0x3B2020 are constructed as std::string values during a JSON key-lookup operation at RVA 0x09D7D0 (called from the Settings tab). The locale is selected by the same integer switch (ecx) that dispatches the preset writers — 0 maps to 'en', 1 maps to 'zh_cn', and 2 falls back to 'en'. This implies the preset index also encodes locale preference: 'Default' (index 0) and the two Evangelion presets and 'Matrix' are treated as CN (index 1) by default, and 'en' is the fallback locale for presets 0 and 2. The locale string is used as the second argument to a JSON object accessor, indicating that config field names are stored locale-keyed in the JSON schema. +# 18. GABypass +GABypass is the IL2CPP function pointer resolution subsystem. Its sole function is to locate the game's IL2CPP runtime module (GameAssembly.dll) in the process address space, then compute and cache the addresses of 71 specific IL2CPP and Unity API methods that the cheat's modules call at runtime. It does not patch instructions, overwrite vtables, or install hooks — it is a pure address-resolution table initializer. The resolved pointers are stored in .data slots at offsets 0x1C48 through 0x1E80 and are subsequently used by every cheat module that makes IL2CPP calls: ESPModule, NoClip, FreeCam, SkillHack, FpsUnlocker, and the UnityExplorer component. +## 18.1 Initialization Sequence +GABypass::Patch (RVA 0x09D1E0) is called exactly once during startup from the main DLL thread at RVA 0x0A942A, immediately after the 'Initializing..' console log and before any module Update() or Render() calls. The call sequence is: +// RVA 0x0A942A (main.cpp line 53, per embedded source path) +Log("Initializing.."); +GABypass::Patch(); // RVA 0x09D1E0 — resolve 71 IL2CPP pointers +il2cpp_domain = [.data+0x1E80](); // call il2cpp_domain_get_assemblies immediately +if (il2cpp_domain != null) { +Log("IL2CPP Domain Found: " + ...); +} +// ... module init continues +Inside GABypass::Patch, execution branches on whether [.data+0x00F0] is already non-null. That slot holds the cached GameAssembly.dll module base address. On first call (cold start), [.data+0x00F0] is zero, so the function calls GetModuleHandleW(L"GameAssembly.dll") via the IAT slot at 0x1800B1290 to obtain the module base, stores it in rdx, then computes all 71 pointers as fixed offsets from that base. On subsequent calls (if Patch is ever called again), [.data+0x00F0] is already populated so the 'GA Bypass successfully!' log and GetModuleHandleW call are skipped and rdx is loaded directly from the cached value before the offset table is re-written. In practice Patch is only called once. +// GABypass::Patch (RVA 0x09D1E0) — annotated +if ([.data+0x00F0] != 0) { +Log("GA Bypass successfully!"); // already cached, log and skip resolve +rdx = [.data+0x00F0]; +goto write_table; +} +rdx = GetModuleHandleW(L"GameAssembly.dll"); // first-run: locate module +write_table: +// 71x: [.data+slot] = rdx + IL2CPP_offset +[.data+0x1C70] = rdx + 0x0018AD80; // il2cpp_object_get_class +[.data+0x1C78] = rdx + 0x00007480; // il2cpp_class_get_method_from_name +[.data+0x1E70] = rdx + 0x00D94C10; // il2cpp_domain_get +[.data+0x1E78] = rdx + 0x00D94DA0; // il2cpp_assembly_get_image +[.data+0x1E80] = rdx + 0x00D93A60; // il2cpp_domain_get_assemblies +// ... 66 additional Unity/game method pointers +ret +## 18.2 The 71-Entry Pointer Table +Each entry is a QWORD at a fixed .data offset. The IL2CPP offset column is the byte distance from the GameAssembly.dll module base to the target function — these are static, computed at compile time from a known game binary version. The table spans two contiguous .data regions: 0x1C48–0x1CF8 (IL2CPP runtime and UnityEngine core) and 0x1D00–0x1E80 (game-specific methods, additional Unity API, UI/camera). +# +.data offset +IL2CPP offset +Resolved function +Used by +1 +0x1C48 ++0x09DC0120 +GameObject.GetComponentByIndex +UnityExplorer inspector +2 +0x1C50 ++0x0018CEC0 +il2cpp_domain_get_assemblies (A) +GABypass init / UnityExplorer +3 +0x1C58 ++0x0B390700 +Component.GetComponent +UnityExplorer / NoClip +4 +0x1C60 ++0x0B3A2D20 +Transform.get_localScale +UnityExplorer inspector +5 +0x1C68 ++0x0B3A2CB0 +Transform.get_rotation +UnityExplorer inspector +6 +0x1C70 ++0x0018AD80 +il2cpp_object_get_class +UnityExplorer type query +7 +0x1C78 ++0x00007480 +il2cpp_class_get_method_from_name +UnityExplorer method lookup +8 +0x1C80 ++0x0B3A1AE0 +Transform.get_localPosition +UnityExplorer / NoClip +9 +0x1C88 ++0x0B3A1A70 +Transform.get_position +ESP / NoClip +10 +0x1C90 ++0x0B3A51D0 +Transform.set_localPosition +NoClip teleport +11 +0x1C98 ++0x0B398830 +GameObject.SetActive +UnityExplorer / NameChanger +12 +0x1CA0 ++0x0B3911F0 +GameObject.get_transform +ESP / NoClip +13 +0x1CA8 ++0x0B3A59D0 +Transform.set_rotation +FreeCam / NoClip +14 +0x1CB0 ++0x0B391D90 +GameObject.get_activeInHierarchy +UnityExplorer inspector +15 +0x1CB8 ++0x0B3B2410 +GameObject.get_tag +UnityExplorer inspector +16 +0x1CC0 ++0x0B3B2120 +GameObject.get_name +UnityExplorer inspector +17 +0x1CC8 ++0x0B3B40B0 +GameObject.get_layer +UnityExplorer inspector +18 +0x1CD0 ++0x0B397980 +GameObject.get_scene +UnityExplorer inspector +19 +0x1CD8 ++0x02F3DA80 +Game: skill/buff method A +SkillHack +20 +0x1CE0 ++0x00F27E10 +Game: skill/buff method B +SkillHack +21 +0x1CE8 ++0x0B329000 +Component.GetComponents +UnityExplorer component list +22 +0x1CF0 ++0x0B329D80 +Component.GetComponentsInChildren +UnityExplorer tree walk +23 +0x1CF8 ++0x03E9BB50 +Game: skill/ability slot method A +SkillHack +24 +0x1D00 ++0x0B383F60 +Object.get_name +UnityExplorer name display +25 +0x1D08 ++0x0B33CAB0 +Component.GetType (A) +UnityExplorer type display +26 +0x1D10 ++0x0B33CB00 +Component.GetType (B) +UnityExplorer type display +27 +0x1D18 ++0x039D1AA0 +Game: skill/ability slot method B +SkillHack +28 +0x1D20 ++0x026DE9F0 +Game: combat/hit method A +SkillHack / combat +29 +0x1D28 ++0x0478E860 +Game: UI show/hide toggle +NoClip / FpsUnlocker UI +30 +0x1D30 ++0x025E2D40 +Game: combat/hit method B +SkillHack / combat +31 +0x1D38 ++0x087C2CD0 +Game: movement/physics method A +NoClip CharacterController +32 +0x1D40 ++0x03419AF0 +Game: movement/physics method B +NoClip CharacterController +33 +0x1D48 ++0x0B322FB0 +SceneManagement.Scene.get_name +UnityExplorer scene display +34 +0x1D50 ++0x0B396A20 +SceneManager.GetActiveScene +UnityExplorer scene query +35 +0x1D58 ++0x0B397700 +CinemachineBrain.get_ActiveVirtualCamera +FreeCam hook +36 +0x1D60 ++0x03766810 +Game: entity/actor state method A +ESP / SkillHack +37 +0x1D68 ++0x0B3A2A60 +Transform.set_localScale +UnityExplorer inspector +38 +0x1D70 ++0x0B326660 +Rigidbody.get_velocity +NoClip / Vacuum +39 +0x1D78 ++0x0B3266B0 +Rigidbody.set_velocity +NoClip / Vacuum +40 +0x1D80 ++0x0B383200 +Object.Destroy +UnityExplorer +41 +0x1D88 ++0x0B3A1A10 +Transform.set_position +NoClip teleport / Vacuum +42 +0x1D90 ++0x0B3A2340 +Game: entity/actor state method B +ESP +43 +0x1D98 ++0x0B421800 +Input.GetAxis('Mouse X') +FreeCam look X +44 +0x1DA0 ++0x0B3A26D0 +Game: player state method A +ESP / SkillHack +45 +0x1DA8 ++0x0B3A1FB0 +Game: player state method B +ESP / SkillHack +46 +0x1DB0 ++0x0B32B030 +Game: player health/stat accessor +ESP health display +47 +0x1DB8 ++0x0B391240 +GameObject.SetActive (CinemachineBrain active flag) +FreeCam enable/disable +48 +0x1DC0 ++0x0B390440 +Camera.get_main +ESP worldToScreen / FreeCam +49 +0x1DC8 ++0x0B390F80 +GameObject.FindObjectOfType +Active scene object scan +50 +0x1DD0 ++0x0B3A19A0 +Transform.get_position (2nd ref) +ESP / NoClip +51 +0x1DD8 ++0x03F85430 +Game: skill/action method C +SkillHack +52 +0x1DE0 ++0x0B3A1D30 +Transform.set_rotation (2nd ref) +FreeCam / NoClip +53 +0x1DE8 ++0x0B3A1C90 +Camera.get_fieldOfView +FreeCam FOV control +54 +0x1DF0 ++0x00E92CF0 +Game: entity/actor state method C +ESP +55 +0x1E00 ++0x03DC14C0 +Game: skill/action method D +SkillHack +56 +0x1E08 ++0x03E0D2C0 +Game: skill/action method E +SkillHack +57 +0x1E10 ++0x03D9DF30 +Game: skill/action method F +SkillHack +58 +0x1E18 ++0x00E9E9F0 +Game: skill/action method G +SkillHack +59 +0x1E20 ++0x03EA53C0 +Game: skill/action method H +SkillHack +60 +0x1E28 ++0x0ACA0EC0 +TMPro.TextMeshProUGUI.set_text +Name changer UI label +61 +0x1E30 ++0x0B391D40 +UnityEngine.UI.Text.set_text +ON/OFF toggle labels / Name changer +62 +0x1E38 ++0x036AA8F0 +Game: skill/action method I +SkillHack +63 +0x1E40 ++0x03EC31C0 +Game: skill/action method J +SkillHack +64 +0x1E48 ++0x037F8CD0 +Game: entity/actor method D +ESP / combat +65 +0x1E50 ++0x036EA640 +Game: skill/action method K +SkillHack +66 +0x1E58 ++0x03EC30E0 +Game: skill/action method L +SkillHack +67 +0x1E60 ++0x037F2A40 +Game: entity/actor method E +ESP / combat +68 +0x1E68 ++0x037FD7E0 +Game: entity/actor method F +ESP / combat +69 +0x1E70 ++0x00D94C10 +il2cpp_domain_get +UnityExplorer domain probe +70 +0x1E78 ++0x00D94DA0 +il2cpp_assembly_get_image +UnityExplorer assembly walk +71 +0x1E80 ++0x00D93A60 +il2cpp_domain_get_assemblies (B) +Post-patch domain probe (main.cpp:67) +## 18.3 Functional Grouping +The 71 entries divide into four functional groups. Six entries (slots 2, 6, 7, 69, 70, 71) are IL2CPP runtime API functions — the low-level metadata accessors that the cheat uses to walk the IL2CPP type system for the UnityExplorer inspector. Their offsets are clustered near the start of GameAssembly.dll (+0x0007480, +0x0018AD80, +0x0018CEC0, +0x00D93A60, +0x00D94C10, +0x00D94DA0), consistent with early-loaded IL2CPP initialization code. +Thirty-four entries are UnityEngine managed API methods — Transform, GameObject, Component, Camera, Rigidbody, SceneManager, and Object — that provide the cheat with Unity scene graph access, world-space position manipulation, and object lifecycle control. These are used across all active modules: ESP calls position/camera methods every frame, NoClip writes to Transform.set_position and Rigidbody.set_velocity, FreeCam uses Camera.get_fieldOfView and CinemachineBrain.get_ActiveVirtualCamera, and the UnityExplorer inspector uses the full component introspection set. +Twenty-six entries are game-specific methods at offsets deep into GameAssembly.dll (+0x02F3DA80 and above), most concentrated in the 0x03xxxxxx–0x0Bxxxxxx range. Twelve of these are identifiable SkillHack targets (slots 19–20, 23, 27–28, 30, 51, 55–59, 62–66) — the methods responsible for skill cooldown, buff application, and action validation that SkillHack intercepts or spoofs. The remaining game-specific entries cover combat hit methods, movement/physics controllers, entity state accessors, and player stat readers used by the ESP and combat modules. +Five entries cover additional UI and camera libraries: Cinemachine (slot 35, CinemachineBrain), TextMeshPro (slot 60, TextMeshProUGUI.set_text), and legacy Unity UI (slot 61, UnityEngine.UI.Text.set_text). These are used exclusively by the Name Changer module and the FreeCam camera management code. +## 18.4 Version Sensitivity +All 71 IL2CPP offsets are hard-coded at compile time as fixed displacements from the GameAssembly.dll base. There is no runtime method name lookup, no FNV hash scan, and no fallback if an offset is wrong — if the game updates and shifts any of these methods, the corresponding cheat feature silently malfunctions (calling into an arbitrary address). The SkillHack module uses a separate FNV-1a name-hash lookup path (documented in Section 8) as a secondary resolution mechanism for its core hook target, but the 26 game-specific GABypass entries have no such fallback. This architecture implies the binary is built and tested against a specific pinned game version; the version-selector system documented in Section 15 may exist partly to accommodate minor offsets shifts across game build variants, but the offsets themselves are not adjusted per variant. +# 19. JSON Config Schema and Save/Load System +This chapter resolves the config-schema investigation. The binary does not implement a standalone .json config file. All cheeto settings persistence is handled through ImGui’s built-in .ini settings mechanism, augmented with per-module custom settings handlers registered at runtime. +## 19.1 IAT — File I/O Functions (Complete Resolution) +The PE import table was fully parsed this session, resolving every previously unidentified IAT slot relevant to file I/O and config: +IAT[0xB1268] = GetCurrentThreadId (stack cookie check at 0xAC709, NOT file I/O) +IAT[0xB1278] = VirtualFree +IAT[0xB1288] = VirtualProtect +IAT[0xB1178] = GetConsoleWindow (used in Settings tab Toggle Console) +IAT[0xB1628] = ShowWindow (used in Settings tab Toggle Console) +IAT[0xB1858] = fread (file read, called ONLY from 0x12121) +IAT[0xB1868] = fwrite (called from 0xEA1B, 0x170D6, 0x3033B, 0x3076D) +IAT[0xB1870] = fclose (called from 0xEAB0, 0x1212F, 0x121A9, 0x170DF etc.) +IAT[0xB1888] = _wfopen (wide-char file open, called ONLY from 0x11F93) +IAT[0xB1890] = fseek (called from 0x120BC, 0x120E7) +IAT[0xB1898] = ftell (called from 0x120A0, 0x120CD) +## 19.2 No Standalone JSON Config File +Exhaustive scanning of the binary confirmed no .json filename string exists anywhere in rdata or .data. The config system is the standard ImGui .ini persistence layer. All module settings are serialized through ImGui’s settings-handler API, not a JSON library. The nlohmann::json_abi_v3_12_0 library present in the binary is used exclusively for the i18n translation table, not for config I/O. +## 19.3 Config File: imgui.ini +The config filename “imgui.ini” (RVA 0x3ABB60) is set at RVA 0x1117A into ImGuiIO+0x20 (the IniFilename field) during ImGuiIO initialization. The log filename “imgui_log.txt” (RVA 0x3ABB70) is set into ImGuiIO+0x28 at the same site. Both are written relative to the process working directory at runtime. +## 19.4 Save/Load Trigger and Execution Path +Load path (on startup): RVA 0x30661 calls the file-read helper at 0x12050, which executes ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell again (0x120CD) → malloc → fread (0x12121) → fclose (0x1212F). The buffer is passed to 0x30840 (ParseIniSettingsFromMemory), which walks the handler list at [ImGuiContext+0x2920] calling each registered handler’s ReadLine callback. +Save path (periodic): The render loop checks [ImGuiContext+0x2900] (dirty flag, byte) and [ImGuiContext+0x2904] (float countdown timer). When both conditions are met, RVA 0x30A90 (SaveIniSettingsToDisk) builds the path from [ImGuiContext+0x2910] (custom IniFilename) or falls back to [.data+0x1BEC]. It calls each handler’s WriteAll callback, then passes the buffer to 0x11EA0 (_wfopen wrapper with “wt” mode at RVA 0x1803AD594), fwrite (0x3076D), and fclose (0x30776). The manual save trigger at RVA 0x17072 sets [ImGuiContext+0x2900]=1 and [ImGuiContext+0x2904]=0 to force an immediate write. +## 19.5 i18n Translation Table (Clarification) +The blob starting at RVA 0x3B10E8 is the compile-time JSON localization table, not the config schema. It is a single JSON object mapping English UI label strings to Chinese (zh_cn) equivalents. At startup (RVA 0x2164), a std::string constructor copies this blob (length 0xEED bytes) into [.data+0x1EB8]. The i18n loader at RVA 0x9D660 selects either “en” or “zh_cn” values based on the language toggle flag. The nlohmann runtime type-error strings (object, array, null, string, number, parse_error etc.) at 0x3B3010–0x3B30D8 confirm nlohmann v3.12.0 is statically linked. +The “enabled” string at RVA 0x3B0B28 is one of these UI labels; it is used to display the module on/off state in the GUI and is not a JSON config key. +## 19.6 Module Settings Handler Architecture +Each module registers a settings handler at [ImGuiContext+0x2920] (a dynamically-grown array of 0x48-byte handler structs). The handler struct layout (from RVA 0x30904): ++0x00 TypeName (const char*) — section identifier in .ini file ++0x08 TypeHash (u32) — CRC32 of TypeName (computed at 0x3079C–0x30803) ++0x18 ReadOpenFn — called when section header encountered ++0x38 WriteAllFn — called during save to emit key=value lines +The 11 registered module classes identified from RTTI at .data+0x0590–0x0E60 are: ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule. +## 19.7 ModuleManager Lifecycle +ModuleManager::Init (RVA 0x9ACA4) iterates the module registry at [.data+0x23B8], calls vtable[+0x10] to obtain each module instance, then vtable[+0x08] to initialize it. Each initialized module is logged as “Module {} initialized” (string at RVA 0x3B0C48). Completion is logged as “ModuleManager initialization complete” (RVA 0x3B0C60). The per-frame dispatch methods are vtable[+0x18] (Update, iterated at 0x9AE80) and vtable[+0x30] (RenderOverlay, iterated at 0x9AEF0). Both iterate the same module list checking [module+0x28] (enabled flag) before calling the virtual. +## 19.8 Settings Tab Behavior +Settings::RenderOverlay (RVA 0x9A4F0–0x9AB98, source E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp) handles: language toggle via 0x9D660 (reads [.data+0x1EB8] i18n blob, selects “en” or “zh_cn” values); theme color initialization via 0x98650 (parses hex color strings e.g. “00FF41FF” from rdata into [.data+0x1C00+0xD9C..] float RGBA fields); console window toggle via GetConsoleWindow (IAT[0xB1178]) and ShowWindow (IAT[0xB1628]). There are no Save/Load buttons; settings are persisted automatically by the ImGui .ini mechanism on each render frame that detects a dirty flag. +# 20. FPSModule +FPSModule implements two independent features controlled by the “FPS Monitor” tab in the GUI: an in-game FPS counter overlay and a separate FPS cap unlocker. The RTTI decorated name is .?AVFPSModule@@ (RVA 0x3C5CF8). The module name string “FPS Monitor” resides at RVA 0x3AFA88; “Show FPS Overlay” at 0x3AFA98; the overlay prefix string “FPS: ” at 0x3AFAAC. +## 20.1 Registration and Vtable +The registrar constructor references the name string at RVA 0x1B71 and calls the module registry at 0x9B2C0. Two vtable blocks are emitted. The lambda vtable (for the registrar’s std::function wrapper) lives at 0x3B0E00; the module instance vtable is at 0x3B0E38. The singleton object is heap-allocated and its pointer cached at [.data+0x22E0] (VA 0x1803C72E0). +Instance vtable (0x3B0E38): +[+0x00] 0x9B660 dtor +[+0x08] 0x9B660 dtor (scalar deleting) +[+0x10] 0x9B650 Initialize -> jmp 0x90060 +[+0x18] 0x9B640 GetSingleton -> returns [.data+0x05D0] +[+0x20] 0x9B620 dtor with size 0x10 +[+0x28] 0x9B630 GetSelf -> lea rax,[rcx+8]; ret +[+0x38] 0x9B720 vtable setter (returns ptr to 0x3B0E70) +[+0x48] 0x9B710 Update -> jmp 0x81300 +## 20.2 Initialize (RVA 0x814C0) +Guarded by a once_flag at [.data+0x2310]. On first call it allocates the module object (0xD8 bytes via 0xAC86A), stores the vtable pointer from 0x3AFA38 into [.data+0x22E0], copies the name string “FPS Monitor” into [.data+0x22E8], sets enabled = 0x0 at [.data+0x2308], then overwrites the vtable slot with the render-function pointer from 0x3AFAC0. If already initialized the singleton pointer is returned early from [.data+0x22E0]. +## 20.3 RenderOverlay — Panel (RVA 0x85660; inner ImGui branch at 0x856F0) +The panel render function is called by ModuleManager::RenderOverlay. It renders two ImGui checkboxes inside the “FPS Monitor” collapsing header. The first checkbox (“FPS Monitor”, bound to [module+0x28]) toggles the FPS counter overlay; on state change it sets [ImGuiContext+0x2900]=1 (dirty flag) and resets the ini-save timer. The second checkbox (“Show FPS Overlay”, RVA 0x3AFA98) is bound to [module+0x28] via 0x85320 (Checkbox with state-ptr helper) and controls display of the overlay window. After both checkboxes, the function calls ImGui::EndDisabled via [ImGuiContext+0x27F0] WORD counter decrement. +## 20.4 RenderOverlay — FPS Counter Overlay (RVA 0x858D0) +When the FPS overlay is enabled ([module+0x28] != 0), this function draws a frameless ImGui window labelled “##Foreground” (RVA 0x3ABF10) pinned to the top-left of the viewport. It calls [.data+0x1D38] (GetDeltaTime via ImGuiContext) with rcx=0, computes xmm6 = 1.0 / deltaTime (i.e. current FPS), builds the display string “FPS: ” + integer FPS value (via 0x7F5C0), then selects a text color from three XMMWORD constants based on two hard-coded thresholds: +fps >= 60 -> color constant at 0x1803B3530 (green) +30 <= fps < 60 -> color constant at 0x1803B3540 (yellow) +fps < 30 -> color constant at 0x1803B3510 (red) +The colored FPS string is then submitted to the ImGui drawlist via 0x51580 (AddText with explicit color). The overlay window uses ImGui foreground drawlist accessed through [ImGuiContext+0x15D8]+0x40. +## 20.5 Singleton State Layout +FPSModule singleton base address: [.data+0x22E0] (VA 0x1803C72E0). Object size: 0xD8 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3AFAC0 after init) ++0x08 std::string name = "FPS Monitor" ([.data+0x22E8]..[.data+0x2307]) ++0x28 BYTE enabled (0 = disabled; written at [.data+0x2308]) ++0x30 BYTE show_fps_overlay (checkbox state for "Show FPS Overlay") ++0x60 XMMWORD (overlay window position/size, zeroed on init) +# 21. PreventScreenshot +PreventScreenshot prevents the game window from being captured by screen-recording tools. RTTI: .?AVPreventScreenshot@@ (RVA 0x3C5DA8). GUI label: “Prevent Screenshot” (RVA 0x3B00B8). The module uses the Windows API SetWindowDisplayAffinity (string at .data RVA 0x3C34A6, imported dynamically from user32.dll at RVA 0x3AEC70) with a Windows 10 build check before applying the affinity flag. +## 21.1 Registration and Vtable +Singleton pointer cached at [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. Once_flag at [.data+0x2390]. Two boolean state fields: [.data+0x2380] = enabled (BYTE, 0 on init), [.data+0x2388] = second toggle flag (BYTE, 0 on init). +## 21.2 Initialize (RVA 0x8AD70) +Guarded by a once_flag at [.data+0x2390]. On first call: constructs the std::string name “Prevent Screenshot” at [.data+0x2360], stores base vtable ptr 0x3AFA38 at [.data+0x2358], overwrites with second vtable ptr from 0x3B0110, zeroes both bool fields at [.data+0x2380] and [.data+0x2388]. +## 21.3 RenderOverlay (RVA 0x8AE60) +Calls GetInstance (0x8AD70) to obtain the module pointer. Renders a single ImGui checkbox “Prevent Screenshot” via 0x9D7D0 (toggle-checkbox helper) with state pointer [module+0x28] (enabled bool). The result is passed to 0x61FE0 (ImGui::Checkbox state commit), then ImGui::EndDisabled is called via the [ImGuiContext+0x27F0] WORD counter path (with an assertion for “Calling EndDisabled() too many times!” at 0x3AC160 if the counter is already zero). +## 21.4 Update — SetWindowDisplayAffinity Dispatch (RVA 0x8AFC0) +Called per-frame by ModuleManager::Update. The logic is: +1. Call GetInstance (0x8AD70) -> rbp = module object ptr +2. If [rbp+0x30] already set: skip (module not yet enabled) +3. If [rbp+0x28] (enabled) set: walk the hook/window list at [.data+0x24D0] +4. For each node [rbx+0x10]: call 0x8B220 (OS-version-checked affinity setter) +5. Call 0x81B00 (build HWND list), then 0x869A0 (apply affinity to all HWNDs) +## 21.5 OS Version Check and SetWindowDisplayAffinity (RVA 0x8B220) +This function loads ntdll.dll (via IAT[0x1800B1290]), resolves “RtlGetVersion” (IAT[0x1800B1088]), and fills a 0x11C-byte OSVERSIONINFOEXW struct on the stack. The OS build number (OSVERSIONINFOEXW.dwBuildNumber) is then cached at [.data+0x24FC] after being memcpy’d into [.data+0x24F0]. On subsequent calls, the cached value is used directly. +The affinity call at 0x8B48F reads [rbp+0x28] (enabled bool) and compares the cached build number against 0x4A61 (decimal 19041, Windows 10 Build 19041 = version 20H1). Two code paths result: +build < 19041: affinity arg = (enabled ? 1 : 0) (WDA_MONITOR = 1) +build >= 19041: affinity arg = (enabled ? 0x11 : 0) (WDA_EXCLUDEFROMCAPTURE = 0x11) +The resolved SetWindowDisplayAffinity function pointer is called via IAT[0x1800B1460]. On pre-20H1 builds, WDA_MONITOR (0x1) is used, which prevents the window from appearing in screen captures taken via the PrintScreen key but not via capture APIs. On 20H1 and later, WDA_EXCLUDEFROMCAPTURE (0x11) is used, which prevents capture by all recording tools including OBS and the Windows Game Bar. The “SetWindowDisplayAffinity” string stored at .data RVA 0x3C34A6 is used as the GetProcAddress argument for the dynamic resolve. +## 21.6 Singleton State Layout +PreventScreenshot singleton base: [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3B0110 after init) ++0x08 std::string name = "Prevent Screenshot" ([.data+0x2360]..[.data+0x237F]) ++0x28 BYTE enabled (checkbox state; drives affinity arg) ++0x30 BYTE state_dirty (set=1 when affinity has been applied; guards re-apply) ++0x38 BYTE second_flag ([.data+0x2388]; purpose unclear, zeroed on init) +The HWND target list at [.data+0x24D0] is a doubly-linked list of window handles to which the affinity is applied. The list is populated by 0x81B00 (enumerate Unity windows) and walked by the Update loop. The count of registered HWNDs is tracked at [.data+0x24D8]. +# 22. ESPModule Render and Update Implementation +Chapter 9 established ESPModule’s state layout and color-table defaults. This chapter documents the two remaining vtable slots not covered there: RenderOverlay (the ImGui control panel) and Update (the per-frame world-space entity label loop), both of which were only identified during the current analysis pass. +## 22.1 RenderOverlay (RVA 0x83FA0) +RenderOverlay is a large, monolithic function spanning roughly 0x83FA0–0x8499E. It draws the “ESP Features” collapsing header and all subordinate controls using the same once-lock + ImGui state machine pattern documented in FPSModule (Chapter 20). The function uses rsi throughout as the ESPModule singleton pointer (base VA 0x1803C6F70). +The function opens a CollapsingHeader titled “ESP Features” (string RVA 0x3AF838) via helper 0x9D7D0 with its state bound to [.data+0x27B0]. If collapsed, execution jumps directly to the epilogue. When expanded, the first control rendered is an “ON / OFF” checkbox (string RVA 0x3AF848) via helper 0x85320; its bool is bound to [rsi+0x28] (enabled). If enabled is false, the remainder of the panel still renders but ImGui’s BeginDisabled path dims and suppresses all interaction. +The “Display Types” sub-header (string RVA 0x3AF858) is rendered via 0x6EC20, which is a lightweight CollapsingHeader wrapper that returns false immediately when ImGui’s locked-input flag ([ImGuiContext+0x106]) is set. When expanded, it presents four entity visibility checkboxes, each bound via 0x61FE0 (ImGui::Checkbox commit helper): +“Show Monsters” (RVA 0x3AF868) → [rsi+0x34] show_monsters +“Show NPC” (RVA 0x3AF878) → [rsi+0x35] show_npc +“Show Friendly” (RVA 0x3AF888) → [rsi+0x36] show_friendly +“Show Puzzles” (RVA 0x3AF898) → [rsi+0x37] show_puzzles +“Show All” (RVA 0x3AF8A8) → [rsi+0x38] show_all +After the Show All checkbox, a Separator is emitted via 0x70630 (which also adjusts the cursor Y position). A second sub-header, “Display Info” (RVA 0x3AF8B8), follows the same 0x6EC20 pattern. When expanded, it reveals the per-label visibility checkboxes: +“Show Distance” (RVA 0x3AF8C8) → [rsi+0x39] show_distance +“Show Name” (RVA 0x3AF8D8) → [rsi+0x3A] show_name +“Show Type” (RVA 0x3AF8E8) → [rsi+0x3C] show_type +A second Separator call via 0x70630 closes the Display Info block. The function epilogue at 0x84984–0x8499E restores the ImGui cursor Y, pops the saved XMM registers, and returns. +## 22.2 Update / DrawOverlay (RVA 0x84A00) +Update is the per-frame entity rendering loop. It is guarded at entry (0x8499F) by a two-instruction stub that tests [rcx+0x28] (enabled) and returns immediately if clear, so the entire loop is skipped when the module is disabled. The main body at 0x84A00 proceeds as follows. +Initialization: the function calls the GetEntityManager cached pointer ([.data+0x1D28], xor ecx, ecx) and GetEntityList ([.data+0x1D30]), both resolved by GABypass. It also calls GetScreenResolution ([.data+0x1D18]) into a local {float2, int} struct, and GetCameraPosition ([.data+0x1D00]) to build a world-origin vector. If the entity count at [rax+0x20] is zero, execution jumps to the epilogue at 0x852AB. +Per-entity loop (0x84B30–0x852A5): for each entity pointer in the array, the function calls GetEntityType ([.data+0x1D20], xor edx edx) and dispatches on the returned type code. The dispatch also loads the per-type color XMMWORD directly from the ESPModule object at a type-dependent offset, and selects the corresponding visibility-flag byte: +type 0x08 → color [rdi+0x70] GREEN (0.00, 1.00, 0.00) flag: show_friendly [rdi+0x36] +type 0x10 / 0x4010 → color [rdi+0x40] RED (1.00, 0.00, 0.00) flag: show_monsters [rdi+0x34] +type 0x20 → color [rdi+0x50] ORANGE (1.00, 0.65, 0.00) flag: show_puzzles [rdi+0x37] +type 0x100 → color [rdi+0x80] BLUE (0.00, 0.00, 1.00) flag: show_npc [rdi+0x35] +default → color [rdi+0xB0] WHITE (1.00, 1.00, 1.00) flag: show_all [rdi+0x38] +Visibility gating: for named types the check is (show_all OR type_flag) != 0; for the default case only show_all is tested. If the entity fails the gate, execution jumps to the loop increment at 0x85289. +Screen-space projection: GetScreenPosition ([.data+0x1CF8]) is called with the entity world position and camera origin to produce a {float2, float} screen-coord struct. The resulting screen-space depth is compared against the module’s max_draw_distance field ([rdi+0x30], default 300); entities beyond that distance are culled at 0x84C6B. +Label assembly: a temporary std::string is built on the stack (0x84CB0). If show_distance ([rdi+0x39]) is set, the metric distance is formatted as an integer via 0x7F5C0 and prepended with the distance marker string “m” (RVA 0x3AF8F4). If show_name ([rdi+0x3A]) is set, GetEntityName ([.data+0x1CE0]) is called and the result is appended; if show_type ([rdi+0x3C]) is set, the entity type code is looked up against a six-entry table at RVA 0x3AF908 / 0x3AF920 mapping type values to name string pairs: +0xFFFFFFFF → “All” +0x00000001 → “Invalid” +0x00000008 → “Character” +0x00000010 → “Enemy” +0x00000020 → “Interactive” +0x00000040 → “Projectile” +If multiple label fields are enabled, segments are joined by “ | ” (RVA 0x3AF900). The assembled label string is then submitted to the ImGui foreground draw list via 0x49820, which positions the text at the projected screen coordinate with a small pixel offset (loaded from RVA 0x3B3224), using the type-selected RGBA color. The foreground draw list is accessed through the “##Foreground” window (RVA 0x3ABF10) as documented in FPSModule. The font for the label is pushed/popped around the call via 0x28C00 and 0x28D70 (BeginFontScope / EndFontScope wrappers). +Loop increment: rbx (entity index) is incremented at 0x85289, r15 advances by 8 bytes through the entity pointer array, and the loop repeats from 0x84B30 until rbx reaches the entity count. On exit the stack cookie is verified and the function returns. +## 22.3 ESPModule Singleton State Layout (Complete) +The following table merges the fields identified in Chapter 9 with the RenderOverlay and Update findings above. Base address: [.data+0x1F70] (VA 0x1803C6F70). All booleans are BYTE; all color slots are XMMWORD (16-byte RGBA float4). +Offset +.data addr +Type +Field / Init Value ++0x00 +[.data+0x1F70] +QWORD +vtable ptr (0x3AFA38 before init; 0x3AF9E0 after) ++0x08 +[.data+0x1F78] +std::string +name = 'ESPModule' (RVA 0x3AF828) ++0x28 +[.data+0x1F98] +BYTE +enabled = 0 ++0x30 +[.data+0x1FA0] +DWORD +max_draw_distance = 300 (0x12C) ++0x34 +[.data+0x1FA4] +BYTE +show_monsters = 1 ++0x35 +[.data+0x1FA5] +BYTE +show_npc = 1 ++0x36 +[.data+0x1FA6] +BYTE +show_friendly = 1 ++0x37 +[.data+0x1FA7] +BYTE +show_puzzles = 1 ++0x38 +[.data+0x1FA8] +BYTE +show_all = 0 ++0x39 +[.data+0x1FA9] +BYTE +show_distance = 1 ++0x3A +[.data+0x1FAA] +BYTE +show_name = 1 ++0x3B +[.data+0x1FAB] +BYTE +reserved = 0 ++0x3C +[.data+0x1FAC] +BYTE +show_type = 0 ++0x40 +[.data+0x1FB0] +XMMWORD +color_enemy RED (1.00, 0.00, 0.00, 1.00) ++0x50 +[.data+0x1FC0] +XMMWORD +color_interactive ORANGE (1.00, 0.65, 0.00, 1.00) ++0x60 +[.data+0x1FD0] +XMMWORD +color_slot2 YELLOW (1.00, 1.00, 0.00, 1.00) ++0x70 +[.data+0x1FE0] +XMMWORD +color_friendly GREEN (0.00, 1.00, 0.00, 1.00) ++0x80 +[.data+0x1FF0] +XMMWORD +color_npc BLUE (0.00, 0.00, 1.00, 1.00) ++0x90 +[.data+0x2000] +XMMWORD +color_slot5 CYAN (0.00, 1.00, 1.00, 1.00) ++0xA0 +[.data+0x2010] +XMMWORD +color_slot6 PURPLE (0.58, 0.00, 0.83, 1.00) ++0xB0 +[.data+0x2020] +XMMWORD +color_default WHITE (1.00, 1.00, 1.00, 1.00) ++0xC0 +[.data+0x2030] +XMMWORD +color_slot8 PINK (1.00, 0.08, 0.58, 1.00) ++0xD0 +[.data+0x2040] +XMMWORD +color_slot9 LPINK (1.00, 0.75, 0.80, 1.00) +Color slots 2, 5, 6, 8, and 9 are not assigned to any type code in the Update dispatch and are therefore spare palette entries; they are exposed in the ImGui color-picker widgets but have no current runtime effect on the overlay. +# 23. DamageHack — Ghost Feature Analysis +The i18n table (RVA 0x3B1484) contains four keys with no corresponding RTTI class, vtable, registrar lambda, registered singleton, or callable code anywhere in the binary: “Damagehack Toggle”, “Damage Multiplier”, “Multiplier Value”, and “Random Damage Type”. This chapter documents what can be determined from the available evidence and establishes what is definitively absent. +## 23.1 i18n Evidence +The four DamageHack keys appear as a contiguous block in the JSON i18n blob immediately after the “Version: ” key and immediately before “This is free, if you spend money, then you have been deceived”. Each key carries English and Simplified Chinese translations: +“Damagehack Toggle” en / zh_cn: 伤害修改 (Damage Modification) +“Damage Multiplier” en / zh_cn: 伤害倍数 (Damage Multiplier) +“Multiplier Value” en / zh_cn: 倍数値 (Multiplier Value) +“Random Damage Type” en / zh_cn: 随机伤害类型 (Random Damage Type) +The Chinese translations are idiomatic and consistent with the translations for implemented features in the same blob, indicating they were written at the same time as the rest of the localisation table. The four keys fit the pattern of a planned ImGui panel: one boolean toggle, one float multiplier, a numeric input for the multiplier value, and an enum selector for damage type randomization. +## 23.2 What Is Absent +A complete binary search for any string containing “Damage”, “damage”, “DamageHack”, or “damagehack” outside the JSON blob returns zero results. The RTTI scan of the .data section (RVA 0x3C5000–0x3C8000) identifies exactly 11 cheat-module class names — ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule — and no DamageHack entry. Similarly, the registrar-lambda RTTI list contains no DamageHack entry. There is no singleton pointer, no once_flag guard, no vtable, and no callable RenderOverlay or Update function anywhere in the image. +## 23.3 Interpretation +DamageHack was planned but never implemented in this build. The i18n keys were added to the localisation file during feature planning or alongside a partial implementation that was subsequently stripped, but no code corresponding to those keys was ever compiled into the binary. This is consistent with the developer shipping the localisation blob as a whole-file asset while selectively excluding unfinished module source files from the build. +The intended design, inferred from the four i18n keys, would have been: a boolean master toggle (“Damagehack Toggle”) gating an intercepted damage-calculation call, a float multiplier applied to the outgoing damage value (“Damage Multiplier” / “Multiplier Value”), and an enum-driven randomisation mode for the damage type field (“Random Damage Type”). The implementation would most likely have operated as an IL2CPP function hook resolved via GABypass, consistent with how SkillHack intercepts cooldown and cost values. +From a detection standpoint, the ghost i18n keys are a useful indicator: any version of this cheat that activates DamageHack controls would be a different build from the one analysed here. The presence of these keys in an extracted string dump of a suspect binary is therefore a build-version discriminator, not evidence of active functionality. +# 25. Sidebar / Main Panel Render (RVA 0x7F8F0) +The top-level overlay panel is rendered by the function at RVA 0x7F8F0 (VA 0x18007F8F0). This function draws the outer “Sidebar” ImGui window that contains all module tab buttons and the About page. It is called from the ModuleManager render loop on every Present() frame and is responsible for the entire visible cheat UI chrome. +## 25.1 Function Signature and Layout +Entry point: RVA 0x7F8F0, approximately 0x146E bytes (tail-calls into ImGui epilogue at 0x180023E20 via jmp at 0x180080D5E). The function allocates a 0x380-byte stack frame, saves xmm6–xmm8, and takes a single rcx argument (ModuleManager / global context pointer). Key address references: +Window title: "Sidebar" (RVA 0x3AF2C8) — used as module lookup key (CRC32 via 0x180011DF0, registry lookup via 0x18003D1A0 and 0x18001D2B0); ImGui::Begin is not called from within 0x7F8F0 itself +Banner string: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) +Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) +Active tab idx: [.data+0x1F68] (VA 0x1803C6F68; written on click, read by jump table at 0x80B52) +## 25.2 Tab Navigation and Rendering +The sidebar renders six tab buttons. Each label is looked up from the i18n table via 0x18009D660 (the same translation dispatcher used by all modules). The six tabs, their label RVAs, and the jump-table case bodies dispatched on selection are: +Tab 0: "About" (RVA 0x3AF2D0) — sidebar header (banner + disclaimer) + About body sub-function (0x80E80) +Tab 1: "Player" (RVA 0x3AF2DC) — NoClip, SkillHack (movement/skill controls) +Tab 2: "ESP" (RVA 0x3AF2E8) — ESPModule overlay features +Tab 3: "World" (RVA 0x3AF2F0) — Vacuum (world/item interaction) +Tab 4: "Visual" (RVA 0x3AF2FC) — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +Tab 5: "Settings" (RVA 0x3ADFD8) — Theme/preset selection via 0x18009A4F0 (language, color theme) +The banner string (RVA 0x3AF258) and anti-scam disclaimer (RVA 0x3AF288) are rendered as a Sidebar-level header before the tab bar. Each of the six tab buttons is rendered by calling 0x80D80 (click-state handler, returns bool); if a tab is clicked its index (0–5) is written to [.data+0x1F68] (VA 0x1803C6F68). After all tab buttons are rendered, a jump table at RVA 0x80B52 reads [.data+0x1F68], bounds-checks against 5, and dispatches to the corresponding case via [0x180000000 + rax*4 + 0x80D64]. Case 0 calls sub-function 0x80E80 (About body: game title, version, author). Cases 1–4 call module-getter helpers that return the relevant singleton pointer, then invoke vtable[0x28] (RenderOverlay) for each. Case 5 delegates to 0x18009A4F0 (Settings/Theme renderer). +## 25.3 Author and Version Display +The About tab body is rendered by sub-function 0x80E80. It displays game context via the format string “%s Game: Endfield CTB3” (RVA 0x3AF350), the version label “Version: ” (RVA 0x3AF368) with value “1.0.0” (RVA 0x3AF374), and the author label “Author: ” (RVA 0x3AF380) with value “gktwo” (RVA 0x3AF38C). These are direct string literals, not i18n-dispatched keys. +## 25.4 Key Address Summary +RVA 0x7F8F0 Sidebar::RenderMainPanel (this chapter) +RVA 0x3AF258 Banner string +RVA 0x3AF288 Anti-scam disclaimer +RVA 0x3AF2C8 "Sidebar" window title +.data+0x1F68 Active tab index (VA 0x1803C6F68; written per-click, dispatched at jump table 0x80B52) +# 26. Language Selector (Sidebar Unconditional Panel) +The sidebar function (0x7F8F0) renders a language-selection sub-panel unconditionally on every frame, before the jump-table dispatch for tab bodies. The panel appears at VA range 0x180080770–0x180080B50 and is part of the sidebar’s Settings section rather than any individual tab body. +## 26.1 String Inventory +RVA 0x3AF310 "English" — first Combo item (index 0) +RVA 0x3AF318 "简体中文" — second Combo item (index 1) +RVA 0x3AF328 " Language" — tab label (5-space indent, 0xD chars) +RVA 0x3AF338 "##Language" — ImGui::Combo widget ID +## 26.2 Execution Flow +The language selector logic follows this sequence: +0x180080895 call 0x18009D660 — locale context init +0x1800808DD lea rsi,[...] # 0x1803AF310 — "English" item ptr +0x1800808E3 lea rbx,[...] # 0x1803AF318 — "简体中文" item ptr +0x1800809A1 lea rdx,[...] # 0x1803AF328 — tab label " Language" +0x1800809C6 call 0x18009D7D0 — BeginTab (render label) +0x180080A03 call 0x180064220 — ImGui::Combo (language dropdown) +al = 1 if selection changed, 0 otherwise +if English selected: +0x180080A2F mov DWORD PTR [0x1803C77B0], r12d — store 0 (language index = English) +if 简体中文 selected: +0x180080A5D mov DWORD PTR [0x1803C77B0], 0x1 — store 1 (language index = ZH-CN) +0x180080A6E call 0x18002A530 — i18n content refresh (reload translations) +0x180080A73 dec DWORD PTR [g_Config+0x2764] — decrement content ref-count +0x180080A80 mov rax,[g_Config+0x15D8] — get active config preset ptr +0x180080A87 mov BYTE PTR [rax+0x103], 0x1 — set dirty flag for config save +0x180080B0B lea rcx,[...] # 0x1803ADFC8 "Content" — module key +0x180080B12 call 0x180011DF0 — CRC32 lookup on "Content" module +0x180080B33 call 0x18003D1A0 — registry lookup +0x180080B4D call 0x18001D2B0 — module notify/update +## 26.3 Language Index State +VA 0x1803C77B0 language_index (DWORD) +0 = English +1 = 简体中文 (Simplified Chinese) +On language change, three things happen: the i18n content is refreshed via 0x18002A530, a config-preset dirty bit is set at [g_Config+0x15D8+0x103], and the “Content” module is notified via the standard CRC32/registry/notify triple (0x180011DF0, 0x18003D1A0, 0x18001D2B0). Two languages are supported in this build: English (default) and Simplified Chinese. +# 27. FreeCam Key Binding Display Panel (RVA 0x87A70–0x88606) +The documented FreeCam::Update function (RVA 0x871A0, see Ch.12.3) is 0x14C6 bytes long and includes a key-binding display section beginning at approximately 0x87A70 that was not previously described. This section renders four float-value sliders and eleven key-binding label rows using ImGui. +## 27.1 Float Sliders +Four consecutive DragFloat/SliderFloat controls appear before the key-binding rows, all using the ImGui slider variant at 0x180065570: +RVA 0x3AFCB0 "Free Camera" — sub-panel BeginTab label +RVA 0x3AF848 "ON / OFF" — toggle checkbox +RVA 0x3AFCC0 "Move Speed" — DragFloat, fmt "%.3f" (0x3ADFB0) +RVA 0x3AFCD0 "Look Sensitivity" — DragFloat, fmt "%.3f" +RVA 0x3AFCE8 "Roll Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFCF8 "FOV Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFD04 "FOV" — DragFloat, fmt "%.1f" (0x3ADFEC) +## 27.2 Key Binding Label Rows +Eleven key-binding rows follow. Each row: (1) calls 0x18000FCB0 (MakeString) to format the label via 0x18005FB60 (sprintf-style, substituting the key name), (2) calls 0x18009D7D0 to render the resulting string as a tab-style label. Unbound keys display “NONE” (RVA 0x3AF820). +RVA 0x3AFD08 "Forward Key: %s" — VA 0x180087A87 +RVA 0x3AFD18 "Backward Key: %s" — VA 0x180087B1A (approx) +RVA 0x3AFD30 "Left Key: %s" +RVA 0x3AFD40 "Right Key: %s" +RVA 0x3AFD50 "Up Key: %s" +RVA 0x3AFD60 "Down Key: %s" +RVA 0x3AFD70 "IncFOV Key: %s" +RVA 0x3AFD80 "DecFOV Key: %s" +RVA 0x3AFD90 "LeftRoll Key: %s" +RVA 0x3AFDA8 "RightRoll Key: %s" +RVA 0x3AFDC0 "ResetRoll Key: %s" +RVA 0x3AF820 "NONE" — displayed for any unbound key +## 27.3 Dispatch Pattern +Each key row uses the same three-call sequence: MakeString (0x18000FCB0) to build the “Key Name: %s” format string, 0x18005FB60 to sprintf the current key name into it, and 0x18009D7D0 to render the result. The key name state block is at [rip+...] # 0x1803C6E98 (the “Pu;” RTTI sentinel in .data indicates the key-binding state array). This panel is visually shown as a collapsible key-rebinding display inside the FreeCam tab when enabled. +# 28. Settings Tab — Theme Selector and Console Toggle (RVA 0x9A4F0) +The Settings tab body function at RVA 0x18009A4F0 (source: SettingsTAB.cpp, RVA 0x3B0B30) renders a theme selector and a console toggle. It is called from sidebar case 5 (0x80D25). The function ends at approximately RVA 0x9AB31. +## 28.1 Theme Selector +A “Theme” combo-box (“Theme” at RVA 0x3B0AD4, rendered via ImGui::Combo at 0x180064220) presents four themes. Selecting a theme calls the corresponding palette-applicator function, which writes RRGGBBAA hex color strings from .rdata into the active ImGui color table. +Theme name strings: +RVA 0x3B0AF8 "Default" — applicator: RVA 0x941F0 (restores ImGui defaults) +RVA 0x3B06D0 "Evangelion Unit 01" — applicator: RVA 0x94890 +RVA 0x3B0AE0 "Evangelion Unit 02" — applicator: RVA 0x96770 +RVA 0x3B0B10 "Matrix" — applicator: RVA 0x98650 +## 28.2 Palette Color Tables +Each non-default theme applicator reads RRGGBBAA hex strings from .rdata and applies them to ImGui style slots. The colors below are listed in the order each applicator writes them (11 colors for Evangelion themes, 10 for Matrix): +Evangelion Unit 01 (RVA 0x94890): +0x3B06F8 #FFFFFFFF 0x3B06E8 #7857A7FF 0x3B0718 #19171CFF +0x3B0708 #2A282EFF 0x3B0738 #2A282EE6 0x3B0728 #4DE6A5FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B0778 #A38CCF80 +0x3B0768 #7857A780 0x3B0798 #4A4552FF +Evangelion Unit 02 (RVA 0x96770): +0x3B06F8 #FFFFFFFF 0x3B0898 #D9293BFF 0x3B0888 #1E1E1EFF +0x3B08B8 #3A3A3AFF 0x3B08A8 #3A3A3AE6 0x3B08D8 #F7B302FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B08C8 #F7465880 +0x3B08F8 #D9293B80 0x3B0798 #4A4552FF +Matrix (RVA 0x98650): +0x3B09B8 #00FF41FF 0x3B09A8 #00AA2CFF 0x3B09D8 #000000FF +0x3B09C8 #0A0A0AFF 0x3B09F8 #0A0A0AE6 0x3B09E8 #004400FF +0x3B0758 #00000000 0x3B0A18 #00440040 0x3B0A08 #00881EFF +0x3B0A38 #00FF4180 +## 28.2.1 Per-Slot Color Applicator Helper (RVA 0x94190) +Each individual color push in the three non-default theme applicators (0x94890, 0x96770, 0x98650) is performed by a shared helper at RVA 0x94190. This function reads an RRGGBBAA hex string from .rdata using __stdio_common_vsscanf (IAT[0xB1880]), converts it to a packed RGBA value, then calls ImGui::PushStyleColor (via 0x180010840) with the target style-slot index and the parsed colour. It is called 159 times across the four writer functions (52 times from 0x94890 alone, corresponding to the full 52-slot Default palette). +## 28.3 Console Toggle +After the theme selector, the function renders a “Toggle Console” checkbox (RVA 0x3B0B00) using CheckboxToggle (0x180085320). The console state is read and displayed via two branches: +RVA 0x3B0B00 "Toggle Console" — checkbox label +if console enabled: display format "Console {}" (RVA 0x3B0B78) +using IAT AllocConsole (0x1800B1178) / GetStdHandle (0x1800B1628) +if console disabled: display "enabled" (RVA 0x3B0B28) +or "Disabled" (RVA 0x3B0B18) +## 28.4 Key Address Summary +RVA 0x9A4F0 SettingsTab::Render (this chapter) +RVA 0x941F0 Default palette applicator +RVA 0x94890 Evangelion Unit 01 palette applicator +RVA 0x96770 Evangelion Unit 02 palette applicator +RVA 0x98650 Matrix palette applicator +RVA 0x3B0AD4 "Theme" combo label +RVA 0x3B0B30 E:\git\Endfield_Cheeto\...\SettingsTAB.cpp +# 29. Win32/D3D11 Overlay Window Initialisation (RVA 0x827A0–0x8375C) +The overlay window subsystem is a single large function at 0x827A0 (called from the startup function 0xA9190 at 0xA9585) with two sub-functions: FindGameWindow (0x835D0) and GetOverlayRect (0x836A0). It creates the transparent layered Win32 window, initialises a D3D11 device and swap chain, runs the Win32 message loop, and keeps the overlay aligned to the game window. Ch. 7 documents the WndProc at 0x826A0 (the window procedure registered by this subsystem); Ch. 15.5 documents the Present hook call site at 0x82F00 which lies inside the message loop body. +## 29.1 DPI Awareness Initialisation (0x827FF–0x82923) +The function opens with a TLS-guarded once_flag block before performing DPI setup. Two DPI APIs are tried in priority order. First, LoadLibraryA(‘user32.dll’) is called (via IAT[0xB10E0]) and GetProcAddress is used to locate SetThreadDpiAwarenessContext; if found, it is called with context value 0xFFFFFFFFFFFFFFFC (DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2). If that fails, LoadLibraryA(‘shcore.dll’) and GetProcAddress resolve SetProcessDpiAwareness, which is then called with value 2 (PROCESS_PER_MONITOR_DPI_AWARE). If both dynamic lookups fail, the fallback is SetProcessDPIAware (IAT[0xB15A0]), a legacy API that sets system-DPI awareness. The guard at [.data+0x3C7440] / [.data+0x3C7448] ensures each path runs at most once. +## 29.2 Game Window Location and Window Class Registration (0x82924–0x82A28) +EnumWindows (IAT[0xB14A0]) is called with FindGameWindow (0x835D0) as the callback to locate the Unity game window. A WNDCLASSEX structure is then populated: CreateSolidBrush(0x7F00) (IAT[0xB1018]) sets the background brush to an opaque olive colour used only as a placeholder; LoadCursorW (IAT[0xB15C8]) provides the standard arrow cursor; two LoadIconW calls (IAT[0xB14E8]) load the small and large application icons. RegisterClassExW (IAT[0xB1638]) registers the class. GetSystemMetrics (IAT[0xB14E0]) is called twice to retrieve the full screen width (SM_CXSCREEN) and height (SM_CYSCREEN) for the initial window geometry. +## 29.3 Overlay Window and D3D11 Device Creation (0x82A29–0x82BFF) +CreateWindowExW (IAT[0xB1650]) creates the overlay window with WS_EX_LAYERED | WS_EX_TRANSPARENT style flags so it passes mouse input through to the game beneath it. SetLayeredWindowAttributes (IAT[0xB15E0]) sets the colour key and alpha. DwmExtendFrameIntoClientArea (IAT[0xB1918]) extends the DWM glass frame into the entire client area, which together with the layered attributes produces a fully transparent background. D3D11CreateDeviceAndSwapChain (IAT[0xB1908]) is called twice: the first call at 0x82B24 attempts D3D_FEATURE_LEVEL_11_0 with DXGI_FORMAT_R8G8B8A8_UNORM; on failure the second call at 0x82B7E retries with a DXGI_FORMAT_B8G8R8A8_UNORM swap chain as a fallback. After a successful device create, the compiled shader objects from Ch. 5 are bound. The helper 0x825B0 (called at 0x82B8C; documented in Ch. 7 as D3D11::Reinit) sets up the ImGui D3D11 backend. ShowWindow (IAT[0xB1628]) and UpdateWindow (IAT[0xB14D8]) make the window visible. CreateMutexA (IAT[0xB1720]) at 0x82C0D creates a named mutex to prevent duplicate overlay instances. +## 29.4 Initialisation Log and Message Loop (0x82C01–0x8352F) +Before entering the loop, the string ‘Initialized’ (RVA 0x3AF610) is logged at 0x82F5F from source file E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp. The main loop uses the standard Win32 pattern: PeekMessageW (IAT[0xB14D0]) / TranslateMessage (IAT[0xB14C8]) / DispatchMessageW (IAT[0xB14C0]). Each iteration calls FindWindowA(‘UnityWndClass’, NULL) (IAT[0xB14A8] called at 0x8301F) to verify the game process is still running; if the window disappears the loop exits. IsWindow (IAT[0xB1468]) validates the game HWND, GetWindowThreadProcessId (IAT[0xB1498]) retrieves its thread, and GetWindowRect (IAT[0xB1488]) reads its current bounds. SetWindowPos (IAT[0xB1588]) repositions the overlay to match the game window on every frame. GetForegroundWindow (IAT[0xB15F0]) and three GetClassNameA calls (IAT[0xB1490]) detect whether the game is the active foreground window and adjust the overlay visibility state via two SetWindowLongW calls (IAT[0xB15B0]). SwitchToThread (IAT[0xB1148]) at 0x8348A yields the CPU when the game is not in focus. On loop exit, DestroyWindow (IAT[0xB1570]) and UnregisterClassW (IAT[0xB1640]) clean up the overlay window and class. +## 29.5 FindGameWindow Callback (RVA 0x835D0) +This function is passed as the lpEnumFunc callback to EnumWindows. For each top-level window it calls GetWindowThreadProcessId (IAT[0xB1498]) and GetClassNameA (IAT[0xB1490]), then compares the class name against the literal string ‘UnityWndClass’ (RVA 0x3AF658) using the internal string-compare helper at 0xACA12. On a match it calls SetForegroundWindow (IAT[0xB1518]) to bring the game to the front, records the HWND, and then calls GetOverlayRect (0x836A0) to capture the initial window geometry. A second GetWindowThreadProcessId and AttachThreadInput call at 0x8368E synchronise the overlay thread’s input queue with the game thread. +## 29.6 GetOverlayRect (RVA 0x836A0) +Called by FindGameWindow and on every frame to compute the overlay rectangle. IsWindowVisible (IAT[0xB1480]) and IsIconic (IAT[0xB1510]) first check that the game window is visible and not minimised. DwmGetWindowAttribute (IAT[0xB1920]) with DWMWA_EXTENDED_FRAME_BOUNDS retrieves the DWM-adjusted window bounds (which exclude the invisible resize borders). GetClientRect (IAT[0xB15A8]) provides the inner client area. Two GetWindowLongPtrW calls (IAT[0xB1470]) read GWL_STYLE and GWL_EXSTYLE to account for window border widths. The function returns the final overlay RECT which SetWindowPos uses to position the overlay exactly over the game viewport. +## 29.7 Key Address Table +RVA 0x827A0 WinInit top-level entry (called from 0xA9585) +RVA 0x827FF DPI init block TLS-guarded; tries SetThreadDpiAwarenessContext then SetProcessDpiAwareness +RVA 0x82924 EnumWindows find game HWND via FindGameWindow callback +RVA 0x8298B RegisterClassExW overlay window class registration +RVA 0x82A29 CreateWindowExW WS_EX_LAYERED overlay window +RVA 0x82A60 DwmExtendFrameIntoClientArea full transparent client area +RVA 0x82B24 D3D11CreateDeviceAndSwapChain primary attempt (DXGI_FORMAT_R8G8B8A8_UNORM) +RVA 0x82B7E D3D11CreateDeviceAndSwapChain fallback (DXGI_FORMAT_B8G8R8A8_UNORM) +RVA 0x82C0D CreateMutexA single-instance guard mutex +RVA 0x82F5F ‘Initialized’ log source: UI.cpp; emitted after device creation succeeds +RVA 0x82F00 Present hook site documented in Ch. 15.5 +RVA 0x8348A SwitchToThread yields when game is not in foreground +RVA 0x835D0 FindGameWindow EnumWindows callback; locates ‘UnityWndClass’ HWND +RVA 0x836A0 GetOverlayRect DwmGetWindowAttribute + GetClientRect; returns overlay RECT +RVA 0x826A0 WndProc documented in Ch. 7 +# 24. Final Analysis Summary +EF-Cheeto.dll (internal name, distributed as unityexplorer.dll) is a fully-featured Unity game cheat module for an IL2CPP-based game. The complete analysis across twenty-five chapters reveals the following architecture: +Infrastructure Layer: D3D11 Present hook for overlay rendering, Win32 WndProc subclass for hotkeys, Toolhelp32 thread enumeration for safe code patching, MSVC-standard stack cookie security (no active anti-debug), D3DCompile for ImGui shaders, and _wfopen-based config persistence using nlohmann/json serialization. +Hook Engine: Custom hook manager with FNV-1a hash table, trampoline allocation via VirtualAlloc, thread-safe patching via Suspend/Resume, and a 71-entry IL2CPP function pointer bypass table (GABypass). +Cheat Modules (11 registered + 1 ghost): NoClip (CharacterController bypass), SkillHack (cooldown/cost IL2CPP hooks), FreeCam (CinemachineBrain camera override), FpsUnlocker (targetFrameRate), FPSModule (FPS counter overlay; see Ch. 20), SetDither (render setting), PlayerProfile (UI text injection), Vacuum (monster item pull), ESPModule (entity overlay, 10-color table; see Ch. 22), DamageHack (ghost — i18n only, no code; see Ch. 23), PreventScreenshot (registered; SetWindowDisplayAffinity). +Configuration: 172-field g_Config struct at .data+0x1F70, per-version config writers for multiple game versions, auto-save timer at [state+0x2904], ImGui layout persistence via standard ini format. +The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows, targeting IL2CPP Unity games. All twenty-five chapters together constitute a complete static reconstruction of the binary with no significant undocumented regions remaining. diff --git a/IDA/project/docs/input/files2/ef_cheeto_feed_2_header.md b/IDA/project/docs/input/files2/ef_cheeto_feed_2_header.md new file mode 100644 index 0000000..c87a273 --- /dev/null +++ b/IDA/project/docs/input/files2/ef_cheeto_feed_2_header.md @@ -0,0 +1,2371 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 2/3 +# This part: Reconstruction header with all structs, RVAs, string table, IL2CPP table. +# Feed with Parts 1 and 3 for complete reconstruction context. + +================================================================================ +RECONSTRUCTION HEADER (ef_cheeto_reconstruction.h) +Compiles: g++ -std=c++17 -fsyntax-only +2,092 lines covering 538 RVAs, 97 .data addresses, 189 strings, 75 IAT entries +================================================================================ + +// ============================================================================ +// EF-Cheeto (unityexplorer.dll) — Reconstruction Headers +// Derived from: EF-Cheeto_Vol12_Final_Analysis.docx (complete binary audit) +// Target: x86-64 Windows DLL, MSVC build, GameAssembly.dll (Endfield) +// Base VA: 0x180000000 | .data base: 0x1803C5000 (RVA 0x3C5000) +// ============================================================================ + +#pragma once +#include +#include + +// ============================================================================ +// SECTION 1 — PRIMITIVE TYPEDEFS +// ============================================================================ + +using u8 = uint8_t; +using u16 = uint16_t; +using u32 = uint32_t; +using u64 = uint64_t; +using i32 = int32_t; +using f32 = float; +using f64 = double; +using BOOL = int; // IL2CPP managed bool return (al register) + +// ============================================================================ +// SECTION 2 — GLOBAL .DATA LAYOUT (abridged — key singletons) +// ============================================================================ +// All offsets are RVA from binary base 0x180000000. +// VA = 0x180000000 + RVA. +// .data region starts at RVA 0x3C5000 (VA 0x1803C5000). +// References below use shorthand [.data+N] meaning VA 0x1803C5000 + N. +// +// Key global pointers: +// [.data+0x00D8] g_D3DState ptr (D3D11 device/swap chain block) +// [.data+0x00E0] active_preset_name (std::string — "Preset0".."Preset3") +// [.data+0x00EC] active_preset_index (DWORD — 0-3) +// [.data+0x00F0] gameassembly_base (cached GetModuleHandleW result) +// [.data+0x1E88] hook_spinlock (DWORD — 0=free, 1=held) +// [.data+0x1E90] hook_allocator_ptr (IAllocator for hook_array, capacity 0x80) +// [.data+0x23B8] ModuleManager.registrars_begin +// [.data+0x23C0] ModuleManager.registrars_end +// [.data+0x23C8] ModuleManager.registrars_cap +// [.data+0x2398] ModuleManager object ptr +// [.data+0x23A8] ModuleManager secondary ptr +// [.data+0x23D0] ModuleManager once_flag (std::once_flag) + +// ============================================================================ +// SECTION 3 — g_Config (global config object) +// ============================================================================ +// g_Config is a large global object stored in .data. +// Fields below are offsets FROM the g_Config object base (not from .data base). +// g_Config does not have a single documented base address — it IS .data in +// the relevant regions. Use field VA = 0x1803C5000 + offset where offset +// matches the [.data+N] values from the doc. +// +// PANEL / UI scroll state (used by all module Render() panel-open sequences) +struct GConfigPanelFields { + // offset from g_Config (which sits at .data) + // [g_Config+0x0058] scroll_base (float) — horizontal scroll base offset + // [g_Config+0x00D8] d3d_state_ptr (void*) — D3D11 state block + // [g_Config+0x0150] panel_width (float) — rendered panel content width + // [g_Config+0x0194] scroll_accum (float) — accumulated horizontal scroll + // [g_Config+0x0198] scroll_total (float) — total scroll range + // [g_Config+0x0E0C] scroll_step (float) — per-frame scroll delta + // [g_Config+0x15D8] panel_ptr (void*) — pointer to active ImGui panel struct + // [g_Config+0x1BEC] imgui_ini_fallback (void*) — fallback .ini path ptr + // [g_Config+0x1C00] scroll_region_root (void*) — root of scroll region config + // [g_Config+0x1F68] active_tab_idx (DWORD) — written by binding state array +}; + +// Panel-open sequence (all modules — addss path): +// rax = *panel_ptr; +// rax->field_0x103 = 1; +// xmm0 = scroll_step + rax->scroll_accum + rax->scroll_base + rax->scroll_total; +// rax->panel_width = xmm0; +// Panel-close sequence (subss path): same but scroll_accum -= scroll_step. + +// HOOK SLOTS [g_Config+0x1E40..0x1E68] (SkillHack IL2CPP hook target pointers) +// [g_Config+0x1E40] hook5_target — ApplySkillCost() (void fn) +// [g_Config+0x1E48] hook6_target — (dispatcher target) +// [g_Config+0x1E50] hook3_target — GetCooldownPercent() (float fn) +// [g_Config+0x1E58] hook4_target — IsSkillAvailable() (BOOL fn) +// [g_Config+0x1E60] hook1_target — skill check A (BOOL fn) +// [g_Config+0x1E68] hook2_target — skill check B (BOOL fn) + +// OVERLAY FLAGS (written by UnityExplorer when window is active) +// [g_Config+0x1F78] overlay_flags (DWORD) — |= 1 when UE window open +// [g_Config+0x1F90] overlay_scale (float) — set to 300.0f when UE open + +// ============================================================================ +// SECTION 4 — IL2CPP FUNCTION POINTER TABLE +// ============================================================================ +// GABypass::Patch (RVA 0xA9120) resolves 71 function pointers from +// GameAssembly.dll at DLL attach and writes them to .data slots. +// Format: slot_rva = .data offset from g_base 0x1803C5000 +// Access: fn_ptr = *(void**)(gameassembly_base + il2cpp_offset) +// +// Key: ptr = *(void**)(.data + slot_rva) +// call as: ((RetType(*)(Args...))(ptr))(args...); + +struct IL2CPP_Table { + // Slot .data-offset | IL2CPP offset | Resolved name + void* GameObject_GetComponentByIndex; // 0x1C48 +0x09DC0120 + void* il2cpp_domain_get_assemblies_A; // 0x1C50 +0x0018CEC0 + void* Component_GetComponent_Transform; // 0x1C58 +0x0B390700 + void* Transform_get_localScale; // 0x1C60 +0x0B3A2D20 + void* Transform_get_rotation; // 0x1C68 +0x0B3A2CB0 + void* il2cpp_object_get_class; // 0x1C70 +0x0018AD80 + void* il2cpp_class_get_method_from_name;// 0x1C78 +0x00007480 + void* Transform_get_localPosition; // 0x1C80 +0x0B3A1AE0 + void* Transform_get_position; // 0x1C88 +0x0B3A1A70 [also 0x1DD0] + void* Transform_set_localPosition; // 0x1C90 +0x0B3A51D0 + void* GameObject_SetActive; // 0x1C98 +0x0B398830 [also 0x1DB8] + void* GameObject_get_transform; // 0x1CA0 +0x0B3911F0 + void* Transform_set_rotation; // 0x1CA8 +0x0B3A59D0 [also 0x1DE0] + void* GameObject_get_activeInHierarchy; // 0x1CB0 +0x0B391D90 + void* GameObject_get_tag; // 0x1CB8 +0x0B3B2410 + void* GameObject_get_name; // 0x1CC0 +0x0B3B2120 + void* GameObject_get_layer; // 0x1CC8 +0x0B3B40B0 + void* GameObject_get_scene; // 0x1CD0 +0x0B397980 + void* Game_SkillBuff_A; // 0x1CD8 +0x02F3DA80 (SkillHack) + void* GetEntityName; // 0x1CE0 +0x00F27E10 (ESP label) + void* Component_GetComponents; // 0x1CE8 +0x0B329000 + void* Component_GetComponentsInChildren;// 0x1CF0 +0x0B329D80 + void* Game_SkillSlot_A; // 0x1CF8 +0x03E9BB50 (SkillHack) + void* Object_get_name; // 0x1D00 +0x0B383F60 + void* Component_GetType_A; // 0x1D08 +0x0B33CAB0 + void* Component_GetType_B; // 0x1D10 +0x0B33CB00 + void* Game_SkillSlot_B; // 0x1D18 +0x039D1AA0 (SkillHack) + void* Game_Combat_HitA; // 0x1D20 +0x026DE9F0 + void* GetEntityManager; // 0x1D28 +0x0478E860 (NoClip/FpsUnlocker) + void* Game_Combat_HitB; // 0x1D30 +0x025E2D40 + void* Game_Movement_PhysA; // 0x1D38 +0x087C2CD0 (NoClip CharCtrl) + void* Game_Movement_PhysB; // 0x1D40 +0x03419AF0 (NoClip CharCtrl) + void* Application_set_targetFrameRate; // 0x1D48 +0x0B322FB0 (FpsUnlocker) + void* SceneManager_GetActiveScene; // 0x1D50 +0x0B396A20 + void* CinemachineBrain_GetActiveVCam; // 0x1D58 +0x0B397700 (FreeCam) + void* Game_EntityState_A; // 0x1D60 +0x03766810 (ESP/SkillHack) + void* Transform_set_localScale; // 0x1D68 +0x0B3A2A60 + void* Rigidbody_get_velocity; // 0x1D70 +0x0B326660 (NoClip/Vacuum) + void* Rigidbody_set_velocity; // 0x1D78 +0x0B3266B0 (NoClip/Vacuum) + void* Object_Destroy; // 0x1D80 +0x0B383200 + void* Transform_set_position; // 0x1D88 +0x0B3A1A10 (NoClip/Vacuum) + void* Game_EntityState_B; // 0x1D90 +0x0B3A2340 (ESP) + void* Input_GetAxis_MouseX; // 0x1D98 +0x0B421800 (FreeCam look X) + void* Game_PlayerState_A; // 0x1DA0 +0x0B3A26D0 (ESP/SkillHack) + void* Game_PlayerState_B; // 0x1DA8 +0x0B3A1FB0 (ESP/SkillHack) + void* Game_PlayerHealthStat; // 0x1DB0 +0x0B32B030 (ESP health) + void* Camera_get_main; // 0x1DC0 +0x0B390440 (ESP/FreeCam) + void* GameObject_FindObjectOfType; // 0x1DC8 +0x0B390F80 + void* Game_SkillAction_C; // 0x1DD8 +0x03F85430 (SkillHack) + void* GetDeltaTime; // 0x1D38 +0x087C2CD0 (also FPS overlay) + void* Camera_get_fieldOfView; // 0x1DE8 +0x0B3A1C90 (FreeCam FOV) + void* Game_EntityState_C; // 0x1DF0 +0x00E92CF0 (ESP) + void* Rigidbody_AddForce; // 0x1E00 +0x03DC14C0 (Vacuum) + void* CharCtrl_set_enabled; // 0x1E08 +0x03E0D2C0 (NoClip) + void* Game_SkillAction_F; // 0x1E10 +0x03D9DF30 (SkillHack) + void* Game_SkillAction_G; // 0x1E18 +0x00E9E9F0 (SkillHack) + void* GetCharacterController; // 0x1E20 +0x03EA53C0 (NoClip) + void* TMPro_set_text; // 0x1E28 +0x0ACA0EC0 (PlayerProfile/NameChanger) + void* UnityUI_Text_set_text; // 0x1E30 +0x0B391D40 (ON/OFF labels) + void* Game_SkillAction_I; // 0x1E38 +0x036AA8F0 (SkillHack) + void* Game_SkillAction_J; // 0x1E40 +0x03EC31C0 (SkillHack hook5 target) + void* Game_EntityActor_D; // 0x1E48 +0x037F8CD0 (ESP/combat, hook6 target) + void* Game_SkillAction_K; // 0x1E50 +0x036EA640 (hook3/cooldown target) + void* Game_SkillAction_L; // 0x1E58 +0x03EC30E0 (hook4/avail target) + void* Game_EntityActor_E; // 0x1E60 +0x037F2A40 (hook1 target) + void* Game_EntityActor_F; // 0x1E68 +0x037FD7E0 (hook2 target) + void* il2cpp_domain_get; // 0x1E70 +0x00D94C10 + void* il2cpp_assembly_get_image; // 0x1E78 +0x00D94DA0 + void* il2cpp_domain_get_assemblies_B; // 0x1E80 +0x00D93A60 +}; + +// ============================================================================ +// SECTION 5 — BASE CLASS +// ============================================================================ + +struct BaseModule { + void* vtable; // [+0x00] vtable ptr + // std::string name at [+0x08] (SSO string, 24 bytes total: ptr+len+cap) + char name_sso[24]; // [+0x08] SSO buffer + // std::string tab_name at [+0x20] + char tab_name_sso[24]; // [+0x20] secondary name / tab label (SSO) + u8 enabled; // [+0x28] ON/OFF flag (BYTE) + u8 _pad[7]; // [+0x29..+0x2F] + // module-specific fields follow at [+0x30] +}; + +// BaseModule vtable layout (from factory stubs RVA 0x9B660–0x9B7A0): +// [0] +0x00 copy-ctor / factory() — placement-new ctor, writes vtable, returns this +// [1] +0x08 copy-ctor / factory() — same as [0] +// [2] +0x10 Init() / RegisterTab() — jmp stub → actual RegisterTab fn +// [3] +0x18 Render() — per-frame UI + game-state dispatch +// [4] +0x20 ~BaseModule() — dtor: frees name string, optional delete +// [5] +0x28 getNamePtr() — returns &this->name_string (+0x08) +// [6] +0x30 onHotkey() — pure virtual (sentinel value = 1) +// [7] +0x38 getLinkedModuleFactory() — returns paired module factory ptr + +// ============================================================================ +// SECTION 6 — MODULE STATE STRUCTS +// ============================================================================ + +// --- NoClip --- +// Singleton base: [.data+0x27B0] (referenced by RegisterTab / Render calls) +// Object size: ~0x38 bytes +struct NoClipModule : BaseModule { + // [+0x28] u8 enabled (ON/OFF checkbox) + i32 move_speed; // [+0x30] DragInt range [1, 10], default unknown +}; +// NoClip function table: +// RegisterTab 0x081300 — one-time init +// Render 0x0813D0 — ImGui panel (checkbox + Move Speed slider) +// Update 0x089B50 — per-frame CharacterController toggle +// Update stub 0x089B00 — tab destructor/cleanup wrapper +// Update stub2 0x089B40 — tab #2 setup (lea rdx, panel_callback → jmp 0x89060) + +// --- FreeCam --- +// Singleton base: [.data+0x2200] (0xD8 bytes, zeroed by RegisterMainTab) +struct FreeCamModule : BaseModule { + // [+0x28] u8 enabled + f32 move_speed; // [+0x30] SliderFloat max=500.0f default=30.0f + f32 roll_speed; // [+0x34] SliderFloat max=100.0f + f32 fov_speed; // [+0x38] (Look Sensitivity slider) + u8 _pad2[0x28]; // [+0x3C..+0x63] + void* active_cam_ptr; // [+0x68] cached active camera GameObject* + void* override_cam_ptr; // [+0x70] override camera ptr (cleared on disable) + u8 _pad3[0x40]; // [+0x78..+0xB7] + u8 cam_override_active; // [+0xB8] + // Key bindings written at RegisterMainTab to [.data+0x2230..0x225E]: + // [+0x2230] movdqa block1 = 0x1803B34F0 (WASD + misc keys) + // [+0x2240] movdqa block2 = 0x1803B35C0 + // [+0x2250] 0x3F800000 = 1.0f (FOV multiplier default) + // [+0x2254] 0x44415357 = 'WASD' key code mask + // [+0x2258] 0x6D6BA220 = additional keybind + // [+0x225C] 0x2725 = two-byte keybind + // [+0x225E] 0x60 = backtick key code + // Accumulator floats [+0x2260..0x22A8] pitch/yaw/roll/FOV — zeroed on init +}; +// FreeCam function table: +// RegisterFpsTab 0x0814C0 — registers FPS Monitor overlay tab +// RegisterMainTab 0x081590 — zeroes 0xD8 state, writes key defaults +// FpsUpdate stub 0x087150 — FPS overlay destructor wrapper +// Update 0x0871A0 — per-frame camera override (WASD+mouse) + +// --- FpsUnlocker --- +// Singleton base: [.data+0x21E8] +// Object size: 0x38 bytes +struct FpsUnlockerModule : BaseModule { + // [+0x28] u8 enabled + i32 fps_target; // [+0x30] DragInt max=500, min=30, default=300 +}; +// FpsUnlocker function table: +// RegisterTab 0x081730 — registers tab, writes fps_target default = 300 +// Render 0x085B90 — ImGui panel + Application.set_targetFrameRate call +// Update stub 0x085B40 — destructor wrapper, size 0x38 + +// --- SetDither --- +// Singleton base: referenced from registrar at RVA 0x001C41 +// Object size: 0x38 bytes (shared stub with SkillHack) +struct SetDitherModule : BaseModule { + // [+0x28] u8 enabled (unused — no per-frame write) +}; +// SetDither function table: +// RegisterTab/Render 0x081810 — registers tab only; no ImGui panel body +// Update stub 0x083DC0 — shared no-op: frees name string, optional delete + +// --- PlayerProfile --- +// Singleton base: referenced from registrar at RVA 0x001E20 +// Object size: 0x78 bytes +struct PlayerProfileModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + // [+0x30] std::string uid_str (wstring buffer for UID display text) + char uid_str_sso[24]; // [+0x30] + u8 _pad4[8]; // [+0x48..+0x4F] + // [+0x50] std::string name_str (wstring buffer for ManagerName text) + char name_str_sso[24]; // [+0x50] + u8 _pad5[8]; // [+0x68..+0x6F] + u8 name_changer_enabled; // [+0x70] +}; +// PlayerProfile function table: +// RegisterTab/Render 0x0818E0 — zeroes uid_str, name_str; stores IL2CPP fn ptrs +// Update 0x08A4F0 — per-frame UI path walk + SetText on TMP labels +// Update stub 0x08A4A0 — dtor: frees [+0x50],[+0x30],[+0x08], delete(0x78) +// UI paths used: +// UID: "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (RVA 0x3AFED0, len 0x2F) +// Name: "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (RVA 0x3AFFD0, len 0x8D) + +// --- Vacuum --- +// Singleton base: [.data+0x05D0] fn-ptr slot; obj referenced from registrar 0x001FC0 +// Object size: 0x38 bytes +struct VacuumModule : BaseModule { + // [+0x28] u8 vacuum_on ('Vacuum' main checkbox) + u8 _pad3[7]; + u8 monster_on; // [+0x30] 'Monster' sub-checkbox +}; +// Vacuum function table: +// RegisterTab 0x081A20 — stores update fn ptr 0x1803B0680 → 0x085B40 stub +// Render 0x093CA0 — 'Vacuum' + 'Monster' checkboxes +// PhysicsLoop 0x093F10 — per-frame Rigidbody.AddForce attraction +// Update stub 0x085B40 — shared destructor wrapper (frees [+0x08], delete 0x38) +// Attraction constant: *(float*)0x1803B32B4 + +// --- SkillHack --- +// Singleton base: referenced from registrar at RVA 0x001D50 +// Object size: ~0x38 bytes +struct SkillHackModule : BaseModule { + // [+0x28] u8 enabled — read by all 6 hook callbacks + // No per-frame Update; all work done by IL2CPP hook callbacks +}; +// SkillHack function table: +// Render 0x08D1F0 — hook installer only (installs 6 hooks, tail-jmps to 0x8D8A0) +// RenderPanel 0x08D240 — actual ImGui panel ('Free Skill' + ON/OFF toggle) +// Update stub 0x083DC0 — shared no-op (same as SetDither) +// Dispatcher 0x08D4B0 — BOOL callback: returns 1 when enabled +// CooldownBypass 0x08D500 — float callback: returns 100.0f when enabled +// AvailBypass 0x08D640 — BOOL callback: returns 1 when enabled +// CostBypass 0x08D780 — void callback: early-return (skip cost deduction) + +// --- ESPModule --- +// Singleton base: [.data+0x1F70] VA 0x1803C6F70 +// Object size: 0x100 bytes (12 RGBA color slots × 16 bytes = 0xC0, starts at +0x40) +struct ESPModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + i32 max_draw_distance; // [+0x30] default 300 (0x12C) + u8 show_monsters; // [+0x34] default 1 + u8 show_npc; // [+0x35] default 1 + u8 show_friendly; // [+0x36] default 1 + u8 show_puzzles; // [+0x37] default 1 + u8 show_all; // [+0x38] default 0 + u8 show_distance; // [+0x39] default 1 + u8 show_name; // [+0x3A] default 1 + u8 show_type; // [+0x3B] default 0 (reserved, unused) + u8 _reserved; // [+0x3C] + u8 _pad4[3]; // [+0x3D..+0x3F] + float color[12][4]; // [+0x40] 12 × RGBA float4, 16-byte aligned + // Color slot defaults (RGBA): + // [0] +0x40 enemy RED (1.0, 0.0, 0.0, 1.0) + // [1] +0x50 interactive ORANGE (1.0, 0.65, 0.0, 1.0) + // [2] +0x60 slot2 YELLOW (1.0, 1.0, 0.0, 1.0) + // [3] +0x70 friendly GREEN (0.0, 1.0, 0.0, 1.0) + // [4] +0x80 npc BLUE (0.0, 0.0, 1.0, 1.0) + // [5] +0x90 slot5 CYAN (0.0, 1.0, 1.0, 1.0) + // [6] +0xA0 slot6 PURPLE (0.58, 0.0, 0.83, 1.0) + // [7] +0xB0 default WHITE (1.0, 1.0, 1.0, 1.0) + // [8] +0xC0 slot8 PINK (1.0, 0.08, 0.58, 1.0) + // [9] +0xD0 slot9 LPINK (1.0, 0.75, 0.80, 1.0) + // [10] +0xE0 slot10 BLACK (0.0, 0.0, 0.0, 1.0) + // [11] +0xF0 slot11 GRAY (0.502, 0.502, 0.502, 1.0) +}; +// ESPModule function table: +// Singleton init 0x083E00 — lazy init via MSVC thread-safe static +// RenderOverlay 0x083FA0 — ImGui 'ESP Features' panel (large, 0x83FA0–0x8499E) +// Update 0x085C00 — per-frame world-space entity label loop (approx) +// Entity type dispatch in Update (byte code → color slot): +// 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle, default=slot7(white) + +// --- FPSModule (FpsOverlay) --- +// Singleton base: [.data+0x22E0] VA 0x1803C72E0 +// Object size: 0xD8 bytes +struct FPSModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + u8 show_fps_overlay; // [+0x30] 'Show FPS Overlay' checkbox + u8 _pad4[0x2F]; // [+0x31..+0x5F] + float overlay_pos[4]; // [+0x60] XMMWORD (position/size, zeroed on init) +}; +// FPSModule function table: +// RegisterTab 0x081810 — shared with SetDither registrar +// Render [via FpsOverlay chain] + +// --- PreventScreenshot --- +// Singleton base: [.data+0x2358] VA 0x1803C7358 +// Object size: 0x48 bytes +struct PreventScreenshotModule : BaseModule { + // [+0x28] u8 enabled — drives SetWindowDisplayAffinity arg + u8 _pad3[7]; + u8 state_dirty; // [+0x30] 1 = affinity applied, guard re-apply + u8 _pad4[7]; + u8 second_flag; // [+0x38] purpose unclear, zeroed on init +}; + +// ============================================================================ +// SECTION 7 — HOOK MANAGER +// ============================================================================ + +// Singleton: [.data+0x2470] VA 0x1803C7470 +// Object size: 0x90 bytes +struct HookManager { + void* hook_array; // [+0x00] flat array of HookEntry (0x38 bytes each) + u32 hook_capacity; // [+0x08] allocated slot count (initial 0x80) + u32 hook_count; // [+0x0C] active hook count + void* hash_buckets; // [+0x10] hash table bucket array (linked list heads) + u32 bucket_count; // [+0x18] power of 2, initial 8 + u32 bucket_mask; // [+0x1C] = bucket_count * 2 - 1 + void* free_list_head; // [+0x20] freed/recycled slot free list head + u8 _pad[4]; // [+0x28..+0x2B] + f32 load_factor; // [+0x28] hash load factor threshold (1.0f = 0x3F800000) + u8 initialized; // [+0x30] 0 after init (prevents double-init) + // Global spinlock: [.data+0x1E88] (DWORD, separate from struct) +}; + +// Each hook entry in hook_array is 0x38 bytes: +struct HookEntry { + u64 target_va; // [+0x00] VA of hooked IL2CPP function + u64 callback_va; // [+0x08] VA of replacement/detour function + u64 trampoline_va; // [+0x10] VirtualAlloc'd trampoline (orig bytes + JMP back) + u32 orig_bytes_0_3; // [+0x18] saved original bytes 0-3 + u16 orig_bytes_4_5; // [+0x1C] saved original bytes 4-5 + u8 orig_byte_6; // [+0x1E] saved original byte 6 + u8 flags; // [+0x20] bit0=has_far_jmp, bit1=enabled, bit2=suspended + u32 flags2; // [+0x24] lower nibble: hook type (0=near JMP, 1=far) + u64 hash_next; // [+0x28] next ptr in hash bucket chain + // [+0x30..+0x37] additional chain/bookkeeping fields +}; + +// HookManager API (all acquire spinlock at [.data+0x1E88]): +// CreateHook RVA 0x0A9CC8 — install new hook (FNV-1a hash lookup, trampoline alloc) +// RemoveHook RVA 0x0A9FA0 — remove and free hook +// EnableHook RVA 0x0AA140 — enable suspended hook +// GetHookInfo RVA 0x0AA2C0 — query hook by target VA +// Spinlock acq RVA 0x0A9C88 — acquire [.data+0x1E88] +// Spinlock rel inline — mov [.data+0x1E88], 0 + +// ============================================================================ +// SECTION 8 — MODULE MANAGER +// ============================================================================ + +// Singleton: [.data+0x2398] +// Registrar array: [.data+0x23B8]..[.data+0x23C0] (stride 0x60 bytes/slot) +struct ModuleManager { + u8 _pad[0x18]; // [+0x00..+0x17] + u8 initialized; // [+0x18] double-init guard + u8 _pad2[7]; // [+0x19..+0x1F] + // [+0x20..+0x57] registrar list (vector — 0x60-byte stride) +}; + +// ModuleManager API: +// AddRegistrar RVA 0x09B2C0 — push registrar slot (name str + factory fn) +// Grow helper RVA 0x09B3C0 — expand registrar vector +// Init RVA 0x09AC10 — called once from startup (RVA 0xA9190) +// Dispatch loops (each wraps vtable call in __try/__except via CxxFrameHandler4): +// Update loop RVA 0x09AE80 — calls vtable[+0x18] on each module +// Render loop RVA 0x09AEF0 — calls vtable[+0x20] on each module +// Hotkey loop RVA 0x09AF60 — calls vtable[+0x28] on each module +// Exception handlers (log + resume, do not propagate): +// Update catch RVA 0x0AEBC0 — logs "[ERROR] Failed to update module ''" +// Render catch RVA 0x0AEC50 — logs "[ERROR] Failed to render overlay for module ''" +// Hotkey catch RVA 0x0AECE0 — logs "[ERROR] Failed to process hotkeys for module ''" + +// Registration order (DLL init lambdas, before ModuleManager::Init): +// 1. SetDither (RVA 0x001C41) vtable 0x3B0D58 +// 2. FreeCam FPS (RVA 0x001C80) vtable 0x3B0E70 +// 3. SkillHack (RVA 0x001D50) vtable 0x3B0EE0 +// 4. PlayerProfile (RVA 0x001E20) vtable 0x3B0D90 +// 5. NoClip (RVA 0x001EF0) vtable 0x3B0DC8 +// 6. Vacuum (RVA 0x001FC0) vtable 0x3B0E38 +// 7. UnityExplorer (RVA 0x002090) vtable 0x3B0D28 +// 8. FpsUnlocker (RVA 0x001B80) vtable 0x3B0E00 +// 9. FreeCam main (RVA 0x001AB0) vtable 0x3B0E70 +// 10. ESPModule (RVA 0x001980) + +// ============================================================================ +// SECTION 9 — KEY FUNCTION RVA REFERENCE +// ============================================================================ +// All RVAs relative to binary base 0x180000000. +// Add 0x180000000 to get VA; add file raw offset base for file seek. + +namespace RVA { + // Startup / init + constexpr u32 DllMain_entry = 0x0AC840; // CRT DllMain thunk + constexpr u32 Startup_sequence = 0x0A9190; // main init: GABypass + ModMgr + constexpr u32 GABypass_Patch = 0x0A9120; // writes 71 IL2CPP fn ptrs + constexpr u32 ModuleManager_Init = 0x09AC10; + + // D3D11 / overlay + constexpr u32 D3D11_Hook_Install = 0x0827A0; // hooks IDXGISwapChain::Present + constexpr u32 D3D11_Present_Hook = 0x082820; // Present detour entry + constexpr u32 D3D11_CreateBuffers = 0x0551F0; // post-shader vertex/index buffer init + constexpr u32 ImGui_EndFrame = 0x001C2D0; // D3D11/ImGui EndFrame boundary + + // ImGui wrappers (cheat-side) + constexpr u32 ImGui_Toggle = 0x070820; // TabManager::BeginTab + constexpr u32 CheckboxToggle = 0x085320; // flip enabled flag + constexpr u32 ImGui_DragInt = 0x066750; // move_speed DragInt + constexpr u32 ImGui_SliderFloat = 0x065570; // move_speed SliderFloat (max 500) + constexpr u32 ImGui_InputText_ws = 0x08AC20; // InputText wstring wrapper + + // Config I/O + constexpr u32 ConfigSerialize = 0x012050; // serialize config to string + constexpr u32 BuildFilePath = 0x030A90; // build config file path + constexpr u32 ConfigFileIO = 0x011EA0; // UTF-8→wide fopen helper + constexpr u32 ConfigWrite = 0x0170D6; // fwrite config to file (approx) + + // Hook manager + constexpr u32 HookMgr_singleton = 0x081B00; // thread-safe static accessor + constexpr u32 HookMgr_CreateHook = 0x0A9CC8; + constexpr u32 HookMgr_RemoveHook = 0x0A9FA0; + constexpr u32 HookMgr_EnableHook = 0x0AA140; + constexpr u32 HookMgr_Spinlock = 0x0A9C88; + constexpr u32 Trampoline_Alloc = 0x0AA478; // GetSystemInfo+VirtualQuery sub + + // IL2CPP infrastructure + constexpr u32 IL2CPP_FindByPath = 0x09BCB0; // resolve Unity path to object + constexpr u32 WideToString = 0x00EB10; // UTF-8 → wstring + constexpr u32 BaseModule_Dtor = 0x00FA60; // shared dtor + + // ModuleManager dispatch + constexpr u32 ModMgr_UpdateLoop = 0x09AE80; + constexpr u32 ModMgr_RenderLoop = 0x09AEF0; + constexpr u32 ModMgr_HotkeyLoop = 0x09AF60; + constexpr u32 ModMgr_AddRegistrar = 0x09B2C0; + + // Theme / config preset writers (Ch.17 / Ch.28) + constexpr u32 Theme_Writer_Preset0 = 0x094890; // writes 52 color slots + constexpr u32 Theme_Writer_Preset1 = 0x096770; + constexpr u32 Theme_Writer_Preset2 = 0x098650; + constexpr u32 ColorApplicator = 0x094190; // shared helper: hex→RGBA×159 calls + + // Settings / NameChanger (Ch.19) + constexpr u32 Settings_RenderOverlay = 0x09A4F0; // Settings panel render + constexpr u32 Settings_end = 0x09AB98; // (end of Settings body) + + // UnityExplorer (Ch.16) + constexpr u32 UE_RegisterTab = 0x090060; + constexpr u32 UE_Render = 0x090250; + constexpr u32 UE_RefreshScenes = 0x090D40; +} + +// ============================================================================ +// SECTION 10 — CONFIG PRESET NAMES & STRINGS +// ============================================================================ +// Preset name string: [.data+0x00E0] (std::string, set during Settings load) +// Preset index: [.data+0x00EC] (DWORD, 0-3) +// Config file path: built by BuildFilePath (RVA 0x030A90) from [.data+0x0050]+0x50 +// Config strings (RVA): +// "Preset0" 0x3B0680 +// "Preset1" 0x3B0688 +// "Preset2" 0x3B0690 +// "Preset3" 0x3B0698 +// "EF-Cheeto.dll" 0x3B0358 (used by GABypass file scan) +// "gatmp.tmp" 0x3B0338 (temp file for bypass) +// "testyip" 0x3B0328 (test bypass marker) +// Source path embedded: "E:\git\Endfield_Cheeto\libraries\pipeline\..." + +// ============================================================================ +// SECTION 11 — KNOWN GAME API SIGNATURES (inferred from call sites) +// ============================================================================ +// These are IL2CPP managed method signatures inferred from cheat call sites. +// Calling convention: __fastcall (RCX=this/arg0, RDX=arg1, R8=arg2, etc.) +// Return in RAX (ptr/int) or XMM0 (float). + +// Transform methods +using fn_get_position = void*(*)(void* transform); // returns vec3* +using fn_set_position = void (*)(void* transform, void* vec3); +using fn_get_rotation = void*(*)(void* transform); // returns Quaternion* +using fn_set_rotation = void (*)(void* transform, void* quaternion); +using fn_get_localPos = void*(*)(void* transform); +using fn_set_localPos = void (*)(void* transform, void* vec3); +using fn_get_localScale= void*(*)(void* transform); +using fn_set_localScale= void (*)(void* transform, void* vec3); + +// GameObject methods +using fn_get_transform = void*(*)(void* gameObject); +using fn_SetActive = void (*)(void* gameObject, bool active); +using fn_get_name_go = void*(*)(void* gameObject); // returns System.String* + +// Rigidbody methods +using fn_AddForce = void (*)(void* rigidbody, void* vec3, int forceMode); +using fn_get_velocity = void*(*)(void* rigidbody); +using fn_set_velocity = void (*)(void* rigidbody, void* vec3); + +// Application +using fn_setTargetFPS = void (*)(int targetFrameRate); + +// TMPro / UI +using fn_set_text = void (*)(void* textComponent, int zero, void* wstring_ptr); + +// CharacterController +using fn_setEnabled = void (*)(void* ctrl, bool enabled, int zero); + +// Camera +using fn_Camera_main = void*(*)(void* zero); // Camera.get_main +using fn_get_fov = float(*)(void* camera); + +// SkillHack hook callbacks (return types match hooked method signatures): +using fn_BOOL_bypass = BOOL (*)(void); // Dispatcher / AvailBypass +using fn_float_bypass = float(*)(void); // CooldownBypass → returns 100.0f +using fn_void_bypass = void (*)(void); // CostBypass → early return + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 12 — IL2CPP TABLE ACCESSOR MACROS +// ============================================================================ +// Usage: CALL_IL2CPP(slot_name, RetType, arg0, ...) +// All slots live at fixed .data offsets from binary base 0x1803C5000. +// At runtime: ptr = *(void**)([.data + slot_offset]) +// +// Direct call helpers — use after GABypass has patched the table: + +#define IL2CPP_BASE_VA ((uintptr_t)0x1803C5000) +#define IL2CPP_SLOT(off) (*(void**)(IL2CPP_BASE_VA + (off))) + +// Transform +#define IL2_Transform_get_position(t) ((fn_get_position) IL2CPP_SLOT(0x1C88))(t) +#define IL2_Transform_set_position(t,v) ((fn_set_position) IL2CPP_SLOT(0x1D88))(t,v) +#define IL2_Transform_get_localPos(t) ((fn_get_localPos) IL2CPP_SLOT(0x1C80))(t) +#define IL2_Transform_set_localPos(t,v) ((fn_set_localPos)IL2CPP_SLOT(0x1C90))(t,v) +#define IL2_Transform_get_rotation(t) ((fn_get_rotation)IL2CPP_SLOT(0x1C68))(t) +#define IL2_Transform_set_rotation(t,q) ((fn_set_rotation)IL2CPP_SLOT(0x1CA8))(t,q) +#define IL2_Transform_get_localScale(t) ((fn_get_localScale)IL2CPP_SLOT(0x1C60))(t) +#define IL2_Transform_set_localScale(t,v) ((fn_set_localScale)IL2CPP_SLOT(0x1D68))(t,v) + +// GameObject +#define IL2_GO_get_transform(go) ((fn_get_transform)IL2CPP_SLOT(0x1CA0))(go) +#define IL2_GO_SetActive(go,a) ((fn_SetActive) IL2CPP_SLOT(0x1C98))(go,a) +#define IL2_GO_get_name(go) ((fn_get_name_go) IL2CPP_SLOT(0x1CC0))(go) + +// Rigidbody +#define IL2_RB_AddForce(rb,v,fm) ((fn_AddForce) IL2CPP_SLOT(0x1E00))(rb,v,fm) +#define IL2_RB_get_velocity(rb) ((fn_get_velocity) IL2CPP_SLOT(0x1D70))(rb) +#define IL2_RB_set_velocity(rb,v) ((fn_set_velocity) IL2CPP_SLOT(0x1D78))(rb,v) + +// Application +#define IL2_App_setTargetFPS(fps) ((fn_setTargetFPS) IL2CPP_SLOT(0x1D48))(fps) + +// Camera +#define IL2_Camera_main() ((fn_Camera_main) IL2CPP_SLOT(0x1DC0))(nullptr) +#define IL2_Camera_get_fov(cam) ((fn_get_fov) IL2CPP_SLOT(0x1DE8))(cam) + +// UI +#define IL2_TMPro_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E28))(comp,0,ws) +#define IL2_UI_Text_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E30))(comp,0,ws) + +// CharacterController +#define IL2_CharCtrl_setEnabled(c,en) ((fn_setEnabled) IL2CPP_SLOT(0x1E08))(c,en,0) + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 13 — STARTUP / LOADER CHAIN +// ============================================================================ +// DLL entry and initialization sequence (Ch.11 / Ch.29) + +namespace RVA { + // Entry point chain + constexpr u32 DllMain_entry_real = 0x01000; // CRT DllMain (spawns loader thread) + constexpr u32 LoaderThread = 0x05000; // main init thread: IL2CPP + window + hooks + constexpr u32 Startup_main = 0x0A9190; // step-by-step startup (steps 1-11) + constexpr u32 ModMgr_RegisterAll = 0x09AE00; // 11 modules registered via stubs + constexpr u32 ModMgr_MainLoop = 0x082000; // Present hook + ImGui render loop (0x82000-0x82300) + constexpr u32 D3D11Init_Shaders = 0x054DC0; // D3DCompile vertex+pixel shader (x2: 0x54DC0, 0x551E8) + constexpr u32 D3D11Init_Setup = 0x082500; // ImGui Win32+D3D11 backend init, WndProc subclass + + // Startup step addresses (from Ch.11.4): + // 1 0x0A91CE AllocConsole — 'il2cpp Game Console' + // 2 0x0A9267 SetConsoleCP(0xFDE9) — UTF-8 + // 3 0x0A92F7 FindWindowA(NULL,'UnityWndClass') — poll until game window present + // 4 0x0A93CC HookInstallerWrapper(EnumProcessModules) — module scanner install + // 5 0x0A93E6 Log 'Initializing..' (source: main.cpp:53) + // 6 0x0A942F Call [g_Config+0x1E80] — IL2CPP domain resolver + // 7 0x0A945A Log 'IL2CPP Domain Found: ' (if domain non-null) + // 8 0x0A94C4 Log 'IL2CPP Thread Attached Successfully: ' + // 9 0x0A9506 Error: Log 'Failed to Attach IL2CPP Thread!' + // 10 0x0A9545 Error: Log 'IL2CPP Domain Not Found!' + // 11 0x0A959F Success: Log 'Initialized' → then launch overlay window thread (0x827A0) + + // D3D11 overlay window subsystem (Ch.29) + constexpr u32 OverlayWindowInit = 0x0827A0; // create layered window + D3D11 device (0x827A0-0x8375C) + constexpr u32 FindGameWindow = 0x0835D0; // EnumWindows callback — locate Unity window + constexpr u32 GetOverlayRect = 0x0836A0; // compute overlay rect from game window bounds + constexpr u32 D3D11_Setup_sub = 0x0825B0; // D3D11::Reinit — recreate RT + ImGui D3D11 backend + constexpr u32 WndProc = 0x0826A0; // Win32 WndProc (HWND,UINT,WPARAM,LPARAM)→LRESULT + constexpr u32 ImGui_Win32_Handler = 0x057720; // ImGui_ImplWin32_WndProcHandler — all kb/mouse + constexpr u32 PresentHook_callsite = 0x082F00; // IDXGISwapChain::Present hook call site (inside msg loop) + constexpr u32 RenderFrame = 0x082FC0; // ImGui NewFrame + per-module Render dispatch + constexpr u32 ImGui_Begin_wrapper = 0x0937D0; // ImGui::Begin wrapper (Unity Explorer Window title) + constexpr u32 ImGui_Selectable = 0x0708D0; // ImGui::Selectable (preset selector, Ch.17) + + // Thread suspension for hook install (Ch.3) + constexpr u32 CollectProcessThreads = 0x0A96B0; // Toolhelp32 snapshot → thread ID array (0xA96B0-0xA9A1C) + constexpr u32 SuspendOrResumeThreads= 0x0A9A20; // OpenThread + Suspend/Resume all (0xA9A20-0xA9A98) + constexpr u32 PatchCode = 0x0A9A9C; // VirtualProtect + write hook bytes (0xA9A9C-0xA9BC3) + + // Hook manager detailed RVAs (Ch.8) + constexpr u32 HookMgr_Install = 0x0A9CC8; // alloc trampoline + FNV hash (= CreateHook) + constexpr u32 HookMgr_Remove = 0x0A9E8C; // remove + restore original bytes + constexpr u32 HookMgr_Enable_fn = 0x0A9A9C; // toggle enabled bit + patch + constexpr u32 HookMgr_AllocTramp = 0x0A960C; // allocate trampoline slot near target VA + constexpr u32 HookMgr_FreeSlot = 0x0AA684; // free trampoline + compact hook array + constexpr u32 HookInstaller_Wrapper = 0x08BAF0; // wrapper called at 0xA93CC during startup + + // Module scanner (Ch.11.2) + constexpr u32 ModulePathScanner = 0x08B650; // scan loaded modules for testyip/gatmp/EF-Cheeto + constexpr u32 ModPathScanner_EF = 0x08B937; // wcsstr branch: search for 'EF-Cheeto.dll' + + // String helpers + constexpr u32 UTF8ToWide = 0x08B4E0; // MultiByteToWideChar CP_UTF8(0xFDE9) wrapper + constexpr u32 WideStr_wcsstr = 0x0AB6A0; // custom wcsstr — returns iterator, -1 if not found + constexpr u32 WideStr_Dtor = 0x0AB758; // wstring destructor (used in path scanner) + + // Module-specific helpers + constexpr u32 NoClip_RegisterTab = 0x00FCB0; // one-time NoClip tab init + constexpr u32 FreeCam_RegisterTab = 0x00F7D0; // one-time FreeCam tab init + constexpr u32 ManagerName_Init = 0x00FFF0; // zero std::string fields for ModuleManager name + constexpr u32 NoClip_EntityIter = 0x089DC0; // entity iterator inner loop (NoClip::Update) + constexpr u32 SetDither_Render = 0x08C490; // SetDither::Render — graphics dither toggle + constexpr u32 SkillHack_PatchFloat = 0x08E220; // installs FloatReturn hook on [g_Config+0x1E50] + constexpr u32 SkillHack_PatchBool = 0x08EBC0; // installs BoolTrue hook on [g_Config+0x1E58] + constexpr u32 SkillHack_PatchVoid = 0x08F560; // installs VoidReturn hook on [g_Config+0x1E40] + constexpr u32 SkillHack_Trampoline = 0x08FF00; // common trampoline dispatcher (calls original fn) + constexpr u32 UE_GuardReturn = 0x0901D8; // early return after once_flag sealed (UE::RegisterTab) + constexpr u32 UE_AutoRefresh = 0x093B10; // auto-refresh timer check for scene list + constexpr u32 UE_Memset_block = 0x0AC86A; // memset 0xD8 bytes at [.data+0x2200] (FreeCam init) + constexpr u32 PreventSS_Init = 0x08AD70; // once_flag guarded PreventScreenshot init + constexpr u32 PreventSS_Render = 0x08AE60; // ImGui single checkbox 'Prevent Screenshot' + constexpr u32 PreventSS_Update = 0x08AFC0; // SetWindowDisplayAffinity dispatch (per-frame) + constexpr u32 PreventSS_OsCheck = 0x08B220; // Win10 build check + affinity setter + constexpr u32 TabMgr_BeginTab_full = 0x09D7D0; // full BeginTab with state+title resolution + constexpr u32 GABypass_Init = 0x09D1E0; // 71 IL2CPP stub patch sequence + constexpr u32 Std_once_flag_Execute = 0x0AFF60; // MSVC _Execute_once (once_flag) + constexpr u32 Sidebar_Settings = 0x080770; // sidebar settings section (0x80770-0x80B50) + // ImGui_EndFrame alias: see RVA::ImGui_EndFrame (0x001C2D0) defined in Section 9 +} + +// ============================================================================ +// SECTION 14 — D3D11 OVERLAY WINDOW INIT (Ch.29 summary) +// ============================================================================ +// OverlayWindowInit (RVA 0x827A0) sequence: +// +// 29.1 DPI setup (0x827FF-0x82923): +// Try SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) +// Fallback: SetProcessDpiAwareness(2) +// Final fallback: SetProcessDPIAware() +// Guard: [.data+0x3C7440] / [.data+0x3C7448] +// +// 29.2 Game window location + class registration (0x82924-0x82A28): +// EnumWindows(FindGameWindow@0x835D0) → locate Unity game HWND +// WNDCLASSEX: CreateSolidBrush(0x7F00), LoadCursorW, LoadIconW×2 +// RegisterClassExW +// GetSystemMetrics(SM_CXSCREEN/SM_CYSCREEN) +// +// 29.3 Overlay window + D3D11 device (0x82A29-0x82BFF): +// CreateWindowExW(WS_EX_LAYERED|WS_EX_TRANSPARENT) +// SetLayeredWindowAttributes +// DwmExtendFrameIntoClientArea (full glass) +// D3D11CreateDeviceAndSwapChain — attempt 1: DXGI_FORMAT_R8G8B8A8_UNORM +// on failure: attempt 2: DXGI_FORMAT_B8G8R8A8_UNORM +// D3D11::Reinit (0x825B0) — set up ImGui D3D11 backend +// ShowWindow / UpdateWindow +// CreateMutexA — prevent duplicate instances +// +// 29.4 Message loop (0x82C01-0x8352F): +// Log 'Initialized' (source: UI.cpp, RVA 0x3AF610) +// Loop: PeekMessageW / TranslateMessage / DispatchMessageW +// Each iter: FindWindowA('UnityWndClass',NULL) — exit if game gone +// IsWindow, GetWindowThreadProcessId, GetWindowRect +// SetWindowPos to track game window + +// WndProc (RVA 0x826A0) — pseudocode: +// LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// if (g_ImGuiCtx) { +// LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// if (r) return 1; +// } +// switch (msg) { +// case WM_DESTROY: PostQuitMessage(0); return 0; +// case WM_SIZE: +// if (g_pSwapChain && wParam != SIZE_MINIMIZED) { +// if (g_pRenderTargetView) { g_pRenderTargetView->Release(); g_pRenderTargetView=NULL; } +// g_pSwapChain->ResizeBuffers(0,LOWORD(lParam),HIWORD(lParam),DXGI_FORMAT_UNKNOWN,0); +// D3D11_Setup_sub(); // 0x825B0 — recreate RT + shaders +// } +// return 0; +// case WM_SYSCOMMAND: +// if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +// break; +// default: +// return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// } +// return 0; +// } + +// ============================================================================ +// SECTION 15 — MODULE PATH SCANNER (Ch.11.2) +// ============================================================================ +// ModulePathScanner (RVA 0x8B650): +// Args: HANDLE process, void** module_array, DWORD count +// For each module path: +// UTF8ToWide(path) → wpath +// wcsstr(wpath, L"testyip") → if found: found_count++ +// wcsstr(wpath, L"gatmp.tmp") → if found: found_count++ +// if not found: ModPathScanner_EF (0x8B937): +// wcsstr(wpath, L"EF-Cheeto.dll") → if found: found_count++ +// Returns found_count +// +// Injection identity strings (.data): +// L"testyip" [.data+0x0318] alternate temp-file loader name +// L"gatmp.tmp" [.data+0x0338] primary temp-file loader name +// L"EF-Cheeto.dll" [.data+0x0358] published DLL name (fallback) + +// ============================================================================ +// SECTION 16 — THREAD SUSPENSION SUBSYSTEM (Ch.3) +// ============================================================================ +// CollectProcessThreads (RVA 0xA96B0): +// CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,0) → hSnapshot +// THREADENTRY32 te32; te32.dwSize = sizeof(THREADENTRY32); +// Thread32First(hSnapshot, &te32) +// while Thread32Next: if te32.th32OwnerProcessID==GetCurrentProcessId() +// AND te32.th32ThreadID != calling_thread: append to array +// +// SuspendOrResumeThreads (RVA 0xA9A20): +// For each collected thread ID: +// hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// if suspend: SuspendThread(hThread) +// if resume: ResumeThread(hThread) +// CloseHandle(hThread) +// +// PatchCode (RVA 0xA9A9C): +// VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &oldProt) +// memcpy(target, patch_bytes, size) +// VirtualProtect(target, size, oldProt, &oldProt) +// FlushInstructionCache(GetCurrentProcess(), target, size) + +// ============================================================================ +// SECTION 17 — PREVENT SCREENSHOT MODULE (Ch.21 supplement) +// ============================================================================ +// PreventScreenshot::Initialize (RVA 0x8AD70): +// Guarded by once_flag at [.data+0x2390] +// Allocates module object (0x48 bytes) +// Sets vtable: 0x3AFA38 → 0x3B0110 after init +// Zeroes: enabled, state_dirty, second_flag +// +// PreventScreenshot::Update (RVA 0x8AFC0): +// 1. Call GetInstance (0x8AD70) +// 2. Check enabled [module+0x28] +// 3. If enabled && !state_dirty: call OsCheck (0x8B220) +// 4. Build HWND list at [.data+0x24D0] +// 5. For each HWND node [rbx+0x10]: call OsCheck affinity setter +// 6. Call HookMgr_singleton (0x81B00) to update hook state +// +// PreventScreenshot::OsCheck (RVA 0x8B220): +// Checks Windows 10 build version +// Calls SetWindowDisplayAffinity(hwnd, WDA_MONITOR) via IAT[0xB1460] +// On disable: SetWindowDisplayAffinity(hwnd, WDA_NONE) + +// ============================================================================ +// SECTION 18 — COMPLETE FUNCTION INDEX (all 91 named functions) +// ============================================================================ +// Cross-reference: function name → RVA (use RVA:: namespace above for most) +// This table captures every named entry from the doc cross-reference (Ch.24/25). + +// Name RVA Chapter +// DllMain 0x001000 Entry +// LoaderThread 0x005000 Ch.11 +// FreeCam::RegisterTab 0x00F7D0 Ch.12.3 +// FreeCam::RegisterFpsTab 0x0814C0 Ch.12.3 +// NoClip::RegisterTab 0x00FCB0 Ch.12.2 +// ManagerName::Init 0x00FFF0 Ch.15 +// ImGui::EndFrame 0x01C2D0 Ch.15 +// ConfigSerialize 0x012050 Ch.6 +// ConfigFileIO (UTF8→wide fopen) 0x011EA0 Ch.6 +// BuildFilePath 0x030A90 Ch.6 +// D3D11Init_Shaders A 0x054DC0 Ch.5 +// D3D11Init_Shaders B 0x0551E8 Ch.5 +// D3D11::CreateBuffers 0x0551F0 Ch.5 +// ImGui_ImplWin32_WndProcHandler 0x057720 Ch.7 +// ImGui::Toggle (TabMgr) 0x070820 Ch.12 +// ImGui::Selectable 0x0708D0 Ch.17 +// TabMgr::BeginTabFull 0x09D7D0 Ch.12 +// Sidebar_Settings entry 0x080770 Ch.25 +// D3D11::Setup (ImGui backend init) 0x082500 Ch.29 +// D3D11::Reinit 0x0825B0 Ch.7/29 +// WndProc 0x0826A0 Ch.7 +// OverlayWindowInit 0x0827A0 Ch.29 +// FindGameWindow 0x0835D0 Ch.29 +// GetOverlayRect 0x0836A0 Ch.29 +// PresentHook callsite 0x082F00 Ch.15.5 +// RenderFrame 0x082FC0 Ch.15 +// HookMgr_singleton 0x081B00 Ch.8 +// ESPModule singleton init 0x083E00 Ch.9 +// ESPModule::RenderOverlay 0x083FA0 Ch.22 +// SetDither::Render 0x08C490 Ch.12.5 +// CheckboxToggle 0x085320 Ch.12 +// ImGui::SliderFloat 0x065570 Ch.12.3 +// ImGui::DragInt 0x066750 Ch.12.2 +// NoClip::Render 0x0813D0 Ch.12.2 +// NoClip::Update 0x089B50 Ch.12.2 +// NoClip::EntityIterator 0x089DC0 Ch.12.2 +// FreeCam::Update 0x0871A0 Ch.12.3 +// FpsUnlocker::Render 0x085B90 Ch.12.4 +// PlayerProfile::Update 0x08A4F0 Ch.12.6 +// Vacuum::Render 0x093CA0 Ch.12.7 +// Vacuum::PhysicsLoop 0x093F10 Ch.12.7 +// Vacuum::EntityIterator 0x094000 Ch.12.7 +// SkillHack::Render (hook install) 0x08D1F0 Ch.12.8 +// SkillHack::RenderPanel 0x08D240 Ch.12.8 +// SkillHack::Dispatcher 0x08D4B0 Ch.10 +// SkillHack::CooldownBypass 0x08D500 Ch.10 +// SkillHack::AvailBypass 0x08D640 Ch.10 +// SkillHack::CostBypass 0x08D780 Ch.10 +// SkillHack::PatchFloat 0x08E220 Ch.10 +// SkillHack::PatchBool 0x08EBC0 Ch.10 +// SkillHack::PatchVoid 0x08F560 Ch.10 +// SkillHack::TrampolineDispatch 0x08FF00 Ch.10 +// PreventScreenshot::Initialize 0x08AD70 Ch.21 +// PreventScreenshot::Render 0x08AE60 Ch.21 +// PreventScreenshot::Update 0x08AFC0 Ch.21 +// PreventScreenshot::OsCheck 0x08B220 Ch.21 +// UTF8ToWide 0x08B4E0 Ch.11 +// ModulePathScanner 0x08B650 Ch.11.2 +// ModulePathScanner::EFSearch 0x08B937 Ch.11.2 +// HookInstallerWrapper 0x08BAF0 Ch.11.3 +// ImGui::InputText_ws 0x08AC20 Ch.12.6 +// HookInstaller inner 0x08BAF0 Ch.11.3 +// ColorApplicator 0x094190 Ch.28.2.1 +// Theme_Writer_Preset0 0x094890 Ch.17/28 +// Theme_Writer_Preset1 0x096770 Ch.17/28 +// Theme_Writer_Preset2 0x098650 Ch.17/28 +// Settings::RenderOverlay 0x09A4F0 Ch.19.8 +// UnityExplorer::RegisterTab 0x090060 Ch.16 +// UnityExplorer::Render 0x090250 Ch.16 +// UnityExplorer::RefreshScenes 0x090D40 Ch.16 +// UnityExplorer::GuardReturn 0x0901D8 Ch.16 +// UnityExplorer::AutoRefresh 0x093B10 Ch.16 +// ImGui::Begin wrapper 0x0937D0 Ch.16 +// ModuleManager::AddRegistrar 0x09B2C0 Ch.15 +// ModuleManager::Grow 0x09B3C0 Ch.15 +// ModuleManager::Init 0x09AC10 Ch.15 +// ModuleManager::UpdateLoop 0x09AE80 Ch.15 +// ModuleManager::RenderLoop 0x09AEF0 Ch.15 +// ModuleManager::HotkeyLoop 0x09AF60 Ch.15 +// ModuleManager::RegisterAll 0x09AE00 Ch.15 +// DispatchLoop_UpdateCatch 0x0AEBC0 Ch.15.4.1 +// DispatchLoop_RenderCatch 0x0AEC50 Ch.15.4.1 +// DispatchLoop_HotkeyCatch 0x0AECE0 Ch.15.4.1 +// IL2CPP_FindByPath 0x09BCB0 Ch.16/19 +// GABypass::Init 0x09D1E0 Ch.18 +// CollectProcessThreads 0x0A96B0 Ch.3 +// SuspendOrResumeThreads 0x0A9A20 Ch.3 +// PatchCode 0x0A9A9C Ch.3 +// Startup_main 0x0A9190 Ch.11.4 +// HookMgr_AllocTrampoline 0x0A960C Ch.8 +// HookMgr_CreateHook 0x0A9CC8 Ch.8 +// HookMgr_RemoveHook 0x0A9FA0 Ch.8 +// HookMgr_EnableHook 0x0AA140 Ch.8 +// HookMgr_FreeSlot 0x0AA684 Ch.8 +// HookMgr_Spinlock 0x0A9C88 Ch.8 +// WideStr::wcsstr 0x0AB6A0 Ch.11 +// WideStr::Dtor 0x0AB758 Ch.11 +// Memset_block 0x0AC86A (alloc+memset 0xD8 bytes) +// BaseModule::Dtor 0x00FA60 Ch.12 +// WideToString 0x00EB10 Ch.11 +// PreventScreenshot::SetAffinity 0x08B490 Ch.21 (SetWindowDisplayAffinity call site) +// Vacuum::Render (alt addr) 0x093C90 Ch.12.7 (one-byte offset alias for 0x93CA0) + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 19 — CONFIG I/O FUNCTIONS (Ch.6 complete) +// ============================================================================ + +namespace RVA { + // Config I/O + constexpr u32 ReadConfig = 0x0302D2; // fread JSON config on startup → populate g_Config + constexpr u32 ReadConfig_end = 0x030348; // ReadConfig range end + constexpr u32 SaveConfig = 0x030620; // fwrite g_Config state to JSON file (0x30620-0x307A0) + constexpr u32 SaveConfig_end = 0x0307A0; + constexpr u32 ImGuiSaveIni = 0x017078; // fwrite ImGui window layout to .ini (0x17078-0x172CA) + constexpr u32 ImGuiSaveIni_end = 0x0172CA; + constexpr u32 ConsoleDebugWrite = 0x00EA1B; // fwrite to stdout/console (debug output, size=1) + + // SaveConfig (RVA 0x30620) pseudocode: + // Check state->enabled_flag [rbx+0x2900] + // Load state->file_path ptr [rbx+0x50] + // Call BuildFilePath (0x30A90) + // Call OpenConfigFile(path, "wt") → FILE* fp + // Serialize via ConfigSerialize (0x12050) → string + // fwrite(string, 1, len, fp); fclose(fp) + // Auto-save timer: xmm0=[rbx+0x2904], timer -= delta; on expire: re-save + // + // Config field written by language selector: + // [g_Config+0x2764] content ref-count (DWORD, decremented on lang change) + constexpr u32 LangSelector_refcount_off = 0x2764; // g_Config+0x2764 = content ref-count +} + +// ============================================================================ +// SECTION 20 — LOG / PRINT / CRC32 / REGISTRY (Ch.15 / Ch.26 helpers) +// ============================================================================ + +namespace RVA { + constexpr u32 Log_Print = 0x00FDA0; // shared logging helper (called by all 3 dispatch catchers) + constexpr u32 ImGui_PushStyleColor = 0x010840; // ImGui::PushStyleColor — theme system (159 calls) + constexpr u32 CRC32_Lookup = 0x011DF0; // CRC32 of module key string (e.g. "Sidebar", "Content") + constexpr u32 Module_RegistryLookup = 0x03D1A0; // registry lookup by CRC32 hash → module ptr + constexpr u32 Module_Notify = 0x01D2B0; // module notify/update (called after lang change) + constexpr u32 ImGui_Epilogue = 0x023E20; // ImGui epilogue tail-call target (Sidebar tail-jmps here) + constexpr u32 I18n_Refresh = 0x02A530; // i18n content refresh — reload translations on lang change + constexpr u32 Locale_ContextInit = 0x09D660; // locale context init — selects "en" or "zh_cn" based on flag + constexpr u32 Label_Formatter = 0x05FB60; // sprintf-style: build "Key Name: %s" label strings + constexpr u32 ImGui_Combo = 0x064220; // ImGui::Combo (language dropdown, 2-item list) + constexpr u32 FPS_StringBuild = 0x07F5C0; // build "FPS: NNN" string for FPS overlay +} + +// i18n language flag: [.data+0x3C77B0] (VA 0x1803C77B0) +// 0 = English (RVA 0x3AF310) +// 1 = 简体中文 (RVA 0x3AF318) +// Language tab label: " Language" (RVA 0x3AF328, 5-space indent) +// Combo widget ID: "##Language" (RVA 0x3AF338) + +// ============================================================================ +// SECTION 21 — SIDEBAR / MAIN PANEL (Ch.25 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 Sidebar_Render = 0x07F8F0; // top-level overlay panel (0x7F8F0, ~0x146E bytes) + // Sidebar_Render calls: + // CRC32_Lookup(0x11DF0) on "Sidebar" key (RVA 0x3AF2C8) + // Module_RegistryLookup(0x3D1A0) + // Module_Notify(0x1D2B0) + // Language selector sub-panel (0x80770-0x80B50) unconditionally + // Jump-table dispatch for all tab bodies + // Tail-jmp to ImGui_Epilogue (0x23E20) at 0x80D5E + // Stack frame: 0x380 bytes; saves xmm6–xmm8; single rcx arg (ModuleManager ptr) + // + // Key strings: + // Banner: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) + // Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) + // Window key: "Sidebar" (RVA 0x3AF2C8) — ImGui::Begin not called inside 0x7F8F0 itself + // Active tab index written to [.data+0x1F68] on click, read by jump table + + constexpr u32 Lang_Selector_start = 0x080770; // language selector sub-panel start (unconditional) + constexpr u32 Lang_Selector_end = 0x080B50; // language selector sub-panel end +} + +// Language selector execution flow (Ch.26.2): +// 0x80895 call Locale_ContextInit(0x9D660) +// 0x808DD lea rsi, "English" (RVA 0x3AF310) +// 0x808E3 lea rbx, "简体中文" (RVA 0x3AF318) +// 0x809A1 lea rdx, " Language" (RVA 0x3AF328) +// 0x809C6 call TabMgr::BeginTab(0x9D7D0) +// 0x80A03 call ImGui::Combo(0x64220) → al=1 if changed +// 0x80A2F if English: mov [.data+0x3C77B0], 0 +// 0x80A5D if ZH-CN: mov [.data+0x3C77B0], 1 +// 0x80A6E call I18n_Refresh(0x2A530) +// 0x80A73 dec [g_Config+0x2764] (content ref-count) +// 0x80A80 rax = [g_Config+0x15D8] (active config preset ptr) +// 0x80A87 [rax+0x103] = 1 (dirty flag → triggers config save) +// 0x80B0B lea rcx, "Content" (RVA 0x3ADFC8) +// 0x80B12 call CRC32_Lookup(0x11DF0) +// 0x80B33 call Module_RegistryLookup(0x3D1A0) +// 0x80B4D call Module_Notify(0x1D2B0) + +// ============================================================================ +// SECTION 22 — ESPMODULE COMPLETE FUNCTION TABLE (Ch.22) +// ============================================================================ + +namespace RVA { + constexpr u32 ESPModule_Init = 0x083E00; // lazy singleton init (thread-safe static) + constexpr u32 ESPModule_Render = 0x083F60; // Ch.22 §22.1 — "ESP Features" collapsing header + constexpr u32 ESPModule_DrawOverlay = 0x083000; // Ch.22 §22.2 — world-space entity label overlay + constexpr u32 ESPModule_Update = 0x084A00; // per-frame entity label draw loop start + constexpr u32 ESPModule_Update_loop = 0x0852A5; // entity label loop body +} +// ESPModule::RenderOverlay (0x83FA0–0x8499E): large monolithic ImGui panel +// ESPModule::Update entity type dispatch: 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle + +// ============================================================================ +// SECTION 23 — FPSMODULE COMPLETE (Ch.20) +// ============================================================================ + +namespace RVA { + constexpr u32 FPSModule_Initialize = 0x0814C0; // once_flag guarded init (once_flag at [.data+0x2310]) + constexpr u32 FPSModule_RenderPanel = 0x085660; // panel render (two checkboxes: FPS Monitor + Show FPS Overlay) + constexpr u32 FPSModule_RenderPanel_branch = 0x0856F0; // inner ImGui branch of panel render + constexpr u32 FPSModule_RenderOverlay = 0x085700; // FPS counter overlay start + constexpr u32 FPSModule_RenderOverlay_end = 0x085900; // FPS counter overlay end + constexpr u32 FPSModule_RenderOverlay_counter = 0x0858D0; // "##Foreground" frameless window (FPS display) +} +// FPSModule::Initialize (0x814C0): +// Guarded by once_flag at [.data+0x2310] +// Alloc 0xD8 bytes (via 0xAC86A), store ptr at [.data+0x22E0] +// vtable: 0x3AFA38 → 0x3AFAC0 after init +// name: "FPS Monitor" (RVA 0x3AFA88) at [.data+0x22E8] +// enabled = 0 at [.data+0x2308] +// +// FPSModule overlay color thresholds (RVA of XMMWORD constants): +// fps >= 60: 0x1803B3530 (green) +// 30 <= fps < 60: 0x1803B3540 (yellow) +// fps < 30: 0x1803B3510 (red) +// FPS display string built by FPS_StringBuild (0x7F5C0): "FPS: " + integer + +// ============================================================================ +// SECTION 24 — SETDITHER COMPLETE (Ch.12.5.1) +// ============================================================================ + +namespace RVA { + constexpr u32 SetDither_RenderOverlay = 0x08C4A0; // SetDither::RenderOverlay — distinct from RegisterTab + // SetDither::RenderOverlay is invoked by the tab-callback pointer chain + // (not directly from RegisterTab at 0x81810) + // Implements the graphics dither toggle panel body +} + +// ============================================================================ +// SECTION 25 — FREECAM KEY BINDING DISPLAY (Ch.27.3) +// ============================================================================ +// Key display sub-panel inside FreeCam tab (when enabled): +// Each row uses: MakeString(0xFCB0) → Label_Formatter(0x5FB60) → TabMgr::BeginTab(0x9D7D0) +// Key binding state array: [rip + ...] # 0x1803C6E98 ("Pu;" RTTI sentinel in .data) +// Key label format strings (RVAs): +// "Forward Key: %s" 0x3AFD08 VA 0x180087A87 +// "Backward Key: %s" 0x3AFD18 VA 0x180087B1A (approx) +// "Left Key: %s" 0x3AFD30 +// "Right Key: %s" 0x3AFD40 +// "Up Key: %s" 0x3AFD50 +// "Down Key: %s" 0x3AFD60 +// "IncFOV Key: %s" 0x3AFD70 +// "DecFOV Key: %s" 0x3AFD80 +// "LeftRoll Key: %s" 0x3AFD90 +// "RightRoll Key: %s" 0x3AFDA8 +// "ResetRoll Key: %s" 0x3AFDC0 +// "NONE" 0x3AF820 — displayed for any unbound key + +namespace RVA { + constexpr u32 FreeCam_KeyDisplay = 0x087A87; // FreeCam key binding display panel start +} + +// ============================================================================ +// SECTION 26 — SKILLHACK INTERNALS (Ch.10 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 SkillHack_FNV_hash = 0x08D555; // FNV-1a 64-bit hash (unrolled, 8-byte XOR/MUL loop) + // FNV constants: prime=0x100000001B3, offset=0xCBF29CE484222325 + constexpr u32 SkillHack_HashMiss = 0x08D770; // hash miss fallback: xor al,al → ret 0 + constexpr u32 SkillHack_CallOrig = 0x08D891; // call-original trampoline: call r8 (original fn) + constexpr u32 SkillHack_SkipRet = 0x08D894; // skip-to-ret jmp target (cost bypass early exit) + constexpr u32 Vacuum_Monster_subss = 0x093EAC; // Vacuum::Render Monster sub-checkbox subss sequence +} + +// ============================================================================ +// SECTION 27 — CRT SECURITY FUNCTIONS (Ch.4) +// ============================================================================ + +namespace RVA { + constexpr u32 CRT_SecurityInit = 0x0AC580; // __security_check_cookie + SEH init (0xAC580-0xAC6CA) + constexpr u32 CRT_SecurityInit_end = 0x0AC6CA; + constexpr u32 CRT_SecurityCookie = 0x0AC6CC; // __security_check_cookie verifier (0xAC6CC-0xAC77B) + constexpr u32 CRT_SecurityCookie_end= 0x0AC77B; +} +// CRT_SecurityInit pseudocode (called at DllMain + first-chance exception dispatch): +// call IsProcessorFeaturePresent(0x17) → if supported: int 29h (fast fail) +// call __security_check_cookie helper (sub_0x1800AC574) +// RtlCaptureContext / RtlLookupFunctionEntry / RtlVirtualUnwind +// Build EXCEPTION_RECORD: code=0x40000015 (STATUS_FATAL_APP_EXIT), flags=NONCONTINUABLE +// call IsDebuggerPresent → save eax +// call SetUnhandledExceptionFilter(NULL) +// call UnhandledExceptionFilter(&record) +// if !result && !debugger: call TerminateProcess(handle, code) [via int 29h at 0xAC628] + +// ============================================================================ +// SECTION 28 — THREAD ENUMERATION DETAIL (Ch.3 call-site map) +// ============================================================================ +// All CollectProcessThreads (0xA96B0) internal call sites: +// 0xA9701 TH32CS_SNAPTHREAD = 4 (lea ecx,[rbx+4]) +// 0xA970B CreateToolhelp32Snapshot(4, pid) +// 0xA971E sizeof(THREADENTRY32) = 28 = 0x1C +// 0xA972F Thread32First(hSnapshot, &te32) +// [loop body] +// 0xA9740 check te32.th32OwnerProcessID offset (0x10) +// 0xA974B GetCurrentProcessId() +// 0xA9751 cmp te32.th32OwnerProcessID, eax +// 0xA9757 GetCurrentThreadId() +// 0xA975D cmp te32.th32ThreadID, eax +// 0xA9761 je skip (exclude caller thread) +// 0xA9763 get vector data ptr +// 0xA9778 VirtualAlloc/HeapReAlloc if vector full +// 0xA97CA store thread ID: [rdx+rcx*4] = eax +// 0xA97CD inc [rdi+0xC] (vector count++) +// 0xA97DD Thread32Next(hSnapshot, &te32) +// 0xA97E3 test eax,eax → jne loop +// 0xA97EB GetLastError → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0xA9815 CloseHandle(hSnapshot) +// +// SuspendOrResumeThreads (0xA9A20) call sites: +// 0xA9849 OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// 0xA9861 SuspendThread(hThread) +// 0xA9964 ResumeThread(hThread) [×37 total resume calls] +// 0xA988B GetThreadContext(hThread, &ctx) +// 0xA993C CreateToolhelp32Snapshot (secondary snapshot) +// +// PatchCode (0xA9A9C) call sites: +// 0xA9AFC VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &old) +// 0xA9B6C VirtualProtect(target, size, old, &old) (restore) +// 0xA9B72 GetCurrentProcess() +// 0xA9B81 FlushInstructionCache(hProc, target, size) + +// ============================================================================ +// SECTION 29 — IAT CALL SITE MAP (Ch.2 complete) +// ============================================================================ +// All Win32 IAT entries with RVAs and call sites: +// SuspendThread IAT 0xB1050 call site 0xA9861 +// ResumeThread IAT 0xB1058 call site 0xA9964 (×37) +// GetThreadContext IAT 0xB1068 call site 0xA988B +// FlushInstructionCache IAT 0xB1070 call site 0xA9B81 +// SetThreadContext IAT 0xB1078 call site 0xA993C +// GetProcAddress IAT 0xB1088 call sites 0x55F7E, 0x55F92 (×7) +// LoadLibraryA IAT 0xB10E0 call sites 0x55F57, 0x585AE (×4) +// AllocConsole IAT 0xB1108 +// GetConsoleMode IAT 0xB1120 +// SetConsoleMode IAT 0xB1128 +// SetConsoleTitleA IAT 0xB12A0 +// GetCurrentProcess IAT 0xB1270 call site 0xA9B72 +// VirtualFree IAT 0xB1278 call sites 0x81D5B, 0xAA6E1 +// VirtualProtect IAT 0xB1288 call sites 0xA9AFC, 0xA9B6C +// VirtualAlloc IAT 0xB11A0 call sites 0xAA566, 0xAA607 +// IsDebuggerPresent IAT 0xB11E8 call site 0xAC67B +// IsProcessorFeaturePresent IAT 0xB11F0 call site 0xAC5A2 +// TerminateProcess IAT 0xB11F8 call site 0xAC628 (via int 29h) +// SetUnhandledExceptionFilter IAT 0xB1200 call site 0xAC698 +// UnhandledExceptionFilter IAT 0xB1208 call site 0xAC6A3 +// RtlVirtualUnwind IAT 0xB1210 +// RtlLookupFunctionEntry IAT 0xB1218 +// RtlCaptureContext IAT 0xB1220 +// OpenThread IAT 0xB11D0 call site 0xA9849 (×38) +// Thread32Next IAT 0xB11A8 call site 0xA97DD +// Thread32First IAT 0xB11B0 call site 0xA972F +// CreateToolhelp32Snapshot IAT 0xB1160 call site 0xA970B +// SetWindowDisplayAffinity IAT 0xB1460 call site 0x8B48F +// FindWindowA IAT 0xB14A8 call site 0x8301F +// EnumWindows IAT 0xB14A0 +// GetWindowRect IAT 0xB1488 +// GetWindowThreadProcessId IAT 0xB1498 +// IsWindow IAT 0xB1468 +// GetSystemMetrics IAT 0xB14E0 +// LoadIconW IAT 0xB14E8 +// GetAsyncKeyState IAT 0xB???? call site 0x8301A +// ShowWindow IAT 0xB1628 +// UpdateWindow IAT 0xB14D8 +// RegisterClassExW IAT 0xB1638 +// CreateWindowExW IAT 0xB1650 +// SetLayeredWindowAttributes IAT 0xB15E0 +// SetProcessDPIAware IAT 0xB15A0 +// LoadCursorW IAT 0xB15C8 +// PeekMessageW IAT 0xB14D0 +// TranslateMessage IAT 0xB14C8 +// DispatchMessageW IAT 0xB14C0 +// PostQuitMessage IAT 0xB???? (WndProc WM_DESTROY) +// SetWindowPos IAT 0xB???? (overlay alignment) +// CreateSolidBrush IAT 0xB1018 +// CreateMutexA IAT 0xB1720 +// DwmExtendFrameIntoClientArea IAT 0xB1918 +// D3D11CreateDeviceAndSwapChain IAT 0xB1908 +// D3DCompile IAT 0xB1000 call sites 0x54E77, 0x55069 +// _wfopen IAT 0xB1888 call site 0x11F93 +// fwrite IAT 0xB1868 call sites 0xEA1B, 0x170D6, 0x3033B, 0x3076D +// fread IAT 0xB1870 (via 0x11EA0 helper) +// fclose IAT 0xB1878 call sites 0x170DF, 0x30776 + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 30 — REMAINING CALL-SITE ADDRESSES (final gap closure) +// ============================================================================ +// These are internal addresses referenced in the doc that complete coverage. +// They are instruction-level addresses, not function entry points. + +namespace RVA { + // Config I/O range markers + constexpr u32 OpenConfigFile_end = 0x012043; // OpenConfigFile range end (0x11EA0–0x12043) + constexpr u32 ImGuiSaveIni_caller = 0x0170B9; // caller VA of ImGuiSaveIni (fopen 'wt' for .ini) + constexpr u32 SaveConfig_iniwrite = 0x030750; // SaveConfig: write ImGui ini section call site + + // FpsUnlocker alt address (function table ref) + constexpr u32 FpsUnlocker_Render_alt = 0x085B80; // FpsUnlocker::Render alt ref addr (one-byte offset) + + // FreeCam key display + constexpr u32 FreeCam_BackwardKey = 0x087B1A; // "Backward Key: %s" display address (approx) + + // ModuleManager::DispatchRegistrarInit call site + constexpr u32 DispatchRegInit_callsite = 0x083348; // called at 0x83348 — init ImGui panel layout after first Present + + // ModulePathScanner skip-on-failure + constexpr u32 ModPathScanner_skip = 0x08BA41; // je target: skip module on GetModuleFileNameW failure + + // CollectProcessThreads instruction-level addresses (within 0xA96B0 body) + // 0xA96E7 xor ebx,ebx — thread count = 0 + // 0xA96F8 init empty vector — mov [rcx],rbx; mov [rcx+8],rbx + // 0xA9711 mov r14,rax — hSnapshot = CreateToolhelp32Snapshot result + // 0xA9714 cmp rax,-1 — INVALID_HANDLE_VALUE check + // 0xA9725 lea rdx,[rsp+0x30] — THREADENTRY32 buffer ptr + // 0xA972A mov [rsp+0x30],r12d — te32.dwSize = 28 + // 0xA9751 cmp [rsp+0x3C],eax — te32.th32OwnerProcessID == GetCurrentProcessId + // 0xA9755 jne skip — skip threads from other processes + // (All within CollectProcessThreads body at 0xA96B0; see Section 28 for full map) +} + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 19 — SIDEBAR / MAIN PANEL (Ch.25) +// ============================================================================ +// Top-level overlay panel function: RVA 0x7F8F0 (~0x146E bytes) +// Called every Present() frame from ModuleManager render loop. +// Stack frame: 0x380 bytes; saves xmm6-xmm8; single rcx arg (global ctx ptr) +// +// Key strings: +// "Sidebar" RVA 0x3AF2C8 — window lookup key (CRC32 0x11DF0, reg 0x3D1A0/0x1D2B0) +// "EF - Cheeto Press F12 to show panel" RVA 0x3AF258 +// "This is free, if you spend money, then you have been deceived" RVA 0x3AF288 +// Active tab index: [.data+0x1F68] VA 0x1803C6F68 (written on click, read at 0x80B52) +// +// Six tabs (jump-table dispatch at 0x80B52, case bodies): +// Tab 0 "About" RVA 0x3AF2D0 — banner + disclaimer + About sub-fn (0x80E80) +// Tab 1 "Player" RVA 0x3AF2DC — NoClip, SkillHack +// Tab 2 "ESP" RVA 0x3AF2E8 — ESPModule overlay +// Tab 3 "World" RVA 0x3AF2F0 — Vacuum +// Tab 4 "Visual" RVA 0x3AF2FC — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +// Tab 5 "Settings" RVA 0x3ADFD8 — Settings::RenderOverlay (case 5 at 0x80D25) +// +// i18n label dispatcher: 0x9D660 (translates label string per language toggle) +// Sidebar function tail-calls into ImGui epilogue at 0x23E20 via jmp at 0x80D5E + +namespace RVA { + constexpr u32 Sidebar_Main = 0x07F8F0; // top-level sidebar render + constexpr u32 Sidebar_About = 0x080E80; // About tab sub-function + constexpr u32 Sidebar_JumpTable = 0x080B52; // tab jump table (reads [.data+0x1F68]) + constexpr u32 Sidebar_Case5 = 0x080D25; // Settings tab case entry + constexpr u32 i18n_Dispatcher = 0x09D660; // translation dispatcher (en/zh_cn) + // ImGui_Combo = 0x064220 (already defined in Section 9 RVA namespace) + // ImGui_Epilogue = 0x023E20 (already defined in Section 9 RVA namespace) + constexpr u32 CRC32_fn = 0x011DF0; // CRC32 hash (window key) + constexpr u32 Registry_lookup = 0x03D1A0; // registry lookup by CRC32 + constexpr u32 Registry_lookup2 = 0x01D2B0; // secondary registry lookup +} + +// ============================================================================ +// SECTION 20 — FREECAM KEY BINDING DISPLAY PANEL (Ch.27) +// ============================================================================ +// Sub-section of FreeCam::Update (RVA 0x871A0), begins at ~0x87A70, ends 0x88606 +// (FreeCam::Update is 0x14C6 bytes total) +// +// Float sliders (ImGui variant 0x65570): +// "Free Camera" RVA 0x3AFCB0 — sub-panel BeginTab label +// "ON / OFF" RVA 0x3AF848 — toggle checkbox +// "Move Speed" RVA 0x3AFCC0 — DragFloat fmt "%.3f" (0x3ADFB0) +// "Look Sensitivity" RVA 0x3AFCD0 — DragFloat fmt "%.3f" +// "Roll Speed" RVA 0x3AFCE8 — DragFloat fmt "%.3f" +// "FOV Speed" RVA 0x3AFCF8 — DragFloat fmt "%.3f" +// "FOV" RVA 0x3AFD04 — DragFloat fmt "%.1f" (0x3ADFEC) +// +// Key binding rows (11 total) — each row: +// MakeString(0xFCB0) → sprintf(0x5FB60, "Key: %s", key_name) → TabLabel(0x9D7D0) +// "NONE" RVA 0x3AF820 — displayed for unbound keys +// Key-binding state array: [rip+...] 0x1803C6E98 +// Rows: +// "Forward Key: %s" RVA 0x3AFD08 (VA 0x180087A87) +// "Backward Key: %s" RVA 0x3AFD18 +// "Left Key: %s" RVA 0x3AFD30 +// "Right Key: %s" RVA 0x3AFD40 +// "Up Key: %s" RVA 0x3AFD50 +// "Down Key: %s" RVA 0x3AFD60 +// "IncFOV Key: %s" RVA 0x3AFD70 +// "DecFOV Key: %s" RVA 0x3AFD80 +// "LeftRoll Key: %s" RVA 0x3AFD90 +// "RightRoll Key: %s" RVA 0x3AFDA8 +// "ResetRoll Key: %s" RVA 0x3AFDC0 + +namespace RVA { + constexpr u32 FreeCam_KeyBindPanel = 0x087A70; // key binding display section start + constexpr u32 FreeCam_KeyBind_end = 0x088606; // end of FreeCam::Update + constexpr u32 Sprintf_label = 0x05FB60; // sprintf-style label formatter +} + +// ============================================================================ +// SECTION 21 — SETTINGS TAB (Ch.28) +// ============================================================================ +// Settings::RenderOverlay RVA 0x9A4F0 (source: SettingsTAB.cpp RVA 0x3B0B30) +// Called from sidebar case 5 (0x80D25). Ends at ~0x9AB31. +// +// 28.1 Theme selector: +// ImGui::Combo("Theme", ...) via 0x64220 +// Four themes → four applicator functions: +// "Default" RVA 0x3B0AF8 → applicator 0x941F0 (restores ImGui defaults) +// "Evangelion Unit 01" RVA 0x3B06D0 → applicator 0x94890 (52 color writes) +// "Evangelion Unit 02" RVA 0x3B0AE0 → applicator 0x96770 +// "Matrix" RVA 0x3B0B10 → applicator 0x98650 +// Each non-default applicator uses per-slot helper RVA 0x94190 (159 calls total): +// reads RRGGBBAA hex string → __stdio_common_vsscanf → ImGui::PushStyleColor (0x10840) +// +// Evangelion Unit 01 colors (RVA 0x94890, in write order): +// #FFFFFFFF #7857A7FF #19171CFF #2A282EFF #2A282EE6 #4DE6A5FF +// #00000000 #4A455240 #A38CCF80 #7857A780 #4A4552FF +// +// Evangelion Unit 02 colors (RVA 0x96770): +// #FFFFFFFF #D9293BFF #1E1E1EFF #3A3A3AFF #3A3A3AE6 #F7B302FF +// #00000000 #4A455240 #F7465880 #D9293B80 #4A4552FF +// +// Matrix colors (RVA 0x98650): +// #00FF41FF #00AA2CFF #000000FF #0A0A0AFF #0A0A0AE6 #004400FF +// #00000000 #00440040 #00881EFF #00FF4180 +// +// 28.3 Console toggle: +// CheckboxToggle(0x85320) with label "Toggle Console" (RVA 0x3B0B00) +// Enabled branch: AllocConsole (IAT 0xB1178) / GetStdHandle → display "Console {}" +// Disabled branch: FreeConsole + +namespace RVA { + constexpr u32 Theme_Default = 0x0941F0; // restores ImGui default palette + constexpr u32 StyleColor_push = 0x010840; // ImGui::PushStyleColor wrapper + // Settings_end 0x09AB31 — see also RVA::Settings_end 0x09AB98 in Section 9 +} + +// ============================================================================ +// SECTION 22 — CONFIG / IMGUI .INI SYSTEM (Ch.19) +// ============================================================================ +// ImGui .ini filename: "imgui.ini" RVA 0x3ABB60 +// Set at RVA 0x1117A into ImGuiIO+0x20 (IniFilename field) +// +// Config save/load: +// Load path (startup): RVA 0x30661 → ConfigSerialize (0x12050) +// → ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell → fread → fclose +// Manual save trigger: RVA 0x17072 +// Sets [ImGuiContext+0x2900]=1, [ImGuiContext+0x2904]=0 → forces immediate write +// fwrite calls: 0x3076D (config body), also 0x170D6 +// fclose: 0x30776 +// +// Module settings handler struct (ImGuiContext+0x2920 array, 0x48 bytes each): +// +0x00 TypeName (const char*) — .ini section name +// +0x08 TypeHash (u32) — CRC32 of TypeName (computed 0x3079C–0x30803) +// +0x18 ReadOpenFn — called on section header encounter +// +0x38 WriteAllFn — called during save to emit key=value lines +// 11 registered modules (RTTI .data+0x0590–0x0E60): +// ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule +// +// i18n blob: RVA 0x3B10E8 (0xEED bytes, nlohmann JSON, en→zh_cn map) +// Copied to [.data+0x1EB8] at startup RVA 0x2164 +// Loader: RVA 0x9D660 — selects en or zh_cn based on language flag +// nlohmann version: v3.12.0 (statically linked; error strings at 0x3B3010–0x3B30D8) + +namespace RVA { + constexpr u32 ImGuiIni_set = 0x01117A; // IniFilename = "imgui.ini" write + constexpr u32 Config_save_trigger = 0x017072; // manual save: set ImGuiCtx+0x2900 + constexpr u32 Config_load_entry = 0x030661; // config file load entry + constexpr u32 Config_ftell = 0x0120A0; // ftell in config read + constexpr u32 Config_fseek_A = 0x0120BC; // fseek in config read + constexpr u32 Config_fseek_B = 0x0120E7; // fseek in config read + constexpr u32 Config_fwrite = 0x03076D; // config body fwrite + constexpr u32 Config_fclose = 0x030776; // config fclose + constexpr u32 ImGui_handler_CRC = 0x03079C; // CRC32 of TypeName (start) + constexpr u32 ImGui_handler_CRC_end = 0x030803; // CRC32 of TypeName (end) + constexpr u32 i18n_blob_rva = 0x3B10E8; // JSON localization blob (.rdata) + constexpr u32 i18n_loader = 0x09D660; // translation dispatcher + constexpr u32 i18n_copy_site = 0x02164; // startup: copies blob to [.data+0x1EB8] + constexpr u32 Registrar_name_str = 0x01B71; // registrar constructor name string RVA ref +} + +// ============================================================================ +// SECTION 23 — UNITY EXPLORER MODULE (Ch.16 supplement) +// ============================================================================ +// UE draw body: RVA 0x0902E0 (per-frame inspector UI, called from UE::Render 0x90250) +// Window title: "Unity Explorer Window" RVA 0x3B02E0 (via ImGui::Begin wrapper 0x937D0) +// +// Scene panel (pseudocode): +// if (scene_list empty) { +// ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +// } else { +// ImGui::Text("Select Scene:"); +// ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +// if (changed) LoadScene(selected_scene_idx); +// } +// // When scene panel active: g_Config->overlay_flags |= 1; overlay_scale = 300.0f +// // ([g_Config+0x1F78], [g_Config+0x1F90]) +// +// Auto-refresh (RVA 0x090250): +// if (enabled && auto_refresh) { +// now = GetTime(); // 0x93B10 +// if ((now - last_refresh_time) * SCALE >= refresh_interval) +// RefreshScenes(this); last_refresh_time = now; +// } +// +// Scene list storage: vector at [this+0x58]..[this+0x60] +// GameObject list: vector at [this+0x40]..[this+0x48] +// Search filter: [this+?] char[0x100] buffer "##SearchFilter" +// +// Inspector panel (when object selected via 'Ins' button): +// 'Active' checkbox → GameObject.SetActive via IL2CPP +// Transform: Position, LocalPosition, Rotation, Scale (float3 inputs) +// 'Components' section via IL2CPP GetComponents(UnityEngine.Component) +// Per component: "%s.%s" (namespace.classname) +// Failure strings: "Unknown Component", "Unable to get GameObject class information." +// +// Key strings (Ch.16.4): +// "No scenes available. Click 'Refresh Scenes' to load." +// "Select Scene:" "No GameObjects found in this scene." "DontDestroyOnLoad" +// "No GameObject selected." "Active" "Components" "All Components:" + +namespace RVA { + constexpr u32 UE_DrawBody = 0x0902E0; // main per-frame inspector draw + constexpr u32 UE_AutoRefresh_fn = 0x093B10; // auto-refresh timer check +} + +// ============================================================================ +// SECTION 24 — ADDITIONAL IAT ENTRIES (referenced in doc but not in Ch.2 table) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw offset 0xAF600) +// These slots appear in inline code references throughout the doc: + +// IAT[0xB1148] SwitchToThread — spinlock backoff (if backoff<32: SwitchToThread else Sleep(1)) +// IAT[0xB1168] GetModuleFileNameExW — module path scanner, get full path of each module +// IAT[0xB1178] AllocConsole — Settings console toggle enable branch +// IAT[0xB1290] GetModuleHandleW — GABypass: GetModuleHandleW(L"GameAssembly.dll") +// also: PreventScreenshot::OsCheck loads ntdll for RtlGetVersion + +// ============================================================================ +// SECTION 25 — MODULEMANGER INIT VARIANT ADDRESS (Ch.19.7) +// ============================================================================ +// Two RVAs for ModuleManager::Init appear in the doc: +// RVA 0x09AC10 — from Ch.15 (primary reference) +// RVA 0x09ACA4 — from Ch.19.7 (alternate call site / body continuation) +// Both refer to the same function; 0x9AC10 is entry, 0x9ACA4 is within body. +// Body action (Ch.19.7): +// Iterates module registry [.data+0x23B8], calls vtable[+0x10] → module instance, +// then vtable[+0x18] (Render dispatch) per registered module. +// Source: ModuleManager.cpp lines 34 and 52 (assert strings in binary). + +// Vacuum::RegisterTab stub at RVA 0x9B650 resolves via jmp to +// UnityExplorerModule::RegisterTab at RVA 0x090060. +// (Vacuum and UE share a registrar stub due to module ordering in init sequence) + +// GABypass::Patch call site in startup: RVA 0x0A942A +// Called exactly once from LoaderThread, immediately after 'Initializing..' log (0xA93E6) +// and before any module Update()/Render() calls. + +// ============================================================================ +// SECTION 26 — COMPLETE ADDRESS COVERAGE INDEX +// ============================================================================ +// All 282 unique cheat-range addresses extracted from the doc, organized by subsystem. +// Addresses not in RVA:: namespace appear inline below with descriptions. + +// -- Config / i18n / .ini system -- +// 0x01B71 registrar constructor name string ref +// 0x02164 i18n blob copy to [.data+0x1EB8] at startup +// 0x1117A ImGuiIO.IniFilename = "imgui.ini" write site +// 0x17072 manual config save trigger (sets ImGuiCtx+0x2900=1) +// 0x30661 config file load entry (calls ConfigSerialize 0x12050) +// 0x30904 ImGui handler struct layout base (from CRC32 compute chain) + +// -- Sidebar / UI -- +// 0x80B52 sidebar tab jump table (reads active_tab_idx [.data+0x1F68]) + +// -- D3D11 overlay window (detailed call sites Ch.29) -- +// 0x8298B EnumWindows → FindGameWindow, end of DPI section +// 0x82A60 DwmExtendFrameIntoClientArea call site +// 0x82B24 D3D11CreateDeviceAndSwapChain attempt 1 (R8G8B8A8) +// 0x82B7E D3D11CreateDeviceAndSwapChain attempt 2 (B8G8R8A8 fallback) +// 0x82C0D CreateMutexA — duplicate-instance guard +// 0x82F5F Log "Initialized" (source UI.cpp, before message loop) +// 0x83386 DispatchRegistrarInit once_flag — install registrar hooks +// 0x8348A SwitchToThread yield site (game out of focus) + +// -- FreeCam -- +// 0x87A70 FreeCam key binding display panel start (inside FreeCam::Update) +// 0x88606 FreeCam::Update end + +// -- UnityExplorer -- +// 0x902E0 UE main draw body (scene panel + GO inspector) + +// -- Settings / Theme -- +// 0x941F0 Default theme applicator (restores ImGui defaults) +// 0x9AB31 Settings::RenderOverlay approximate end + +// -- ModuleManager -- +// 0x9ACA4 ModuleManager::Init body (alt addr, iterates registry vtable[+0x10]/[+0x18]) +// 0x9B650 Vacuum/UE RegisterTab shared stub (resolves to UE::RegisterTab 0x90060) + +// -- Startup -- +// 0xA942A GABypass::Patch call site in LoaderThread (after 'Initializing..' log) + +// -- IAT slots (additional, not in main IAT table) -- +// 0xB1148 SwitchToThread +// 0xB1168 GetModuleFileNameExW +// 0xB1178 AllocConsole +// 0xB1290 GetModuleHandleW (GameAssembly + ntdll RtlGetVersion) + +// ============================================================================ +// SECTION 27 — COMPLETE .RDATA STRING TABLE +// ============================================================================ +// All 189 .rdata string RVAs from the document, grouped by subsystem. +// Format: RVA — "string content" — usage + +// --- ImGui / config filenames --- +// 0x3ABB60 "imgui.ini" ImGuiIO+0x20 IniFilename (written at RVA 0x1117A) +// 0x3ABB70 "imgui_log.txt" ImGuiIO+0x28 LogFilename (written at same site) +// 0x3ABF10 "##Foreground" FPS overlay frameless window label +// 0x3AC160 "Calling EndDisabled() too many times!" ImGui assert string + +// --- D3D11 shaders (HLSL source, compiled at runtime) --- +// 0x3AE660 Vertex shader HLSL source length=0x2DD (733 bytes) +// entry="main" target="vs_4_0" +// cbuffer vertexBuffer:b0 { float4x4 ProjectionMatrix } +// VS_INPUT{float2 pos:POSITION, float4 col:COLOR0, float2 uv:TEXCOORD0} +// PS_INPUT main: output.pos = mul(ProjectionMatrix, float4(pos.xy,0,1)) +// 0x3AE940 Pixel shader HLSL source length=0x191 (401 bytes) +// entry="main" target="ps_4_0" +// sampler sampler0; Texture2D texture0; +// float4 main: return input.col * texture0.Sample(sampler0, input.uv) + +// --- PreventScreenshot --- +// 0x3AEC70 dynamic import string for SetWindowDisplayAffinity (from user32.dll, RVA 0x3C34A6) +// 0x3B00B8 module name "PreventScreenshot" (registrar) + +// --- About page (Tab 0, sub-fn 0x80E80) --- +// 0x3AF350 "%s Game: Endfield CTB3" format string +// 0x3AF368 "Version: " label +// 0x3AF374 "1.0.0" version value +// 0x3AF380 "Author: " label +// 0x3AF38C "gktwo" author value +// (All direct string literals, not i18n-dispatched) + +// --- Window class detection --- +// 0x3AF658 "UnityWndClass" FindWindowA arg / string-compare (0xACA12) + +// --- ESP module (ESPModule::RenderOverlay RVA 0x83FA0) --- +// 0x3AF828 "ESPModule" module name +// 0x3AF838 "ESP Features" CollapsingHeader title → state [.data+0x27B0] +// 0x3AF848 "ON / OFF" checkbox label → [module+0x28] +// 0x3AF858 "Display Types" CollapsingHeader sub-header (via 0x6EC20) +// 0x3AF868 "Show Monsters" checkbox → [rsi+0x34] show_monsters +// 0x3AF878 "Show NPC" checkbox → [rsi+0x35] show_npc +// 0x3AF888 "Show Friendly" checkbox → [rsi+0x36] show_friendly +// 0x3AF898 "Show Puzzles" checkbox → [rsi+0x37] show_puzzles +// 0x3AF8A8 "Show All" checkbox → [rsi+0x38] show_all +// 0x3AF8B8 "Display Info" CollapsingHeader sub-header +// 0x3AF8C8 "Show Distance" checkbox → [rsi+0x39] show_distance +// 0x3AF8D8 "Show Name" checkbox → [rsi+0x3A] show_name +// 0x3AF8E8 "Show Type" checkbox → [rsi+0x3C] show_type +// 0x3AF8F4 (entity label separator string, used in Update DrawOverlay) +// 0x3AF900 (entity label buffer string) +// 0x3AF908 entity type dispatch table start (type→name pairs) +// 0x3AF920 entity type dispatch table continued (0xFFFFFFFF sentinel) +// 0x3AF9E0 vtable ptr value (0x3AF9E0 = post-init vtable for ESPModule) + +// --- FPS overlay (FPSModule) --- +// 0x3AFA98 FPSModule vtable block start +// 0x3AFAAC "FPS: " prefix for FPS display string (via 0x7F5C0) +// Color thresholds for FPS display (XMMWORD constants, already in .rdata): +// fps >= 60: color at 0x1803B3530 (green 0.0, 1.0, 0.0, 1.0) +// 30<=fps<60: color at 0x1803B3540 (yellow 1.0, 1.0, 0.0, 1.0) +// fps < 30: color at 0x1803B3510 (red 1.0, 0.0, 0.0, 1.0) + +// --- FreeCam --- +// 0x3AF820 "NONE" unbound key display in key binding rows + +// --- PlayerProfile UI paths --- +// 0x3AFED0 "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (len 0x2F) +// 0x3AFFD0 "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (len 0x8D) + +// --- FreeCam key binding panel (Ch.27) --- +// 0x3AFCB0 "Free Camera" +// 0x3AFCC0 "Move Speed" +// 0x3AFCD0 "Look Sensitivity" +// 0x3AFCE8 "Roll Speed" +// 0x3AFCF8 "FOV Speed" +// 0x3AFD04 "FOV" +// 0x3AFD08 "Forward Key: %s" +// 0x3AFD18 "Backward Key: %s" +// 0x3AFD30 "Left Key: %s" +// 0x3AFD40 "Right Key: %s" +// 0x3AFD50 "Up Key: %s" +// 0x3AFD60 "Down Key: %s" +// 0x3AFD70 "IncFOV Key: %s" +// 0x3AFD80 "DecFOV Key: %s" +// 0x3AFD90 "LeftRoll Key: %s" +// 0x3AFDA8 "RightRoll Key: %s" +// 0x3AFDC0 "ResetRoll Key: %s" + +// --- UE module string table (Ch.16.4) --- +// 0x3B02D0 "Unity Explorer" tab label / ImGui::Begin title +// 0x3B02E0 "Unity Explorer Window" ImGui window title +// 0x3B02F8 "Search Filter:" label above search input +// 0x3B0308 "##SearchFilter" ImGui InputText widget ID +// 0x3B0318 "Inspector" inspector sub-panel label +// 0x3B0328 "GameObjectHierarchy" hierarchy sub-panel label +// 0x3B0340 "No scenes loaded. Click Refresh..." +// 0x3B0390 "Scene: " scene prefix label +// 0x3B0398 "No GameObjects found in this scene." +// 0x3B03C0 "DontDestroyOnLoad" special DDOL scene label +// 0x3B03D8 "DontDestroyOnLoad (Not Found)" +// 0x3B03F8 "Refresh" button label +// 0x3B0400 "Auto Refresh" checkbox label +// 0x3B0410 "Interval (s)" refresh interval slider +// 0x3B0420 "Scenes found: %d" +// 0x3B0438 "No scenes available. Click 'Refresh Scenes' to load." +// 0x3B0470 "Select Scene:" +// 0x3B0480 "Select Scene" combo default text +// 0x3B0490 "##SceneCombo" ImGui Combo widget ID +// 0x3B04A0 "]: " object list entry separator +// 0x3B04A8 "Ins##" inspect button label prefix +// 0x3B04B8 "No GameObject selected." +// 0x3B04D0 "Click 'Ins' button..." inspector hint +// 0x3B0508 "Active" active checkbox label +// 0x3B0510 "Transform" section header +// 0x3B0520 "Position" +// 0x3B0530 "Local Position" +// 0x3B0540 "Rotation" +// 0x3B054C "Scale" +// 0x3B0558 "No Transform component found." +// 0x3B0578 "Components" section header +// 0x3B0588 "GameObject Class: %s.%s" +// 0x3B05A0 "All Components:" +// 0x3B05B0 "UnityEngine.Component, UnityEngine.CoreModule" (GetComponents type arg) +// 0x3B05E0 "%s.%s" component name format +// 0x3B05E8 "Unknown Component" +// 0x3B0600 "No components found or failed to get components." +// 0x3B0638 "Unable to get GameObject class information." +// 0x3B0D28 "UnityExplorerModule" module name (registrar) +// UE auto-refresh state: bool at [.data+0x2640], float at [.data+0x2644] + +// --- Settings tab (Ch.28) --- +// 0x3B0AD4 "Theme" combo label +// 0x3B0AF8 "Default" theme name +// 0x3B06D0 "Evangelion Unit 01" theme name +// 0x3B0AE0 "Evangelion Unit 02" theme name +// 0x3B0B10 "Matrix" theme name +// 0x3B0B00 "Toggle Console" checkbox label +// 0x3B0B18 (Settings key address for enabled state) +// 0x3B0B28 "enabled" UI label for module on/off state (not JSON key) +// 0x3B0B78 "Console {}" console enabled display format +// 0x3B0B30 SettingsTAB.cpp source file path string + +// Theme color string RVAs (Evangelion Unit 01): +// 0x3B06E8 0x3B06F8 0x3B0708 0x3B0718 0x3B0728 0x3B0738 +// 0x3B0748 0x3B0758 0x3B0768 0x3B0778 0x3B0798 +// Theme color string RVAs (Evangelion Unit 02): +// 0x3B0888 0x3B0898 0x3B08A8 0x3B08B8 0x3B08C8 0x3B08D8 0x3B08F8 +// Theme color string RVAs (Matrix): +// 0x3B09A8 0x3B09B8 0x3B09C8 0x3B09D8 0x3B09E8 0x3B09F8 +// 0x3B0A08 0x3B0A18 0x3B0A38 + +// --- ModuleManager log strings (Ch.15.7) --- +// 0x3B0B88 "[WARNING] ModuleManager already initialized" +// 0x3B0BC0 ModuleManager.cpp assert source file path +// 0x3B0C08 "Initializing ModuleManager" +// 0x3B0C28 "Failed to initialize module {}" +// 0x3B0C48 "Module {} initialized" +// 0x3B0C60 "ModuleManager initialization complete" +// 0x3B0C90 "[ERROR] Failed to update module " +// 0x3B0CB8 "[ERROR] Failed to render overlay for module " +// 0x3B0CE8 "[ERROR] Failed to process hotkeys for module " + +// --- Config file mode strings --- +// 0x3AD590 "rb" Config READ - binary read mode +// 0x3AD594 "wt" Config WRITE - text write mode (ImGui ini) + +// --- DamageHack ghost keys (Ch.23) --- +// 0x3B1484 i18n table — four keys with no RTTI class (ghost/unimplemented feature) + +// --- Locale --- +// 0x3B2020 "en" locale string passed to string-construct at 0x9D890 + +// --- Startup / project identity --- +// 0x3B3148 "E:\git\Endfield_Cheeto\user\main.cpp" (confirms project name) + +// --- ESP color constant addresses in .data (ESP Update type dispatch) --- +// 0x3B3224 drawlist color source (XMMWORD, type-selected RGBA) +// 0x3B3308 100.0f constant (SkillHack CooldownBypass return value) +// ESP color table .rdata bases (correspond to ESPModule::color[] slots): +// 0x3B3500 color[10] BLACK (0.0,0.0,0.0,1.0) +// 0x3B3510 color[0] RED (1.0,0.0,0.0,1.0) also FPS<30 threshold +// 0x3B3520 color[1] ORANGE (1.0,0.647,0.0,1.0) +// 0x3B3530 color[3] GREEN (0.0,1.0,0.0,1.0) also FPS>=60 threshold +// 0x3B3540 color[2] YELLOW (1.0,1.0,0.0,1.0) also FPS 30-60 threshold +// 0x3B3550 color[11] GRAY (0.502,0.502,0.502,1.0) +// 0x3B3560 color[8] PINK (1.0,0.078,0.576,1.0) +// 0x3B3570 color[9] LPINK (1.0,0.753,0.796,1.0) +// 0x3B3580 color[6] PURPLE (0.58,0.0,0.827,1.0) +// 0x3B3590 color[4] BLUE (0.0,0.0,1.0,1.0) +// 0x3B35A0 color[5] CYAN (0.0,1.0,1.0,1.0) +// 0x3B35B0 color[7] WHITE (1.0,1.0,1.0,1.0) + +// --- Preset/config JSON keys (Ch.17/19) --- +// 0x3B06F8 "Default" preset name (also used as JSON key, via 0x3B0AF8) + +// --- FPS Overlay / PreventScreenshot extra --- +// 0x3B0198 "FPSMonitor" / FPS module registrar tab label (inside main cheat overlay) + +// ============================================================================ +// SECTION 28 — COMPLETE IAT TABLE (all 75 entries) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw 0xAF600). Format: IAT[RVA] = function (DLL) + +// Previously documented entries (Sections 9/24) plus newly added: +// 0xB1148 SwitchToThread KERNEL32 spinlock backoff (if backoff<32) +// 0xB1168 GetModuleFileNameExW PSAPI module path scanner full-path retrieval +// 0xB1178 AllocConsole KERNEL32 Settings console toggle enable +// 0xB1268 GetCurrentThreadId KERNEL32 stack cookie check (RVA 0xAC709) +// 0xB1290 GetModuleHandleW KERNEL32 GABypass: L"GameAssembly.dll"; OsCheck: ntdll +// 0xB1470 GetWindowLongPtrW USER32 overlay: read GWL_STYLE, GWL_EXSTYLE +// 0xB1480 IsWindowVisible USER32 overlay: check game window visible +// 0xB1490 GetClassNameA USER32 overlay: detect foreground window class (×3) +// 0xB1510 IsIconic USER32 overlay: check not minimized +// 0xB1518 SetForegroundWindow USER32 overlay: bring game to front on match +// 0xB1570 DestroyWindow USER32 overlay: cleanup on loop exit +// 0xB1588 SetWindowPos USER32 overlay: reposition to match game window +// 0xB15A8 GetClientRect USER32 overlay: get inner client area +// 0xB15B0 SetWindowLongW USER32 overlay: update window style ×2 +// 0xB15F0 GetForegroundWindow USER32 overlay: check active foreground window +// 0xB1640 UnregisterClassW USER32 overlay: cleanup window class on exit +// 0xB1858 fread CRT config file read (called ONLY from 0x12121) +// 0xB1880 __stdio_common_vsscanf CRT theme color parser (RRGGBBAA hex→RGBA) +// 0xB1890 _wfopen CRT config file open (called ONLY from 0x11F93) +// 0xB1898 fseek CRT config seek (from 0x120BC, 0x120E7) +// 0xB1920 DwmGetWindowAttribute DWMAPI overlay: DWMWA_EXTENDED_FRAME_BOUNDS rect + +// ============================================================================ +// SECTION 29 — IMGUI HELPER RVAs (inline functions used throughout modules) +// ============================================================================ +// ImGui wrapper functions used by module Render() bodies (not in main RVA namespace) + +namespace RVA { + constexpr u32 ImGui_CollapsingHeader = 0x06EC20; // lightweight wrapper; checks ImGuiCtx+0x106 locked flag + constexpr u32 ImGui_Checkbox_commit = 0x061FE0; // checkbox state commit helper + constexpr u32 ImGui_Separator_cursor = 0x070630; // Separator + cursor Y adjust + constexpr u32 ImGui_AddText_colored = 0x051580; // drawlist AddText with explicit color + constexpr u32 FPS_string_builder = 0x07F5C0; // "FPS: " + int → display string + constexpr u32 Str_compare_helper = 0x0ACA12; // internal string compare (wchar/char) + constexpr u32 ImGui_EndDisabled_path = 0x0ACA1F; // EndDisabled via ImGuiCtx+0x27F0 decrement +} + +// ImGuiContext field offsets referenced in cheat code: +// [ImGuiContext+0x106] locked_input_flag (BYTE) — CollapsingHeader disabled check +// [ImGuiContext+0x15D8] foreground_drawlist — FPS overlay drawlist ptr (+0x40 = draw cmds) +// [ImGuiContext+0x27F0] EndDisabled_counter (WORD) — decremented on EndDisabled call +// [ImGuiContext+0x2900] save_to_disk_flag (set=1 by manual save trigger 0x17072) +// [ImGuiContext+0x2904] save_timer (set=0 by manual save trigger) +// [ImGuiContext+0x2910] custom IniFilename (ptr; config save path source) +// [ImGuiContext+0x2920] settings_handlers (dynamically-grown array of 0x48-byte structs) + +// ============================================================================ +// SECTION 30 — D3D11 SHADER SOURCE (Ch.5) +// ============================================================================ +// Both shaders are stored as raw HLSL text in .rdata and compiled at runtime +// via D3DCompile (IAT[0xB1000]) during D3D11Init (RVA 0x54DC0/0x551E8). + +// Vertex shader (RVA 0x3AE660, 733 bytes, "main"/"vs_4_0"): +static const char* VS_HLSL_SOURCE_RVA = "0x3AE660"; // marker only — see comment +// cbuffer vertexBuffer : register(b0) { float4x4 ProjectionMatrix; }; +// struct VS_INPUT { float2 pos:POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// PS_INPUT main(VS_INPUT input) { +// PS_INPUT output; +// output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +// output.col = input.col; output.uv = input.uv; +// return output; } + +// Pixel shader (RVA 0x3AE940, 401 bytes, "main"/"ps_4_0"): +static const char* PS_HLSL_SOURCE_RVA = "0x3AE940"; // marker only — see comment +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// sampler sampler0; Texture2D texture0; +// float4 main(PS_INPUT input) : SV_Target { +// return input.col * texture0.Sample(sampler0, input.uv); } + +// Shader init sequence (RVA 0x54DC0): +// load g_D3DState from [g_Config+0xD8] → R14 +// check already-init: cmp (*r14), null; je skip +// call 0x551F0 (create vertex/index buffers) +// D3DCompile(0x3AE660, 0x2DD, NULL,NULL,NULL, "main","vs_4_0",0,0,...) → vertex blob +// D3DCompile(0x3AE940, 0x191, NULL,NULL,NULL, "main","ps_4_0",0,0,...) → pixel blob + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 31 — COMPLETE .DATA ADDRESS MAP (SUPPLEMENTAL) +// ============================================================================ +// All 97 .data offsets documented across all chapters, with absolute VAs and +// semantic descriptions. Base: .data = 0x1803C5000 (RVA 0x3C5000) + +// --- Module dispatch fn ptr state blocks (vtable[+0x18] accessor targets) --- +// Each module's vtable[+0x18] stub returns the module's .data state block. +// At offset [+0x00] of that block is the actual Render/Update fn ptr written +// by RegisterTab. The ModuleManager dispatch loop calls stub → gets this ptr → calls it. +// +// [.data+0x0530] FpsOverlay state block → fn ptr (overlay render) +// [.data+0x0580] PlayerProfile state block → fn ptr +// [.data+0x0630] SetDither state block → fn ptr (no-op stub 0x83DC0) +// [.data+0x06D0] NoClip state block → fn ptr +// [.data+0x0770] SkillHack state block → fn ptr (hook installer) +// [.data+0x07D0] FreeCam state block → fn ptr + +// --- RTTI / module name strings (.data) --- +// [.data+0x0590]–[.data+0x0E60] 11 module RTTI class descriptors +// (ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule) + +// --- Panel state init config block (.data, written by DispatchRegistrarInit) --- +// [.data+0x1F08] panel_config_src_A (16 bytes) — source for movups xmm0 +// [.data+0x1F18] panel_config_src_B (16 bytes) — source for movups xmm1 +// [.data+0x1F28] panel_config_dst_A (16 bytes) — dest: initial panel state copy +// [.data+0x1F38] panel_config_dst_B (16 bytes) — dest: initial panel state copy + +// --- ESPModule singleton — absolute .data field addresses --- +// Base: [.data+0x1F70] VA 0x1803C6F70 +// +// [.data+0x1F70] QWORD vtable ptr (pre-init: 0x3AFA38; post-init: 0x3AF9E0) +// [.data+0x1F78] STRING name = "ESPModule" (SSO std::string, RVA 0x3AF828) +// [.data+0x1F98] BYTE enabled = 0 +// [.data+0x1FA0] DWORD max_draw_distance = 300 (0x12C) +// [.data+0x1FA4] BYTE show_monsters = 1 +// [.data+0x1FA5] BYTE show_npc = 1 +// [.data+0x1FA6] BYTE show_friendly = 1 +// [.data+0x1FA7] BYTE show_puzzles = 1 +// [.data+0x1FA8] BYTE show_all = 0 +// [.data+0x1FA9] BYTE show_distance = 1 +// [.data+0x1FAA] BYTE show_name = 1 +// [.data+0x1FAB] BYTE reserved = 0 +// [.data+0x1FAC] BYTE show_type = 0 +// [.data+0x1FB0] XMMWD color[0] RED (1.00, 0.00, 0.00, 1.00) — Enemies +// [.data+0x1FC0] XMMWD color[1] ORANGE (1.00, 0.65, 0.00, 1.00) — Interactive/NPC +// [.data+0x1FD0] XMMWD color[2] YELLOW (1.00, 1.00, 0.00, 1.00) — spare +// [.data+0x1FE0] XMMWD color[3] GREEN (0.00, 1.00, 0.00, 1.00) — Friendly +// [.data+0x1FF0] XMMWD color[4] BLUE (0.00, 0.00, 1.00, 1.00) — NPC/spare +// [.data+0x2000] XMMWD color[5] CYAN (0.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2010] XMMWD color[6] PURPLE (0.58, 0.00, 0.83, 1.00) — spare +// [.data+0x2020] XMMWD color[7] WHITE (1.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2030] XMMWD color[8] PINK (1.00, 0.08, 0.58, 1.00) — spare +// [.data+0x2040] XMMWD color[9] LPINK (1.00, 0.75, 0.80, 1.00) — spare +// (color[10] BLACK and color[11] GRAY not stored separately; loaded from .rdata at runtime) +// Note: Color slots 2,5,6,8,9 are spare palette entries with no current entity type mapping. +// Slots 0,1,3,4 map to Enemies/Interactive/Friendly/NPC respectively. + +// --- FPSModule singleton --- +// [.data+0x22E0] QWORD FPSModule singleton ptr VA 0x1803C72E0 +// [.data+0x22E8] STRING name = "FPS Monitor" (SSO std::string) +// [.data+0x2308] BYTE enabled = 0 +// [.data+0x2310] QWORD once_flag (std::once_flag, guards Initialize RVA 0x814C0) + +// --- PreventScreenshot singleton --- +// [.data+0x2358] QWORD PreventScreenshot singleton ptr VA 0x1803C7358 +// [.data+0x2360] STRING name = "Prevent Screenshot" (SSO std::string) +// [.data+0x2380] BYTE enabled = 0 +// [.data+0x2388] BYTE second_toggle_flag = 0 +// [.data+0x2390] QWORD once_flag (guards Initialize RVA 0x8AD70) +// [.data+0x24D0] QWORD hook/window list head (linked list; nodes have HWND at [+0x10]) +// [.data+0x24F0] DWORD cached OSVERSIONINFOEXW.dwBuildNumber (from memcpy of RtlGetVersion) +// [.data+0x24FC] DWORD cached OS build number (same value, second copy for comparison) + +// --- UnityExplorer module --- +// [.data+0x260C] QWORD once_flag (guards RegisterTab RVA 0x90060) +// [.data+0x2610] QWORD update_fn_ptr = 0x083DC0 (shared no-op stub) +// [.data+0x2618] STRING tab_string = "Unity Explorer" (std::string) +// [.data+0x2638] BYTE enabled = 0 +// [.data+0x2640] BOOL auto_refresh = 0 +// [.data+0x2644] float refresh_interval = 3.0f (0x40400000) +// [.data+0x2648] QWORD* scene_list_begin = NULL +// [.data+0x2650] QWORD* scene_list_end = NULL +// [.data+0x2660] QWORD* scene_list_cap = NULL +// [.data+0x2670] DWORD selected_scene_idx = 0 +// [.data+0x2680] DWORD selected_obj_idx = 0 +// [.data+0x2684] char[0x100] search_filter = "" (zero-filled) +// [.data+0x2784] BOOL inspector_active = 0 +// [.data+0x2788] QWORD inspected_obj_ptr = 0 +// [.data+0x2790] STRING inspected_obj_name = "" (std::string) + +// ============================================================================ +// SECTION 32 — MAGIC CONSTANTS AND IEEE 754 VALUES +// ============================================================================ + +// --- IEEE 754 float constants --- +static_assert(sizeof(float) == 4, "float must be 32-bit"); + +// 0x41F00000 = 30.0f — FreeCam Move Speed default +// 0x3DCCCCCD = 0.1f — FreeCam Move Speed / Roll Speed / FOV Speed step +// 0x42C80000 = 100.0f — FreeCam Roll Speed max; SkillHack CooldownBypass return value +// 0x43FA0000 = 500.0f — FreeCam Move Speed max +// 0x40400000 = 3.0f — UnityExplorer auto-refresh interval default +// 0x3F800000 = 1.0f — HookManager load factor threshold; FreeCam FOV multiplier default +// 0x42960000 = 75.0f — FreeCam Look Sensitivity default +// 0x44415357 = (reinterpret: packed 'WASD' ASCII) — FreeCam default key binding word + +// --- FreeCam default key binding block --- +// Written to [.data+0x2230..0x225E] by FreeCam::RegisterMainTab: +// [+0x2230..0x223F] = [0x1803B34F0] (key config block 1, 16 bytes) +// [+0x2240..0x224F] = [0x1803B35C0] (key config block 2, 16 bytes) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier) +// [+0x2254] = 0x44415357 ('WASD' key mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind word) +// [+0x225E] = 0x60 (backtick key — FreeCam toggle) + +// --- Security cookie --- +// Stack canary magic value (lower 48 bits): 0x2B992DDFA232 +// Full XOR combination of: GetSystemTimeAsFileTime, GetCurrentThreadId, +// GetCurrentProcessId, QueryPerformanceCounter (see Ch.4 / Section 4) +// Checked at RVA 0x0AC6CC by __security_check_cookie (CRT standard) + +// --- Windows version constants --- +// 0x4A61 = 19041 decimal — Windows 10 Build 19041 (20H1) +// Used in PreventScreenshot::OsCheck to select WDA_MONITOR vs WDA_EXCLUDEFROMCAPTURE: +// build < 19041: SetWindowDisplayAffinity(..., 1) // WDA_MONITOR +// build >= 19041: SetWindowDisplayAffinity(..., 0x11) // WDA_EXCLUDEFROMCAPTURE + +// --- Hash constants --- +// FNV-1a 64-bit (used in HookManager hash table): +// Offset basis: 0xCBF29CE484222325ULL +// Prime: 0x00000100000001B3ULL +// (See Section 8 / Ch.8.7 for unrolled implementation at RVA 0x8D555) + +// --- CP_UTF8 --- +// 0xFDE9 = 65001 = CP_UTF8 +// Used in: MultiByteToWideChar calls in OpenConfigFile (0x11EA0), +// SetConsoleOutputCP (startup), UTF8ToWide helper (0x8B4E0) + +// --- Module object sizes --- +// BaseModule object size: 0x30 bytes (used by operator delete in NoOpUpdateStub) +// FPSModule object size: 0xD8 bytes (zeroed by memset 0xAC86A in Initialize) +// PreventScreenshot object size: 0x48 bytes (from vtable dtor stub size arg) +// UnityExplorer state block size: 0x190 bytes (zero-filled in RegisterTab) +// FreeCam state block size: 0xD8 bytes (zeroed in RegisterMainTab) +// HookEntry size: 0x38 bytes (stride in hook_array) +// HookManager singleton size: 0x90 bytes +// ModuleManager registrar stride: 0x60 bytes per slot +// ImGui settings handler size: 0x48 bytes per handler struct +// THREADENTRY32 size: 28 (sizeof: written as r12d = [rbx+0x1C]) +// OSVERSIONINFOEXW size: 0x11C bytes (stack-allocated in OsCheck) + +// --- HookManager array constants --- +// Initial hook array capacity: 0x80 slots +// Shrink threshold: count <= capacity/2 AND count > 0x20 +// Load factor threshold: 1.0f (0x3F800000) — triggers hash table rehash + +// --- SkillHack callback return constants --- +// 0x42C80000 = 100.0f returned by Callback_CooldownBypass (RVA 0x8D500) +// stored at .rdata RVA 0x3B3308 +// Note: prior summary incorrectly stated 0.0; doc confirms 100.0f + +// ============================================================================ +// SECTION 33 — IAT SUPPLEMENTAL ENTRIES (Ch.19 / final resolution) +// ============================================================================ +// Additional IAT entries resolved in Ch.19 not previously in header: +// IAT[0xB1278] VirtualFree KERNEL32 hook manager cleanup +// IAT[0xB1288] VirtualProtect KERNEL32 hook patcher (Ch.8.6) +// IAT[0xB1628] ShowWindow USER32 Settings console toggle visibility +// IAT[0xB1868] fwrite CRT config body (0xEA1B, 0x170D6, 0x3033B, 0x3076D) +// IAT[0xB1870] fclose CRT (0xEAB0, 0x1212F, 0x121A9, 0x170DF) + +// ============================================================================ +// END SUPPLEMENTAL SECTIONS +// ============================================================================ + +// ============================================================================ +// SECTION 34 — FINAL FIVE .DATA ADDRESSES +// ============================================================================ + +// [.data+0x2180] QWORD SetDither update fn ptr = 0x1803B01B0 → 0x83DC0 (no-op stub) +// Written by SetDither::RegisterTab (RVA 0x181810) + +// [.data+0x2307] BYTE End of FPSModule name std::string SSO buffer +// Name "FPS Monitor" occupies [.data+0x22E8]..[.data+0x2307] +// (19 chars + null = 20 bytes; SSO inline storage) + +// [.data+0x237F] BYTE End of PreventScreenshot name std::string SSO buffer +// Name "Prevent Screenshot" occupies [.data+0x2360]..[.data+0x237F] +// +0x28 field = enabled BYTE (checkbox state; drives affinity arg) + +// [.data+0x245C] BYTE g_showPanel — overlay panel visibility flag +// 0 = hidden, 1 = visible +// Toggled by VK_F12 (0x7B) poll at RVA 0x8301A (GetAsyncKeyState) +// Banner shown when hidden: "EF - Cheeto ... Press F12" (RVA 0x3AF258) + +// [.data+0x24D8] QWORD PreventScreenshot HWND list count / tracked window count +// Companion to [.data+0x24D0] (linked list head) +// Used in Update affinity application loop (RVA 0x8AFC0) + + + +# COMPLETE IMPORT TABLE — EF-Cheeto.dll +# All imported DLLs and functions needed for Visual Studio .def / linker +# These must ALL be linked in the VS project + +## KERNEL32.dll (76 functions) + VirtualAlloc + VirtualFree + VirtualProtect + VirtualQuery + GetCurrentProcess + GetCurrentProcessId + GetCurrentThreadId + CreateThread + TerminateThread + SuspendThread + ResumeThread + OpenThread + CloseHandle + GetLastError + GetProcAddress + LoadLibraryA + FreeLibrary + GetModuleHandleA + GetModuleHandleW + FlushInstructionCache + SetThreadContext + GetThreadContext + MultiByteToWideChar + WideCharToMultiByte + GlobalAlloc + GlobalFree + GlobalLock + GlobalUnlock + HeapCreate + HeapAlloc + HeapFree + HeapReAlloc + HeapDestroy + AllocConsole + FreeConsole + GetConsoleMode + SetConsoleMode + GetConsoleWindow + GetConsoleScreenBufferInfo + SetConsoleTextAttribute + SetConsoleOutputCP + SetConsoleTitleA + GetStdHandle + CreateToolhelp32Snapshot + Thread32First + Thread32Next + K32EnumProcessModules + K32GetModuleFileNameExW + Sleep + OutputDebugStringA + GetSystemInfo + DisableThreadLibraryCalls + QueryPerformanceCounter + QueryPerformanceFrequency + GetLocaleInfoA + IsDBCSLeadByte + VerSetConditionMask + GetSystemTimeAsFileTime + IsDebuggerPresent + IsProcessorFeaturePresent + TerminateProcess + UnhandledExceptionFilter + SetUnhandledExceptionFilter + RtlCaptureContext + RtlLookupFunctionEntry + RtlVirtualUnwind + LocalFree + FormatMessageA + GetLocaleInfoEx + AreFileApisANSI + ReleaseSRWLockExclusive + AcquireSRWLockExclusive + SleepConditionVariableSRW + WakeAllConditionVariable + InitializeSListHead + memmove + +## USER32.dll (67 functions) + CreateWindowExW + DestroyWindow + RegisterClassExW + UnregisterClassW + DefWindowProcW + PeekMessageW + TranslateMessage + DispatchMessageW + PostQuitMessage + UpdateWindow + GetClientRect + GetWindowRect + GetWindowLongW + GetWindowLongPtrW + SetWindowLongW + SetWindowLongPtrW + SetWindowPos + ShowWindow + BringWindowToTop + IsIconic + IsWindow + IsWindowVisible + IsWindowUnicode + IsChild + FindWindowA + EnumWindows + GetForegroundWindow + SetForegroundWindow + SetFocus + GetCursorPos + SetCursorPos + GetCapture + SetCapture + ReleaseCapture + GetAsyncKeyState + GetKeyState + GetKeyboardLayout + GetMessageExtraInfo + TrackMouseEvent + ClientToScreen + ScreenToClient + WindowFromPoint + GetDC + ReleaseDC + GetDeviceCaps + CreateSolidBrush + LoadCursorW + LoadIconW + SetCursor + EnumDisplayMonitors + GetMonitorInfoW + MonitorFromWindow + GetSystemMetrics + GetClassNameA + GetWindowThreadProcessId + AdjustWindowRectEx + OpenClipboard + CloseClipboard + EmptyClipboard + GetClipboardData + SetClipboardData + GetPropA + SetPropA + SetLayeredWindowAttributes + SetWindowDisplayAffinity + GetWindowDisplayAffinity + SetProcessDPIAware + +## GDI32.dll/SHELL32.dll (1 functions) + ShellExecuteW + +## imm32.dll (4 functions) + ImmGetContext + ImmReleaseContext + ImmSetCandidateWindow + ImmSetCompositionWindow + +## d3d11.dll (1 functions) + D3D11CreateDeviceAndSwapChain + +## d3dcompiler_47.dll (1 functions) + D3DCompile + +## dwmapi.dll (2 functions) + DwmExtendFrameIntoClientArea + DwmGetWindowAttribute + +## xinput1_4.dll (2 functions) + XInputGetState + XInputGetCapabilities + +## ntdll.dll (2 functions) + RtlGetVersion + RtlVerifyVersionInfo + +## shcore.dll (3 functions) + SetThreadDpiAwarenessContext + SetProcessDpiAwareness + GetDpiForMonitor + +## api-ms-win-crt-*.dll (CRT) (62 functions) + malloc + calloc + free + realloc + memcmp + memcpy + memset + memchr + memmove + strcmp + strncmp + strncpy + strchr + strtod + strtoll + strtoull + atof + tolower + fopen + fclose + fread + fwrite + ftell + fseek + fflush + freopen_s + _wfopen + qsort + localeconv + __stdio_common_vfprintf + __stdio_common_vsprintf + __stdio_common_vsscanf + __acrt_iob_func + ___lc_codepage_func + _errno + _localtime64_s + acosf + ceilf + cosf + fmodf + logf + powf + sinf + sqrtf + _dclass + _dsign + _fdclass + _fdsign + _ldclass + _ldsign + _callnewh + _seh_filter_dll + _configure_narrow_argv + _initialize_narrow_environment + _initialize_onexit_table + _register_onexit_function + _execute_onexit_table + _crt_atexit + _cexit + _initterm + _initterm_e + terminate + +## vcruntime140.dll / vcruntime140_1.dll (11 functions) + __CxxFrameHandler4 + __C_specific_handler + _CxxThrowException + __std_terminate + __std_exception_copy + __std_exception_destroy + __current_exception + __current_exception_context + __std_type_info_destroy_list + _invoke_watson + _purecall + +## msvcp140.dll (5 functions) + _Mtx_lock + _Mtx_unlock + _Xtime_get_ticks + _Query_perf_counter + _Query_perf_frequency diff --git a/IDA/project/docs/input/files2/ef_cheeto_full_imports.md b/IDA/project/docs/input/files2/ef_cheeto_full_imports.md new file mode 100644 index 0000000..dba246f --- /dev/null +++ b/IDA/project/docs/input/files2/ef_cheeto_full_imports.md @@ -0,0 +1,266 @@ +# COMPLETE IMPORT TABLE — EF-Cheeto.dll +# All imported DLLs and functions needed for Visual Studio .def / linker +# These must ALL be linked in the VS project + +## KERNEL32.dll (76 functions) + VirtualAlloc + VirtualFree + VirtualProtect + VirtualQuery + GetCurrentProcess + GetCurrentProcessId + GetCurrentThreadId + CreateThread + TerminateThread + SuspendThread + ResumeThread + OpenThread + CloseHandle + GetLastError + GetProcAddress + LoadLibraryA + FreeLibrary + GetModuleHandleA + GetModuleHandleW + FlushInstructionCache + SetThreadContext + GetThreadContext + MultiByteToWideChar + WideCharToMultiByte + GlobalAlloc + GlobalFree + GlobalLock + GlobalUnlock + HeapCreate + HeapAlloc + HeapFree + HeapReAlloc + HeapDestroy + AllocConsole + FreeConsole + GetConsoleMode + SetConsoleMode + GetConsoleWindow + GetConsoleScreenBufferInfo + SetConsoleTextAttribute + SetConsoleOutputCP + SetConsoleTitleA + GetStdHandle + CreateToolhelp32Snapshot + Thread32First + Thread32Next + K32EnumProcessModules + K32GetModuleFileNameExW + Sleep + OutputDebugStringA + GetSystemInfo + DisableThreadLibraryCalls + QueryPerformanceCounter + QueryPerformanceFrequency + GetLocaleInfoA + IsDBCSLeadByte + VerSetConditionMask + GetSystemTimeAsFileTime + IsDebuggerPresent + IsProcessorFeaturePresent + TerminateProcess + UnhandledExceptionFilter + SetUnhandledExceptionFilter + RtlCaptureContext + RtlLookupFunctionEntry + RtlVirtualUnwind + LocalFree + FormatMessageA + GetLocaleInfoEx + AreFileApisANSI + ReleaseSRWLockExclusive + AcquireSRWLockExclusive + SleepConditionVariableSRW + WakeAllConditionVariable + InitializeSListHead + memmove + +## USER32.dll (67 functions) + CreateWindowExW + DestroyWindow + RegisterClassExW + UnregisterClassW + DefWindowProcW + PeekMessageW + TranslateMessage + DispatchMessageW + PostQuitMessage + UpdateWindow + GetClientRect + GetWindowRect + GetWindowLongW + GetWindowLongPtrW + SetWindowLongW + SetWindowLongPtrW + SetWindowPos + ShowWindow + BringWindowToTop + IsIconic + IsWindow + IsWindowVisible + IsWindowUnicode + IsChild + FindWindowA + EnumWindows + GetForegroundWindow + SetForegroundWindow + SetFocus + GetCursorPos + SetCursorPos + GetCapture + SetCapture + ReleaseCapture + GetAsyncKeyState + GetKeyState + GetKeyboardLayout + GetMessageExtraInfo + TrackMouseEvent + ClientToScreen + ScreenToClient + WindowFromPoint + GetDC + ReleaseDC + GetDeviceCaps + CreateSolidBrush + LoadCursorW + LoadIconW + SetCursor + EnumDisplayMonitors + GetMonitorInfoW + MonitorFromWindow + GetSystemMetrics + GetClassNameA + GetWindowThreadProcessId + AdjustWindowRectEx + OpenClipboard + CloseClipboard + EmptyClipboard + GetClipboardData + SetClipboardData + GetPropA + SetPropA + SetLayeredWindowAttributes + SetWindowDisplayAffinity + GetWindowDisplayAffinity + SetProcessDPIAware + +## GDI32.dll/SHELL32.dll (1 functions) + ShellExecuteW + +## imm32.dll (4 functions) + ImmGetContext + ImmReleaseContext + ImmSetCandidateWindow + ImmSetCompositionWindow + +## d3d11.dll (1 functions) + D3D11CreateDeviceAndSwapChain + +## d3dcompiler_47.dll (1 functions) + D3DCompile + +## dwmapi.dll (2 functions) + DwmExtendFrameIntoClientArea + DwmGetWindowAttribute + +## xinput1_4.dll (2 functions) + XInputGetState + XInputGetCapabilities + +## ntdll.dll (2 functions) + RtlGetVersion + RtlVerifyVersionInfo + +## shcore.dll (3 functions) + SetThreadDpiAwarenessContext + SetProcessDpiAwareness + GetDpiForMonitor + +## api-ms-win-crt-*.dll (CRT) (62 functions) + malloc + calloc + free + realloc + memcmp + memcpy + memset + memchr + memmove + strcmp + strncmp + strncpy + strchr + strtod + strtoll + strtoull + atof + tolower + fopen + fclose + fread + fwrite + ftell + fseek + fflush + freopen_s + _wfopen + qsort + localeconv + __stdio_common_vfprintf + __stdio_common_vsprintf + __stdio_common_vsscanf + __acrt_iob_func + ___lc_codepage_func + _errno + _localtime64_s + acosf + ceilf + cosf + fmodf + logf + powf + sinf + sqrtf + _dclass + _dsign + _fdclass + _fdsign + _ldclass + _ldsign + _callnewh + _seh_filter_dll + _configure_narrow_argv + _initialize_narrow_environment + _initialize_onexit_table + _register_onexit_function + _execute_onexit_table + _crt_atexit + _cexit + _initterm + _initterm_e + terminate + +## vcruntime140.dll / vcruntime140_1.dll (11 functions) + __CxxFrameHandler4 + __C_specific_handler + _CxxThrowException + __std_terminate + __std_exception_copy + __std_exception_destroy + __current_exception + __current_exception_context + __std_type_info_destroy_list + _invoke_watson + _purecall + +## msvcp140.dll (5 functions) + _Mtx_lock + _Mtx_unlock + _Xtime_get_ticks + _Query_perf_counter + _Query_perf_frequency diff --git a/IDA/project/docs/input/files2/ef_cheeto_reconstruction_prompt.md b/IDA/project/docs/input/files2/ef_cheeto_reconstruction_prompt.md new file mode 100644 index 0000000..53af924 --- /dev/null +++ b/IDA/project/docs/input/files2/ef_cheeto_reconstruction_prompt.md @@ -0,0 +1,122 @@ +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed diff --git a/IDA/project/docs/input/files3/ef_cheeto_feed_1_analysis.md b/IDA/project/docs/input/files3/ef_cheeto_feed_1_analysis.md new file mode 100644 index 0000000..8db0eca --- /dev/null +++ b/IDA/project/docs/input/files3/ef_cheeto_feed_1_analysis.md @@ -0,0 +1,3963 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 1/3 +# Feed ALL THREE PARTS before asking reconstruction questions. +# Part 1: Orientation + Full Analysis (prose, pseudocode, tables) + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed +# Part 2: Reconstruction Header (structs, addresses, constants) +# Part 3: Machine Code (hex dumps + raw binary sections) + +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +ANALYSIS DOCUMENT — All 29 Chapters +================================================================================ + +EF-Cheeto.dll (unityexplorer.dll) +Complete Reverse Engineering Report — Final Consolidated Edition +24 Chapters · 11 Registered Modules · Complete Static Reconstruction +February 27, 2026 +# 1. Executive Summary +This document is the complete consolidated reverse engineering analysis of EF-Cheeto.dll (distributed as unityexplorer.dll), spanning twenty-five chapters. It covers all subsystems from infrastructure (thread enumeration, anti-debug, shader compilation, config I/O) through the hook engine, eleven registered cheat modules, the ModuleManager dispatch architecture, GABypass IL2CPP resolver, JSON config schema, and analyses added in later passes: ESPModule Render/Update implementation (Ch. 22), DamageHack ghost feature analysis (Ch. 23), SetDither RenderOverlay body (Ch. 12.5.1), and the Sidebar/Main Panel rendering function (Ch. 25). +IAT base is RVA 0xB1000 (file raw offset 0xAF600). The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows. The binary is fully reverse engineered with no significant undocumented regions remaining. +# 2. Corrected IAT Address Map +Previous analysis used incorrect IAT RVAs derived from objdump -p output. The correct IAT base is RVA 0xB1000 (file raw offset 0xAF600), not the 0x3C2xxx addresses previously listed. The following table gives the correct IAT RVAs and all call sites. +Function +IAT RVA +DLL +Call Sites (VA) +SuspendThread +0xB1050 +KERNEL32.dll +0x1800A9861 +ResumeThread +0xB1058 +KERNEL32.dll +0x1800A9964 (×37 total) +GetThreadContext +0xB1068 +KERNEL32.dll +0x1800A988B +SetThreadContext +0xB1078 +KERNEL32.dll +0x1800A993C +CreateToolhelp32Snapshot +0xB1160 +KERNEL32.dll +0x1800A970B +Thread32First +0xB11B0 +KERNEL32.dll +0x1800A972F +Thread32Next +0xB11A8 +KERNEL32.dll +0x1800A97DD +OpenThread +0xB11D0 +KERNEL32.dll +0x1800A9849 (×38 total) +VirtualProtect +0xB1288 +KERNEL32.dll +0x1800A9AFC, 0x1800A9B6C +FlushInstructionCache +0xB1070 +KERNEL32.dll +0x1800A9B81 +GetCurrentProcess +0xB1270 +KERNEL32.dll +0x1800A9B72 +IsDebuggerPresent +0xB11E8 +KERNEL32.dll +0x1800AC67B +SetUnhandledExceptionFilter +0xB1200 +KERNEL32.dll +0x1800AC698 +UnhandledExceptionFilter +0xB1208 +KERNEL32.dll +0x1800AC6A3 +IsProcessorFeaturePresent +0xB11F0 +KERNEL32.dll +0x1800AC5A2 +TerminateProcess +0xB11F8 +KERNEL32.dll +0x1800AC628 (via int 29h) +D3DCompile +0xB1000 +D3DCOMPILER_47 +0x180054E77, 0x180055069 +_wfopen +0xB1888 +CRT +0x180011F93 +fwrite +0xB1868 +CRT +0x18000EA1B, 0x1800170D6, 0x18003033B, 0x18003076D +fread +0xB1870 +CRT +(called via 0x180011EA0 helper) +fclose +0xB1878 +CRT +0x1800170DF, 0x180030776 +SetWindowDisplayAffinity +0xB1460 +USER32.dll +0x18008B48F +LoadLibraryA +0xB10E0 +KERNEL32.dll +0x180055F57, 0x1800585AE (×4) +GetProcAddress +0xB1088 +KERNEL32.dll +0x180055F7E, 0x180055F92 (×7) +VirtualAlloc +0xB11A0 +KERNEL32.dll +0x1800AA566, 0x1800AA607 +VirtualFree +0xB1278 +KERNEL32.dll +0x180081D5B, 0x1800AA6E1 +# 3. Thread Enumeration and Suspension +Thread enumeration serves a critical role in safe hook installation: the cheat must suspend all Unity render/game threads before patching code bytes, then resume them after patching, to prevent race conditions. This subsystem uses two cooperating functions. +## 3.1 Thread Collection Function (0x1800A96B0–0x1800A9A1C) +This function collects all thread IDs for the current process using a Toolhelp32 snapshot, filtering out the calling thread and storing results in a caller-provided vector. The function signature is: +int CollectProcessThreads( +DWORD* out_vec, // RCX: vector { begin, end, capacity } +DWORD current_pid, // RDX: passed to CreateToolhelp32Snapshot +DWORD current_tid // R8d: thread to exclude (caller's thread) +Key sequence: +// 0x1800A96B0: Prologue, save RSI/RDI/RBX/R12-R15, allocate 0x530 bytes stack +// 0x1800A96E7: xor ebx, ebx (thread count = 0) +// 0x1800A96F8: mov [rcx], rbx; mov [rcx+8], rbx (init empty vector) +// 0x1800A9701: lea ecx, [rbx+4] = TH32CS_SNAPTHREAD = 4 +// 0x1800A970B: call [IAT:CreateToolhelp32Snapshot](dwFlags=4, pid=r15) +// 0x1800A9711: mov r14, rax (hSnapshot = result) +// 0x1800A9714: cmp rax, -1 → je fail (INVALID_HANDLE_VALUE) +// 0x1800A971E: lea r12d, [rbx+0x1C] (sizeof THREADENTRY32 = 28) +// 0x1800A9725: lea rdx, [rsp+0x30] (THREADENTRY32 buffer) +// 0x1800A972A: mov [rsp+0x30], r12d (te32.dwSize = 28) +// 0x1800A972F: call [IAT:Thread32First](hSnapshot, &te32) +// --- LOOP --- +// 0x1800A9740: cmp [rsp+0x30], 0x10 (check th32OwnerProcessID offset) +// 0x1800A974B: call [IAT:GetCurrentProcessId] +// 0x1800A9751: cmp [rsp+0x3C], eax (te32.th32OwnerProcessID == GetCurrentProcessId?) +// 0x1800A9755: jne skip (skip threads not in our process) +// 0x1800A9757: call [IAT:GetCurrentThreadId] +// 0x1800A975D: cmp [rsp+0x38], eax (te32.th32ThreadID == calling thread?) +// 0x1800A9761: je skip (exclude caller's thread) +// 0x1800A9763: mov rdx, [rdi] (vector data pointer) +// 0x1800A9778: call [IAT:VirtualAlloc] or HeapReAlloc if needed +// 0x1800A97CA: mov [rdx+rcx*4], eax (store thread ID) +// 0x1800A97CD: incl [rdi+0xC] (vector count++) +// 0x1800A97DD: call [IAT:Thread32Next](hSnapshot, &te32) +// 0x1800A97E3: test eax, eax → jne loop +// 0x1800A97EB: call [IAT:GetLastError] → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0x1800A9815: call [IAT:CloseHandle](hSnapshot) +Return value: 0 on success (ESI = 0 → je path), 9 on error (EBX = 9 → mov eax, 9). +## 3.2 Thread Suspend/Resume Function (0x1800A9A20–0x1800A9A98) +Iterates the thread ID vector and either suspends or resumes each thread. Called before and after code patching. +void SuspendOrResumeThreads(DWORD* id_vector, int action) { +// action: 0 = resume, 1 = suspend +for (int i = 0; i < id_vector->count; i++) { +DWORD tid = id_vector->data[i]; +if (tid == 0) continue; +HANDLE hThread = OpenThread(0x5A, FALSE, tid); // THREAD_SUSPEND+CONTEXT +if (!hThread) continue; +if (action == 0) ResumeThread(hThread); +else SuspendThread(hThread); +CloseHandle(hThread); +} +// free id_vector->data via HeapFree +} +## 3.3 Code Patcher (0x1800A9A9C–0x1800A9BC3) +Writes trampoline/hook bytes at a target address with full thread-safety. Called from SkillHack and other modules during hook installation. +int PatchCode(int hook_index, int is_jmp) { +// Lookup hook entry: base = g_hookTable[hook_index * 0x38] +void* target = hook_entry->target_va; +void* jump_dest = hook_entry->callback; // or target-5 if is_short_jmp +DWORD old_protect; +// First VirtualProtect: make target page EXECUTE_READWRITE (0x40) +VirtualProtect(target, patch_size, PAGE_EXECUTE_READWRITE, &old_protect); +if (is_jmp) { +// Write E9 JMP rel32 +*(BYTE*)target = 0xE9; +*(DWORD*)(target+1) = (DWORD)jump_dest - (DWORD)target - 5; +if (hook_entry->flags & 1) +*(WORD*)orig_ptr = 0xF9EB; // short jmp back +} else { +// Copy original bytes (stub) +*(DWORD*)target = hook_entry->orig_bytes_dword; +if (hook_entry->flags & 1) { +*(WORD*)(target+4) = hook_entry->orig_word; +*(BYTE*)(target+6) = hook_entry->orig_byte; +} else { +*(BYTE*)(target+4) = hook_entry->orig_byte; +} +} +// Second VirtualProtect: restore original protection +VirtualProtect(target, patch_size, old_protect, &old_protect); +FlushInstructionCache(GetCurrentProcess(), target, patch_size); +// Update flags: toggle enable/jmp bits in hook_entry->flags +return 0; // success +} +# 4. Anti-Debug and Exception Handling +The binary contains two related security functions: a structured exception handler setup that uses IsDebuggerPresent, and a stack security cookie verifier. +## 4.1 Exception Handler Setup (0x1800AC580–0x1800AC6CA) +This function is the C runtime __security_check_cookie and SEH initializer. It is called during DLL initialization (DllMain) and during first-chance exception dispatching. +// 0x1800AC580: CRT security init function +// ecx = fault code (passed in from caller) +// Check IsProcessorFeaturePresent(0x17 = PF_FASTFAIL_AVAILABLE) +call [IAT:IsProcessorFeaturePresent](0x17) +test eax, eax +je skip_int29 +int 29h // Fast fail - terminate without SEH if supported +skip_int29: +call sub_1800AC574 // __security_check_cookie helper +// Set up EXCEPTION_RECORD and CONTEXT for RtlCaptureContext +call RtlCaptureContext // [IAT:0xB1220] +call RtlLookupFunctionEntry // [IAT:0xB1218] - find handler +call RtlVirtualUnwind // [IAT:0xB1210] - unwind frame +// Build EXCEPTION_RECORD: +movl [rsp+50h], 0x40000015 // ExceptionCode = STATUS_FATAL_APP_EXIT +movl [rsp+54h], 1 // ExceptionFlags = EXCEPTION_NONCONTINUABLE +call [IAT:IsDebuggerPresent] // 0x1800AC67B +mov ebx, eax // save result +call [IAT:SetUnhandledExceptionFilter](NULL) // remove any handler +call [IAT:UnhandledExceptionFilter](&record) +test eax, eax +jne done +cmp ebx, 1 // was debugger present? +je done +lea ecx, [eax+3] +call __report_gsfailure // terminate +Note: IsDebuggerPresent is NOT used as an anti-cheat measure; it is part of the MSVC CRT __security_check_cookie fast-fail path. The binary does not actively attempt to detect or evade debuggers — it simply invokes standard MSVC security cookie failure reporting. +## 4.2 Security Canary Verifier (0x1800AC6CC–0x1800AC77B) +This is the standard MSVC __security_check_cookie function. It compares the stack cookie against a magic constant, then triggers a fast-fail if mismatch is detected. +// 0x1800AC6CC: __security_check_cookie +// rcx = stack cookie value to verify +mov rax, [__security_cookie] // load expected cookie (initialized at startup) +mov rbx, 0x2B992DDFA232 // partial expected value (lower 48 bits) +cmp rax, rbx +jne fail // mismatch → security violation +// Derive additional check from: +// GetSystemTimeAsFileTime, GetCurrentThreadId, GetCurrentProcessId, +// QueryPerformanceCounter, combined via XOR and shift +call [IAT:GetSystemTimeAsFileTime] +call [IAT:GetCurrentThreadId] +xor -0x10(%rbp), rax +call [IAT:GetCurrentProcessId] +xor -0x10(%rbp), rax +call [IAT:QueryPerformanceCounter] +// ... XOR operations combining all values +// Mask to 0xFFFFFFFFFFFF (48 bits) +// Compare with stored cookie — mismatch → crash +// This is 100% MSVC runtime security, NOT an anti-cheat check +# 5. HLSL Shader Compilation (D3DCompile) +The cheat overlay uses two shaders compiled at runtime via D3DCompile from D3DCOMPILER_47.dll. Both shaders are the standard ImGui Direct3D11 backend shaders embedded verbatim in .rdata. They are compiled in the D3D11 initialization function (0x180054DC0–0x1800551E8) which is called during the Present hook setup. +## 5.1 Vertex Shader +// Source at RVA 0x3AE660, length = 0x2DD (733 bytes) +// Compilation: D3DCompile(src, 0x2DD, NULL, NULL, NULL, "main", "vs_4_0", 0, 0, ...) +cbuffer vertexBuffer : register(b0) { +float4x4 ProjectionMatrix; +}; +struct VS_INPUT { +float2 pos : POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +PS_INPUT main(VS_INPUT input) { +PS_INPUT output; +output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +output.col = input.col; +output.uv = input.uv; +return output; +} +## 5.2 Pixel Shader +// Source at RVA 0x3AE940, length = 0x191 (401 bytes) +// Compilation: D3DCompile(src, 0x191, NULL, NULL, NULL, "main", "ps_4_0", 0, 0, ...) +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +sampler sampler0; +Texture2D texture0; +float4 main(PS_INPUT input) : SV_Target { +float4 out_col = input.col * texture0.Sample(sampler0, input.uv); +return out_col; +} +## 5.3 Shader Initialization Sequence (0x180054DC0) +// Prologue: save R14-R15, allocate 0x220 stack +// Load g_D3DState from [g_Config+0xD8] into R14 +// Check if already initialized: cmp (*r14), null +je skip_init +// Call sub_0x1800551F0 (create vertex/index buffers) +// === Compile Vertex Shader === +lea rcx, [rip+0x1803AE660] // HLSL source ptr +mov edx, 0x2DD // source length +xor r8d, r8d // pSourceName = NULL +xor r9d, r9d // pDefines = NULL +mov [rsp+20h], r15 // pInclude = NULL +lea rax, [0x1803AEADC] // 'main' string +mov [rsp+28h], r12 // pInclude (NULL) +mov [rsp+30h], rax // pEntrypoint = 'main' +lea rax, [0x1803AEAD4] // 'vs_4_0' +mov [rsp+38h], r15d // Flags1 = 0 +mov [rsp+40h], r15d // Flags2 = 0 +mov [rsp+48h], &ppVSCode // output blob ptr +mov [rsp+50h], r15 // ppErrorBlob = NULL +call [IAT:D3DCompile] +js fail +// Get VS blob pointer, call ID3DBlob::GetBufferPointer/GetBufferSize +// Then: call ID3D11Device::CreateVertexShader via vtable slot[0x20/8] +// Create input layout via vtable slot[0x58/8] +// Create constant buffer (ProjectionMatrix) via vtable slot[0x60/8] +// === Compile Pixel Shader === +lea rcx, [rip+0x1803AE940] // PS HLSL source +mov edx, 0x191 // PS source length +// ... same parameters pattern ... +// pEntrypoint = 'main', target = 'ps_4_0' +call [IAT:D3DCompile] +js fail +// Create pixel shader via vtable slot[0x78/8] (CreatePixelShader) +// Create sampler state via vtable slot[0x78/8] on device +// Create blend state (alpha blending) with blend ops +// Create depth stencil state +// Create rasterizer state +# 6. Configuration File I/O +Configuration is read and written using a helper function (0x180011EA0) that converts UTF-8 paths to wide-char then calls _wfopen. Callers pass different file mode strings ('rb' for read, 'wt' for write) to the same function. +## 6.1 File Open Helper (0x180011EA0–0x180012043) +FILE* OpenConfigFile(const char* path_utf8, const char* mode_utf8) { +// rcx = path_utf8, rdx = mode_utf8 +// Get length of path: MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0) +int path_len = MultiByteToWideChar(0xFDE9, 0, path, -1, NULL, 0); // CP_UTF8=65001=0xFDE9 +// Get length of mode string +int mode_len = MultiByteToWideChar(0xFDE9, 0, mode, -1, NULL, 0); +// Allocate wide char buffer (stack if small enough, heap if > 0x104 chars) +if (path_len + mode_len > 0x104) +wbuf = malloc((path_len + mode_len) * 2); +else +wbuf = alloca((path_len + mode_len) * 2); +wchar_t* wpath = wbuf; +wchar_t* wmode = wbuf + path_len; +// Convert path to wide +MultiByteToWideChar(0xFDE9, 0, path, -1, wpath, path_len); +// Convert mode to wide +MultiByteToWideChar(0xFDE9, 0, mode, -1, wmode, mode_len); +// Open file +FILE* fp = _wfopen(wpath, wmode); +if (heap_buf) free(heap_buf); +return fp; +} +## 6.2 Config File Mode Strings +Two mode strings are stored in .rdata at consecutive addresses: +RVA +String +Usage +0x3AD590 +'rb' +Config READ - binary read mode +0x3AD594 +'wt' +Config WRITE - text write mode (ImGui ini) +## 6.3 Config Read Callers +The config file open helper is called from two read contexts and two write contexts: +Caller VA +Func Range +Mode +Data Source / Purpose +0x1800170B9 +0x17078-0x172CA +'wt' +Serialize ImGui window positions/sizes to ini file (ImGui_ImplDX11 save) +0x180030750 +0x30620-0x307A0 +'wt' +Write g_Config state to JSON file on module disable/exit +(via fread) +0x302D2-0x30348 +'rb' +Read JSON config on startup, populate g_Config fields +0x18000EA1B +0xE9F4-0xEA33 +n/a +fwrite to stdout/console (debug output, size=1) +## 6.4 Config Write Function (0x180030620) +void SaveConfig(ConfigState* state) { +// Check state->enabled_flag [rbx+0x2900] +// Load state->file_path pointer [rbx+0x50] +// Call sub_0x180030A90 (build file path string) +// Call OpenConfigFile(path, 'wt') → returns FILE* fp +// Serialize config to string via sub_0x180012050 +// fwrite(config_string, 1, string_length, fp) +// fclose(fp) +// Also handles periodic auto-save: +// xmm0 = [rbx+0x2904] (auto-save timer) +// if (timer > 0) { timer -= delta_time } +// When timer expires: rebuild path, re-open, write again +} +# 7. WndProc Handler and Hotkey Dispatch +The WndProc callback is registered at VA 0x1800826A0 during window class creation (RegisterClassExW). It is the Win32 message handler for the overlay window and handles three specific messages before deferring all others to ImGui's built-in handler. +## 7.1 WndProc Function (0x1800826A0) +Signature: LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// Step 1: Pass ALL messages to ImGui first +if (g_ImGuiCtx != NULL) { +// ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam) +// [rsp+0x20] = g_ImGuiCtx+0x30 +LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +if (r != 0) return 1; // ImGui consumed the message +} +switch (msg) { +case WM_DESTROY (0x0002): +PostQuitMessage(0); +return 0; +case WM_SIZE (0x0005): +// Ignore minimize (SIZE_MINIMIZED = 1) +if (g_pSwapChain != NULL && wParam != 1) { +// Free existing render target +if (g_pRenderTargetView) { +g_pRenderTargetView->Release(); // vtable[0x10] +g_pRenderTargetView = NULL; +} +// Resize swap chain buffers +// pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), 0, 0) +g_pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), +DXGI_FORMAT_UNKNOWN, 0); // vtable[0x68] +// Recreate D3D11 resources (render target, shaders, etc.) +HookInstall(); // 0x1800825B0 +} +return 0; +case WM_SYSCOMMAND (0x0112): +// Suppress SC_KEYMENU (ALT key activating system menu) +if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +break; +default: +// Forward to DefWindowProcW via ImGui_ImplWin32_WndProcHandler +return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +} +return 0; +} +## 7.2 Message Dispatch Table +WM_ Code +Value +Action +Notes +WM_DESTROY +0x0002 +PostQuitMessage(0) +Triggers clean shutdown of message loop +WM_SIZE +0x0005 +ResizeBuffers + HookInstall() recreate +Skipped if wParam==SIZE_MINIMIZED(1) +WM_SYSCOMMAND +0x0112 +Return 0 if SC_KEYMENU (0xF100) +Suppresses ALT-key menu flash on overlay +(all others) +- +Defer to ImGui_ImplWin32_WndProcHandler +ImGui handles mouse/keyboard/focus/IME +## 7.3 F12 Hotkey — Panel Toggle +The overlay panel toggle is NOT processed inside WndProc. It is polled via GetAsyncKeyState in the per-frame Present hook loop at VA 0x18008301A, which is part of the ModuleManager main render function (0x180082FC0). +// Inside ModuleManager render loop (0x180082FC0), called each Present() frame: +// Poll F12 key (VK_F12 = 0x7B) +SHORT keyState = GetAsyncKeyState(0x7B); // VK_F12 +if (keyState & 0x1) { +// Key was pressed since last call — toggle panel visibility +// Static init guard pattern (MSVC thread-safe static) +// g_showPanel (.data+0x245C) = !g_showPanel +g_Config.show_panel ^= 1; // [.data+0x245C] toggle +} +// Banner string shown in game window title / tray when panel is hidden: +// 'EF - Cheeto Press F12 to show panel' (RVA 0x3AF258) +Address +Description +0x18008301A +GetAsyncKeyState(VK_F12=0x7B) call — panel toggle poll +.data+0x245C +g_showPanel flag (BYTE): 0=hidden, 1=visible +RVA 0x3AF258 +Banner string 'EF - Cheeto ... Press F12 to show panel' +0x1800826A0 +WndProc callback registered via RegisterClassExW +0x180057720 +ImGui_ImplWin32_WndProcHandler (handles all ImGui keyboard/mouse) +0x1800825B0 +HookInstall / D3D11 resource recreation (called on WM_SIZE) +## 7.4 Module Hotkeys +A dedicated hotkey error handler exists at 0x1800AECE0, referenced by the string '[ERROR] Failed to process hotkeys for module'. This function is an exception handler — it is called if a module's hotkey processing throws. Individual module hotkey configurations are stored in the per-module state structs and dispatched by the ModuleManager loop, not in WndProc. +# 8. Hook Manager Internals +The hook manager is a global singleton initialized lazily via an MSVC thread-safe static at 0x180081B00. It manages a flat array of hook entries, a hash table for fast lookup by target address, and a spinlock for thread safety. All four hook API functions (CreateHook, RemoveHook, EnableHook, GetHookInfo) acquire the spinlock at entry and release it on every exit path. +## 8.1 Singleton Memory Layout +The singleton is stored at .data+0x2470 (VA 0x1803C7470). The structure is 0x90 bytes, zero-initialized on first call. +Offset +Type +Field +Description ++0x00 +QWORD* +hook_array +Pointer to flat array of hook entries (0x38 bytes each) ++0x08 +DWORD +hook_capacity +Allocated slot count for hook_array ++0x0C +DWORD +hook_count +Number of active hooks currently installed ++0x10 +QWORD* +hash_buckets +Pointer to hash table bucket array (linked list heads) ++0x18 +DWORD +bucket_count +Number of hash buckets (power of 2, initial=8) ++0x1C +DWORD +bucket_mask +hash_mod mask = bucket_count*2 - 1 ++0x20 +QWORD* +free_list_head +Head of freed/recycled hook slot free list ++0x28 +float +load_factor +Hash table load factor threshold (0x3f800000 = 1.0f) ++0x30 +BYTE +initialized +Set to 0 after init, prevents double-init +.data+0x1E88 +DWORD +spinlock +Global spinlock DWORD; 0=free, 1=held +## 8.2 Hook Entry Structure (0x38 bytes) +Each entry in the hook_array is 0x38 bytes. The hook array grows dynamically; initial capacity is 0x80 slots allocated via the IAllocator at .data+0x1E90. +Offset +Type +Field +Description ++0x00 +QWORD +target_va +Virtual address of the hooked IL2CPP function ++0x08 +QWORD +callback_va +Virtual address of the replacement/detour function ++0x10 +QWORD +trampoline_va +VirtualAlloc'd trampoline (original bytes + JMP back) ++0x18 +DWORD +orig_bytes_0_3 +Saved original 4 bytes at target (for restore) ++0x1C +WORD +orig_bytes_4_5 +Saved original bytes 4–5 at target ++0x1E +BYTE +orig_byte_6 +Saved original byte 6 at target ++0x20 +BYTE +flags +Bit 0: has_far_jmp (6-byte JMP); Bit 1: enabled; Bit 2: suspended ++0x24 +DWORD +flags2 +Lower nibble: hook type (0=near JMP, 1=far) ++0x28 +QWORD +hash_next +Next entry pointer in hash chain (for collision chaining) ++0x30 +QWORD +reserved +Padding / future use +## 8.3 Spinlock (0x1800A9C88) +All four hook API functions call the spinlock acquire function at 0x1800A9C88 on entry. Release is done inline via XCHG [.data+0x1E88], 0 at the end of each function. +// Spinlock acquire — 0x1800A9C88 +// Uses LOCK CMPXCHG on .data+0x1E88 (global DWORD spinlock) +void AcquireSpinlock() { +DWORD backoff = 0; +while (true) { +DWORD expected = 0; +// LOCK CMPXCHG [.data+0x1E88], 1 +if (InterlockedCompareExchange(&g_spinlock, 1, 0) == 0) +return; // acquired +// Exponential backoff: if backoff < 32, SwitchToThread(0); else Sleep(1) +backoff += 1; +if (backoff < 32) +SwitchToThread(); // IAT 0x1800B1148 +else +Sleep(1); +} +} +// Spinlock release — inline in all callers +// XCHG [.data+0x1E88], ebx (where ebx=0, atomic store 0) +## 8.4 CreateHook (0x1800A9CC8) +Installs a new hook. Takes target VA (rcx), callback VA (rdx), and optional out_trampoline pointer (r8). Returns 0 on success, error code otherwise. +// CreateHook(void* target, void* callback, void** out_trampoline) -> int +// RVA 0x0A9CC8 +int CreateHook(void* target, void* callback, void** out_trampoline) { +AcquireSpinlock(); // 0x1800A9C88 +// Validate hook manager initialized +if (g_hookMgr.allocator == NULL) return 2; // MH_ERROR_NOT_INITIALIZED +// Validate target and callback are executable +if (!IsExecutable(target)) return 7; // MH_ERROR_NOT_EXECUTABLE +if (!IsExecutable(callback)) return 7; +// Check if hook already exists for this target +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +if (i == -1) continue; +return 3; // MH_ERROR_ALREADY_CREATED +} +} +// Allocate a trampoline buffer near the target +TrampolineSlot* slot = AllocTrampolineSlot(target); // 0x1800A960C +if (!slot) return 9; // MH_ERROR_MEMORY_ALLOC +// Build trampoline: copy prologue bytes + write JMP back +HookEntry entry = {}; +if (!BuildTrampoline(target, callback, slot, &entry)) return 8; +// Fill hook entry fields +entry.target_va = target; // [r8+0x00] +entry.callback_va = callback; // [r8+0x08] (from [rsp+0x28]) +entry.trampoline_va = slot->code; // [r8+0x10] +// Save original bytes for unhook restore +if (entry.flags & 1) { // far JMP (6-byte) +entry.orig_bytes_0_3 = *(DWORD*)(target - 5); +entry.orig_bytes_4_5 = *(WORD*) (target - 1); +entry.orig_byte_6 = *(BYTE*) (target + 1); +} else { // near JMP (5-byte) +entry.orig_bytes_0_3 = *(DWORD*)target; +entry.orig_byte_6 = *(BYTE*)(target + 4); +} +if (out_trampoline) *out_trampoline = slot->code; +ReleaseSpinlock(); // XCHG [.data+0x1E88], 0 +return 0; // MH_OK +} +## 8.5 RemoveHook (0x1800A9E8C) +Removes an installed hook by target address. If the hook is enabled, it is disabled first (original bytes restored). The entry is removed from the array by swapping with the last element. The array is shrunk by half if utilization drops below 50% and count > 0x20. +// RemoveHook(void* target) -> int +// RVA 0x0A9E8C +int RemoveHook(void* target) { +AcquireSpinlock(); +if (g_hookMgr.allocator == NULL) return 2; +// Linear search for target in hook array (stride 0x38) +int idx = -1; +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +idx = i; break; +} +} +if (idx == -1) return 4; // MH_ERROR_NOT_CREATED +HookEntry* entry = &g_hookMgr.hook_array[idx]; +// If hook is currently enabled, disable it first (restore original bytes) +if (entry->flags & 0x2) { +GetHookInfo(idx, 0, ...); // 0x1800A96B0 +EnableHook(idx, 0); // 0x1800A9A9C — restore original bytes +SuspendOtherThreads(...); // 0x1800A9A20 — thread safety +} +// Free trampoline memory +FreeSlot(entry->trampoline_va); // 0x1800AA684 +// Compact array: move last entry into freed slot +int last = g_hookMgr.hook_count - 1; +if (idx < last) { +// memmove: copy 0x38 bytes from hook_array[last] to hook_array[idx] +// (3x movups xmm0 + movsd for full 0x38-byte copy) +hook_array[idx] = hook_array[last]; +} +g_hookMgr.hook_count--; +// Shrink array if count <= capacity/2 and count > 0x20 +if (g_hookMgr.hook_capacity / 2 >= 0x20 && +g_hookMgr.hook_count <= g_hookMgr.hook_capacity / 2) { +realloc(hook_array, (capacity/2) * 0x38); +g_hookMgr.hook_capacity /= 2; +} +ReleaseSpinlock(); +return 0; +} +## 8.6 EnableHook / PatchCode (0x1800A9A9C) +Patches or unpatches the target function's first bytes. Suspends all other threads during the write using VirtualProtect + WriteProcessMemory, then resumes them. Handles both near (5-byte E9 JMP) and far (6-byte FF25 indirect JMP) hook types. +// EnableHook(int hook_idx, BOOL enable) -> int +// RVA 0x0A9A9C +int EnableHook(int hook_idx, BOOL enable) { +HookEntry* e = &g_hookMgr.hook_array[hook_idx * 0x38]; +// Determine patch target and size +BOOL far_jmp = e->flags & 0x1; // bit 0: uses 6-byte far JMP +void* patch_target = far_jmp ? (e->target_va - 5) : e->target_va; +SIZE_T patch_size = far_jmp ? 7 : 5; // [rcx*2 + 5] +// VirtualProtect(patch_target, patch_size, PAGE_EXECUTE_READWRITE, &old) +VirtualProtect(patch_target, patch_size, 0x40, &old_protect); +if (enable) { +// Write JMP hook: +*(BYTE*)patch_target = 0xE9; // near JMP opcode +*(DWORD*)(patch_target+1) = +(DWORD)(e->callback_va - (QWORD)patch_target - 5); +if (far_jmp) { +// Also patch 2 bytes before target_va with short JMP back +*(WORD*)(e->target_va) = 0xF9EB; // JMP -5 (back to patch_target) +} +} else { +// Restore original bytes +*(DWORD*)patch_target = e->orig_bytes_0_3; +if (far_jmp) { +*(WORD*) (patch_target+4) = e->orig_bytes_4_5; +*(BYTE*) (patch_target+6) = e->orig_byte_6; +} else { +*(BYTE*) (patch_target+4) = (BYTE)e->orig_bytes_4_5; +} +} +// Restore page protection +VirtualProtect(patch_target, patch_size, old_protect, &old_protect); +// Flush instruction cache +FlushInstructionCache(GetCurrentProcess(), patch_target, patch_size); +// Update flags: set/clear enabled bit (bit 1) and suspended bit (bit 2) +// Bit manipulation: (enable<<2) XOR flags, AND 0x2, XOR flags, XOR enable_bit +e->flags = (e->flags & ~0x6) | ((enable ? 0x2 : 0x0)); +return 0; // MH_OK +} +## 8.7 FNV-1a Hash Implementation +The hash table uses FNV-1a (Fowler–Noll–Vo) 64-bit hashing to map target VA pointers to hash bucket indices. The compiler has unrolled the byte loop into 8 sequential XOR+MUL pairs operating on each byte of the 8-byte pointer. +// FNV-1a 64-bit hash of a pointer value (unrolled, 0x18008D555) +// r11 = target_va (8 bytes to hash) +// r10 = FNV prime = 0x00000100000001B3 +// r9 = FNV offset = 0xCBF29CE484222325 (init value) +uint64_t FNV1a_64(uint64_t target_va) { +uint64_t hash = 0xCBF29CE484222325ULL; // FNV offset basis +uint64_t prime = 0x00000100000001B3ULL; // FNV prime +// Byte 0 (bits 0-7) +hash ^= (uint8_t)(target_va >> 0); hash *= prime; +// Byte 1 (bits 8-15) +hash ^= (uint8_t)(target_va >> 8); hash *= prime; +// Byte 2 (bits 16-23) +hash ^= (uint8_t)(target_va >> 16); hash *= prime; +// Byte 3 (bits 24-31) +hash ^= (uint8_t)(target_va >> 24); hash *= prime; +// Byte 4 (bits 32-39) +hash ^= (uint8_t)(target_va >> 32); hash *= prime; +// Byte 5 (bits 40-47) +hash ^= (uint8_t)(target_va >> 40); hash *= prime; +// Byte 6 (bits 48-55) +hash ^= (uint8_t)(target_va >> 48); hash *= prime; +// Byte 7 (bits 56-63) +hash ^= (uint8_t)(target_va >> 56); hash *= prime; +// Map to bucket index +uint64_t bucket_idx = hash & bucket_mask; // [r8+0x48] +bucket_idx += bucket_idx; // *2 for pointer-sized bucket entries +return bucket_idx; +} +// Bucket lookup in hash chain: +// head = hash_buckets[bucket_idx] // [rcx + r9*8 + 0x00] +// sentinel = hash_buckets[bucket_idx + 1] // [rcx + r9*8 + 0x08] +// while (node != sentinel): +// if node->target_va == target: return node +// node = node->hash_next +## 8.8 Hook Manager Key Addresses +Address +Function / Field +Notes +0x1800A9C88 +AcquireSpinlock() +LOCK CMPXCHG loop with SwitchToThread/Sleep backoff +0x1800A9CC8 +CreateHook(target, cb, tramp) +Validates, searches array, builds trampoline, patches +0x1800A9E8C +RemoveHook(target) +Finds by linear search, disables if live, frees trampoline, compacts +0x1800A9A9C +EnableHook(idx, enable) +VirtualProtect + write JMP/restore + FlushInstructionCache +0x1800A96B0 +GetHookInfo(idx, ...) +Reads hook entry fields into caller-supplied buffer +0x1800A960C +AllocTrampolineSlot(target) +Finds or allocates VirtualAlloc page near target +0x1800AA684 +FreeTrampolineSlot(tramp) +Returns slot to free list +.data+0x1E88 +g_spinlock (DWORD) +Global spinlock; acquired via CMPXCHG, released via XCHG +.data+0x1E90 +g_allocator (QWORD*) +IAllocator vtable pointer used by hook manager +.data+0x2470 +g_hookMgr (struct, 0x90B) +Hook manager singleton base address +.data+0x2480 +hook_array (QWORD*) +Flat array of 0x38-byte hook entries +.data+0x27E0 +hook_array (mirror ptr) +Second reference to hook_array base +.data+0x27EC +hook_count (DWORD) +Number of currently installed hooks +0x18008D555 +FNV-1a hash body +Unrolled 8-byte XOR/MUL loop, prime=0x100000001B3 +# 9. ESPModule State Layout and Color Table Defaults +The ESPModule state struct is stored at .data+0x1F70 (VA 0x1803C6F70). It is initialized by the lazy singleton at 0x180083E00, which zero-initializes all fields, sets the module name, wires up both vtable pointers, writes boolean defaults for the eight display flags, and loads 12 RGBA color slots from .rdata constants via MOVDQA into 16-byte-aligned slots starting at state+0x40. +## 9.1 ESPModule State Struct Layout +Offset +Type +Field +Default ++0x00 +QWORD* +vtable[0] (init thunk) +0x1803AF9E0 ++0x08 +str* +module_name (std::string) +'ESPModule' ++0x28 +BYTE +enabled +0 (off) ++0x30 +DWORD +max_dist +0x12C = 300 (integer) ++0x34 +BYTE +show_monsters +1 (true) ++0x35 +BYTE +show_npc +1 (true) ++0x36 +BYTE +show_friendly +1 (true) ++0x37 +BYTE +show_puzzles +1 (true) ++0x38 +BYTE +show_all +0 (false) ++0x39 +BYTE +show_distance +1 (true) ++0x3A +BYTE +show_name +1 (true) ++0x3B +BYTE +show_type +0 (false) ++0x3C +DWORD +(alignment padding) +- ++0x40 +float[4] +color[0] RGBA +see table below ++0x50 +float[4] +color[1] RGBA +see table below ++0x60 +float[4] +color[2] RGBA +see table below ++0x70 +float[4] +color[3] RGBA +see table below ++0x80 +float[4] +color[4] RGBA +see table below ++0x90 +float[4] +color[5] RGBA +see table below ++0xA0 +float[4] +color[6] RGBA +see table below ++0xB0 +float[4] +color[7] RGBA +see table below ++0xC0 +float[4] +color[8] RGBA +see table below ++0xD0 +float[4] +color[9] RGBA +see table below ++0xE0 +float[4] +color[10] RGBA +see table below ++0xF0 +float[4] +color[11] RGBA +see table below +## 9.2 Color Table Defaults (12 slots × 16 bytes) +Each slot is a 128-bit XMMWORD (4× IEEE 754 float, little-endian order R, G, B, A). Values are loaded from .rdata constants at init time via MOVDQA. The color slot-to-entity-type mapping follows the order the show_* flags were written in the initializer. +Slot +State Offset +.rdata RVA +R +G +B +A +Color Name +Entity Type +0 ++0x40 +0x3B3510 +1.000 +0.000 +0.000 +1.000 +Red +Monsters / Enemies +1 ++0x50 +0x3B3520 +1.000 +0.647 +0.000 +1.000 +Orange +NPC +2 ++0x60 +0x3B3540 +1.000 +1.000 +0.000 +1.000 +Yellow +Friendly +3 ++0x70 +0x3B3530 +0.000 +1.000 +0.000 +1.000 +Green +Puzzles +4 ++0x80 +0x3B3590 +0.000 +0.000 +1.000 +1.000 +Blue +(spare/all) +5 ++0x90 +0x3B35A0 +0.000 +1.000 +1.000 +1.000 +Cyan +(spare) +6 ++0xA0 +0x3B3580 +0.580 +0.000 +0.827 +1.000 +Purple +(spare) +7 ++0xB0 +0x3B35B0 +1.000 +1.000 +1.000 +1.000 +White +(spare) +8 ++0xC0 +0x3B3560 +1.000 +0.078 +0.576 +1.000 +Hot Pink +(spare) +9 ++0xD0 +0x3B3570 +1.000 +0.753 +0.796 +1.000 +Light Pink +(spare) +10 ++0xE0 +0x3B3500 +0.000 +0.000 +0.000 +1.000 +Black +(spare) +11 ++0xF0 +0x3B3550 +0.502 +0.502 +0.502 +1.000 +Gray +(spare) +All 12 slots have alpha fixed at 1.000 (fully opaque). Slots 0–3 correspond to the four named entity types controlled by show_monsters / show_npc / show_friendly / show_puzzles flags. Slots 4–11 are spare palette entries available for future entity categories; the ImGui color picker in ESPModule::Render exposes all 12 via '##Foreground' color edit widgets. +## 9.3 Show Flag Default Summary +Flag +Offset +Default +Notes +show_monsters ++0x34 +1 (ON) +Draws boxes/labels for monster entities +show_npc ++0x35 +1 (ON) +Draws boxes/labels for NPC entities +show_friendly ++0x36 +1 (ON) +Draws boxes/labels for friendly entities +show_puzzles ++0x37 +1 (ON) +Draws boxes/labels for puzzle objects +show_all ++0x38 +0 (OFF) +Override: draw all entity types regardless of flags above +show_distance ++0x39 +1 (ON) +Appends distance string to entity label +show_name ++0x3A +1 (ON) +Appends entity name string to label +show_type ++0x3B +0 (OFF) +Appends entity type string to label +max_dist ++0x30 +300 +Integer cutoff distance; entities beyond this are not drawn +# 10. SkillHack Hook Callbacks +SkillHack installs up to six IL2CPP hooks across five callback functions. The hooks intercept game methods that govern skill cooldowns, skill availability checks, and skill costs. All five callbacks share the same guard pattern: call SkillHack singleton init (0x180081300), check enabled flag at [singleton+0x28], and either return the bypass value immediately or fall through to the original method via the hook manager's trampoline dispatcher (0x18008FF00). +## 10.1 Hook Installation Map +SkillHack::Render (0x18008D1F0) installs hooks in two stages. Three hooks are installed directly via the hook-installer wrapper (0x18008D8A0). Three more are installed by dedicated patch functions called from Render. All six use the same FNV-1a hash lookup pattern and CreateHook call. +Hook # +Target Ptr +Callback VA +Patch Function +Installed By +1 +[g_Config+0x1E60] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +2 +[g_Config+0x1E68] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +3 +[g_Config+0x1E50] +0x18008D500 (float 100.0) +0x18008E220 +Render → 8E220 → CreateHook +4 +[g_Config+0x1E58] +0x18008D640 (bool true) +0x18008EBC0 +Render → 8EBC0 → CreateHook +5 +[g_Config+0x1E40] +0x18008D780 (void return) +0x18008F560 +Render → 8F560 → CreateHook +6 +[g_Config+0x1E48] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 (tail) +The g_Config IL2CPP function pointer slots are populated at runtime from IL2CPP metadata. Their contents are zero/garbage in the static binary on disk. +## 10.2 Generic Dispatcher — 0x18008D4B0 +Used for hooks 1, 2, and 6. When the skill hack is enabled, returns BOOL true (1) immediately to the caller, bypassing any skill gate check. When disabled, passes through to the original IL2CPP function via the trampoline. +// Generic dispatcher callback — 0x18008D4B0 +// Used for: hooks on [g_Config+0x1E60], [g_Config+0x1E68], [g_Config+0x1E48] +// Return type: BOOL (BYTE in al) +BOOL Callback_Dispatcher(void* self, void* arg) { +// Get SkillHack singleton (lazy init, 0x180081300) +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { // [singleton+0x28] != 0 +return 1; // bypass — skill check always passes +} +// Disabled: look up original function via FNV-1a hash and call trampoline +// HookManager::GetOriginal(hookMgr, this_callback_va, self, arg) +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +return CallOriginal(hookMgr, /*callback=*/0x18008D4B0, self, arg); // → 0x18008FF00 +} +## 10.3 Variant 1: Float Return — 0x18008D500 +Installed by patch function 0x18008E220 on the target at [g_Config+0x1E50]. Intercepts a method that returns a float — most likely GetCooldownPercent() or GetCooldownRemaining(). Returns 100.0 when enabled, indicating the skill is fully cooled down / available. +// Cooldown bypass callback — 0x18008D500 +// Installed on: [g_Config+0x1E50] (via patch fn 0x18008E220) +// Return type: float (xmm0) +float Callback_CooldownBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +// movss xmm0, [rip+0x325de5] -> RVA 0x3B3308 = 100.0f +return 100.0f; // skill cooldown = 100% complete (fully ready) +} +// Hash self VA via FNV-1a, look up hook entry, call original via trampoline +auto* hookMgr = HookManager_GetSingleton(); +return CallOriginal_Float(hookMgr, /*callback=*/0x18008D500, self, arg); +} +// Note: 0x42C80000 = 100.0 IEEE 754 single-precision (confirmed from .rdata RVA 0x3B3308) +// The prior volume summary incorrectly stated this returns 0.0. +## 10.4 Variant 2: Bool True — 0x18008D640 +Installed by patch function 0x18008EBC0 on the target at [g_Config+0x1E58]. Intercepts a method that returns a boolean — most likely IsSkillAvailable() or CanUseSkill(). When enabled, always returns true (1). When disabled, the hash lookup falls through: if the original function is found in the hook table, it is called via tail JMP; otherwise, returns false (0) as a safe default. +// Skill availability bypass callback — 0x18008D640 +// Installed on: [g_Config+0x1E58] (via patch fn 0x18008EBC0) +// Return type: BOOL (BYTE in al) +BOOL Callback_SkillAvailable(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return 1; // skill is always available +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D640); +if (original != NULL) { +// rex.WB JMP r8 — tail call to original +return original(self, arg); +} +// Hash miss — safe fallback +return 0; // xor al,al (0x18008D770) +} +## 10.5 Variant 3: Void Early Return — 0x18008D780 +Installed by patch function 0x18008F560 on the target at [g_Config+0x1E40]. Intercepts a void method — most likely ApplySkillCost() or DeductMana(). When enabled, returns immediately without executing the function body, discarding the cost deduction entirely. When disabled, the hash lookup finds the original and tail-calls it. +// Skill cost bypass callback — 0x18008D780 +// Installed on: [g_Config+0x1E40] (via patch fn 0x18008F560) +// Return type: void +void Callback_SkillCostBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return; // jne 0x18008D894 — skip to ret immediately +// Original cost deduction never executes +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D780); +if (original != NULL) { +// call r8 — call original, then return +original(self, arg); // 0x18008D891: call r8 +} +// If hash miss: no-op (safe for void) +} +## 10.6 Common Trampoline Dispatcher — 0x18008FF00 +When any callback is disabled and needs to call the original IL2CPP method, it calls 0x18008FF00. This function computes the FNV-1a hash of the callback's own VA, looks up the corresponding hook entry's trampoline_va field (+0x18), and tail-jumps to it. It is effectively the 'call original' helper shared by all SkillHack callbacks. +// CallOriginal trampoline dispatcher — 0x18008FF00 +// rcx = hookMgr, rdx = callback_va (used as hash key), r8 = self, r9 = arg +void* CallOriginal(HookManager* mgr, void* callback_va, void* self, void* arg) { +// FNV-1a hash of callback_va -> bucket index +uint64_t hash = FNV1a_64(callback_va); // same unrolled loop as 0x18008D555 +uint64_t bucket_idx = hash & mgr->bucket_mask; +// Walk hash chain to find entry where entry->callback_va == callback_va +HookEntry* entry = FindInHashChain(mgr, bucket_idx, callback_va); +if (entry && entry->trampoline_va) { +// Tail jump to trampoline (original bytes + JMP back) +JMP entry->trampoline_va; // rex.WB jmp r8 +} +// If no entry found: return NULL / no-op +} +## 10.7 Callback Summary Table +VA +Name +Return Type +Enabled Value +Disabled Behavior +Game Method (inferred) +0x18008D4B0 +Dispatcher +BOOL +1 (true) +Call original via 0x8FF00 +Skill gate / permission check +0x18008D500 +CooldownBypass +float +100.0f +Call original via FNV hash + trampoline +GetCooldownPercent / GetCooldownRemaining +0x18008D640 +SkillAvailable +BOOL +1 (true) +Original via tail JMP, or return 0 +IsSkillAvailable / CanUseSkill +0x18008D780 +SkillCostBypass +void +early ret +Original via call r8, or no-op +ApplySkillCost / DeductMana +# 11. DLL Injection Strings — testyip / gatmp.tmp / EF-Cheeto.dll +Three std::string objects are statically pre-initialised in .data and used during the loader's startup sequence. They are not classic injection strings in the sense of being written to a remote process; they are module-path substrings used by the self-presence scanner to confirm that the cheat DLL (or its temp-file loader copy) is already mapped into the target Unity process before the IL2CPP domain is attached. +## 11.1 String Object Layout in .data +All three are MSVC SSO (small-string-optimised) std::string objects with the inline buffer variant active (length ≤ 15, so no heap allocation). Each occupies 24 bytes: 8-byte inline buffer, 8-byte _Mysize, 8-byte _Myres. +String +.data offset (base) +Inline buf offset +Length +Capacity +Content +testyip ++0x308 ++0x318 +7 +15 (0x0F) +testyip\0 (7 bytes) +gatmp.tmp ++0x328 ++0x338 +9 +15 (0x0F) +gatmp.tmp\0 (9 bytes) +EF-Cheeto.dll ++0x348 ++0x358 +13 +15 (0x0F) +EF-Cheeto.dll\0 (13 bytes) +The _Mysize field for testyip reads as zero in the static binary image because the std::string was zero-initialised before the inline buffer was written — the buffer bytes are present but the constructor has not run. At runtime MSVC CRT initialises the object before DllMain executes. +## 11.2 Module Path Scanner — 0x18008B650 +The function at 0x18008B650 receives a process handle (rcx), a pointer array of HMODULE values (rdx), and a count output pointer (r8). For each module handle it calls GetModuleFileNameExW (IAT 0x1800B1168) to obtain the full path as a wide string, then uses the UTF-8→wide converter at 0x18008B4E0 (wrapping MultiByteToWideChar with CP_UTF8 = 0xFDE9) to convert the two search strings, and searches each path with wcsstr. It returns the zero-based array index of the first matching module, or -1 if not found. +// ModulePathScanner — 0x18008B650 +// Scans a process's loaded module list for paths containing known substrings. +// rcx = hProcess rdx = HMODULE[] r8 = DWORD* count_out r9 = extra_arg +int ModulePathScanner(HANDLE hProcess, HMODULE* modules, DWORD* count, void* extra) { +DWORD module_count = *count >> 3; // [rsi] >> 3 = byte-count / sizeof(HMODULE) +if (module_count == 0) return 0; +// Convert search strings from UTF-8 std::string to std::wstring +// 0x18008B4E0: MultiByteToWideChar(CP_UTF8=0xFDE9, 0, src, len, dst, dst_cap) +std::wstring w_gatmp = Utf8ToWide("gatmp.tmp"); // .data+0x338 +std::wstring w_efdll = Utf8ToWide("EF-Cheeto.dll"); // .data+0x358 +int found_count = 0; +for (DWORD i = 0; i < module_count; i++) { +WCHAR path[0x104] = {}; +// GetModuleFileNameExW(hProcess, modules[i], path, 0x104) +if (!GetModuleFileNameExW(hProcess, modules[i], path, 0x104)) +continue; // skip on failure → je 0x18008BA41 +// Convert wide path to std::wstring for wcsstr search +std::wstring wpath = WideToString(path); // 0x18000EB10 +// Search for 'gatmp.tmp' in the path +const wchar_t* pos_gatmp = wcsstr(wpath.c_str(), w_gatmp.c_str()); +// 0x1800AB6A0: custom wcsstr returning iterator, -1 if not found +intptr_t idx_gatmp = (pos_gatmp ? (pos_gatmp - wpath.c_str()) : -1); +if (idx_gatmp == -1) { +// Search for 'EF-Cheeto.dll' in the path instead → 0x18008B937 +const wchar_t* pos_ef = wcsstr(wpath.c_str(), w_efdll.c_str()); +intptr_t idx_ef = (pos_ef ? (pos_ef - wpath.c_str()) : -1); +if (idx_ef != -1) { +// Found — store module handle and record match +modules[found_count] = modules[i]; // compact in-place +found_count++; +} +// else: neither string found, skip module +} else { +// gatmp.tmp match — store module handle +modules[found_count] = modules[i]; +found_count++; +} +} +*count = (found_count * 8); // write back as byte count +return ; // propagates from call r10 (original fn) +} +## 11.3 Hook Installer Wrapper — 0x18008BAF0 +Called at 0x1800A93CC during the main startup sequence (0x1800A9190), after FindWindow('UnityWndClass') confirms the game window exists. Receives the IL2CPP method pointer for a function to hook (rcx = r14 from [IAT+0x7DA4] = EnumProcessModules or similar resolved pointer). Calls CreateHook (0x1800A9CC8) with 0x18008B650 as the callback, handling error codes with log messages 'Failed to remove existing hook: {}' (0x1803AFB30) and 'Failed to create new hook: {}' (0x1803AFB90). +// HookInstallerWrapper — 0x18008BAF0 +// Installs ModulePathScanner (0x18008B650) as hook on a target IL2CPP function. +// Called from main startup (0x1800A9190) once game window is found. +void HookInstallerWrapper(void* target_fn) { +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +// Check if hook already exists — RemoveHook first if so +if (FindExistingHook(hookMgr, target_fn)) { +int rc = RemoveHook(target_fn); // 0x1800A9E8C +if (rc != 0) { +Log("Failed to remove existing hook: {}", FormatError(rc)); // 0x1803AFB30 +return; +} +} +// Install new hook with ModulePathScanner as callback +void* trampoline = nullptr; +int rc = CreateHook(target_fn, /*cb=*/0x18008B650, &trampoline); // 0x1800A9CC8 +if (rc != 0) { +Log("Failed to create new hook: {}", FormatError(rc)); // 0x1803AFB90 +return; +} +// trampoline stored at [rbp-0x1] for later EnableHook call +} +## 11.4 Startup Sequence Context — 0x1800A9190 +The main DLL startup function at 0x1800A9190 establishes the console, hooks the module scanner, then proceeds to IL2CPP domain attachment. The three injection strings serve as the identity check: if neither 'gatmp.tmp' nor 'EF-Cheeto.dll' appears in any loaded module's path, the scanner returns no matches and the cheat does not proceed. +Step +Address +Action +1 +0x1800A91CE +AllocConsole — create 'il2cpp Game Console' window +2 +0x1800A9267 +SetConsoleCP(0xFDE9) — set UTF-8 code page +3 +0x1800A92F7 +FindWindowA(NULL, 'UnityWndClass') — poll until game window present +4 +0x1800A93CC +HookInstallerWrapper(EnumProcessModules) — install module scanner +5 +0x1800A93E6 +Log 'Initializing..' — source: E:\\git\\Endfield_Cheeto\\user\\main.cpp:53 +6 +0x1800A942F +Call [g_Config+0x1E80] — IL2CPP domain resolver +7 +0x1800A945A +Log 'IL2CPP Domain Found: ' if domain non-null +8 +0x1800A94C4 +Log 'IL2CPP Thread Attached Successfully: ' on attach +9 +0x1800A9506 +Error branch: Log ‘Failed to Attach IL2CPP Thread!’ (source: main.cpp) +10 +0x1800A9545 +Error branch: Log ‘IL2CPP Domain Not Found!’ (source: main.cpp) if domain is null +11 +0x1800A959F +Success path: Log ‘Initialized’ (source: main.cpp); function returns +Console initialisation detail (steps 1–2): AllocConsole (IAT[0xB1108]) allocates the console window. Three freopen_s calls (IAT[0xB1878]) redirect stdin, stdout, and stderr to CONIN$ and CONOUT$. SetConsoleOutputCP(0xFDE9) sets the UTF-8 code page. GetConsoleMode (IAT[0xB1120]) reads the current output mode flags and SetConsoleMode (IAT[0xB1128]) adds ENABLE_VIRTUAL_TERMINAL_PROCESSING for ANSI colour support. SetConsoleTitleA (IAT[0xB12A0]) sets the window caption to ‘il2cpp Game Console’. The overlay window thread is then launched (call 0x1800827A0) at step 12 (see Ch. 29), running independently of the IL2CPP attach sequence. +The source path 'E:\\git\\Endfield_Cheeto\\user\\main.cpp' (RVA 0x3B3148) confirms the project name and local build directory. 'Endfield_Cheeto' matches the cheat's internal identity; the published DLL name 'EF-Cheeto.dll' abbreviates this. +## 11.5 Injection String Summary +String +.data VA +Role +Search context +testyip +0x1803C5318 +Alternate temp-file loader name +wcsstr scan against each loaded module's full path +gatmp.tmp +0x1803C5338 +Primary temp-file loader name +wcsstr scan — match means loader copy is present +EF-Cheeto.dll +0x1803C5358 +Published DLL name +wcsstr fallback if gatmp.tmp not found in path +The naming pattern indicates a two-stage loader: the cheat is first written as a temp file (gatmp.tmp or testyip) via a dropper, then optionally renamed or loaded directly as EF-Cheeto.dll. The module path scanner confirms whichever form is loaded before proceeding with IL2CPP hooking. +# 12. Module Render() and Update() Implementations +Each module exposes two callable entry points registered with ModuleManager: a Render() function that draws the ImGui tab panel and handles one-shot toggle/config writes, and an Update() callback (stored as a .rdata function pointer) that runs the per-frame game-state mutation. SetDither and the SkillHack 'Free Skill' tab share a no-op stub at 0x18008/3DC0 whose entire job is to free a string and optionally call operator delete on the module object — meaning those two tabs perform all their work at Render time, not per-frame. The seven implementations are documented below. +## 12.1 Shared g_Config Panel-Width Sequence +All modules that expand their ImGui tab panel write an identical five-instruction sequence at panel-open and invert it at panel-close. This sequence adjusts the panel scroll region width in the global config object g_Config ([.data+0x1c00]). The fields involved are: +Field +g_Config offset +Role +panel_ptr ++0x15D8 +Pointer to the active ImGui panel/window struct +scroll_step ++0x0E0C +Per-frame scroll delta (float, typically a small positive value) +scroll_accum ++0x194 +Accumulated horizontal scroll position (float) +scroll_base ++0x58 +Base horizontal offset for child panels (float) +scroll_total ++0x198 +Total scroll range (float) +panel_width ++0x150 +Rendered panel content width (float, written each frame) +// Panel-open sequence (addss — widens panel each frame module is visible) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; // mark panel as active/dirty +rax = g_Config->panel_ptr; +xmm0 = g_Config->scroll_step; // [g_Config+0x0E0C] +xmm0 += rax->scroll_accum; // [panel+0x194] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; // [panel+0x58] +xmm0 += rax->scroll_total; // [panel+0x198] +rax->panel_width = xmm0; // [panel+0x150] — expand +// Panel-close sequence (subss — narrows panel each frame module is hidden) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; +rax = g_Config->panel_ptr; +xmm0 = rax->scroll_accum; // [panel+0x194] +xmm0 -= g_Config->scroll_step; // [g_Config+0x0E0C] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; +xmm0 += rax->scroll_total; +rax->panel_width = xmm0; // shrink +This pattern appears verbatim in every module's Render body and is not repeated in the per-module pseudocode below — it is implied by 'panel-open sequence' and 'panel-close sequence'. +## 12.2 NoClip +Function +RVA +Role +NoClip::RegisterTab +0x180081300 +One-time tab registration (Render stub #1) +NoClip::Render +0x1800813D0 +ImGui tab panel — checkbox + Move Speed slider +NoClip::Update +0x180089B50 +Per-frame: CharacterController.enabled toggle + speed slider +NoClip::Update stub +0x180089B00 +Tab-manager destructor/cleanup wrapper +NoClip disables/re-enables the Unity CharacterController component on matching entities each frame. When enabled the controller's collision is suppressed, allowing the player to pass through geometry. A Move Speed integer slider ([module+0x30], range 1–10, step 1) controls movement rate while noclip is active. +// NoClip::Render RVA 0x1800813D0 +// rcx = NoClip* this +void NoClip::Render() { +// Panel-open sequence (g_Config+0x1c00, +0x15D8/0xE0C/0x194/0x58/0x198/0x150) +std::string title = MakeString("NoClip", 6); // 0x18000FCB0 +std::string tmp; +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &title); // 0x18009D7D0 +// resolve std::string to char* via SSO check (cmp [rax+0x18], 0xF) +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 — returns true if clicked +// free tmp, title +if (!clicked) { panel-close sequence; return; } +// Panel-open sequence +// second tab header: 'ON / OFF' +bool on_off_clicked = TabManager_BeginTab([.data+0x27B0], &tmp, &title); +// resolve buf, call 0x180085320 (CheckboxToggle) with &this->enabled [+0x28] +// CheckboxToggle: if edx (new_val) != *rdx (current), flip and update +// Panel-open/close based on [this+0x28] +if ([this+0x28] enabled) { +// 'Move Speed' DragInt slider: [this+0x30], range [1,10], step 1, format '%d' +// 0x180066750 — ImGui::DragInt4-variant +panel-open sequence; +} else { +panel-close sequence; +} +} +// NoClip::Update RVA 0x180089B50 +// Called per-frame by ModuleManager hook +void NoClip::Update() { +// Same 'NoClip' tab header + ON/OFF checkbox pattern as Render +if (!clicked) return; +panel-open sequence (if enabled) +'Move Speed' DragInt slider — same as Render, writes [this+0x30] +// Entity iterator loop (0x180089DC0) +bool noclip_on = [this+0x28]; +void* entity_mgr = g_Config->GetEntityManager(); // [g_Config+0x1D28] — IL2CPP call +if (!entity_mgr) return; +void* list = entity_mgr->GetComponentList(); // [entity_mgr+0x10]->field_0x10 +int count = list->count; // [list+0x20] +void** arr = list->items; // [list+0x10][+0x10] +arr += 0x20; // skip header slots +for (int i = 0; i < count; i++, arr++) { +void* component = *arr; +if (!component) continue; +void* ctrl = GetCharacterController(component); // [g_Config+0x1E20] IL2CPP call +if (!ctrl) continue; +// CharacterController.set_enabled(!noclip_on, 0) +// [g_Config+0x1E08]: IL2CPP setter — dl = !noclip_on, r8d = 0 +bool enable_cc = !noclip_on; +SetEnabled(ctrl, enable_cc, 0); // 0x1803C6E08 +} +// Move Speed DragInt — panel sequence at close +} +## 12.3 FreeCam +Function +RVA +Role +FreeCam::RegisterFpsTab +0x1800814C0 +Registers FPS Monitor overlay tab +FreeCam::RegisterMainTab +0x180081590 +Registers FreeCam main tab (0xD8-byte zeroed state) +FreeCam::FpsUpdate stub +0x180087150 +FPS overlay destructor wrapper; tab cleanup +FreeCam::Update +0x1800871A0 +Per-frame: camera override, WASD+mouse input, speed sliders +FreeCam overrides the game camera's transform each frame when enabled. RegisterMainTab zeroes a 0xD8-byte state block in .data ([.data+0x2200]) and writes hard-coded default key bindings (0x44415357 = 'WASD', 0x6D6BA220, 0x2725, 0x60) and clears floats for pitch/yaw/roll/FOV accumulators. It also clears an 8-byte 'active camera' pointer and related state. Move Speed defaults to 30.0f (0x41F00000 IEEE 754), step 0.1f (0x3DCCCCCD). Look Sensitivity defaults to 100.0f (0x42C80000), step 0.1f (0x3DCCCCCD). Roll Speed ([this+0x34]) and FOV Speed ([this+0x38]) have dedicated sliders with format '%.3f'. +// FreeCam::RegisterMainTab RVA 0x180081590 +// Runs once at DLL init; zeroes FreeCam state block and writes defaults +void FreeCam::RegisterMainTab() { +// Zero [.data+0x2200] block (0xD8 bytes via memset-like call 0x1800AC86A) +std::string tab = MakeString("FreeCam", 7); +// register tab with TabManager (0x18000F7D0), clear active flag, free strings +// Write update fn ptr: [.data+0x2200] = 0x1803AFE10 → FreeCam::Update +// Write default key bindings to [.data+0x2230..0x225E]: +// movdqa [+0x2230] = [0x1803B34F0] (key config block 1) +// movdqa [+0x2240] = [0x1803B35C0] (key config block 2) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier default) +// [+0x2254] = 0x44415357 ('WASD' key code mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind) +// [+0x225E] = 0x60 (backtick key code) +// Zero floats: pitch/yaw/roll/FOV [+0x2260..0x22A8], camera ptr [+0x22B0..0x22D0] +} +// FreeCam::Update RVA 0x1800871A0 +void FreeCam::Update() { +std::string hdr = MakeString("Free Camera", 11); +bool open = TabManager_BeginTab(&tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// ON/OFF checkbox → [this+0x28] +bool on_off = TabManager_BeginTab(...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 +if (!this->enabled) { +// Disable camera override: clear active cam ptr [this+0x70] and [this+0x68] +// [g_Config+0x1DB8]: IL2CPP Camera.set_enabled(false/true calls) +Camera_SetEnabled([this+0x70], false, 0); // 0x1803C6DB8 +Camera_SetEnabled([this+0x68], true, 0); +[this+0xB8] = 0; // clear 'cam override active' flag +panel-close sequence; +return; +} +// Move Speed float slider: [this+0x30], max 500.0f, min 0.1f, fmt '%.3f' +// 0x180065570 — ImGui::SliderFloat8 variant (8 = DragFloat with extra params) +// [rsp+0x40]=500.0f (max), [rsp+0x48]=0.1f (min), xmm3=step +// Roll Speed float slider: [this+0x34], max 100.0f (0x42C80000), min 0.1f +// Look Sensitivity float slider: [this+0x38]? (identified from 'FOV Speed' string) +// (Three consecutive float sliders: Move Speed, Roll Speed, FOV Speed) +// Key input + camera transform written via IL2CPP calls on camera component +// (Camera.get_main, Transform.set_position, Transform.set_rotation via vtable) +} +## 12.4 FpsUnlocker +Function +RVA +Role +FpsUnlocker::RegisterTab +0x180081730 +Registers 'Fps Unlocker' tab; writes default fps=300 ([.data+0x21E8]) +FpsUnlocker::Render +0x180085B90 +ImGui panel: checkbox + Fps Value DragInt, calls Application.targetFrameRate +FpsUnlocker::Update stub +0x180085B40 +Tab destructor/cleanup wrapper; cleanup size 0x38 +FpsUnlocker calls the IL2CPP Application.set_targetFrameRate setter ([.data+0x1D48]) on every Render call (not per-frame Update). When the checkbox is off, it passes 60 (0x3C) as the frame rate. When on, it passes [this+0x30] — the user's chosen value. A Fps Value DragInt slider ([this+0x30], max 500, min 30, step 1, format '%d') is displayed in a second tab header. RegisterTab writes a default of 300 (0x12C) to the .data slot backing [this+0x30]. +// FpsUnlocker::Render RVA 0x180085B90 +void FpsUnlocker::Render() { +std::string hdr = MakeString("Fps Unlocker", 12); +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// First action on open: call Application.set_targetFrameRate +// (regardless of enabled state — immediate effect) +int fps_val = this->enabled ? this->fps_target : 60; +Application_SetTargetFrameRate(fps_val); // [.data+0x1D48] IL2CPP +// ON/OFF checkbox → CheckboxToggle([this+0x28]) +if (this->enabled) { +panel-open sequence; +// 'Fps Value' DragInt: [this+0x30], max=500, min=30, step=1, fmt='%d' +// 0x180065570 ImGui::DragInt variant +// On each interaction: call Application.set_targetFrameRate([this+0x30]) +// ... then subss panel-close sequence +} else { +// panel-close sequences x2 (one per BeginTab call) +} +} +## 12.5 SetDither +Function +RVA +Role +SetDither::RegisterTab +0x180081810 +Registers 'SetDither' tab; stores update ptr 0x1803B01B0 → stub 0x180083DC0 +SetDither::Render +0x180081810 +Identical to RegisterTab (same address — no separate Render body) +SetDither::Update +0x180083DC0 +No-op stub: frees string [this+0x8], optionally operator delete(this, 0x30) +SetDither is the simplest module. Its registration function and Render body coincide at the same RVA — the 'tab' it registers has no interactive widgets beyond the standard tab header registration. The stored update pointer leads to the shared no-op stub at 0x180083DC0. The stub frees a std::string at [rcx+0x8] then, if the dirty bit (bl & 1) is set, calls operator delete on the module pointer with size 0x30. There is no per-frame game-state write associated with SetDither in this binary; the feature is either not yet implemented or was stripped before release. +// SetDither::RegisterTab / Render RVA 0x180081810 +void SetDither::RegisterTab() { +std::string hdr = MakeString("SetDither", 9); +// Register tab with TabManager (0x18000F7D0) +// Write update fn ptr: [.data+0x2180] = 0x1803B01B0 → 0x180083DC0 (stub) +// Cleanup string, return [.data+0x2180] +} +// Shared no-op Update stub RVA 0x180083DC0 +// Used by SetDither, FreeCam FPS overlay, and SkillHack 'Free Skill' tab +void* NoOpUpdateStub(void* this_ptr, BOOL dirty) { +std::string& s = *(std::string*)((char*)this_ptr + 8); +std::string_destroy(&s); // 0x18000FA60 +if (dirty & 1) { +operator_delete(this_ptr, 0x30); // 0x1800AB758 +} +return this_ptr; +} +## 12.5.1 SetDither::RenderOverlay (RVA 0x8C4A0) +SetDither::RenderOverlay is a separate callable entry point distinct from RegisterTab. It is invoked by the ModuleManager render loop on every Present() frame. The function (0x8C4A0–0x8C70D, 621 bytes) draws the “Set Dither” (i18n key RVA 0x3B0198) panel inside the main cheat overlay. Its control flow follows the standard module pattern: +// SetDither::RenderOverlay RVA 0x18008C4A0 +void SetDither::RenderOverlay(SetDither* this) { +// Tab guard: i18n lookup for "Set Dither" key (RVA 0x3B0198, 10 chars) +std::string tabName = i18n_lookup("Set Dither"); // 0x18000FCB0 +bool open = TabManager_BeginTab(tabName, g_locale); // 0x18009D7D0 +if (!open) { string_destroy(tabName); return; } +// Panel-open: addss [g_Config+0x15D8]+0x194 with [g_Config+0xE0C] +g_Config->panel_state->height += g_Config->dither_panel_height; // expand +// "ON / OFF" toggle bound to [this+0x28] (dither_enabled BOOL) +std::string label = i18n_lookup("ON / OFF"); // RVA 0x3AF848, 8 chars +DitherToggle(label, &this->dither_enabled); // 0x180085320 (rcx=label, rdx=&[rsi+0x28]) +// Panel-close: subss restores height +g_Config->panel_state->height -= g_Config->dither_panel_height; +} +The singleton state block for SetDither is accessed via [g_Config+0x15D8] (pointer to the active game state node at runtime). The field [this+0x28] is the dither_enabled BOOL; the DitherToggle helper at 0x180085320 is the same ImGui toggle helper used by other modules. The “ON / OFF” i18n label at RVA 0x3AF848 distinguishes this from the other modules which use a module-name toggle pattern. +## 12.6 PlayerProfile +Function +RVA +Role +PlayerProfile::RegisterTab +0x1800818E0 +Registers tab, zeroes two std::string fields, stores IL2CPP find fn ptrs +PlayerProfile::Render +0x1800818E0 +Same RVA — tab registration IS the render registration +PlayerProfile::Update +0x18008A4F0 +Per-frame: UI node traversal, SetText on two TMP labels, Name Changer input +PlayerProfile::Update stub +0x18008A4A0 +Destructor wrapper: frees [this+0x50], [this+0x30], [this+0x8], delete(0x78) +PlayerProfile resolves two Unity UI node paths each frame when enabled. The first path '/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text' (RVA 0x3AFED0, len 0x2F) finds the UID display TextMeshProUGUI component and overwrites its text with the content of [this+0x30] (an internal std::wstring). The second path '/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName' (RVA 0x3AFFD0, len 0x8D) finds the name label and overwrites it with [this+0x50]. A 'UID text' input box and a 'Name text' input box are shown in the panel. A 'Name changer' checkbox ([this+0x70]) enables the ManagerName write. RegisterTab zeroes both std::string fields via 0x18000FFF0 (wstring init) and stores find-by-path and get-component IL2CPP function pointers. +// PlayerProfile::Update RVA 0x18008A4F0 +void PlayerProfile::Update() { +std::string hdr = MakeString("PlayerProfile", 13); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +CheckboxToggle(&this->enabled, ...); // ON/OFF → [this+0x28] +if (this->enabled) { +// Resolve UID text node +std::string path1 = "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text"; +void* uid_node = IL2CPP_FindByPath(path1); // 0x18009BCB0 +if (uid_node) { +// Get TextMeshProUGUI component +void* tmp_comp = GetComponent(uid_node, "TextMeshProUGUI"); +if (tmp_comp) { +// SetText(tmp_comp, 0, this->uid_wstring) — [g_Config+0x1E28] +SetText(tmp_comp, 0, &this->uid_str); // 0x1803C6E28 +} +} +// Resolve second name node (for first name label) +// Same pattern: path → find → GetComponent → SetText +// 'UID text' InputText: writes [this+0x30] (displayed uid string) +// call 0x18008AC20 — InputText_wstring wrapper +// 'Name text' InputText: writes [this+0x50] (player name buffer) +// 'Name changer' checkbox → [this+0x70] +if (this->name_changer_enabled) { // [this+0x70] +// Resolve ManagerName node via long world path +void* name_node = IL2CPP_FindByPath( +"/UINode/WorldUIRoot/WatchPanel/.../ManagerName"); +if (name_node) { +void* tmp_comp = GetComponent(name_node, "TextMeshProUGUI"); +if (tmp_comp) { +SetText(tmp_comp, 0, &this->name_str); // [this+0x50] wstring +} +} +} +} +panel-close sequence; +} +## 12.7 Vacuum +Function +RVA +Role +Vacuum::RegisterTab +0x180081A20 +Registers 'Vacuum' tab, stores update fn ptr 0x1803B0680 → 0x180085B40 stub +Vacuum::Render +0x180093CA0 +ImGui panel: 'Vacuum' checkbox + 'Monster' sub-checkbox; panel-width logic +Vacuum::PhysicsLoop +0x180093F10 +Per-frame Rigidbody.AddForce attraction loop over entity list +Vacuum::Update stub +0x180085B40 +Destructor wrapper: frees [this+0x8], optionally delete(0x38) +Vacuum renders two checkboxes: 'Vacuum' ([this+0x28]) and 'Monster' ([this+0x30]). The physics loop at 0x180093F10 runs each frame when any vacuum flag is active. It obtains the camera's position via IL2CPP (Camera.main → transform → position), then iterates all rigidbody entities and applies an AddForce call that pulls each toward the camera origin. The force vector is computed per-entity as: forceX = (entity.x × attractStrength) + camera.x, forceY similarly, forceZ similarly, where attractStrength (xmm8) is loaded from [.rdata+0x1803B32B4] — a compile-time constant. The 'Monster' flag controls whether monster-type entities are included in the iteration. +// Vacuum::Render RVA 0x180093CA0 +void Vacuum::Render() { +std::string hdr = MakeString("Vacuum", 6); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// 'Vacuum' checkbox: CheckboxToggle(&this->vacuum_on [+0x28]) +// 'Monster' checkbox: CheckboxToggle(&this->monster_on [+0x30]) +// — Monster sub-checkbox uses panel-open/subss sequence at 0x180093EAC +} +// Vacuum::PhysicsLoop RVA 0x180093F10 (called from physics hook each frame) +// rcx = Vacuum* this, xmm1 = attract_vector, r8 = entity_array +void Vacuum::PhysicsLoop(void* this_ptr, vec3 attract_vec, void** entities) { +if (!this->vacuum_on) return; // [this+0x30] +// Get camera position +void* cam_mgr = g_Config->GetCameraManager(); // [g_Config+0x1D28] +if (!cam_mgr) return; +void* main_cam = cam_mgr->GetMainCamera(); // [g_Config+0x1CF0] +void* cam_rb = main_cam->GetRigidbody(); // [g_Config+0x1D60] +void* cam_pos = cam_rb->GetPosition(0); // [g_Config+0x1DC8] +// cam_pos struct: {double x, double y, int z_int, ...} +double cam_x = cam_pos->x; +double cam_y = cam_pos->y; +int cam_z = cam_pos->z_int; +float attract = *(float*)0x1803B32B4; // compile-time attraction constant +// Iterate entity array (from Vacuum::Update inner call 0x180094000) +for each entity in entities { +if (!entity) continue; +void* rb = GetRigidbody(entity); // [g_Config+0x1DF8] +if (!rb) continue; +vec3 pos = rb->GetPosition(0); // [g_Config+0x1D18] +vec3 force; +// Get entity world position +void* rb2 = GetEntityRoot(entity); // [g_Config+0x1D60] +vec3 rb2pos = rb2->GetWorldPos(0); // [g_Config+0x1DC8] +vec3 rb2pos2 = rb2->GetAltPos(0); // [g_Config+0x1DA8] +vec3 rb3pos = rb2->GetFwd(0); // [g_Config+0x1D90] +// force = attract * rb3pos + camera_pos (component-wise) +force.x = rb3pos.x * attract + cam_x; +force.y = rb3pos.y * attract + cam_y_component; +force.z = rb3pos.z * attract + cam_z_component; +// Rigidbody.AddForce(rb, &force, ForceMode=0) [g_Config+0x1E00] +AddForce(rb, &force, 0); +} +} +## 12.8 SkillHack::Render — Complete Panel Body +Function +RVA +Role +SkillHack::Render +0x18008D1F0 +Hook installer entry: installs six IL2CPP hooks, then falls to panel fn +SkillHack::RenderPanel +0x18008D240 +ImGui panel: 'Free Skill' checkbox + ON/OFF toggle + panel-width sequence +SkillHack::Update +0x180083DC0 +No-op stub (shared with SetDither — no per-frame game write) +SkillHack::Dispatcher +0x18008D4B0 +BOOL hook callback: returns 1 when [SkillHack+0x28] is set +SkillHack::CooldownBypass +0x18008D500 +float hook callback: returns 100.0f when enabled +SkillHack::AvailBypass +0x18008D640 +BOOL hook callback: returns 1 when enabled +SkillHack::CostBypass +0x18008D780 +void hook callback: early-return (skip cost deduction) when enabled +SkillHack::Render at 0x18008D1F0 is a pure hook-installation function — it does not itself draw any ImGui widgets. It installs the six IL2CPP hooks (documented in Section 10) and then tail-jumps to 0x18008D8A0 (the CreateHook wrapper / EnableHook dispatcher). The actual ImGui panel rendering is at 0x18008D240, referenced via the .rdata tab-callback pointer chain. That panel body contains the standard 'SkillHack'/'Free Skill' tab header pair followed by the ON/OFF checkbox and the full panel-width sequence. +// SkillHack::Render RVA 0x18008D1F0 — hook installer, NOT the ImGui panel +void SkillHack::Render() { +// Install hooks on six IL2CPP function pointers (see Section 10) +InstallHook(g_Config->il2cpp_fn[0x1E60], &Dispatcher); // 0x18008D8A0 +InstallHook(g_Config->il2cpp_fn[0x1E68], &Dispatcher); +InstallHook_CooldownBypass(); // 0x18008E220 → 0x18008D500 +InstallHook_AvailBypass(); // 0x18008EBC0 → 0x18008D640 +InstallHook_CostBypass(); // 0x18008F560 → 0x18008D780 +InstallHook(g_Config->il2cpp_fn[0x1E48], &Dispatcher); // tail jmp +} +// SkillHack::RenderPanel RVA 0x18008D240 — actual ImGui panel +void SkillHack::RenderPanel() { +// Tab header: 'Free Skill' (10 chars) via TabManager_BeginTab +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// Second tab: 'ON / OFF' +bool on_off = TabManager_BeginTab(..., &tmp_str, ...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 → [this+0x28] +if (this->enabled) { +panel-open sequence; // addss path +// (no additional sliders or sub-widgets beyond the toggle) +} else { +panel-close sequence; // subss path +} +// All six hook callbacks read [SkillHack_singleton+0x28] at call time +// — no deferred write needed here +} +## 12.9 Module Render/Update Address Summary +Module +RegisterTab RVA +Render RVA +Update RVA +Update type +Key field offsets +NoClip +0x181300 +0x1813D0 +0x189B50 +Per-frame entity loop +[+0x28] enabled, [+0x30] move_speed (int) +FreeCam +0x181590 +0x1871A0 +0x1871A0 +Per-frame camera override +[+0x28] enabled, [+0x30] move_speed (float), [+0x34] roll_spd, [+0x38] fov_spd, [+0x68/70] cam ptrs +FpsUnlocker +0x181730 +0x185B90 +stub/none +Render-time only +[+0x28] enabled, [+0x30] fps_target (int, default 300) +SetDither +0x181810 +0x181810 +stub/none +No-op +[+0x28] enabled (unused) +PlayerProfile +0x1818E0 +0x18A4F0 +0x18A4F0 +Per-frame UI path walk +[+0x28] enabled, [+0x30] uid_str, [+0x50] name_str, [+0x70] name_changer +Vacuum +0x181A20 +0x193CA0 +0x193F10 +Per-frame AddForce loop +[+0x28] vacuum_on, [+0x30] monster_on +SkillHack +N/A +0x18D1F0 +stub/none +No-op (hook callbacks handle IL2CPP) +[+0x28] enabled (read by all 6 callbacks) +# 13. Gap Closure Status +Gap +Status +Volume Resolved +Notes +Module Update() bodies +COMPLETE +Ch. 22 +ESPModule::Update completed in Ch. 22; all others in Ch. 12 +Module Render() bodies +COMPLETE +Ch. 22 +ESPModule::RenderOverlay completed in Ch. 22; all others in Ch. 12 +ModuleManager main loop +COMPLETE +Ch. 15 +Present hook + module dispatch; see Ch. 15 +GABypass IL2CPP patching +COMPLETE +Ch. 18 +71 function pointers patched; see Ch. 18 +Config file I/O +COMPLETE +Ch. 6 +UTF-8→wide→_wfopen, 'rb'/'wt' +DLL injection (testyip/gatmp) +COMPLETE +Ch. 11 +Temp file injection pattern; see Ch. 11 +Thread enumeration +COMPLETE +Ch. 3 +Toolhelp32 snapshot loop; see Ch. 3 +Anti-debug checks +COMPLETE +Ch. 4 +MSVC CRT only, no active anti-debug; see Ch. 4 +Shader compilation +COMPLETE +Ch. 5 +Two ImGui HLSL shaders, vs/ps 4_0 +SetWindowDisplayAffinity +COMPLETE +Ch. 21 +PreventScreenshot registered module; full analysis in Ch. 21 +ImGui integration +COMPLETE +Ch. 12 +Win32+D3D11 backends; see Ch. 12. Overlay window init (DPI, CreateWindowExW, D3D11CreateDeviceAndSwapChain, message loop, FindGameWindow, GetOverlayRect) see Ch. 29 +Exception handling +COMPLETE +Ch. 4 +MSVC __security_check_cookie; see Ch. 4 +JSON parsing +COMPLETE +Ch. 19 +Full schema, save/load path, and IAT traced; see Ch. 19 +# 14. Definitive Function Address Table +Complete map of all significant functions identified across all twenty-five chapters: +Function / Purpose +VA Start +VA End +Key Operations +DllMain +0x180001000 +- +Entry point, spawns loader thread +LoaderThread +0x180005000 +- +Init IL2CPP, create window, Present hook +ModuleManager::RegisterAll +0x18009AE00 +- +11 modules registered via stubs +ModuleManager::MainLoop +0x180082000 +0x180082300 +Present hook, ImGui render loop +D3D11Init (shaders) +0x180054DC0 +0x1800551E8 +2× D3DCompile, create D3D resources +ImGui Win32+D3D11 Setup +0x180082500 +- +Backend init, WndProc subclass +CollectProcessThreads +0x1800A96B0 +0x1800A9A1C +Toolhelp32 thread enumeration +SuspendOrResumeThreads +0x1800A9A20 +0x1800A9A98 +OpenThread + Suspend/Resume +PatchCode +0x1800A9A9C +0x1800A9BC3 +VirtualProtect + write hook bytes +HookManager::Install +0x1800A9CC8 +- +Alloc trampoline + FNV hash +HookManager::Remove +0x1800A9E8C +- +Remove and restore bytes +HookManager::Enable +0x1800A9A9C +- +Toggle enabled bit + patch +GABypass::Init +0x18009D1E0 +- +71 IL2CPP stubs patched +OpenConfigFile +0x180011EA0 +0x180012043 +_wfopen(UTF8→wide path, mode) +SaveConfig +0x180030620 +0x1800307A0 +fwrite JSON config to disk +ReadConfig +0x1800302D2 +0x180030348 +fread JSON config from disk +ImGuiSaveIni +0x180017078 +0x1800172CA +fwrite ImGui window layout +__security_init +0x1800AC580 +0x1800AC6CA +CRT SEH + IsDebuggerPresent +__security_check_cookie +0x1800AC6CC +0x1800AC77B +Stack canary: magic 0x2B992DDFA232 +NoClip::Render +0x180089B40 +- +CharacterController enable toggle +SkillHack::Render +0x18008D1F0 +- +IL2CPP hook installer +FreeCam::Render +0x180087150 +- +CinemachineBrain override +FpsUnlocker::Render +0x180085B80 +- +Application.targetFrameRate +SetDither::Render +0x18008C490 +- +Graphics dither toggle +PlayerProfile::Render +0x18008A4A0 +- +Unity UI text manipulation +Vacuum::Render +0x180093C90 +- +Monster item collection +ESPModule::Render +0x180083F60 +- +See Ch. 22 (§22.1) +DamageHack (ghost) +N/A (no code) +- +Ghost feature — no code; see Ch. 23 +PreventScreenshot +0x18008B490 +- +SetWindowDisplayAffinity +ESPModule::DrawOverlay +0x180083000 +- +See Ch. 22 (§22.2) +WndProc +0x1800826A0 +- +Win32 message + WM_SIZE/DESTROY handler; see Ch. 7 +SkillHack::Dispatcher +0x18008D4B0 +- +Generic hook dispatcher (2 hooks); see Ch. 10 +SkillHack::FloatReturn +0x18008D500 +- +Hook cb: return 100.0f (float skills); see Ch. 10 +SkillHack::BoolTrue +0x18008D640 +- +Hook cb: return true (bool checks); see Ch. 10 +SkillHack::VoidReturn +0x18008D780 +- +Hook cb: early void return; see Ch. 10 +SkillHack::TrampolineDispatch +0x18008FF00 +- +Common trampoline dispatcher; see Ch. 10 +ModuleManager::Init +0x18009AC10 +- +Construct + register all modules; see Ch. 15 +ModuleManager::DispatchRender +0x18009AE80 +- +Per-frame Render() dispatch loop; see Ch. 15 +ModuleManager::DispatchHotkeys +0x18009AEF0 +- +Per-frame hotkey dispatch; see Ch. 15 +ModuleManager::DispatchRegInit +0x18009AF60 +- +Registrar init dispatcher; see Ch. 15 +ModuleManager::PresentHook +0x180082F00 +- +D3D11 Present hook; calls Render+Hotkey loops; see Ch. 15 +ModulePathScanner +0x18008B650 +- +Scans loaded modules for testyip/gatmp/EF-Cheeto; see Ch. 11 +HookInstallerWrapper +0x18008BAF0 +- +Wraps CreateHook; validates target ptr; see Ch. 11 +StartupSequence +0x1800A9190 +- +DLL loader startup context; see Ch. 11 +ESPModule::Init +0x180083E00 +- +Lazy singleton init; sets color defaults; see Ch. 9 +ESPModule::RenderOverlay +0x180083FA0 +0x18008499E +ImGui ESP panel (full); see Ch. 22 +ESPModule::Update +0x180084A00 +0x1800852A5 +Entity label draw loop; see Ch. 22 +FPSModule::Initialize +0x1800814C0 +- +once_flag guarded init; see Ch. 20 +FPSModule::RenderOverlay +0x180085700 +0x180085900 +FPS panel + overlay counter; see Ch. 20 +PreventScreenshot::Initialize +0x18008AD70 +- +once_flag guarded init; see Ch. 21 +PreventScreenshot::Render +0x18008AE60 +- +ImGui checkbox; see Ch. 21 +PreventScreenshot::Update +0x18008AFC0 +- +SetWindowDisplayAffinity dispatch; see Ch. 21 +PreventScreenshot::OsCheck +0x18008B220 +- +Win10 build check + affinity call; see Ch. 21 +UnityExplorer::RegisterTab +0x180090060 +- +Tab init, scene hierarchy setup; see Ch. 16 +UnityExplorer::Render +0x180090250 +- +Per-frame scene inspector; see Ch. 16 +UnityExplorer::RefreshScenes +0x180090D40 +- +Scene list refresh helper; see Ch. 16 +HookManager::Spinlock +0x1800A9C88 +- +Spinlock acquire/release; see Ch. 8 +WideToString +0x18000EB10 +- +UTF-8 path to wstring for wcsstr; see Ch. 11 +FreeCam::RegisterTab +0x18000F7D0 +- +Registers FreeCam main tab; see Ch. 12 +BaseModule::Dtor +0x18000FA60 +- +Shared dtor: destroy name string + optional delete; see Ch. 12 +NoClip::RegisterTab +0x18000FCB0 +- +Registers NoClip tab; stores update fn ptr; see Ch. 12 +ManagerName::Init +0x18000FFF0 +- +Zeroes std::string fields for ModuleManager name; see Ch. 15 +ConfigSerialize +0x180012050 +- +Serialize config struct to string for fwrite; see Ch. 6 +ImGui::EndFrame +0x18001C2D0 +- +D3D11/ImGui frame boundary EndFrame call; see Ch. 15 +BuildFilePath +0x180030A90 +- +Build config file path string from state+0x50; see Ch. 6 +D3D11::CreateBuffers +0x1800551F0 +- +Create vertex/index buffers post shader compile; see Ch. 5 +ImGui_ImplWin32_WndProcHandler +0x180057720 +- +ImGui Win32 WndProc message handler; see Ch. 7 +FreeCam::SliderFloat +0x180065570 +- +Move Speed SliderFloat (max 500.0f); see Ch. 12 +FreeCam::DragInt +0x180066750 +- +Move Speed DragInt (range 1-10); see Ch. 12 +TabManager::BeginTab +0x180070820 +- +ImGui tab begin + toggle helper; see Ch. 12 +ImGui::Selectable +0x1800708D0 +- +Preset selector; Per-Config preset writer dispatch; see Ch. 17 +SkillHack::GetSingleton +0x180081300 +- +Lazy once_flag singleton init for SkillHack; see Ch. 10 +NoClip::Render +0x1800813D0 +- +ImGui panel: checkbox + Move Speed slider; see Ch. 12 +FPSModule::RegisterTab +0x180081590 +- +Registers FPS Monitor overlay tab; see Ch. 20 +FpsUnlocker::RegisterTab +0x180081730 +- +Registers Fps Unlocker tab; see Ch. 12 +SetDither::RegisterTab +0x180081810 +- +Registers SetDither tab; stores update ptr; see Ch. 12 +PlayerProfile::RegisterTab +0x1800818E0 +- +Registers PlayerProfile tab; see Ch. 12 +Vacuum::RegisterTab +0x180081A20 +- +Registers Vacuum tab; stores update fn ptr; see Ch. 12 +HookManager::GetSingleton +0x180081B00 +- +Thread-safe static singleton init for HookManager; see Ch. 8 +NoOpUpdateStub +0x180083DC0 +- +Shared no-op Update stub (SetDither, SkillHack free); see Ch. 12 +ESPModule::CheckboxToggle +0x180085320 +- +Toggle checkbox helper used in ESPModule panel; see Ch. 22 +NoClip::EntityIterator +0x180089DC0 +- +Entity iterator loop inner call; see Ch. 12 +InputText::WString +0x18008AC20 +- +ImGui InputText wrapper for wstring fields; see Ch. 12 +SkillHack::InstallHooks +0x18008D8A0 +- +Installs 3 hooks via HookInstallerWrapper; see Ch. 10 +SkillHack::PatchFloat +0x18008E220 +- +Installs FloatReturn hook on [g_Config+0x1E50]; see Ch. 10 +SkillHack::PatchBool +0x18008EBC0 +- +Installs BoolTrue hook on [g_Config+0x1E58]; see Ch. 10 +SkillHack::PatchVoid +0x18008F560 +- +Installs VoidReturn hook on [g_Config+0x1E40]; see Ch. 10 +UnityExplorer::GuardReturn +0x1800901D8 +- +Early return after once_flag sealed; see Ch. 16 +ImGui::Begin +0x1800937D0 +- +ImGui::Begin wrapper (Unity Explorer Window); see Ch. 16 +UnityExplorer::AutoRefresh +0x180093B10 +- +Auto-refresh timer check for scene list; see Ch. 16 +Vacuum::PhysicsLoop +0x180093F10 +- +Per-frame entity attraction physics loop; see Ch. 12 +PlayerProfile::FindUINode +0x18009BCB0 +- +IL2CPP_FindByPath for UI text/UID node; see Ch. 12 +TabManager::BeginTabFull +0x18009D7D0 +- +Full BeginTab with state+title resolution; see Ch. 12 +HookManager::FreeSlot +0x1800AA684 +- +Free trampoline + compact hook array; see Ch. 8 +WideStr::wcsstr +0x1800AB6A0 +- +Custom wcsstr for wide path scanning; see Ch. 11 +WideStr::Dtor +0x1800AB758 +- +wstring destructor in path scanner; see Ch. 11 +HotkeyErrorHandler +0x1800AECE0 +- +Hotkey error handler, logs '[hotkey error]'; see Ch. 7 +std::once_flag::Execute +0x1800AFF60 +- +MSVC once_flag _Execute_once; used by UnityExplorer; see Ch. 16 +D3D11::Reinit +0x1800825B0 +- +Recreate D3D11 render target+shaders on WM_SIZE; see Ch. 7 +ModuleManager::RenderFrame +0x180082FC0 +- +ImGui NewFrame + per-module Render dispatch; see Ch. 15 +FpsUnlocker::UpdateStub +0x180085B40 +- +Tab destructor/cleanup wrapper for FpsUnlocker; see Ch. 12 +FpsUnlocker::Render +0x180085B90 +- +ImGui panel: FPS cap checkbox + DragInt; see Ch. 12 +FreeCam::Update +0x1800871A0 +- +Per-frame: CinemachineBrain camera override; see Ch. 12 +NoClip::UpdateStub +0x180089B00 +- +Tab destructor/cleanup wrapper for NoClip; see Ch. 12 +NoClip::Update +0x180089B50 +- +Per-frame: CharacterController.enabled toggle; see Ch. 12 +PlayerProfile::Update +0x18008A4F0 +- +Per-frame: UI node traversal + text injection; see Ch. 12 +UTF8ToWide +0x18008B4E0 +- +MultiByteToWideChar wrapper for path conversion; see Ch. 11 +ModulePathScanner::EFSearch +0x18008B937 +- +wcsstr branch: search for EF-Cheeto.dll in path; see Ch. 11 +SkillHack::RenderPanel +0x18008D240 +- +ImGui panel body after hook install; see Ch. 10 +Vacuum::Render +0x180093CA0 +- +ImGui panel: Vacuum checkbox + monster sub-checkbox; see Ch. 12 +Vacuum::EntityIterator +0x180094000 +- +Inner entity array iteration for item vacuum; see Ch. 12 +HookManager::AllocTrampoline +0x1800A960C +- +Allocate trampoline slot near target VA; see Ch. 8 +UnityExplorer::MemsetBlock +0x1800AC86A +- +Memset 0xD8 bytes at [.data+0x2200] during init; see Ch. 16 +# 15. ModuleManager Dispatch Architecture +Source file: E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp (string at RVA 0x3B0BC0). The ModuleManager is the central runtime controller responsible for: (1) maintaining the registrar list, (2) constructing module instances during Init, (3) dispatching per-frame Render calls from the D3D11 Present hook, and (4) dispatching per-frame hotkey processing. +## 15.1 Key Data Structures +ModuleManager object layout (rcx in all dispatch calls): +struct ModuleManager { +BaseModule** instances_begin; // [+0x00] begin ptr (vector) +BaseModule** instances_end; // [+0x08] end ptr +BaseModule** instances_cap; // [+0x10] capacity ptr +bool initialized; // [+0x18] set to 1 after Init() completes +// [+0x19..+0x1F] padding +// [+0x20..+0x57] registrar list (vector — 0x60-byte stride elements) +}; +Global singleton pointers in .data: +[.data+0x23B8] ModuleManager.instances_begin (registrar slots array begin) +[.data+0x23C0] ModuleManager.instances_end +[.data+0x23C8] ModuleManager.instances_cap +[.data+0x2398] ModuleManager object ptr (passed as rcx to dispatch loops) +[.data+0x23A8] secondary ptr (capacity end) +BaseModule vtable layout (confirmed from factory stubs at 0x9B660–0x9B7A0 and dispatch call sites): +Slot +Offset +Description +Notes +[0] ++0x00 +copy-ctor/factory() +placement-new style ctor; writes vtable ptr, returns this +[1] ++0x08 +copy-ctor/factory() +same as [0] +[2] ++0x10 +Init()/RegisterTab() +jmp stub -> actual RegisterTab fn for the module +[3] ++0x18 +Render() +per-frame UI + game-state dispatch — called by Present hook loop +[4] ++0x20 +~BaseModule() +destructor: frees name string, conditional operator delete +[5] ++0x28 +getNamePtr() +returns &this->name_string (this+0x08) +[6] ++0x30 +onHotkey() +pure virtual (value = 1 sentinel); not implemented in any module +[7] ++0x38 +getLinkedModuleFactory() +returns factory ptr for a paired module (e.g. FpsOverlay) +BaseModule instance layout (from dispatch loop field access and RegisterTab writes): +struct BaseModule { +void* vtable; // [+0x00] +std::string name; // [+0x08] SSO string (24 bytes) +std::string tab_name; // [+0x20] secondary name / tab label +bool enabled; // [+0x28] ON/OFF flag — checked by dispatch loops +// [+0x29..+0x2F] padding +// [+0x30..] module-specific fields (move_speed, fps_target, etc.) +}; +## 15.2 Registrar Lambda Registration (startup) +During DLL initialization (before ModuleManager::Init is called), ten registrar lambdas fire. Each calls ModuleManager::AddRegistrar (RVA 0x9B2C0) passing the module name string and a factory std::function. The registrar slots are pushed into the vector at [.data+0x23B8] with stride 0x60 bytes per slot. Registration order (determined from code order in .text): +Order +Module Name +Registrar code RVA +Factory .rdata RVA +vtable RVA +1 +SetDither +0x001C41 +0x3B0D58 +0x3B0D58 +2 +FreeCam (fps) +0x001C80 +0x3B0E70 +0x3B0E70 +3 +SkillHack +0x001D50 +0x3B0EE0 +0x3B0EE0 +4 +PlayerProfile +0x001E20 +0x3B0D90 +0x3B0D90 +5 +NoClip +0x001EF0 +0x3B0DC8 +0x3B0DC8 +6 +Vacuum +0x001FC0 +0x3B0E38 +0x3B0E38 +7 +UnityExplorer +0x002090 +0x3B0D28 +— +8 +FpsUnlocker +0x001B80 +0x3B0E00 +0x3B0E00 +9 +FreeCam (main) +0x001AB0 +0x3B0E70 +0x3B0E70 +10 +ESPModule +0x001980 +— +— +ModuleManager::AddRegistrar (RVA 0x9B2C0) logic: constructs a std::string from the name argument, calls 0x18000F7D0 (TabManager::RegisterTab), then appends the registrar's std::function wrapper to the instances array. If the vector is full it calls the grow helper at 0x9B3C0. +## 15.3 ModuleManager::Init (RVA 0x9AC10) +Called once from startup sequence (RVA 0xA9190). Guards against double-init via [rcx+0x18] flag. Log messages: 'Initializing ModuleManager' (0x3B0C08) and 'ModuleManager initialization complete' (0x3B0C60). Asserts at source lines 34 and 52 reference ModuleManager.cpp. +Init body: +void ModuleManager::Init(ModuleManager* self) { +if (self->initialized) { +Log('[WARNING] ModuleManager already initialized'); +return; +} +Log('Initializing ModuleManager'); +// Assert (line 34 in ModuleManager.cpp) +// Move instances_begin ptr to match registrar list +rsi = &self->instances_begin; +if (self->instances_begin != self->instances_end) +*rsi = self->instances_begin; +// Wait for std::once_flag at [.data+0x23D0] +// (once_flag guards module instance allocation) +// Iterate registrar array ([.data+0x23B8]..[.data+0x23C0]) +// stride = 0x60 bytes per registrar slot +for (rbx = registrars_begin; rbx < registrars_end; rbx += 0x60) { +std::function* factory = rbx->invoke_ptr; // [rbx+0x58] +BaseModule* mod = factory->operator()(); // vtable[+0x10]() +// Append to instances list +*instances_end = mod; +instances_end += 0x8; +// (grow vector if needed via 0x9B0D0) +// Call vtable[+0x8] on module = getName() +const char* name = mod->vtable[+0x8](mod); +// Log 'Module {name} initialized' +// Log formatted assert (line 45 in ModuleManager.cpp) +assert_log(mod->name, ModuleManager_cpp, line=45); +} +self->initialized = true; +Log('ModuleManager initialization complete'); +// Assert (line 52 in ModuleManager.cpp) +} +## 15.4 Per-Frame Dispatch Loops +Three dispatch functions iterate the instances array each frame. All share the same structure: guard on initialized flag, pointer-chase loop over [begin..end], null check, enabled flag check at [module+0x28], then vtable call. +Dispatch Loop 1 — ModuleManager::DispatchRender (RVA 0x9AE80): +// Called from Present hook with rcx = &ModuleManager (at [.data+0x2398]) +void ModuleManager::DispatchRender(ModuleManager* self) { +if (!self->initialized) return; +BaseModule** it = self->instances_begin; +BaseModule** end = self->instances_end; +while (it != end) { +BaseModule* mod = *it; +if (mod && mod->enabled) // [mod+0x28] != 0 +mod->vtable[0x18](mod); // Render() +it++; +} +} +Dispatch Loop 2 — ModuleManager::DispatchHotkeys (RVA 0x9AEF0): +void ModuleManager::DispatchHotkeys(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod && mod->enabled) +mod->vtable[0x30](mod); // onHotkey() — pure virtual, no-op for all current modules +} +} +Dispatch Loop 3 — ModuleManager::DispatchRegistrarInit (RVA 0x9AF60): +// Called at 0x180083348 — initializes ImGui panel layout after first Present +void ModuleManager::DispatchRegistrarInit(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod) +mod->vtable[0x38](mod); // getLinkedModuleFactory() — installs linked tab +} +// After loop: copy default panel config block +// movups xmm0, [.data+0x1F08]; movups [.data+0x1F28], xmm0 +// movups xmm1, [.data+0x1F18]; movups [.data+0x1F38], xmm1 +// (16-byte config copy for initial panel state) +} +15.4.1 Exception Handling in Dispatch Loops +The pseudocode above omits the C++ exception-handling wrappers that the compiler generated around each vtable call. Each dispatch loop body is actually enclosed in a __try/__except block; the MSVC runtime (__CxxFrameHandler4, thunk table at RVA 0xAC840, imported from VCRUNTIME140.dll) is registered as the Structured Exception Handler via the .pdata unwind tables. If a module's virtual method throws, the runtime calls one of three catch-handler functions: 0xAEBC0 logs “[ERROR] Failed to update module ‘’” (associated with DispatchRender / Update), 0xAEC50 logs “[ERROR] Failed to render overlay for module ‘’”, and 0xAECE0 logs “[ERROR] Failed to process hotkeys for module ‘’”. All three handlers call the shared logging helper at 0x18000FDA0 (Log/Print) and then resume normally rather than propagating the exception, so a single misbehaving module cannot crash the entire frame. +## 15.5 Present Hook Call Site (RVA 0x082F00) +The Present hook callback contains all three dispatch calls plus the ImGui frame boundary calls. Relevant excerpt (from context around RVA 0x083386): +// 1. DispatchRegistrarInit (once_flag guarded) — installs linked tabs +rcx = &ModuleManager; // [.data+0x2398] +call ModuleManager::DispatchRegistrarInit; // 0x18009AF60 +// 2. DispatchRender — calls Render() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchRender; // 0x18009AE80 +// 3. DispatchHotkeys — calls onHotkey() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchHotkeys; // 0x18009AEF0 +// 4. Continue to D3D11 frame boundary / ImGui EndFrame +call 0x18001C2D0; +## 15.6 Per-Module vtable[+0x10] and vtable[+0x18] Resolved Targets +vtable[+0x10] = Init/RegisterTab (called once during ModuleManager::Init). vtable[+0x18] = Render (called every frame from DispatchRender). +Module +vtable RVA +vtable[+0x10] target +vtable[+0x18] target +Notes +Vacuum +0x3B0E38 +0x090060 (RegisterTab) +0x09B640 -> [.data+0x05D0] fn ptr +NoClip +0x3B0DC8 +0x081A20 (RegisterTab) +0x09B670 -> [.data+0x06D0] fn ptr +PlayerProfile +0x3B0D90 +0x0813D0 (RegisterTab) +0x09B6A0 -> [.data+0x0580] fn ptr +SkillHack +0x3B0EE0 +0x0818E0 (RegisterTab) +0x09B6D0 -> [.data+0x0770] fn ptr +hook installer +FreeCam +0x3B0E70 +0x081300 (RegisterTab) +0x09B700 -> [.data+0x07D0] fn ptr +SetDither +0x3B0D58 +0x081590 (RegisterTab) +0x09B730 -> [.data+0x0630] fn ptr +no-op +FpsOverlay +0x3B0E00 +0x081810 (RegisterTab) +0x09B760 -> [.data+0x0530] fn ptr +overlay +Note: vtable[+0x18] for each module returns a .data block ptr via a 2-instruction lea/ret stub. This stub serves as the state block accessor used during object cleanup. The actual Render dispatch uses this indirection: the stub returns the module's .data state block, which at offset [+0x00] stores a direct fn ptr to the Render/Update function installed by RegisterTab. The dispatch loop calls the stub (vtable[+0x18]) to get this function pointer, then calls through it. +## 15.7 ModuleManager Log Strings +String +RVA +Context +'[WARNING] ModuleManager already initialized' +0x3B0B88 +Init guard +'Initializing ModuleManager' +0x3B0C08 +Init begin +'Module {} initialized' +0x3B0C48 +Per-module Init success +'ModuleManager initialization complete' +0x3B0C60 +Init end +'Failed to initialize module {}' +0x3B0C28 +Init error handler +'[ERROR] Failed to update module ' +0x3B0C90 +Update error handler +'[ERROR] Failed to render overlay for module ' +0x3B0CB8 +Render error handler +'[ERROR] Failed to process hotkeys for module ' +0x3B0CE8 +Hotkey error handler +ModuleManager.cpp source path +0x3B0BC0 +Assert source file string +# 16. UnityExplorerModule +UnityExplorerModule is a fully implemented, live developer-tool module embedded inside the cheat. It is registered as the final entry in the module list (registration code at RVA 0x002090) and shares the Vacuum vtable (0x3B0E38), inheriting its factory and base dispatch structure. Its RegisterTab function is at RVA 0x090060, its per-frame Update stub points to the shared no-op destructor at RVA 0x083DC0 (same stub as SetDither and SkillHack). The module is not a stub — it contains a complete ImGui-based runtime Unity scene hierarchy browser and component inspector. +## 16.1 Registration and Vtable +The registrar lambda at RVA 0x002090 stores Vacuum's vtable pointer (0x1803B0E38) as the factory and passes the string 'UnityExplorerModule' (RVA 0x3B0D28) to ModuleManager::AddRegistrar. This means during ModuleManager::Init, calling vtable[+0x10] on UnityExplorerModule's registrar invokes Vacuum's RegisterTab stub (RVA 0x9B650), which resolves via jmp to UnityExplorerModule::RegisterTab at RVA 0x090060. The vtable[+0x18] dispatch slot returns [.data+0x2610] — the module's state block — and the per-frame render fn ptr is written there during RegisterTab. +Registration: RVA 0x002090 (AddRegistrar call; factory = Vacuum vtable 0x3B0E38) +RegisterTab: RVA 0x090060 (init; registers tab 'Unity Explorer', zeroes state) +Render: RVA 0x090250 (per-frame ImGui scene/inspector panel) +Update stub: RVA 0x083DC0 (shared no-op; frees string, optional delete) +State block: [.data+0x2610] (0x190 bytes, zero-filled by memset at 0x0900BC) +Tab name: 'Unity Explorer' (string RVA 0x3B02D0) +Window title: 'Unity Explorer Window' (RVA 0x3B02E0) +## 16.2 RegisterTab (RVA 0x090060) +RegisterTab is guarded by a std::once_flag at [.data+0x260C]. On first call it: (1) zero-fills the 0x190-byte state block at [.data+0x2610] via memset (0x1800AC86A); (2) constructs the tab name std::string 'Unity Explorer' and calls TabManager::RegisterTab (0x18000F7D0) to register the ImGui tab at [.data+0x2618]; (3) writes the Update fn ptr (0x1803AFA38 → RVA 0x083DC0, shared no-op stub) to [.data+0x2610]; (4) zeroes all state fields (scene list vector, selected index, refresh flags, auto-refresh bool, interval float, search filter buffer, component list, inspector string); (5) calls std::once_flag::_Execute_once (0x1800AFF60) to seal the guard. On subsequent calls the already-initialized guard causes an early return at 0x1800901D8. +Key state fields initialized during RegisterTab: +[.data+0x2610] update_fn_ptr = 0x083DC0 (no-op stub) +[.data+0x2618] tab_string = 'Unity Explorer' (std::string) +[.data+0x2638] enabled = 0 (bool, OFF by default) +[.data+0x2640] auto_refresh = 0 (bool) +[.data+0x2644] refresh_interval = 3.0f (0x40400000) +[.data+0x2648] scene_list_begin = 0 (ptr, vector) +[.data+0x2650] scene_list_end = 0 +[.data+0x2660] scene_list_cap = 0 +[.data+0x2670] selected_scene_idx = 0 +[.data+0x2680] selected_obj_idx = 0 +[.data+0x2684] search_filter[0x100] = 0 (char buffer) +[.data+0x2784] inspector_active = 0 (bool) +[.data+0x2788] inspected_obj_ptr = 0 +[.data+0x2790] inspected_obj_name = 0 (std::string) +## 16.3 Render / Per-Frame Logic (RVA 0x090250) +The Render function checks enabled ([this+0x28]) and a secondary active flag ([this+0x30]) before drawing. When both are set it calls ImGui::Begin with 'Unity Explorer Window' (RVA 0x3B02E0, via jmp to 0x1800937D0 = ImGui::Begin wrapper). The main function body at RVA 0x0902E0 is a substantial per-frame function that draws the complete inspector UI. +Scene panel logic: +// Check scene list (vector at [this+0x58]..[this+0x60]) +if (scene_list is empty) { +ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +} else { +ImGui::Text("Select Scene:"); +ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +if (combo changed) { LoadScene(selected_scene_idx); } +} +// Writes g_Config->overlay_flags |= 1 and g_Config->overlay_scale = 300.0f +// (at [g_Config+0x1F78] and [g_Config+0x1F90]) when scene panel is active +Auto-refresh logic (RVA 0x090250): +if (enabled && auto_refresh) { +now = GetTime(); // 0x180093B10 +elapsed = now - last_refresh_time; +max_entries = (float)refresh_interval * SCALE_CONST; +if (elapsed_entries >= max_entries) { +RefreshScenes(this); // 0x180090D40 +last_refresh_time = now; +} +} +GameObject hierarchy panel (drawn when a scene is selected): +// Search filter input: ##SearchFilter — writes to search_filter[0x100] buffer +// GameObject list: iterates [this+0x40]..[this+0x48] (vector) +// Per entry: prints '[namespace]: ' prefix + name +// 'Ins##' button beside each entry -> inspect that object +// If list empty: Text('No GameObjects found in this scene.') +// 'DontDestroyOnLoad' section: special scene with fallback text if not found +Inspector panel (when an object is selected via 'Ins' button): +// 'No GameObject selected.' if none +// Otherwise shows: +// 'Active' checkbox (calls GameObject.SetActive via IL2CPP) +// Transform section: Position, Local Position, Rotation, Scale (float3 inputs) +// 'Components' section: 'GameObject Class: %s.%s' +// 'All Components:' list via IL2CPP GetComponents(UnityEngine.Component) +// Per component: '%s.%s' (namespace.classname) +// On fetch failure: 'Unknown Component' or 'Unable to get GameObject class information.' +## 16.4 Complete String Inventory +String +RVA +Usage +'UnityExplorerModule' +0x3B0D28 +Module name (registrar) +'Unity Explorer' +0x3B02D0 +Tab label; ImGui::Begin title +'Unity Explorer Window' +0x3B02E0 +ImGui window title string +'Search Filter:' +0x3B02F8 +Label above search input +'##SearchFilter' +0x3B0308 +ImGui InputText widget ID +'Inspector' +0x3B0318 +Inspector sub-panel label +'GameObjectHierarchy' +0x3B0328 +Hierarchy sub-panel label +'No scenes loaded. Click Refresh...' +0x3B0340 +Empty scene list message +'Scene: ' +0x3B0390 +Scene prefix label +'No GameObjects found in this scene.' +0x3B0398 +Empty hierarchy message +'DontDestroyOnLoad' +0x3B03C0 +Special DDOL scene label +'DontDestroyOnLoad (Not Found)' +0x3B03D8 +DDOL fallback label +'Refresh' +0x3B03F8 +Refresh button label +'Auto Refresh' +0x3B0400 +Auto-refresh checkbox +'Interval (s)' +0x3B0410 +Refresh interval slider label +'Scenes found: %d' +0x3B0420 +Scene count display +"No scenes available. Click 'Refresh Scenes' to load." +0x3B0438 +No-scenes message +'Select Scene:' +0x3B0470 +Scene selector label +'Select Scene' +0x3B0480 +Combo default text +'##SceneCombo' +0x3B0490 +ImGui Combo widget ID +']: ' +0x3B04A0 +Object list entry separator +'Ins##' +0x3B04A8 +Inspect button label prefix +'No GameObject selected.' +0x3B04B8 +Inspector empty state +"Click 'Ins' button..." +0x3B04D0 +Inspector hint text +'Active' +0x3B0508 +Active checkbox label +'Transform' +0x3B0510 +Transform section header +'Position' +0x3B0520 +Position field label +'Local Position' +0x3B0530 +Local position field label +'Rotation' +0x3B0540 +Rotation field label +'Scale' +0x3B054C +Scale field label +'No Transform component found.' +0x3B0558 +Transform fallback message +'Components' +0x3B0578 +Components section header +'GameObject Class: %s.%s' +0x3B0588 +Class display format +'All Components:' +0x3B05A0 +Component list header +'UnityEngine.Component, UnityEngine.CoreModule' +0x3B05B0 +IL2CPP type name for GetComponents +'%s.%s' +0x3B05E0 +Component name format +'Unknown Component' +0x3B05E8 +Component fallback name +'No components found or failed to get components.' +0x3B0600 +Component fetch failure +'Unable to get GameObject class information.' +0x3B0638 +Class info failure +## 16.5 Assessment +UnityExplorerModule is a developer/debug tool that was purpose-built alongside the cheat modules and registered in the same module system. It provides a runtime Unity scene browser — listing loaded scenes, displaying the active GameObject hierarchy with a search filter, and offering a per-object inspector showing Transform (position, rotation, scale), active state, and all attached components retrieved via IL2CPP reflection (GetComponents with 'UnityEngine.Component, UnityEngine.CoreModule' as the type argument). +The module is enabled by the same ON/OFF flag ([module+0x28]) as all other modules and is rendered every frame from the same DispatchRender loop. Its auto-refresh timer (default 3.0s interval, bool at [.data+0x2640], float at [.data+0x2644]) periodically re-enumerates loaded scenes via RefreshScenes (RVA 0x090D40). The g_Config writes inside Render ([g_Config+0x1F78] |= 1, [g_Config+0x1F90] = 300.0f) activate the overlay resize logic while the explorer window is open. +This is the probable origin of the DLL's filename 'unityexplorer.dll' — the binary was named after this embedded developer tool to serve as cover, making the file appear to be a legitimate Unity debugging utility rather than a game cheat. +# 17. Per-Config-Preset Writers +The cheat implements four named configuration presets that write distinct sets of skill-timing and distance-threshold constants into g_Config at runtime. These are not game-version or region variants as originally suspected; they are user-selectable combat automation profiles, each named after a science-fiction reference. The active preset name string is stored at [.data+0x00E0] and the integer index at [.data+0x00EC]. On startup the Settings tab reads both the current theme name and the default preset indicator from the config JSON, compares the theme string against each preset name via ImGui::Selectable (0x1800708D0), and calls the matching writer directly — all four calls reside in a single function at RVA 0x09A4F0. +## 17.1 Dispatch Mechanism +The dispatch logic is in the Settings tab render function at RVA 0x09A4F0. It reads the saved preset name string from the JSON config object (keyed 'Default', 'Evangelion Unit 01', 'Evangelion Unit 02', or 'Matrix'), compares via ImGui::Selectable, stores the matched preset name pointer to [.data+0x00E0], writes the index integer (0–3) to [.data+0x00EC], then calls the corresponding writer immediately. On subsequent frames the startup code at 0x082F02 reads [.data+0x00EC] and re-routes to the same writer if the selection changes: +// RVA 0x082F00 version dispatch +ecx = g_Config->preset_index; // [.data+0x00EC] +switch (ecx) { +case 0: WriterDefault(); // RVA 0x0941F0 +case 1: WriterEvangelionUnit01(); // RVA 0x094890 +case 2: WriterEvangelionUnit02(); // RVA 0x096770 +case 3: WriterMatrix(); // RVA 0x098650 +} +## 17.2 Preset Summary +Preset name +Index +Writer RVA +Write count +g_Config range +'Default' +0 +0x0941F0 +168 +0xDA4 – 0x12A4 +'Evangelion Unit 01' +1 +0x094890 +23 +0xD9C – 0xEBE +'Evangelion Unit 02' +2 +0x096770 +23 +0xD9C – 0xEBE +'Matrix' +3 +0x098650 +13 +0xD9C – 0xE14 +'Default' is the master preset and the only one that writes the full skill-timing table (g_Config offsets 0xEC8–0x12A4). The three non-default presets are thin overlays that write only the distance-threshold and encounter-tuning floats at offsets 0xD9C–0xEBE, leaving the skill-timing table zeroed for their entries. When any non-default preset is active the skill-timing table fields written by Default remain at their last-written values (the table is not re-zeroed between preset switches). +## 17.3 g_Config Field Semantics +The written offsets cluster into two functional groups identified by value range and stride pattern. +Distance / encounter thresholds (offsets 0xD9C–0xE30) — written by all four presets. Values are floats in the range 0.0–21.0, representing game-unit distances. Groups of four consecutive dwords repeat the stride [min_x, min_y, range, limit] observed in ESP module configuration. Example values across presets: +g_Config offset +Default +EvaUnit01 +EvaUnit02 +Matrix +Semantic +0x0D9C +0.0 +1.0 +1.0 +1.0 +Encounter active flag / base threshold +0x0DA0 +0.0 +0.60 +0.60 +0.50 +Approach multiplier +0x0DA4 +10.0 +10.0 +10.0 +8.0 +Max detect range (units) +0x0DA8 +10.0 +10.0 +10.0 +8.0 +Max engage range (units) +0x0DAC +8.0 +4.0 +4.0 +0.0 +Attack range (units) +0x0DB0 +0.0 +0.0 +0.0 +1.0 +Reserved / extra trigger flag +0x0DDC +8.0 +6.0 +6.0 +5.0 +Secondary range A +0x0DE0 +6.0 +4.0 +4.0 +3.0 +Secondary range B +0x0E0C +21.0 +0.0 +0.0 +0.0 +Max AoE range (Default only) +0x0E14 +15.0 +14.0 +14.0 +12.0 +Long-range threshold +Skill timing table (offsets 0xEC8–0x12A4) — written only by the Default preset (168 entries, all zero in the other three presets). Values are floats in the range 0.02–1.0 organized in repeating groups of four dwords: [min_time, max_time, window_end, confidence]. This matches the SkillHack timing parameters documented in Section 8. Each group of four corresponds to one skill slot. The table spans approximately 40 skill slots covering offsets 0xEC8 through 0x1144, with an additional small block at 0x1298–0x12A4. Example timing entries from Default: +// g_Config[0xEC8..0xED7]: Skill slot 0 timing (Default) +[0xEC8] min_time = 0.85f +[0xECC] max_time = 0.85f +[0xED0] win_end = 0.85f +[0xED4] confidence= 1.00f +// g_Config[0xED8..0xEE7]: Skill slot 1 timing (Default) +[0xED8] min_time = 0.50f +[0xEDC] max_time = 0.50f +[0xEE0] win_end = 0.50f +[0xEE4] confidence= 1.00f +// g_Config[0xEE8..0xEF7]: Skill slot 2 timing (Default) +[0xEE8] min_time = 0.05f +[0xEEC] max_time = 0.05f +[0xEF0] win_end = 0.07f +[0xEF4] confidence= 0.90f +// ... continues through ~40 skill slots to 0x1144 +// g_Config[0x1298..0x12A7]: final 4-entry block +[0x1298] min_time = 0.05f +[0x129C] max_time = 0.05f +[0x12A0] win_end = 0.07f +[0x12A4] confidence= 0.73f +## 17.4 Preset Behavioral Differences +The three non-default presets represent incrementally more conservative tuning. 'Evangelion Unit 01' and 'Evangelion Unit 02' are nearly identical — both reduce attack range from 8.0 to 4.0, reduce long-range threshold from 15.0 to 14.0, and set the secondary detection distance lower than Default. The only distinction between the two Evangelion presets is a small float difference at offset 0xDC0/0xDC4 (both 0.50 in Unit 01 vs. both 0.50 in Unit 02 — functionally identical in the parsed output; any distinction would be in fields that were not written by the respective functions and thus retained from previous state). 'Matrix' is the most conservative preset: it lowers attack range to 0.0 (disabling direct attack trigger), cuts max detect range to 8.0, reduces the long-range threshold to 12.0, and sets the extra trigger flag at 0xDB0 to 1.0, suggesting it relies on a different trigger path. +The 'Default' preset is by definition the most aggressive: it provides the only non-zero skill timing table and the widest detection ranges. This is consistent with the binary having version_index = 1 hardcoded at .data+0x00EC at static-init time, meaning 'Evangelion Unit 01' loads on first launch before the user selects a preset from the Settings tab. +## 17.5 Preset Name Strings +String +RVA +Role +'Default' +0x3B06F8 (via 0x3B0AF8) +Preset name, ImGui label, JSON key; also theme name for Default +'Evangelion Unit 01' +0x3B06D0 (via 0x3B0AD4+) +Preset name and JSON key for index 1 +'Evangelion Unit 02' +0x3B0AE0 +Preset name and JSON key for index 2 +'Matrix' +0x3B0B10 +Preset name and JSON key for index 3 +'Theme' +0x3B0AD4 +JSON field name for preset selection +'zh_cn' +0x3B10E8 +Locale string; passed to string-construct at 0x9D8A4 (ecx==1 branch) +'en' +0x3B2020 +Locale string; passed to string-construct at 0x9D890 (ecx==0/2 branch) +The 'zh_cn' and 'en' locale strings at 0x3B10E8 and 0x3B2020 are constructed as std::string values during a JSON key-lookup operation at RVA 0x09D7D0 (called from the Settings tab). The locale is selected by the same integer switch (ecx) that dispatches the preset writers — 0 maps to 'en', 1 maps to 'zh_cn', and 2 falls back to 'en'. This implies the preset index also encodes locale preference: 'Default' (index 0) and the two Evangelion presets and 'Matrix' are treated as CN (index 1) by default, and 'en' is the fallback locale for presets 0 and 2. The locale string is used as the second argument to a JSON object accessor, indicating that config field names are stored locale-keyed in the JSON schema. +# 18. GABypass +GABypass is the IL2CPP function pointer resolution subsystem. Its sole function is to locate the game's IL2CPP runtime module (GameAssembly.dll) in the process address space, then compute and cache the addresses of 71 specific IL2CPP and Unity API methods that the cheat's modules call at runtime. It does not patch instructions, overwrite vtables, or install hooks — it is a pure address-resolution table initializer. The resolved pointers are stored in .data slots at offsets 0x1C48 through 0x1E80 and are subsequently used by every cheat module that makes IL2CPP calls: ESPModule, NoClip, FreeCam, SkillHack, FpsUnlocker, and the UnityExplorer component. +## 18.1 Initialization Sequence +GABypass::Patch (RVA 0x09D1E0) is called exactly once during startup from the main DLL thread at RVA 0x0A942A, immediately after the 'Initializing..' console log and before any module Update() or Render() calls. The call sequence is: +// RVA 0x0A942A (main.cpp line 53, per embedded source path) +Log("Initializing.."); +GABypass::Patch(); // RVA 0x09D1E0 — resolve 71 IL2CPP pointers +il2cpp_domain = [.data+0x1E80](); // call il2cpp_domain_get_assemblies immediately +if (il2cpp_domain != null) { +Log("IL2CPP Domain Found: " + ...); +} +// ... module init continues +Inside GABypass::Patch, execution branches on whether [.data+0x00F0] is already non-null. That slot holds the cached GameAssembly.dll module base address. On first call (cold start), [.data+0x00F0] is zero, so the function calls GetModuleHandleW(L"GameAssembly.dll") via the IAT slot at 0x1800B1290 to obtain the module base, stores it in rdx, then computes all 71 pointers as fixed offsets from that base. On subsequent calls (if Patch is ever called again), [.data+0x00F0] is already populated so the 'GA Bypass successfully!' log and GetModuleHandleW call are skipped and rdx is loaded directly from the cached value before the offset table is re-written. In practice Patch is only called once. +// GABypass::Patch (RVA 0x09D1E0) — annotated +if ([.data+0x00F0] != 0) { +Log("GA Bypass successfully!"); // already cached, log and skip resolve +rdx = [.data+0x00F0]; +goto write_table; +} +rdx = GetModuleHandleW(L"GameAssembly.dll"); // first-run: locate module +write_table: +// 71x: [.data+slot] = rdx + IL2CPP_offset +[.data+0x1C70] = rdx + 0x0018AD80; // il2cpp_object_get_class +[.data+0x1C78] = rdx + 0x00007480; // il2cpp_class_get_method_from_name +[.data+0x1E70] = rdx + 0x00D94C10; // il2cpp_domain_get +[.data+0x1E78] = rdx + 0x00D94DA0; // il2cpp_assembly_get_image +[.data+0x1E80] = rdx + 0x00D93A60; // il2cpp_domain_get_assemblies +// ... 66 additional Unity/game method pointers +ret +## 18.2 The 71-Entry Pointer Table +Each entry is a QWORD at a fixed .data offset. The IL2CPP offset column is the byte distance from the GameAssembly.dll module base to the target function — these are static, computed at compile time from a known game binary version. The table spans two contiguous .data regions: 0x1C48–0x1CF8 (IL2CPP runtime and UnityEngine core) and 0x1D00–0x1E80 (game-specific methods, additional Unity API, UI/camera). +# +.data offset +IL2CPP offset +Resolved function +Used by +1 +0x1C48 ++0x09DC0120 +GameObject.GetComponentByIndex +UnityExplorer inspector +2 +0x1C50 ++0x0018CEC0 +il2cpp_domain_get_assemblies (A) +GABypass init / UnityExplorer +3 +0x1C58 ++0x0B390700 +Component.GetComponent +UnityExplorer / NoClip +4 +0x1C60 ++0x0B3A2D20 +Transform.get_localScale +UnityExplorer inspector +5 +0x1C68 ++0x0B3A2CB0 +Transform.get_rotation +UnityExplorer inspector +6 +0x1C70 ++0x0018AD80 +il2cpp_object_get_class +UnityExplorer type query +7 +0x1C78 ++0x00007480 +il2cpp_class_get_method_from_name +UnityExplorer method lookup +8 +0x1C80 ++0x0B3A1AE0 +Transform.get_localPosition +UnityExplorer / NoClip +9 +0x1C88 ++0x0B3A1A70 +Transform.get_position +ESP / NoClip +10 +0x1C90 ++0x0B3A51D0 +Transform.set_localPosition +NoClip teleport +11 +0x1C98 ++0x0B398830 +GameObject.SetActive +UnityExplorer / NameChanger +12 +0x1CA0 ++0x0B3911F0 +GameObject.get_transform +ESP / NoClip +13 +0x1CA8 ++0x0B3A59D0 +Transform.set_rotation +FreeCam / NoClip +14 +0x1CB0 ++0x0B391D90 +GameObject.get_activeInHierarchy +UnityExplorer inspector +15 +0x1CB8 ++0x0B3B2410 +GameObject.get_tag +UnityExplorer inspector +16 +0x1CC0 ++0x0B3B2120 +GameObject.get_name +UnityExplorer inspector +17 +0x1CC8 ++0x0B3B40B0 +GameObject.get_layer +UnityExplorer inspector +18 +0x1CD0 ++0x0B397980 +GameObject.get_scene +UnityExplorer inspector +19 +0x1CD8 ++0x02F3DA80 +Game: skill/buff method A +SkillHack +20 +0x1CE0 ++0x00F27E10 +Game: skill/buff method B +SkillHack +21 +0x1CE8 ++0x0B329000 +Component.GetComponents +UnityExplorer component list +22 +0x1CF0 ++0x0B329D80 +Component.GetComponentsInChildren +UnityExplorer tree walk +23 +0x1CF8 ++0x03E9BB50 +Game: skill/ability slot method A +SkillHack +24 +0x1D00 ++0x0B383F60 +Object.get_name +UnityExplorer name display +25 +0x1D08 ++0x0B33CAB0 +Component.GetType (A) +UnityExplorer type display +26 +0x1D10 ++0x0B33CB00 +Component.GetType (B) +UnityExplorer type display +27 +0x1D18 ++0x039D1AA0 +Game: skill/ability slot method B +SkillHack +28 +0x1D20 ++0x026DE9F0 +Game: combat/hit method A +SkillHack / combat +29 +0x1D28 ++0x0478E860 +Game: UI show/hide toggle +NoClip / FpsUnlocker UI +30 +0x1D30 ++0x025E2D40 +Game: combat/hit method B +SkillHack / combat +31 +0x1D38 ++0x087C2CD0 +Game: movement/physics method A +NoClip CharacterController +32 +0x1D40 ++0x03419AF0 +Game: movement/physics method B +NoClip CharacterController +33 +0x1D48 ++0x0B322FB0 +SceneManagement.Scene.get_name +UnityExplorer scene display +34 +0x1D50 ++0x0B396A20 +SceneManager.GetActiveScene +UnityExplorer scene query +35 +0x1D58 ++0x0B397700 +CinemachineBrain.get_ActiveVirtualCamera +FreeCam hook +36 +0x1D60 ++0x03766810 +Game: entity/actor state method A +ESP / SkillHack +37 +0x1D68 ++0x0B3A2A60 +Transform.set_localScale +UnityExplorer inspector +38 +0x1D70 ++0x0B326660 +Rigidbody.get_velocity +NoClip / Vacuum +39 +0x1D78 ++0x0B3266B0 +Rigidbody.set_velocity +NoClip / Vacuum +40 +0x1D80 ++0x0B383200 +Object.Destroy +UnityExplorer +41 +0x1D88 ++0x0B3A1A10 +Transform.set_position +NoClip teleport / Vacuum +42 +0x1D90 ++0x0B3A2340 +Game: entity/actor state method B +ESP +43 +0x1D98 ++0x0B421800 +Input.GetAxis('Mouse X') +FreeCam look X +44 +0x1DA0 ++0x0B3A26D0 +Game: player state method A +ESP / SkillHack +45 +0x1DA8 ++0x0B3A1FB0 +Game: player state method B +ESP / SkillHack +46 +0x1DB0 ++0x0B32B030 +Game: player health/stat accessor +ESP health display +47 +0x1DB8 ++0x0B391240 +GameObject.SetActive (CinemachineBrain active flag) +FreeCam enable/disable +48 +0x1DC0 ++0x0B390440 +Camera.get_main +ESP worldToScreen / FreeCam +49 +0x1DC8 ++0x0B390F80 +GameObject.FindObjectOfType +Active scene object scan +50 +0x1DD0 ++0x0B3A19A0 +Transform.get_position (2nd ref) +ESP / NoClip +51 +0x1DD8 ++0x03F85430 +Game: skill/action method C +SkillHack +52 +0x1DE0 ++0x0B3A1D30 +Transform.set_rotation (2nd ref) +FreeCam / NoClip +53 +0x1DE8 ++0x0B3A1C90 +Camera.get_fieldOfView +FreeCam FOV control +54 +0x1DF0 ++0x00E92CF0 +Game: entity/actor state method C +ESP +55 +0x1E00 ++0x03DC14C0 +Game: skill/action method D +SkillHack +56 +0x1E08 ++0x03E0D2C0 +Game: skill/action method E +SkillHack +57 +0x1E10 ++0x03D9DF30 +Game: skill/action method F +SkillHack +58 +0x1E18 ++0x00E9E9F0 +Game: skill/action method G +SkillHack +59 +0x1E20 ++0x03EA53C0 +Game: skill/action method H +SkillHack +60 +0x1E28 ++0x0ACA0EC0 +TMPro.TextMeshProUGUI.set_text +Name changer UI label +61 +0x1E30 ++0x0B391D40 +UnityEngine.UI.Text.set_text +ON/OFF toggle labels / Name changer +62 +0x1E38 ++0x036AA8F0 +Game: skill/action method I +SkillHack +63 +0x1E40 ++0x03EC31C0 +Game: skill/action method J +SkillHack +64 +0x1E48 ++0x037F8CD0 +Game: entity/actor method D +ESP / combat +65 +0x1E50 ++0x036EA640 +Game: skill/action method K +SkillHack +66 +0x1E58 ++0x03EC30E0 +Game: skill/action method L +SkillHack +67 +0x1E60 ++0x037F2A40 +Game: entity/actor method E +ESP / combat +68 +0x1E68 ++0x037FD7E0 +Game: entity/actor method F +ESP / combat +69 +0x1E70 ++0x00D94C10 +il2cpp_domain_get +UnityExplorer domain probe +70 +0x1E78 ++0x00D94DA0 +il2cpp_assembly_get_image +UnityExplorer assembly walk +71 +0x1E80 ++0x00D93A60 +il2cpp_domain_get_assemblies (B) +Post-patch domain probe (main.cpp:67) +## 18.3 Functional Grouping +The 71 entries divide into four functional groups. Six entries (slots 2, 6, 7, 69, 70, 71) are IL2CPP runtime API functions — the low-level metadata accessors that the cheat uses to walk the IL2CPP type system for the UnityExplorer inspector. Their offsets are clustered near the start of GameAssembly.dll (+0x0007480, +0x0018AD80, +0x0018CEC0, +0x00D93A60, +0x00D94C10, +0x00D94DA0), consistent with early-loaded IL2CPP initialization code. +Thirty-four entries are UnityEngine managed API methods — Transform, GameObject, Component, Camera, Rigidbody, SceneManager, and Object — that provide the cheat with Unity scene graph access, world-space position manipulation, and object lifecycle control. These are used across all active modules: ESP calls position/camera methods every frame, NoClip writes to Transform.set_position and Rigidbody.set_velocity, FreeCam uses Camera.get_fieldOfView and CinemachineBrain.get_ActiveVirtualCamera, and the UnityExplorer inspector uses the full component introspection set. +Twenty-six entries are game-specific methods at offsets deep into GameAssembly.dll (+0x02F3DA80 and above), most concentrated in the 0x03xxxxxx–0x0Bxxxxxx range. Twelve of these are identifiable SkillHack targets (slots 19–20, 23, 27–28, 30, 51, 55–59, 62–66) — the methods responsible for skill cooldown, buff application, and action validation that SkillHack intercepts or spoofs. The remaining game-specific entries cover combat hit methods, movement/physics controllers, entity state accessors, and player stat readers used by the ESP and combat modules. +Five entries cover additional UI and camera libraries: Cinemachine (slot 35, CinemachineBrain), TextMeshPro (slot 60, TextMeshProUGUI.set_text), and legacy Unity UI (slot 61, UnityEngine.UI.Text.set_text). These are used exclusively by the Name Changer module and the FreeCam camera management code. +## 18.4 Version Sensitivity +All 71 IL2CPP offsets are hard-coded at compile time as fixed displacements from the GameAssembly.dll base. There is no runtime method name lookup, no FNV hash scan, and no fallback if an offset is wrong — if the game updates and shifts any of these methods, the corresponding cheat feature silently malfunctions (calling into an arbitrary address). The SkillHack module uses a separate FNV-1a name-hash lookup path (documented in Section 8) as a secondary resolution mechanism for its core hook target, but the 26 game-specific GABypass entries have no such fallback. This architecture implies the binary is built and tested against a specific pinned game version; the version-selector system documented in Section 15 may exist partly to accommodate minor offsets shifts across game build variants, but the offsets themselves are not adjusted per variant. +# 19. JSON Config Schema and Save/Load System +This chapter resolves the config-schema investigation. The binary does not implement a standalone .json config file. All cheeto settings persistence is handled through ImGui’s built-in .ini settings mechanism, augmented with per-module custom settings handlers registered at runtime. +## 19.1 IAT — File I/O Functions (Complete Resolution) +The PE import table was fully parsed this session, resolving every previously unidentified IAT slot relevant to file I/O and config: +IAT[0xB1268] = GetCurrentThreadId (stack cookie check at 0xAC709, NOT file I/O) +IAT[0xB1278] = VirtualFree +IAT[0xB1288] = VirtualProtect +IAT[0xB1178] = GetConsoleWindow (used in Settings tab Toggle Console) +IAT[0xB1628] = ShowWindow (used in Settings tab Toggle Console) +IAT[0xB1858] = fread (file read, called ONLY from 0x12121) +IAT[0xB1868] = fwrite (called from 0xEA1B, 0x170D6, 0x3033B, 0x3076D) +IAT[0xB1870] = fclose (called from 0xEAB0, 0x1212F, 0x121A9, 0x170DF etc.) +IAT[0xB1888] = _wfopen (wide-char file open, called ONLY from 0x11F93) +IAT[0xB1890] = fseek (called from 0x120BC, 0x120E7) +IAT[0xB1898] = ftell (called from 0x120A0, 0x120CD) +## 19.2 No Standalone JSON Config File +Exhaustive scanning of the binary confirmed no .json filename string exists anywhere in rdata or .data. The config system is the standard ImGui .ini persistence layer. All module settings are serialized through ImGui’s settings-handler API, not a JSON library. The nlohmann::json_abi_v3_12_0 library present in the binary is used exclusively for the i18n translation table, not for config I/O. +## 19.3 Config File: imgui.ini +The config filename “imgui.ini” (RVA 0x3ABB60) is set at RVA 0x1117A into ImGuiIO+0x20 (the IniFilename field) during ImGuiIO initialization. The log filename “imgui_log.txt” (RVA 0x3ABB70) is set into ImGuiIO+0x28 at the same site. Both are written relative to the process working directory at runtime. +## 19.4 Save/Load Trigger and Execution Path +Load path (on startup): RVA 0x30661 calls the file-read helper at 0x12050, which executes ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell again (0x120CD) → malloc → fread (0x12121) → fclose (0x1212F). The buffer is passed to 0x30840 (ParseIniSettingsFromMemory), which walks the handler list at [ImGuiContext+0x2920] calling each registered handler’s ReadLine callback. +Save path (periodic): The render loop checks [ImGuiContext+0x2900] (dirty flag, byte) and [ImGuiContext+0x2904] (float countdown timer). When both conditions are met, RVA 0x30A90 (SaveIniSettingsToDisk) builds the path from [ImGuiContext+0x2910] (custom IniFilename) or falls back to [.data+0x1BEC]. It calls each handler’s WriteAll callback, then passes the buffer to 0x11EA0 (_wfopen wrapper with “wt” mode at RVA 0x1803AD594), fwrite (0x3076D), and fclose (0x30776). The manual save trigger at RVA 0x17072 sets [ImGuiContext+0x2900]=1 and [ImGuiContext+0x2904]=0 to force an immediate write. +## 19.5 i18n Translation Table (Clarification) +The blob starting at RVA 0x3B10E8 is the compile-time JSON localization table, not the config schema. It is a single JSON object mapping English UI label strings to Chinese (zh_cn) equivalents. At startup (RVA 0x2164), a std::string constructor copies this blob (length 0xEED bytes) into [.data+0x1EB8]. The i18n loader at RVA 0x9D660 selects either “en” or “zh_cn” values based on the language toggle flag. The nlohmann runtime type-error strings (object, array, null, string, number, parse_error etc.) at 0x3B3010–0x3B30D8 confirm nlohmann v3.12.0 is statically linked. +The “enabled” string at RVA 0x3B0B28 is one of these UI labels; it is used to display the module on/off state in the GUI and is not a JSON config key. +## 19.6 Module Settings Handler Architecture +Each module registers a settings handler at [ImGuiContext+0x2920] (a dynamically-grown array of 0x48-byte handler structs). The handler struct layout (from RVA 0x30904): ++0x00 TypeName (const char*) — section identifier in .ini file ++0x08 TypeHash (u32) — CRC32 of TypeName (computed at 0x3079C–0x30803) ++0x18 ReadOpenFn — called when section header encountered ++0x38 WriteAllFn — called during save to emit key=value lines +The 11 registered module classes identified from RTTI at .data+0x0590–0x0E60 are: ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule. +## 19.7 ModuleManager Lifecycle +ModuleManager::Init (RVA 0x9ACA4) iterates the module registry at [.data+0x23B8], calls vtable[+0x10] to obtain each module instance, then vtable[+0x08] to initialize it. Each initialized module is logged as “Module {} initialized” (string at RVA 0x3B0C48). Completion is logged as “ModuleManager initialization complete” (RVA 0x3B0C60). The per-frame dispatch methods are vtable[+0x18] (Update, iterated at 0x9AE80) and vtable[+0x30] (RenderOverlay, iterated at 0x9AEF0). Both iterate the same module list checking [module+0x28] (enabled flag) before calling the virtual. +## 19.8 Settings Tab Behavior +Settings::RenderOverlay (RVA 0x9A4F0–0x9AB98, source E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp) handles: language toggle via 0x9D660 (reads [.data+0x1EB8] i18n blob, selects “en” or “zh_cn” values); theme color initialization via 0x98650 (parses hex color strings e.g. “00FF41FF” from rdata into [.data+0x1C00+0xD9C..] float RGBA fields); console window toggle via GetConsoleWindow (IAT[0xB1178]) and ShowWindow (IAT[0xB1628]). There are no Save/Load buttons; settings are persisted automatically by the ImGui .ini mechanism on each render frame that detects a dirty flag. +# 20. FPSModule +FPSModule implements two independent features controlled by the “FPS Monitor” tab in the GUI: an in-game FPS counter overlay and a separate FPS cap unlocker. The RTTI decorated name is .?AVFPSModule@@ (RVA 0x3C5CF8). The module name string “FPS Monitor” resides at RVA 0x3AFA88; “Show FPS Overlay” at 0x3AFA98; the overlay prefix string “FPS: ” at 0x3AFAAC. +## 20.1 Registration and Vtable +The registrar constructor references the name string at RVA 0x1B71 and calls the module registry at 0x9B2C0. Two vtable blocks are emitted. The lambda vtable (for the registrar’s std::function wrapper) lives at 0x3B0E00; the module instance vtable is at 0x3B0E38. The singleton object is heap-allocated and its pointer cached at [.data+0x22E0] (VA 0x1803C72E0). +Instance vtable (0x3B0E38): +[+0x00] 0x9B660 dtor +[+0x08] 0x9B660 dtor (scalar deleting) +[+0x10] 0x9B650 Initialize -> jmp 0x90060 +[+0x18] 0x9B640 GetSingleton -> returns [.data+0x05D0] +[+0x20] 0x9B620 dtor with size 0x10 +[+0x28] 0x9B630 GetSelf -> lea rax,[rcx+8]; ret +[+0x38] 0x9B720 vtable setter (returns ptr to 0x3B0E70) +[+0x48] 0x9B710 Update -> jmp 0x81300 +## 20.2 Initialize (RVA 0x814C0) +Guarded by a once_flag at [.data+0x2310]. On first call it allocates the module object (0xD8 bytes via 0xAC86A), stores the vtable pointer from 0x3AFA38 into [.data+0x22E0], copies the name string “FPS Monitor” into [.data+0x22E8], sets enabled = 0x0 at [.data+0x2308], then overwrites the vtable slot with the render-function pointer from 0x3AFAC0. If already initialized the singleton pointer is returned early from [.data+0x22E0]. +## 20.3 RenderOverlay — Panel (RVA 0x85660; inner ImGui branch at 0x856F0) +The panel render function is called by ModuleManager::RenderOverlay. It renders two ImGui checkboxes inside the “FPS Monitor” collapsing header. The first checkbox (“FPS Monitor”, bound to [module+0x28]) toggles the FPS counter overlay; on state change it sets [ImGuiContext+0x2900]=1 (dirty flag) and resets the ini-save timer. The second checkbox (“Show FPS Overlay”, RVA 0x3AFA98) is bound to [module+0x28] via 0x85320 (Checkbox with state-ptr helper) and controls display of the overlay window. After both checkboxes, the function calls ImGui::EndDisabled via [ImGuiContext+0x27F0] WORD counter decrement. +## 20.4 RenderOverlay — FPS Counter Overlay (RVA 0x858D0) +When the FPS overlay is enabled ([module+0x28] != 0), this function draws a frameless ImGui window labelled “##Foreground” (RVA 0x3ABF10) pinned to the top-left of the viewport. It calls [.data+0x1D38] (GetDeltaTime via ImGuiContext) with rcx=0, computes xmm6 = 1.0 / deltaTime (i.e. current FPS), builds the display string “FPS: ” + integer FPS value (via 0x7F5C0), then selects a text color from three XMMWORD constants based on two hard-coded thresholds: +fps >= 60 -> color constant at 0x1803B3530 (green) +30 <= fps < 60 -> color constant at 0x1803B3540 (yellow) +fps < 30 -> color constant at 0x1803B3510 (red) +The colored FPS string is then submitted to the ImGui drawlist via 0x51580 (AddText with explicit color). The overlay window uses ImGui foreground drawlist accessed through [ImGuiContext+0x15D8]+0x40. +## 20.5 Singleton State Layout +FPSModule singleton base address: [.data+0x22E0] (VA 0x1803C72E0). Object size: 0xD8 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3AFAC0 after init) ++0x08 std::string name = "FPS Monitor" ([.data+0x22E8]..[.data+0x2307]) ++0x28 BYTE enabled (0 = disabled; written at [.data+0x2308]) ++0x30 BYTE show_fps_overlay (checkbox state for "Show FPS Overlay") ++0x60 XMMWORD (overlay window position/size, zeroed on init) +# 21. PreventScreenshot +PreventScreenshot prevents the game window from being captured by screen-recording tools. RTTI: .?AVPreventScreenshot@@ (RVA 0x3C5DA8). GUI label: “Prevent Screenshot” (RVA 0x3B00B8). The module uses the Windows API SetWindowDisplayAffinity (string at .data RVA 0x3C34A6, imported dynamically from user32.dll at RVA 0x3AEC70) with a Windows 10 build check before applying the affinity flag. +## 21.1 Registration and Vtable +Singleton pointer cached at [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. Once_flag at [.data+0x2390]. Two boolean state fields: [.data+0x2380] = enabled (BYTE, 0 on init), [.data+0x2388] = second toggle flag (BYTE, 0 on init). +## 21.2 Initialize (RVA 0x8AD70) +Guarded by a once_flag at [.data+0x2390]. On first call: constructs the std::string name “Prevent Screenshot” at [.data+0x2360], stores base vtable ptr 0x3AFA38 at [.data+0x2358], overwrites with second vtable ptr from 0x3B0110, zeroes both bool fields at [.data+0x2380] and [.data+0x2388]. +## 21.3 RenderOverlay (RVA 0x8AE60) +Calls GetInstance (0x8AD70) to obtain the module pointer. Renders a single ImGui checkbox “Prevent Screenshot” via 0x9D7D0 (toggle-checkbox helper) with state pointer [module+0x28] (enabled bool). The result is passed to 0x61FE0 (ImGui::Checkbox state commit), then ImGui::EndDisabled is called via the [ImGuiContext+0x27F0] WORD counter path (with an assertion for “Calling EndDisabled() too many times!” at 0x3AC160 if the counter is already zero). +## 21.4 Update — SetWindowDisplayAffinity Dispatch (RVA 0x8AFC0) +Called per-frame by ModuleManager::Update. The logic is: +1. Call GetInstance (0x8AD70) -> rbp = module object ptr +2. If [rbp+0x30] already set: skip (module not yet enabled) +3. If [rbp+0x28] (enabled) set: walk the hook/window list at [.data+0x24D0] +4. For each node [rbx+0x10]: call 0x8B220 (OS-version-checked affinity setter) +5. Call 0x81B00 (build HWND list), then 0x869A0 (apply affinity to all HWNDs) +## 21.5 OS Version Check and SetWindowDisplayAffinity (RVA 0x8B220) +This function loads ntdll.dll (via IAT[0x1800B1290]), resolves “RtlGetVersion” (IAT[0x1800B1088]), and fills a 0x11C-byte OSVERSIONINFOEXW struct on the stack. The OS build number (OSVERSIONINFOEXW.dwBuildNumber) is then cached at [.data+0x24FC] after being memcpy’d into [.data+0x24F0]. On subsequent calls, the cached value is used directly. +The affinity call at 0x8B48F reads [rbp+0x28] (enabled bool) and compares the cached build number against 0x4A61 (decimal 19041, Windows 10 Build 19041 = version 20H1). Two code paths result: +build < 19041: affinity arg = (enabled ? 1 : 0) (WDA_MONITOR = 1) +build >= 19041: affinity arg = (enabled ? 0x11 : 0) (WDA_EXCLUDEFROMCAPTURE = 0x11) +The resolved SetWindowDisplayAffinity function pointer is called via IAT[0x1800B1460]. On pre-20H1 builds, WDA_MONITOR (0x1) is used, which prevents the window from appearing in screen captures taken via the PrintScreen key but not via capture APIs. On 20H1 and later, WDA_EXCLUDEFROMCAPTURE (0x11) is used, which prevents capture by all recording tools including OBS and the Windows Game Bar. The “SetWindowDisplayAffinity” string stored at .data RVA 0x3C34A6 is used as the GetProcAddress argument for the dynamic resolve. +## 21.6 Singleton State Layout +PreventScreenshot singleton base: [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3B0110 after init) ++0x08 std::string name = "Prevent Screenshot" ([.data+0x2360]..[.data+0x237F]) ++0x28 BYTE enabled (checkbox state; drives affinity arg) ++0x30 BYTE state_dirty (set=1 when affinity has been applied; guards re-apply) ++0x38 BYTE second_flag ([.data+0x2388]; purpose unclear, zeroed on init) +The HWND target list at [.data+0x24D0] is a doubly-linked list of window handles to which the affinity is applied. The list is populated by 0x81B00 (enumerate Unity windows) and walked by the Update loop. The count of registered HWNDs is tracked at [.data+0x24D8]. +# 22. ESPModule Render and Update Implementation +Chapter 9 established ESPModule’s state layout and color-table defaults. This chapter documents the two remaining vtable slots not covered there: RenderOverlay (the ImGui control panel) and Update (the per-frame world-space entity label loop), both of which were only identified during the current analysis pass. +## 22.1 RenderOverlay (RVA 0x83FA0) +RenderOverlay is a large, monolithic function spanning roughly 0x83FA0–0x8499E. It draws the “ESP Features” collapsing header and all subordinate controls using the same once-lock + ImGui state machine pattern documented in FPSModule (Chapter 20). The function uses rsi throughout as the ESPModule singleton pointer (base VA 0x1803C6F70). +The function opens a CollapsingHeader titled “ESP Features” (string RVA 0x3AF838) via helper 0x9D7D0 with its state bound to [.data+0x27B0]. If collapsed, execution jumps directly to the epilogue. When expanded, the first control rendered is an “ON / OFF” checkbox (string RVA 0x3AF848) via helper 0x85320; its bool is bound to [rsi+0x28] (enabled). If enabled is false, the remainder of the panel still renders but ImGui’s BeginDisabled path dims and suppresses all interaction. +The “Display Types” sub-header (string RVA 0x3AF858) is rendered via 0x6EC20, which is a lightweight CollapsingHeader wrapper that returns false immediately when ImGui’s locked-input flag ([ImGuiContext+0x106]) is set. When expanded, it presents four entity visibility checkboxes, each bound via 0x61FE0 (ImGui::Checkbox commit helper): +“Show Monsters” (RVA 0x3AF868) → [rsi+0x34] show_monsters +“Show NPC” (RVA 0x3AF878) → [rsi+0x35] show_npc +“Show Friendly” (RVA 0x3AF888) → [rsi+0x36] show_friendly +“Show Puzzles” (RVA 0x3AF898) → [rsi+0x37] show_puzzles +“Show All” (RVA 0x3AF8A8) → [rsi+0x38] show_all +After the Show All checkbox, a Separator is emitted via 0x70630 (which also adjusts the cursor Y position). A second sub-header, “Display Info” (RVA 0x3AF8B8), follows the same 0x6EC20 pattern. When expanded, it reveals the per-label visibility checkboxes: +“Show Distance” (RVA 0x3AF8C8) → [rsi+0x39] show_distance +“Show Name” (RVA 0x3AF8D8) → [rsi+0x3A] show_name +“Show Type” (RVA 0x3AF8E8) → [rsi+0x3C] show_type +A second Separator call via 0x70630 closes the Display Info block. The function epilogue at 0x84984–0x8499E restores the ImGui cursor Y, pops the saved XMM registers, and returns. +## 22.2 Update / DrawOverlay (RVA 0x84A00) +Update is the per-frame entity rendering loop. It is guarded at entry (0x8499F) by a two-instruction stub that tests [rcx+0x28] (enabled) and returns immediately if clear, so the entire loop is skipped when the module is disabled. The main body at 0x84A00 proceeds as follows. +Initialization: the function calls the GetEntityManager cached pointer ([.data+0x1D28], xor ecx, ecx) and GetEntityList ([.data+0x1D30]), both resolved by GABypass. It also calls GetScreenResolution ([.data+0x1D18]) into a local {float2, int} struct, and GetCameraPosition ([.data+0x1D00]) to build a world-origin vector. If the entity count at [rax+0x20] is zero, execution jumps to the epilogue at 0x852AB. +Per-entity loop (0x84B30–0x852A5): for each entity pointer in the array, the function calls GetEntityType ([.data+0x1D20], xor edx edx) and dispatches on the returned type code. The dispatch also loads the per-type color XMMWORD directly from the ESPModule object at a type-dependent offset, and selects the corresponding visibility-flag byte: +type 0x08 → color [rdi+0x70] GREEN (0.00, 1.00, 0.00) flag: show_friendly [rdi+0x36] +type 0x10 / 0x4010 → color [rdi+0x40] RED (1.00, 0.00, 0.00) flag: show_monsters [rdi+0x34] +type 0x20 → color [rdi+0x50] ORANGE (1.00, 0.65, 0.00) flag: show_puzzles [rdi+0x37] +type 0x100 → color [rdi+0x80] BLUE (0.00, 0.00, 1.00) flag: show_npc [rdi+0x35] +default → color [rdi+0xB0] WHITE (1.00, 1.00, 1.00) flag: show_all [rdi+0x38] +Visibility gating: for named types the check is (show_all OR type_flag) != 0; for the default case only show_all is tested. If the entity fails the gate, execution jumps to the loop increment at 0x85289. +Screen-space projection: GetScreenPosition ([.data+0x1CF8]) is called with the entity world position and camera origin to produce a {float2, float} screen-coord struct. The resulting screen-space depth is compared against the module’s max_draw_distance field ([rdi+0x30], default 300); entities beyond that distance are culled at 0x84C6B. +Label assembly: a temporary std::string is built on the stack (0x84CB0). If show_distance ([rdi+0x39]) is set, the metric distance is formatted as an integer via 0x7F5C0 and prepended with the distance marker string “m” (RVA 0x3AF8F4). If show_name ([rdi+0x3A]) is set, GetEntityName ([.data+0x1CE0]) is called and the result is appended; if show_type ([rdi+0x3C]) is set, the entity type code is looked up against a six-entry table at RVA 0x3AF908 / 0x3AF920 mapping type values to name string pairs: +0xFFFFFFFF → “All” +0x00000001 → “Invalid” +0x00000008 → “Character” +0x00000010 → “Enemy” +0x00000020 → “Interactive” +0x00000040 → “Projectile” +If multiple label fields are enabled, segments are joined by “ | ” (RVA 0x3AF900). The assembled label string is then submitted to the ImGui foreground draw list via 0x49820, which positions the text at the projected screen coordinate with a small pixel offset (loaded from RVA 0x3B3224), using the type-selected RGBA color. The foreground draw list is accessed through the “##Foreground” window (RVA 0x3ABF10) as documented in FPSModule. The font for the label is pushed/popped around the call via 0x28C00 and 0x28D70 (BeginFontScope / EndFontScope wrappers). +Loop increment: rbx (entity index) is incremented at 0x85289, r15 advances by 8 bytes through the entity pointer array, and the loop repeats from 0x84B30 until rbx reaches the entity count. On exit the stack cookie is verified and the function returns. +## 22.3 ESPModule Singleton State Layout (Complete) +The following table merges the fields identified in Chapter 9 with the RenderOverlay and Update findings above. Base address: [.data+0x1F70] (VA 0x1803C6F70). All booleans are BYTE; all color slots are XMMWORD (16-byte RGBA float4). +Offset +.data addr +Type +Field / Init Value ++0x00 +[.data+0x1F70] +QWORD +vtable ptr (0x3AFA38 before init; 0x3AF9E0 after) ++0x08 +[.data+0x1F78] +std::string +name = 'ESPModule' (RVA 0x3AF828) ++0x28 +[.data+0x1F98] +BYTE +enabled = 0 ++0x30 +[.data+0x1FA0] +DWORD +max_draw_distance = 300 (0x12C) ++0x34 +[.data+0x1FA4] +BYTE +show_monsters = 1 ++0x35 +[.data+0x1FA5] +BYTE +show_npc = 1 ++0x36 +[.data+0x1FA6] +BYTE +show_friendly = 1 ++0x37 +[.data+0x1FA7] +BYTE +show_puzzles = 1 ++0x38 +[.data+0x1FA8] +BYTE +show_all = 0 ++0x39 +[.data+0x1FA9] +BYTE +show_distance = 1 ++0x3A +[.data+0x1FAA] +BYTE +show_name = 1 ++0x3B +[.data+0x1FAB] +BYTE +reserved = 0 ++0x3C +[.data+0x1FAC] +BYTE +show_type = 0 ++0x40 +[.data+0x1FB0] +XMMWORD +color_enemy RED (1.00, 0.00, 0.00, 1.00) ++0x50 +[.data+0x1FC0] +XMMWORD +color_interactive ORANGE (1.00, 0.65, 0.00, 1.00) ++0x60 +[.data+0x1FD0] +XMMWORD +color_slot2 YELLOW (1.00, 1.00, 0.00, 1.00) ++0x70 +[.data+0x1FE0] +XMMWORD +color_friendly GREEN (0.00, 1.00, 0.00, 1.00) ++0x80 +[.data+0x1FF0] +XMMWORD +color_npc BLUE (0.00, 0.00, 1.00, 1.00) ++0x90 +[.data+0x2000] +XMMWORD +color_slot5 CYAN (0.00, 1.00, 1.00, 1.00) ++0xA0 +[.data+0x2010] +XMMWORD +color_slot6 PURPLE (0.58, 0.00, 0.83, 1.00) ++0xB0 +[.data+0x2020] +XMMWORD +color_default WHITE (1.00, 1.00, 1.00, 1.00) ++0xC0 +[.data+0x2030] +XMMWORD +color_slot8 PINK (1.00, 0.08, 0.58, 1.00) ++0xD0 +[.data+0x2040] +XMMWORD +color_slot9 LPINK (1.00, 0.75, 0.80, 1.00) +Color slots 2, 5, 6, 8, and 9 are not assigned to any type code in the Update dispatch and are therefore spare palette entries; they are exposed in the ImGui color-picker widgets but have no current runtime effect on the overlay. +# 23. DamageHack — Ghost Feature Analysis +The i18n table (RVA 0x3B1484) contains four keys with no corresponding RTTI class, vtable, registrar lambda, registered singleton, or callable code anywhere in the binary: “Damagehack Toggle”, “Damage Multiplier”, “Multiplier Value”, and “Random Damage Type”. This chapter documents what can be determined from the available evidence and establishes what is definitively absent. +## 23.1 i18n Evidence +The four DamageHack keys appear as a contiguous block in the JSON i18n blob immediately after the “Version: ” key and immediately before “This is free, if you spend money, then you have been deceived”. Each key carries English and Simplified Chinese translations: +“Damagehack Toggle” en / zh_cn: 伤害修改 (Damage Modification) +“Damage Multiplier” en / zh_cn: 伤害倍数 (Damage Multiplier) +“Multiplier Value” en / zh_cn: 倍数値 (Multiplier Value) +“Random Damage Type” en / zh_cn: 随机伤害类型 (Random Damage Type) +The Chinese translations are idiomatic and consistent with the translations for implemented features in the same blob, indicating they were written at the same time as the rest of the localisation table. The four keys fit the pattern of a planned ImGui panel: one boolean toggle, one float multiplier, a numeric input for the multiplier value, and an enum selector for damage type randomization. +## 23.2 What Is Absent +A complete binary search for any string containing “Damage”, “damage”, “DamageHack”, or “damagehack” outside the JSON blob returns zero results. The RTTI scan of the .data section (RVA 0x3C5000–0x3C8000) identifies exactly 11 cheat-module class names — ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule — and no DamageHack entry. Similarly, the registrar-lambda RTTI list contains no DamageHack entry. There is no singleton pointer, no once_flag guard, no vtable, and no callable RenderOverlay or Update function anywhere in the image. +## 23.3 Interpretation +DamageHack was planned but never implemented in this build. The i18n keys were added to the localisation file during feature planning or alongside a partial implementation that was subsequently stripped, but no code corresponding to those keys was ever compiled into the binary. This is consistent with the developer shipping the localisation blob as a whole-file asset while selectively excluding unfinished module source files from the build. +The intended design, inferred from the four i18n keys, would have been: a boolean master toggle (“Damagehack Toggle”) gating an intercepted damage-calculation call, a float multiplier applied to the outgoing damage value (“Damage Multiplier” / “Multiplier Value”), and an enum-driven randomisation mode for the damage type field (“Random Damage Type”). The implementation would most likely have operated as an IL2CPP function hook resolved via GABypass, consistent with how SkillHack intercepts cooldown and cost values. +From a detection standpoint, the ghost i18n keys are a useful indicator: any version of this cheat that activates DamageHack controls would be a different build from the one analysed here. The presence of these keys in an extracted string dump of a suspect binary is therefore a build-version discriminator, not evidence of active functionality. +# 25. Sidebar / Main Panel Render (RVA 0x7F8F0) +The top-level overlay panel is rendered by the function at RVA 0x7F8F0 (VA 0x18007F8F0). This function draws the outer “Sidebar” ImGui window that contains all module tab buttons and the About page. It is called from the ModuleManager render loop on every Present() frame and is responsible for the entire visible cheat UI chrome. +## 25.1 Function Signature and Layout +Entry point: RVA 0x7F8F0, approximately 0x146E bytes (tail-calls into ImGui epilogue at 0x180023E20 via jmp at 0x180080D5E). The function allocates a 0x380-byte stack frame, saves xmm6–xmm8, and takes a single rcx argument (ModuleManager / global context pointer). Key address references: +Window title: "Sidebar" (RVA 0x3AF2C8) — used as module lookup key (CRC32 via 0x180011DF0, registry lookup via 0x18003D1A0 and 0x18001D2B0); ImGui::Begin is not called from within 0x7F8F0 itself +Banner string: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) +Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) +Active tab idx: [.data+0x1F68] (VA 0x1803C6F68; written on click, read by jump table at 0x80B52) +## 25.2 Tab Navigation and Rendering +The sidebar renders six tab buttons. Each label is looked up from the i18n table via 0x18009D660 (the same translation dispatcher used by all modules). The six tabs, their label RVAs, and the jump-table case bodies dispatched on selection are: +Tab 0: "About" (RVA 0x3AF2D0) — sidebar header (banner + disclaimer) + About body sub-function (0x80E80) +Tab 1: "Player" (RVA 0x3AF2DC) — NoClip, SkillHack (movement/skill controls) +Tab 2: "ESP" (RVA 0x3AF2E8) — ESPModule overlay features +Tab 3: "World" (RVA 0x3AF2F0) — Vacuum (world/item interaction) +Tab 4: "Visual" (RVA 0x3AF2FC) — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +Tab 5: "Settings" (RVA 0x3ADFD8) — Theme/preset selection via 0x18009A4F0 (language, color theme) +The banner string (RVA 0x3AF258) and anti-scam disclaimer (RVA 0x3AF288) are rendered as a Sidebar-level header before the tab bar. Each of the six tab buttons is rendered by calling 0x80D80 (click-state handler, returns bool); if a tab is clicked its index (0–5) is written to [.data+0x1F68] (VA 0x1803C6F68). After all tab buttons are rendered, a jump table at RVA 0x80B52 reads [.data+0x1F68], bounds-checks against 5, and dispatches to the corresponding case via [0x180000000 + rax*4 + 0x80D64]. Case 0 calls sub-function 0x80E80 (About body: game title, version, author). Cases 1–4 call module-getter helpers that return the relevant singleton pointer, then invoke vtable[0x28] (RenderOverlay) for each. Case 5 delegates to 0x18009A4F0 (Settings/Theme renderer). +## 25.3 Author and Version Display +The About tab body is rendered by sub-function 0x80E80. It displays game context via the format string “%s Game: Endfield CTB3” (RVA 0x3AF350), the version label “Version: ” (RVA 0x3AF368) with value “1.0.0” (RVA 0x3AF374), and the author label “Author: ” (RVA 0x3AF380) with value “gktwo” (RVA 0x3AF38C). These are direct string literals, not i18n-dispatched keys. +## 25.4 Key Address Summary +RVA 0x7F8F0 Sidebar::RenderMainPanel (this chapter) +RVA 0x3AF258 Banner string +RVA 0x3AF288 Anti-scam disclaimer +RVA 0x3AF2C8 "Sidebar" window title +.data+0x1F68 Active tab index (VA 0x1803C6F68; written per-click, dispatched at jump table 0x80B52) +# 26. Language Selector (Sidebar Unconditional Panel) +The sidebar function (0x7F8F0) renders a language-selection sub-panel unconditionally on every frame, before the jump-table dispatch for tab bodies. The panel appears at VA range 0x180080770–0x180080B50 and is part of the sidebar’s Settings section rather than any individual tab body. +## 26.1 String Inventory +RVA 0x3AF310 "English" — first Combo item (index 0) +RVA 0x3AF318 "简体中文" — second Combo item (index 1) +RVA 0x3AF328 " Language" — tab label (5-space indent, 0xD chars) +RVA 0x3AF338 "##Language" — ImGui::Combo widget ID +## 26.2 Execution Flow +The language selector logic follows this sequence: +0x180080895 call 0x18009D660 — locale context init +0x1800808DD lea rsi,[...] # 0x1803AF310 — "English" item ptr +0x1800808E3 lea rbx,[...] # 0x1803AF318 — "简体中文" item ptr +0x1800809A1 lea rdx,[...] # 0x1803AF328 — tab label " Language" +0x1800809C6 call 0x18009D7D0 — BeginTab (render label) +0x180080A03 call 0x180064220 — ImGui::Combo (language dropdown) +al = 1 if selection changed, 0 otherwise +if English selected: +0x180080A2F mov DWORD PTR [0x1803C77B0], r12d — store 0 (language index = English) +if 简体中文 selected: +0x180080A5D mov DWORD PTR [0x1803C77B0], 0x1 — store 1 (language index = ZH-CN) +0x180080A6E call 0x18002A530 — i18n content refresh (reload translations) +0x180080A73 dec DWORD PTR [g_Config+0x2764] — decrement content ref-count +0x180080A80 mov rax,[g_Config+0x15D8] — get active config preset ptr +0x180080A87 mov BYTE PTR [rax+0x103], 0x1 — set dirty flag for config save +0x180080B0B lea rcx,[...] # 0x1803ADFC8 "Content" — module key +0x180080B12 call 0x180011DF0 — CRC32 lookup on "Content" module +0x180080B33 call 0x18003D1A0 — registry lookup +0x180080B4D call 0x18001D2B0 — module notify/update +## 26.3 Language Index State +VA 0x1803C77B0 language_index (DWORD) +0 = English +1 = 简体中文 (Simplified Chinese) +On language change, three things happen: the i18n content is refreshed via 0x18002A530, a config-preset dirty bit is set at [g_Config+0x15D8+0x103], and the “Content” module is notified via the standard CRC32/registry/notify triple (0x180011DF0, 0x18003D1A0, 0x18001D2B0). Two languages are supported in this build: English (default) and Simplified Chinese. +# 27. FreeCam Key Binding Display Panel (RVA 0x87A70–0x88606) +The documented FreeCam::Update function (RVA 0x871A0, see Ch.12.3) is 0x14C6 bytes long and includes a key-binding display section beginning at approximately 0x87A70 that was not previously described. This section renders four float-value sliders and eleven key-binding label rows using ImGui. +## 27.1 Float Sliders +Four consecutive DragFloat/SliderFloat controls appear before the key-binding rows, all using the ImGui slider variant at 0x180065570: +RVA 0x3AFCB0 "Free Camera" — sub-panel BeginTab label +RVA 0x3AF848 "ON / OFF" — toggle checkbox +RVA 0x3AFCC0 "Move Speed" — DragFloat, fmt "%.3f" (0x3ADFB0) +RVA 0x3AFCD0 "Look Sensitivity" — DragFloat, fmt "%.3f" +RVA 0x3AFCE8 "Roll Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFCF8 "FOV Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFD04 "FOV" — DragFloat, fmt "%.1f" (0x3ADFEC) +## 27.2 Key Binding Label Rows +Eleven key-binding rows follow. Each row: (1) calls 0x18000FCB0 (MakeString) to format the label via 0x18005FB60 (sprintf-style, substituting the key name), (2) calls 0x18009D7D0 to render the resulting string as a tab-style label. Unbound keys display “NONE” (RVA 0x3AF820). +RVA 0x3AFD08 "Forward Key: %s" — VA 0x180087A87 +RVA 0x3AFD18 "Backward Key: %s" — VA 0x180087B1A (approx) +RVA 0x3AFD30 "Left Key: %s" +RVA 0x3AFD40 "Right Key: %s" +RVA 0x3AFD50 "Up Key: %s" +RVA 0x3AFD60 "Down Key: %s" +RVA 0x3AFD70 "IncFOV Key: %s" +RVA 0x3AFD80 "DecFOV Key: %s" +RVA 0x3AFD90 "LeftRoll Key: %s" +RVA 0x3AFDA8 "RightRoll Key: %s" +RVA 0x3AFDC0 "ResetRoll Key: %s" +RVA 0x3AF820 "NONE" — displayed for any unbound key +## 27.3 Dispatch Pattern +Each key row uses the same three-call sequence: MakeString (0x18000FCB0) to build the “Key Name: %s” format string, 0x18005FB60 to sprintf the current key name into it, and 0x18009D7D0 to render the result. The key name state block is at [rip+...] # 0x1803C6E98 (the “Pu;” RTTI sentinel in .data indicates the key-binding state array). This panel is visually shown as a collapsible key-rebinding display inside the FreeCam tab when enabled. +# 28. Settings Tab — Theme Selector and Console Toggle (RVA 0x9A4F0) +The Settings tab body function at RVA 0x18009A4F0 (source: SettingsTAB.cpp, RVA 0x3B0B30) renders a theme selector and a console toggle. It is called from sidebar case 5 (0x80D25). The function ends at approximately RVA 0x9AB31. +## 28.1 Theme Selector +A “Theme” combo-box (“Theme” at RVA 0x3B0AD4, rendered via ImGui::Combo at 0x180064220) presents four themes. Selecting a theme calls the corresponding palette-applicator function, which writes RRGGBBAA hex color strings from .rdata into the active ImGui color table. +Theme name strings: +RVA 0x3B0AF8 "Default" — applicator: RVA 0x941F0 (restores ImGui defaults) +RVA 0x3B06D0 "Evangelion Unit 01" — applicator: RVA 0x94890 +RVA 0x3B0AE0 "Evangelion Unit 02" — applicator: RVA 0x96770 +RVA 0x3B0B10 "Matrix" — applicator: RVA 0x98650 +## 28.2 Palette Color Tables +Each non-default theme applicator reads RRGGBBAA hex strings from .rdata and applies them to ImGui style slots. The colors below are listed in the order each applicator writes them (11 colors for Evangelion themes, 10 for Matrix): +Evangelion Unit 01 (RVA 0x94890): +0x3B06F8 #FFFFFFFF 0x3B06E8 #7857A7FF 0x3B0718 #19171CFF +0x3B0708 #2A282EFF 0x3B0738 #2A282EE6 0x3B0728 #4DE6A5FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B0778 #A38CCF80 +0x3B0768 #7857A780 0x3B0798 #4A4552FF +Evangelion Unit 02 (RVA 0x96770): +0x3B06F8 #FFFFFFFF 0x3B0898 #D9293BFF 0x3B0888 #1E1E1EFF +0x3B08B8 #3A3A3AFF 0x3B08A8 #3A3A3AE6 0x3B08D8 #F7B302FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B08C8 #F7465880 +0x3B08F8 #D9293B80 0x3B0798 #4A4552FF +Matrix (RVA 0x98650): +0x3B09B8 #00FF41FF 0x3B09A8 #00AA2CFF 0x3B09D8 #000000FF +0x3B09C8 #0A0A0AFF 0x3B09F8 #0A0A0AE6 0x3B09E8 #004400FF +0x3B0758 #00000000 0x3B0A18 #00440040 0x3B0A08 #00881EFF +0x3B0A38 #00FF4180 +## 28.2.1 Per-Slot Color Applicator Helper (RVA 0x94190) +Each individual color push in the three non-default theme applicators (0x94890, 0x96770, 0x98650) is performed by a shared helper at RVA 0x94190. This function reads an RRGGBBAA hex string from .rdata using __stdio_common_vsscanf (IAT[0xB1880]), converts it to a packed RGBA value, then calls ImGui::PushStyleColor (via 0x180010840) with the target style-slot index and the parsed colour. It is called 159 times across the four writer functions (52 times from 0x94890 alone, corresponding to the full 52-slot Default palette). +## 28.3 Console Toggle +After the theme selector, the function renders a “Toggle Console” checkbox (RVA 0x3B0B00) using CheckboxToggle (0x180085320). The console state is read and displayed via two branches: +RVA 0x3B0B00 "Toggle Console" — checkbox label +if console enabled: display format "Console {}" (RVA 0x3B0B78) +using IAT AllocConsole (0x1800B1178) / GetStdHandle (0x1800B1628) +if console disabled: display "enabled" (RVA 0x3B0B28) +or "Disabled" (RVA 0x3B0B18) +## 28.4 Key Address Summary +RVA 0x9A4F0 SettingsTab::Render (this chapter) +RVA 0x941F0 Default palette applicator +RVA 0x94890 Evangelion Unit 01 palette applicator +RVA 0x96770 Evangelion Unit 02 palette applicator +RVA 0x98650 Matrix palette applicator +RVA 0x3B0AD4 "Theme" combo label +RVA 0x3B0B30 E:\git\Endfield_Cheeto\...\SettingsTAB.cpp +# 29. Win32/D3D11 Overlay Window Initialisation (RVA 0x827A0–0x8375C) +The overlay window subsystem is a single large function at 0x827A0 (called from the startup function 0xA9190 at 0xA9585) with two sub-functions: FindGameWindow (0x835D0) and GetOverlayRect (0x836A0). It creates the transparent layered Win32 window, initialises a D3D11 device and swap chain, runs the Win32 message loop, and keeps the overlay aligned to the game window. Ch. 7 documents the WndProc at 0x826A0 (the window procedure registered by this subsystem); Ch. 15.5 documents the Present hook call site at 0x82F00 which lies inside the message loop body. +## 29.1 DPI Awareness Initialisation (0x827FF–0x82923) +The function opens with a TLS-guarded once_flag block before performing DPI setup. Two DPI APIs are tried in priority order. First, LoadLibraryA(‘user32.dll’) is called (via IAT[0xB10E0]) and GetProcAddress is used to locate SetThreadDpiAwarenessContext; if found, it is called with context value 0xFFFFFFFFFFFFFFFC (DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2). If that fails, LoadLibraryA(‘shcore.dll’) and GetProcAddress resolve SetProcessDpiAwareness, which is then called with value 2 (PROCESS_PER_MONITOR_DPI_AWARE). If both dynamic lookups fail, the fallback is SetProcessDPIAware (IAT[0xB15A0]), a legacy API that sets system-DPI awareness. The guard at [.data+0x3C7440] / [.data+0x3C7448] ensures each path runs at most once. +## 29.2 Game Window Location and Window Class Registration (0x82924–0x82A28) +EnumWindows (IAT[0xB14A0]) is called with FindGameWindow (0x835D0) as the callback to locate the Unity game window. A WNDCLASSEX structure is then populated: CreateSolidBrush(0x7F00) (IAT[0xB1018]) sets the background brush to an opaque olive colour used only as a placeholder; LoadCursorW (IAT[0xB15C8]) provides the standard arrow cursor; two LoadIconW calls (IAT[0xB14E8]) load the small and large application icons. RegisterClassExW (IAT[0xB1638]) registers the class. GetSystemMetrics (IAT[0xB14E0]) is called twice to retrieve the full screen width (SM_CXSCREEN) and height (SM_CYSCREEN) for the initial window geometry. +## 29.3 Overlay Window and D3D11 Device Creation (0x82A29–0x82BFF) +CreateWindowExW (IAT[0xB1650]) creates the overlay window with WS_EX_LAYERED | WS_EX_TRANSPARENT style flags so it passes mouse input through to the game beneath it. SetLayeredWindowAttributes (IAT[0xB15E0]) sets the colour key and alpha. DwmExtendFrameIntoClientArea (IAT[0xB1918]) extends the DWM glass frame into the entire client area, which together with the layered attributes produces a fully transparent background. D3D11CreateDeviceAndSwapChain (IAT[0xB1908]) is called twice: the first call at 0x82B24 attempts D3D_FEATURE_LEVEL_11_0 with DXGI_FORMAT_R8G8B8A8_UNORM; on failure the second call at 0x82B7E retries with a DXGI_FORMAT_B8G8R8A8_UNORM swap chain as a fallback. After a successful device create, the compiled shader objects from Ch. 5 are bound. The helper 0x825B0 (called at 0x82B8C; documented in Ch. 7 as D3D11::Reinit) sets up the ImGui D3D11 backend. ShowWindow (IAT[0xB1628]) and UpdateWindow (IAT[0xB14D8]) make the window visible. CreateMutexA (IAT[0xB1720]) at 0x82C0D creates a named mutex to prevent duplicate overlay instances. +## 29.4 Initialisation Log and Message Loop (0x82C01–0x8352F) +Before entering the loop, the string ‘Initialized’ (RVA 0x3AF610) is logged at 0x82F5F from source file E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp. The main loop uses the standard Win32 pattern: PeekMessageW (IAT[0xB14D0]) / TranslateMessage (IAT[0xB14C8]) / DispatchMessageW (IAT[0xB14C0]). Each iteration calls FindWindowA(‘UnityWndClass’, NULL) (IAT[0xB14A8] called at 0x8301F) to verify the game process is still running; if the window disappears the loop exits. IsWindow (IAT[0xB1468]) validates the game HWND, GetWindowThreadProcessId (IAT[0xB1498]) retrieves its thread, and GetWindowRect (IAT[0xB1488]) reads its current bounds. SetWindowPos (IAT[0xB1588]) repositions the overlay to match the game window on every frame. GetForegroundWindow (IAT[0xB15F0]) and three GetClassNameA calls (IAT[0xB1490]) detect whether the game is the active foreground window and adjust the overlay visibility state via two SetWindowLongW calls (IAT[0xB15B0]). SwitchToThread (IAT[0xB1148]) at 0x8348A yields the CPU when the game is not in focus. On loop exit, DestroyWindow (IAT[0xB1570]) and UnregisterClassW (IAT[0xB1640]) clean up the overlay window and class. +## 29.5 FindGameWindow Callback (RVA 0x835D0) +This function is passed as the lpEnumFunc callback to EnumWindows. For each top-level window it calls GetWindowThreadProcessId (IAT[0xB1498]) and GetClassNameA (IAT[0xB1490]), then compares the class name against the literal string ‘UnityWndClass’ (RVA 0x3AF658) using the internal string-compare helper at 0xACA12. On a match it calls SetForegroundWindow (IAT[0xB1518]) to bring the game to the front, records the HWND, and then calls GetOverlayRect (0x836A0) to capture the initial window geometry. A second GetWindowThreadProcessId and AttachThreadInput call at 0x8368E synchronise the overlay thread’s input queue with the game thread. +## 29.6 GetOverlayRect (RVA 0x836A0) +Called by FindGameWindow and on every frame to compute the overlay rectangle. IsWindowVisible (IAT[0xB1480]) and IsIconic (IAT[0xB1510]) first check that the game window is visible and not minimised. DwmGetWindowAttribute (IAT[0xB1920]) with DWMWA_EXTENDED_FRAME_BOUNDS retrieves the DWM-adjusted window bounds (which exclude the invisible resize borders). GetClientRect (IAT[0xB15A8]) provides the inner client area. Two GetWindowLongPtrW calls (IAT[0xB1470]) read GWL_STYLE and GWL_EXSTYLE to account for window border widths. The function returns the final overlay RECT which SetWindowPos uses to position the overlay exactly over the game viewport. +## 29.7 Key Address Table +RVA 0x827A0 WinInit top-level entry (called from 0xA9585) +RVA 0x827FF DPI init block TLS-guarded; tries SetThreadDpiAwarenessContext then SetProcessDpiAwareness +RVA 0x82924 EnumWindows find game HWND via FindGameWindow callback +RVA 0x8298B RegisterClassExW overlay window class registration +RVA 0x82A29 CreateWindowExW WS_EX_LAYERED overlay window +RVA 0x82A60 DwmExtendFrameIntoClientArea full transparent client area +RVA 0x82B24 D3D11CreateDeviceAndSwapChain primary attempt (DXGI_FORMAT_R8G8B8A8_UNORM) +RVA 0x82B7E D3D11CreateDeviceAndSwapChain fallback (DXGI_FORMAT_B8G8R8A8_UNORM) +RVA 0x82C0D CreateMutexA single-instance guard mutex +RVA 0x82F5F ‘Initialized’ log source: UI.cpp; emitted after device creation succeeds +RVA 0x82F00 Present hook site documented in Ch. 15.5 +RVA 0x8348A SwitchToThread yields when game is not in foreground +RVA 0x835D0 FindGameWindow EnumWindows callback; locates ‘UnityWndClass’ HWND +RVA 0x836A0 GetOverlayRect DwmGetWindowAttribute + GetClientRect; returns overlay RECT +RVA 0x826A0 WndProc documented in Ch. 7 +# 24. Final Analysis Summary +EF-Cheeto.dll (internal name, distributed as unityexplorer.dll) is a fully-featured Unity game cheat module for an IL2CPP-based game. The complete analysis across twenty-five chapters reveals the following architecture: +Infrastructure Layer: D3D11 Present hook for overlay rendering, Win32 WndProc subclass for hotkeys, Toolhelp32 thread enumeration for safe code patching, MSVC-standard stack cookie security (no active anti-debug), D3DCompile for ImGui shaders, and _wfopen-based config persistence using nlohmann/json serialization. +Hook Engine: Custom hook manager with FNV-1a hash table, trampoline allocation via VirtualAlloc, thread-safe patching via Suspend/Resume, and a 71-entry IL2CPP function pointer bypass table (GABypass). +Cheat Modules (11 registered + 1 ghost): NoClip (CharacterController bypass), SkillHack (cooldown/cost IL2CPP hooks), FreeCam (CinemachineBrain camera override), FpsUnlocker (targetFrameRate), FPSModule (FPS counter overlay; see Ch. 20), SetDither (render setting), PlayerProfile (UI text injection), Vacuum (monster item pull), ESPModule (entity overlay, 10-color table; see Ch. 22), DamageHack (ghost — i18n only, no code; see Ch. 23), PreventScreenshot (registered; SetWindowDisplayAffinity). +Configuration: 172-field g_Config struct at .data+0x1F70, per-version config writers for multiple game versions, auto-save timer at [state+0x2904], ImGui layout persistence via standard ini format. +The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows, targeting IL2CPP Unity games. All twenty-five chapters together constitute a complete static reconstruction of the binary with no significant undocumented regions remaining. diff --git a/IDA/project/docs/input/files3/ef_cheeto_feed_2_header.md b/IDA/project/docs/input/files3/ef_cheeto_feed_2_header.md new file mode 100644 index 0000000..c87a273 --- /dev/null +++ b/IDA/project/docs/input/files3/ef_cheeto_feed_2_header.md @@ -0,0 +1,2371 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 2/3 +# This part: Reconstruction header with all structs, RVAs, string table, IL2CPP table. +# Feed with Parts 1 and 3 for complete reconstruction context. + +================================================================================ +RECONSTRUCTION HEADER (ef_cheeto_reconstruction.h) +Compiles: g++ -std=c++17 -fsyntax-only +2,092 lines covering 538 RVAs, 97 .data addresses, 189 strings, 75 IAT entries +================================================================================ + +// ============================================================================ +// EF-Cheeto (unityexplorer.dll) — Reconstruction Headers +// Derived from: EF-Cheeto_Vol12_Final_Analysis.docx (complete binary audit) +// Target: x86-64 Windows DLL, MSVC build, GameAssembly.dll (Endfield) +// Base VA: 0x180000000 | .data base: 0x1803C5000 (RVA 0x3C5000) +// ============================================================================ + +#pragma once +#include +#include + +// ============================================================================ +// SECTION 1 — PRIMITIVE TYPEDEFS +// ============================================================================ + +using u8 = uint8_t; +using u16 = uint16_t; +using u32 = uint32_t; +using u64 = uint64_t; +using i32 = int32_t; +using f32 = float; +using f64 = double; +using BOOL = int; // IL2CPP managed bool return (al register) + +// ============================================================================ +// SECTION 2 — GLOBAL .DATA LAYOUT (abridged — key singletons) +// ============================================================================ +// All offsets are RVA from binary base 0x180000000. +// VA = 0x180000000 + RVA. +// .data region starts at RVA 0x3C5000 (VA 0x1803C5000). +// References below use shorthand [.data+N] meaning VA 0x1803C5000 + N. +// +// Key global pointers: +// [.data+0x00D8] g_D3DState ptr (D3D11 device/swap chain block) +// [.data+0x00E0] active_preset_name (std::string — "Preset0".."Preset3") +// [.data+0x00EC] active_preset_index (DWORD — 0-3) +// [.data+0x00F0] gameassembly_base (cached GetModuleHandleW result) +// [.data+0x1E88] hook_spinlock (DWORD — 0=free, 1=held) +// [.data+0x1E90] hook_allocator_ptr (IAllocator for hook_array, capacity 0x80) +// [.data+0x23B8] ModuleManager.registrars_begin +// [.data+0x23C0] ModuleManager.registrars_end +// [.data+0x23C8] ModuleManager.registrars_cap +// [.data+0x2398] ModuleManager object ptr +// [.data+0x23A8] ModuleManager secondary ptr +// [.data+0x23D0] ModuleManager once_flag (std::once_flag) + +// ============================================================================ +// SECTION 3 — g_Config (global config object) +// ============================================================================ +// g_Config is a large global object stored in .data. +// Fields below are offsets FROM the g_Config object base (not from .data base). +// g_Config does not have a single documented base address — it IS .data in +// the relevant regions. Use field VA = 0x1803C5000 + offset where offset +// matches the [.data+N] values from the doc. +// +// PANEL / UI scroll state (used by all module Render() panel-open sequences) +struct GConfigPanelFields { + // offset from g_Config (which sits at .data) + // [g_Config+0x0058] scroll_base (float) — horizontal scroll base offset + // [g_Config+0x00D8] d3d_state_ptr (void*) — D3D11 state block + // [g_Config+0x0150] panel_width (float) — rendered panel content width + // [g_Config+0x0194] scroll_accum (float) — accumulated horizontal scroll + // [g_Config+0x0198] scroll_total (float) — total scroll range + // [g_Config+0x0E0C] scroll_step (float) — per-frame scroll delta + // [g_Config+0x15D8] panel_ptr (void*) — pointer to active ImGui panel struct + // [g_Config+0x1BEC] imgui_ini_fallback (void*) — fallback .ini path ptr + // [g_Config+0x1C00] scroll_region_root (void*) — root of scroll region config + // [g_Config+0x1F68] active_tab_idx (DWORD) — written by binding state array +}; + +// Panel-open sequence (all modules — addss path): +// rax = *panel_ptr; +// rax->field_0x103 = 1; +// xmm0 = scroll_step + rax->scroll_accum + rax->scroll_base + rax->scroll_total; +// rax->panel_width = xmm0; +// Panel-close sequence (subss path): same but scroll_accum -= scroll_step. + +// HOOK SLOTS [g_Config+0x1E40..0x1E68] (SkillHack IL2CPP hook target pointers) +// [g_Config+0x1E40] hook5_target — ApplySkillCost() (void fn) +// [g_Config+0x1E48] hook6_target — (dispatcher target) +// [g_Config+0x1E50] hook3_target — GetCooldownPercent() (float fn) +// [g_Config+0x1E58] hook4_target — IsSkillAvailable() (BOOL fn) +// [g_Config+0x1E60] hook1_target — skill check A (BOOL fn) +// [g_Config+0x1E68] hook2_target — skill check B (BOOL fn) + +// OVERLAY FLAGS (written by UnityExplorer when window is active) +// [g_Config+0x1F78] overlay_flags (DWORD) — |= 1 when UE window open +// [g_Config+0x1F90] overlay_scale (float) — set to 300.0f when UE open + +// ============================================================================ +// SECTION 4 — IL2CPP FUNCTION POINTER TABLE +// ============================================================================ +// GABypass::Patch (RVA 0xA9120) resolves 71 function pointers from +// GameAssembly.dll at DLL attach and writes them to .data slots. +// Format: slot_rva = .data offset from g_base 0x1803C5000 +// Access: fn_ptr = *(void**)(gameassembly_base + il2cpp_offset) +// +// Key: ptr = *(void**)(.data + slot_rva) +// call as: ((RetType(*)(Args...))(ptr))(args...); + +struct IL2CPP_Table { + // Slot .data-offset | IL2CPP offset | Resolved name + void* GameObject_GetComponentByIndex; // 0x1C48 +0x09DC0120 + void* il2cpp_domain_get_assemblies_A; // 0x1C50 +0x0018CEC0 + void* Component_GetComponent_Transform; // 0x1C58 +0x0B390700 + void* Transform_get_localScale; // 0x1C60 +0x0B3A2D20 + void* Transform_get_rotation; // 0x1C68 +0x0B3A2CB0 + void* il2cpp_object_get_class; // 0x1C70 +0x0018AD80 + void* il2cpp_class_get_method_from_name;// 0x1C78 +0x00007480 + void* Transform_get_localPosition; // 0x1C80 +0x0B3A1AE0 + void* Transform_get_position; // 0x1C88 +0x0B3A1A70 [also 0x1DD0] + void* Transform_set_localPosition; // 0x1C90 +0x0B3A51D0 + void* GameObject_SetActive; // 0x1C98 +0x0B398830 [also 0x1DB8] + void* GameObject_get_transform; // 0x1CA0 +0x0B3911F0 + void* Transform_set_rotation; // 0x1CA8 +0x0B3A59D0 [also 0x1DE0] + void* GameObject_get_activeInHierarchy; // 0x1CB0 +0x0B391D90 + void* GameObject_get_tag; // 0x1CB8 +0x0B3B2410 + void* GameObject_get_name; // 0x1CC0 +0x0B3B2120 + void* GameObject_get_layer; // 0x1CC8 +0x0B3B40B0 + void* GameObject_get_scene; // 0x1CD0 +0x0B397980 + void* Game_SkillBuff_A; // 0x1CD8 +0x02F3DA80 (SkillHack) + void* GetEntityName; // 0x1CE0 +0x00F27E10 (ESP label) + void* Component_GetComponents; // 0x1CE8 +0x0B329000 + void* Component_GetComponentsInChildren;// 0x1CF0 +0x0B329D80 + void* Game_SkillSlot_A; // 0x1CF8 +0x03E9BB50 (SkillHack) + void* Object_get_name; // 0x1D00 +0x0B383F60 + void* Component_GetType_A; // 0x1D08 +0x0B33CAB0 + void* Component_GetType_B; // 0x1D10 +0x0B33CB00 + void* Game_SkillSlot_B; // 0x1D18 +0x039D1AA0 (SkillHack) + void* Game_Combat_HitA; // 0x1D20 +0x026DE9F0 + void* GetEntityManager; // 0x1D28 +0x0478E860 (NoClip/FpsUnlocker) + void* Game_Combat_HitB; // 0x1D30 +0x025E2D40 + void* Game_Movement_PhysA; // 0x1D38 +0x087C2CD0 (NoClip CharCtrl) + void* Game_Movement_PhysB; // 0x1D40 +0x03419AF0 (NoClip CharCtrl) + void* Application_set_targetFrameRate; // 0x1D48 +0x0B322FB0 (FpsUnlocker) + void* SceneManager_GetActiveScene; // 0x1D50 +0x0B396A20 + void* CinemachineBrain_GetActiveVCam; // 0x1D58 +0x0B397700 (FreeCam) + void* Game_EntityState_A; // 0x1D60 +0x03766810 (ESP/SkillHack) + void* Transform_set_localScale; // 0x1D68 +0x0B3A2A60 + void* Rigidbody_get_velocity; // 0x1D70 +0x0B326660 (NoClip/Vacuum) + void* Rigidbody_set_velocity; // 0x1D78 +0x0B3266B0 (NoClip/Vacuum) + void* Object_Destroy; // 0x1D80 +0x0B383200 + void* Transform_set_position; // 0x1D88 +0x0B3A1A10 (NoClip/Vacuum) + void* Game_EntityState_B; // 0x1D90 +0x0B3A2340 (ESP) + void* Input_GetAxis_MouseX; // 0x1D98 +0x0B421800 (FreeCam look X) + void* Game_PlayerState_A; // 0x1DA0 +0x0B3A26D0 (ESP/SkillHack) + void* Game_PlayerState_B; // 0x1DA8 +0x0B3A1FB0 (ESP/SkillHack) + void* Game_PlayerHealthStat; // 0x1DB0 +0x0B32B030 (ESP health) + void* Camera_get_main; // 0x1DC0 +0x0B390440 (ESP/FreeCam) + void* GameObject_FindObjectOfType; // 0x1DC8 +0x0B390F80 + void* Game_SkillAction_C; // 0x1DD8 +0x03F85430 (SkillHack) + void* GetDeltaTime; // 0x1D38 +0x087C2CD0 (also FPS overlay) + void* Camera_get_fieldOfView; // 0x1DE8 +0x0B3A1C90 (FreeCam FOV) + void* Game_EntityState_C; // 0x1DF0 +0x00E92CF0 (ESP) + void* Rigidbody_AddForce; // 0x1E00 +0x03DC14C0 (Vacuum) + void* CharCtrl_set_enabled; // 0x1E08 +0x03E0D2C0 (NoClip) + void* Game_SkillAction_F; // 0x1E10 +0x03D9DF30 (SkillHack) + void* Game_SkillAction_G; // 0x1E18 +0x00E9E9F0 (SkillHack) + void* GetCharacterController; // 0x1E20 +0x03EA53C0 (NoClip) + void* TMPro_set_text; // 0x1E28 +0x0ACA0EC0 (PlayerProfile/NameChanger) + void* UnityUI_Text_set_text; // 0x1E30 +0x0B391D40 (ON/OFF labels) + void* Game_SkillAction_I; // 0x1E38 +0x036AA8F0 (SkillHack) + void* Game_SkillAction_J; // 0x1E40 +0x03EC31C0 (SkillHack hook5 target) + void* Game_EntityActor_D; // 0x1E48 +0x037F8CD0 (ESP/combat, hook6 target) + void* Game_SkillAction_K; // 0x1E50 +0x036EA640 (hook3/cooldown target) + void* Game_SkillAction_L; // 0x1E58 +0x03EC30E0 (hook4/avail target) + void* Game_EntityActor_E; // 0x1E60 +0x037F2A40 (hook1 target) + void* Game_EntityActor_F; // 0x1E68 +0x037FD7E0 (hook2 target) + void* il2cpp_domain_get; // 0x1E70 +0x00D94C10 + void* il2cpp_assembly_get_image; // 0x1E78 +0x00D94DA0 + void* il2cpp_domain_get_assemblies_B; // 0x1E80 +0x00D93A60 +}; + +// ============================================================================ +// SECTION 5 — BASE CLASS +// ============================================================================ + +struct BaseModule { + void* vtable; // [+0x00] vtable ptr + // std::string name at [+0x08] (SSO string, 24 bytes total: ptr+len+cap) + char name_sso[24]; // [+0x08] SSO buffer + // std::string tab_name at [+0x20] + char tab_name_sso[24]; // [+0x20] secondary name / tab label (SSO) + u8 enabled; // [+0x28] ON/OFF flag (BYTE) + u8 _pad[7]; // [+0x29..+0x2F] + // module-specific fields follow at [+0x30] +}; + +// BaseModule vtable layout (from factory stubs RVA 0x9B660–0x9B7A0): +// [0] +0x00 copy-ctor / factory() — placement-new ctor, writes vtable, returns this +// [1] +0x08 copy-ctor / factory() — same as [0] +// [2] +0x10 Init() / RegisterTab() — jmp stub → actual RegisterTab fn +// [3] +0x18 Render() — per-frame UI + game-state dispatch +// [4] +0x20 ~BaseModule() — dtor: frees name string, optional delete +// [5] +0x28 getNamePtr() — returns &this->name_string (+0x08) +// [6] +0x30 onHotkey() — pure virtual (sentinel value = 1) +// [7] +0x38 getLinkedModuleFactory() — returns paired module factory ptr + +// ============================================================================ +// SECTION 6 — MODULE STATE STRUCTS +// ============================================================================ + +// --- NoClip --- +// Singleton base: [.data+0x27B0] (referenced by RegisterTab / Render calls) +// Object size: ~0x38 bytes +struct NoClipModule : BaseModule { + // [+0x28] u8 enabled (ON/OFF checkbox) + i32 move_speed; // [+0x30] DragInt range [1, 10], default unknown +}; +// NoClip function table: +// RegisterTab 0x081300 — one-time init +// Render 0x0813D0 — ImGui panel (checkbox + Move Speed slider) +// Update 0x089B50 — per-frame CharacterController toggle +// Update stub 0x089B00 — tab destructor/cleanup wrapper +// Update stub2 0x089B40 — tab #2 setup (lea rdx, panel_callback → jmp 0x89060) + +// --- FreeCam --- +// Singleton base: [.data+0x2200] (0xD8 bytes, zeroed by RegisterMainTab) +struct FreeCamModule : BaseModule { + // [+0x28] u8 enabled + f32 move_speed; // [+0x30] SliderFloat max=500.0f default=30.0f + f32 roll_speed; // [+0x34] SliderFloat max=100.0f + f32 fov_speed; // [+0x38] (Look Sensitivity slider) + u8 _pad2[0x28]; // [+0x3C..+0x63] + void* active_cam_ptr; // [+0x68] cached active camera GameObject* + void* override_cam_ptr; // [+0x70] override camera ptr (cleared on disable) + u8 _pad3[0x40]; // [+0x78..+0xB7] + u8 cam_override_active; // [+0xB8] + // Key bindings written at RegisterMainTab to [.data+0x2230..0x225E]: + // [+0x2230] movdqa block1 = 0x1803B34F0 (WASD + misc keys) + // [+0x2240] movdqa block2 = 0x1803B35C0 + // [+0x2250] 0x3F800000 = 1.0f (FOV multiplier default) + // [+0x2254] 0x44415357 = 'WASD' key code mask + // [+0x2258] 0x6D6BA220 = additional keybind + // [+0x225C] 0x2725 = two-byte keybind + // [+0x225E] 0x60 = backtick key code + // Accumulator floats [+0x2260..0x22A8] pitch/yaw/roll/FOV — zeroed on init +}; +// FreeCam function table: +// RegisterFpsTab 0x0814C0 — registers FPS Monitor overlay tab +// RegisterMainTab 0x081590 — zeroes 0xD8 state, writes key defaults +// FpsUpdate stub 0x087150 — FPS overlay destructor wrapper +// Update 0x0871A0 — per-frame camera override (WASD+mouse) + +// --- FpsUnlocker --- +// Singleton base: [.data+0x21E8] +// Object size: 0x38 bytes +struct FpsUnlockerModule : BaseModule { + // [+0x28] u8 enabled + i32 fps_target; // [+0x30] DragInt max=500, min=30, default=300 +}; +// FpsUnlocker function table: +// RegisterTab 0x081730 — registers tab, writes fps_target default = 300 +// Render 0x085B90 — ImGui panel + Application.set_targetFrameRate call +// Update stub 0x085B40 — destructor wrapper, size 0x38 + +// --- SetDither --- +// Singleton base: referenced from registrar at RVA 0x001C41 +// Object size: 0x38 bytes (shared stub with SkillHack) +struct SetDitherModule : BaseModule { + // [+0x28] u8 enabled (unused — no per-frame write) +}; +// SetDither function table: +// RegisterTab/Render 0x081810 — registers tab only; no ImGui panel body +// Update stub 0x083DC0 — shared no-op: frees name string, optional delete + +// --- PlayerProfile --- +// Singleton base: referenced from registrar at RVA 0x001E20 +// Object size: 0x78 bytes +struct PlayerProfileModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + // [+0x30] std::string uid_str (wstring buffer for UID display text) + char uid_str_sso[24]; // [+0x30] + u8 _pad4[8]; // [+0x48..+0x4F] + // [+0x50] std::string name_str (wstring buffer for ManagerName text) + char name_str_sso[24]; // [+0x50] + u8 _pad5[8]; // [+0x68..+0x6F] + u8 name_changer_enabled; // [+0x70] +}; +// PlayerProfile function table: +// RegisterTab/Render 0x0818E0 — zeroes uid_str, name_str; stores IL2CPP fn ptrs +// Update 0x08A4F0 — per-frame UI path walk + SetText on TMP labels +// Update stub 0x08A4A0 — dtor: frees [+0x50],[+0x30],[+0x08], delete(0x78) +// UI paths used: +// UID: "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (RVA 0x3AFED0, len 0x2F) +// Name: "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (RVA 0x3AFFD0, len 0x8D) + +// --- Vacuum --- +// Singleton base: [.data+0x05D0] fn-ptr slot; obj referenced from registrar 0x001FC0 +// Object size: 0x38 bytes +struct VacuumModule : BaseModule { + // [+0x28] u8 vacuum_on ('Vacuum' main checkbox) + u8 _pad3[7]; + u8 monster_on; // [+0x30] 'Monster' sub-checkbox +}; +// Vacuum function table: +// RegisterTab 0x081A20 — stores update fn ptr 0x1803B0680 → 0x085B40 stub +// Render 0x093CA0 — 'Vacuum' + 'Monster' checkboxes +// PhysicsLoop 0x093F10 — per-frame Rigidbody.AddForce attraction +// Update stub 0x085B40 — shared destructor wrapper (frees [+0x08], delete 0x38) +// Attraction constant: *(float*)0x1803B32B4 + +// --- SkillHack --- +// Singleton base: referenced from registrar at RVA 0x001D50 +// Object size: ~0x38 bytes +struct SkillHackModule : BaseModule { + // [+0x28] u8 enabled — read by all 6 hook callbacks + // No per-frame Update; all work done by IL2CPP hook callbacks +}; +// SkillHack function table: +// Render 0x08D1F0 — hook installer only (installs 6 hooks, tail-jmps to 0x8D8A0) +// RenderPanel 0x08D240 — actual ImGui panel ('Free Skill' + ON/OFF toggle) +// Update stub 0x083DC0 — shared no-op (same as SetDither) +// Dispatcher 0x08D4B0 — BOOL callback: returns 1 when enabled +// CooldownBypass 0x08D500 — float callback: returns 100.0f when enabled +// AvailBypass 0x08D640 — BOOL callback: returns 1 when enabled +// CostBypass 0x08D780 — void callback: early-return (skip cost deduction) + +// --- ESPModule --- +// Singleton base: [.data+0x1F70] VA 0x1803C6F70 +// Object size: 0x100 bytes (12 RGBA color slots × 16 bytes = 0xC0, starts at +0x40) +struct ESPModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + i32 max_draw_distance; // [+0x30] default 300 (0x12C) + u8 show_monsters; // [+0x34] default 1 + u8 show_npc; // [+0x35] default 1 + u8 show_friendly; // [+0x36] default 1 + u8 show_puzzles; // [+0x37] default 1 + u8 show_all; // [+0x38] default 0 + u8 show_distance; // [+0x39] default 1 + u8 show_name; // [+0x3A] default 1 + u8 show_type; // [+0x3B] default 0 (reserved, unused) + u8 _reserved; // [+0x3C] + u8 _pad4[3]; // [+0x3D..+0x3F] + float color[12][4]; // [+0x40] 12 × RGBA float4, 16-byte aligned + // Color slot defaults (RGBA): + // [0] +0x40 enemy RED (1.0, 0.0, 0.0, 1.0) + // [1] +0x50 interactive ORANGE (1.0, 0.65, 0.0, 1.0) + // [2] +0x60 slot2 YELLOW (1.0, 1.0, 0.0, 1.0) + // [3] +0x70 friendly GREEN (0.0, 1.0, 0.0, 1.0) + // [4] +0x80 npc BLUE (0.0, 0.0, 1.0, 1.0) + // [5] +0x90 slot5 CYAN (0.0, 1.0, 1.0, 1.0) + // [6] +0xA0 slot6 PURPLE (0.58, 0.0, 0.83, 1.0) + // [7] +0xB0 default WHITE (1.0, 1.0, 1.0, 1.0) + // [8] +0xC0 slot8 PINK (1.0, 0.08, 0.58, 1.0) + // [9] +0xD0 slot9 LPINK (1.0, 0.75, 0.80, 1.0) + // [10] +0xE0 slot10 BLACK (0.0, 0.0, 0.0, 1.0) + // [11] +0xF0 slot11 GRAY (0.502, 0.502, 0.502, 1.0) +}; +// ESPModule function table: +// Singleton init 0x083E00 — lazy init via MSVC thread-safe static +// RenderOverlay 0x083FA0 — ImGui 'ESP Features' panel (large, 0x83FA0–0x8499E) +// Update 0x085C00 — per-frame world-space entity label loop (approx) +// Entity type dispatch in Update (byte code → color slot): +// 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle, default=slot7(white) + +// --- FPSModule (FpsOverlay) --- +// Singleton base: [.data+0x22E0] VA 0x1803C72E0 +// Object size: 0xD8 bytes +struct FPSModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + u8 show_fps_overlay; // [+0x30] 'Show FPS Overlay' checkbox + u8 _pad4[0x2F]; // [+0x31..+0x5F] + float overlay_pos[4]; // [+0x60] XMMWORD (position/size, zeroed on init) +}; +// FPSModule function table: +// RegisterTab 0x081810 — shared with SetDither registrar +// Render [via FpsOverlay chain] + +// --- PreventScreenshot --- +// Singleton base: [.data+0x2358] VA 0x1803C7358 +// Object size: 0x48 bytes +struct PreventScreenshotModule : BaseModule { + // [+0x28] u8 enabled — drives SetWindowDisplayAffinity arg + u8 _pad3[7]; + u8 state_dirty; // [+0x30] 1 = affinity applied, guard re-apply + u8 _pad4[7]; + u8 second_flag; // [+0x38] purpose unclear, zeroed on init +}; + +// ============================================================================ +// SECTION 7 — HOOK MANAGER +// ============================================================================ + +// Singleton: [.data+0x2470] VA 0x1803C7470 +// Object size: 0x90 bytes +struct HookManager { + void* hook_array; // [+0x00] flat array of HookEntry (0x38 bytes each) + u32 hook_capacity; // [+0x08] allocated slot count (initial 0x80) + u32 hook_count; // [+0x0C] active hook count + void* hash_buckets; // [+0x10] hash table bucket array (linked list heads) + u32 bucket_count; // [+0x18] power of 2, initial 8 + u32 bucket_mask; // [+0x1C] = bucket_count * 2 - 1 + void* free_list_head; // [+0x20] freed/recycled slot free list head + u8 _pad[4]; // [+0x28..+0x2B] + f32 load_factor; // [+0x28] hash load factor threshold (1.0f = 0x3F800000) + u8 initialized; // [+0x30] 0 after init (prevents double-init) + // Global spinlock: [.data+0x1E88] (DWORD, separate from struct) +}; + +// Each hook entry in hook_array is 0x38 bytes: +struct HookEntry { + u64 target_va; // [+0x00] VA of hooked IL2CPP function + u64 callback_va; // [+0x08] VA of replacement/detour function + u64 trampoline_va; // [+0x10] VirtualAlloc'd trampoline (orig bytes + JMP back) + u32 orig_bytes_0_3; // [+0x18] saved original bytes 0-3 + u16 orig_bytes_4_5; // [+0x1C] saved original bytes 4-5 + u8 orig_byte_6; // [+0x1E] saved original byte 6 + u8 flags; // [+0x20] bit0=has_far_jmp, bit1=enabled, bit2=suspended + u32 flags2; // [+0x24] lower nibble: hook type (0=near JMP, 1=far) + u64 hash_next; // [+0x28] next ptr in hash bucket chain + // [+0x30..+0x37] additional chain/bookkeeping fields +}; + +// HookManager API (all acquire spinlock at [.data+0x1E88]): +// CreateHook RVA 0x0A9CC8 — install new hook (FNV-1a hash lookup, trampoline alloc) +// RemoveHook RVA 0x0A9FA0 — remove and free hook +// EnableHook RVA 0x0AA140 — enable suspended hook +// GetHookInfo RVA 0x0AA2C0 — query hook by target VA +// Spinlock acq RVA 0x0A9C88 — acquire [.data+0x1E88] +// Spinlock rel inline — mov [.data+0x1E88], 0 + +// ============================================================================ +// SECTION 8 — MODULE MANAGER +// ============================================================================ + +// Singleton: [.data+0x2398] +// Registrar array: [.data+0x23B8]..[.data+0x23C0] (stride 0x60 bytes/slot) +struct ModuleManager { + u8 _pad[0x18]; // [+0x00..+0x17] + u8 initialized; // [+0x18] double-init guard + u8 _pad2[7]; // [+0x19..+0x1F] + // [+0x20..+0x57] registrar list (vector — 0x60-byte stride) +}; + +// ModuleManager API: +// AddRegistrar RVA 0x09B2C0 — push registrar slot (name str + factory fn) +// Grow helper RVA 0x09B3C0 — expand registrar vector +// Init RVA 0x09AC10 — called once from startup (RVA 0xA9190) +// Dispatch loops (each wraps vtable call in __try/__except via CxxFrameHandler4): +// Update loop RVA 0x09AE80 — calls vtable[+0x18] on each module +// Render loop RVA 0x09AEF0 — calls vtable[+0x20] on each module +// Hotkey loop RVA 0x09AF60 — calls vtable[+0x28] on each module +// Exception handlers (log + resume, do not propagate): +// Update catch RVA 0x0AEBC0 — logs "[ERROR] Failed to update module ''" +// Render catch RVA 0x0AEC50 — logs "[ERROR] Failed to render overlay for module ''" +// Hotkey catch RVA 0x0AECE0 — logs "[ERROR] Failed to process hotkeys for module ''" + +// Registration order (DLL init lambdas, before ModuleManager::Init): +// 1. SetDither (RVA 0x001C41) vtable 0x3B0D58 +// 2. FreeCam FPS (RVA 0x001C80) vtable 0x3B0E70 +// 3. SkillHack (RVA 0x001D50) vtable 0x3B0EE0 +// 4. PlayerProfile (RVA 0x001E20) vtable 0x3B0D90 +// 5. NoClip (RVA 0x001EF0) vtable 0x3B0DC8 +// 6. Vacuum (RVA 0x001FC0) vtable 0x3B0E38 +// 7. UnityExplorer (RVA 0x002090) vtable 0x3B0D28 +// 8. FpsUnlocker (RVA 0x001B80) vtable 0x3B0E00 +// 9. FreeCam main (RVA 0x001AB0) vtable 0x3B0E70 +// 10. ESPModule (RVA 0x001980) + +// ============================================================================ +// SECTION 9 — KEY FUNCTION RVA REFERENCE +// ============================================================================ +// All RVAs relative to binary base 0x180000000. +// Add 0x180000000 to get VA; add file raw offset base for file seek. + +namespace RVA { + // Startup / init + constexpr u32 DllMain_entry = 0x0AC840; // CRT DllMain thunk + constexpr u32 Startup_sequence = 0x0A9190; // main init: GABypass + ModMgr + constexpr u32 GABypass_Patch = 0x0A9120; // writes 71 IL2CPP fn ptrs + constexpr u32 ModuleManager_Init = 0x09AC10; + + // D3D11 / overlay + constexpr u32 D3D11_Hook_Install = 0x0827A0; // hooks IDXGISwapChain::Present + constexpr u32 D3D11_Present_Hook = 0x082820; // Present detour entry + constexpr u32 D3D11_CreateBuffers = 0x0551F0; // post-shader vertex/index buffer init + constexpr u32 ImGui_EndFrame = 0x001C2D0; // D3D11/ImGui EndFrame boundary + + // ImGui wrappers (cheat-side) + constexpr u32 ImGui_Toggle = 0x070820; // TabManager::BeginTab + constexpr u32 CheckboxToggle = 0x085320; // flip enabled flag + constexpr u32 ImGui_DragInt = 0x066750; // move_speed DragInt + constexpr u32 ImGui_SliderFloat = 0x065570; // move_speed SliderFloat (max 500) + constexpr u32 ImGui_InputText_ws = 0x08AC20; // InputText wstring wrapper + + // Config I/O + constexpr u32 ConfigSerialize = 0x012050; // serialize config to string + constexpr u32 BuildFilePath = 0x030A90; // build config file path + constexpr u32 ConfigFileIO = 0x011EA0; // UTF-8→wide fopen helper + constexpr u32 ConfigWrite = 0x0170D6; // fwrite config to file (approx) + + // Hook manager + constexpr u32 HookMgr_singleton = 0x081B00; // thread-safe static accessor + constexpr u32 HookMgr_CreateHook = 0x0A9CC8; + constexpr u32 HookMgr_RemoveHook = 0x0A9FA0; + constexpr u32 HookMgr_EnableHook = 0x0AA140; + constexpr u32 HookMgr_Spinlock = 0x0A9C88; + constexpr u32 Trampoline_Alloc = 0x0AA478; // GetSystemInfo+VirtualQuery sub + + // IL2CPP infrastructure + constexpr u32 IL2CPP_FindByPath = 0x09BCB0; // resolve Unity path to object + constexpr u32 WideToString = 0x00EB10; // UTF-8 → wstring + constexpr u32 BaseModule_Dtor = 0x00FA60; // shared dtor + + // ModuleManager dispatch + constexpr u32 ModMgr_UpdateLoop = 0x09AE80; + constexpr u32 ModMgr_RenderLoop = 0x09AEF0; + constexpr u32 ModMgr_HotkeyLoop = 0x09AF60; + constexpr u32 ModMgr_AddRegistrar = 0x09B2C0; + + // Theme / config preset writers (Ch.17 / Ch.28) + constexpr u32 Theme_Writer_Preset0 = 0x094890; // writes 52 color slots + constexpr u32 Theme_Writer_Preset1 = 0x096770; + constexpr u32 Theme_Writer_Preset2 = 0x098650; + constexpr u32 ColorApplicator = 0x094190; // shared helper: hex→RGBA×159 calls + + // Settings / NameChanger (Ch.19) + constexpr u32 Settings_RenderOverlay = 0x09A4F0; // Settings panel render + constexpr u32 Settings_end = 0x09AB98; // (end of Settings body) + + // UnityExplorer (Ch.16) + constexpr u32 UE_RegisterTab = 0x090060; + constexpr u32 UE_Render = 0x090250; + constexpr u32 UE_RefreshScenes = 0x090D40; +} + +// ============================================================================ +// SECTION 10 — CONFIG PRESET NAMES & STRINGS +// ============================================================================ +// Preset name string: [.data+0x00E0] (std::string, set during Settings load) +// Preset index: [.data+0x00EC] (DWORD, 0-3) +// Config file path: built by BuildFilePath (RVA 0x030A90) from [.data+0x0050]+0x50 +// Config strings (RVA): +// "Preset0" 0x3B0680 +// "Preset1" 0x3B0688 +// "Preset2" 0x3B0690 +// "Preset3" 0x3B0698 +// "EF-Cheeto.dll" 0x3B0358 (used by GABypass file scan) +// "gatmp.tmp" 0x3B0338 (temp file for bypass) +// "testyip" 0x3B0328 (test bypass marker) +// Source path embedded: "E:\git\Endfield_Cheeto\libraries\pipeline\..." + +// ============================================================================ +// SECTION 11 — KNOWN GAME API SIGNATURES (inferred from call sites) +// ============================================================================ +// These are IL2CPP managed method signatures inferred from cheat call sites. +// Calling convention: __fastcall (RCX=this/arg0, RDX=arg1, R8=arg2, etc.) +// Return in RAX (ptr/int) or XMM0 (float). + +// Transform methods +using fn_get_position = void*(*)(void* transform); // returns vec3* +using fn_set_position = void (*)(void* transform, void* vec3); +using fn_get_rotation = void*(*)(void* transform); // returns Quaternion* +using fn_set_rotation = void (*)(void* transform, void* quaternion); +using fn_get_localPos = void*(*)(void* transform); +using fn_set_localPos = void (*)(void* transform, void* vec3); +using fn_get_localScale= void*(*)(void* transform); +using fn_set_localScale= void (*)(void* transform, void* vec3); + +// GameObject methods +using fn_get_transform = void*(*)(void* gameObject); +using fn_SetActive = void (*)(void* gameObject, bool active); +using fn_get_name_go = void*(*)(void* gameObject); // returns System.String* + +// Rigidbody methods +using fn_AddForce = void (*)(void* rigidbody, void* vec3, int forceMode); +using fn_get_velocity = void*(*)(void* rigidbody); +using fn_set_velocity = void (*)(void* rigidbody, void* vec3); + +// Application +using fn_setTargetFPS = void (*)(int targetFrameRate); + +// TMPro / UI +using fn_set_text = void (*)(void* textComponent, int zero, void* wstring_ptr); + +// CharacterController +using fn_setEnabled = void (*)(void* ctrl, bool enabled, int zero); + +// Camera +using fn_Camera_main = void*(*)(void* zero); // Camera.get_main +using fn_get_fov = float(*)(void* camera); + +// SkillHack hook callbacks (return types match hooked method signatures): +using fn_BOOL_bypass = BOOL (*)(void); // Dispatcher / AvailBypass +using fn_float_bypass = float(*)(void); // CooldownBypass → returns 100.0f +using fn_void_bypass = void (*)(void); // CostBypass → early return + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 12 — IL2CPP TABLE ACCESSOR MACROS +// ============================================================================ +// Usage: CALL_IL2CPP(slot_name, RetType, arg0, ...) +// All slots live at fixed .data offsets from binary base 0x1803C5000. +// At runtime: ptr = *(void**)([.data + slot_offset]) +// +// Direct call helpers — use after GABypass has patched the table: + +#define IL2CPP_BASE_VA ((uintptr_t)0x1803C5000) +#define IL2CPP_SLOT(off) (*(void**)(IL2CPP_BASE_VA + (off))) + +// Transform +#define IL2_Transform_get_position(t) ((fn_get_position) IL2CPP_SLOT(0x1C88))(t) +#define IL2_Transform_set_position(t,v) ((fn_set_position) IL2CPP_SLOT(0x1D88))(t,v) +#define IL2_Transform_get_localPos(t) ((fn_get_localPos) IL2CPP_SLOT(0x1C80))(t) +#define IL2_Transform_set_localPos(t,v) ((fn_set_localPos)IL2CPP_SLOT(0x1C90))(t,v) +#define IL2_Transform_get_rotation(t) ((fn_get_rotation)IL2CPP_SLOT(0x1C68))(t) +#define IL2_Transform_set_rotation(t,q) ((fn_set_rotation)IL2CPP_SLOT(0x1CA8))(t,q) +#define IL2_Transform_get_localScale(t) ((fn_get_localScale)IL2CPP_SLOT(0x1C60))(t) +#define IL2_Transform_set_localScale(t,v) ((fn_set_localScale)IL2CPP_SLOT(0x1D68))(t,v) + +// GameObject +#define IL2_GO_get_transform(go) ((fn_get_transform)IL2CPP_SLOT(0x1CA0))(go) +#define IL2_GO_SetActive(go,a) ((fn_SetActive) IL2CPP_SLOT(0x1C98))(go,a) +#define IL2_GO_get_name(go) ((fn_get_name_go) IL2CPP_SLOT(0x1CC0))(go) + +// Rigidbody +#define IL2_RB_AddForce(rb,v,fm) ((fn_AddForce) IL2CPP_SLOT(0x1E00))(rb,v,fm) +#define IL2_RB_get_velocity(rb) ((fn_get_velocity) IL2CPP_SLOT(0x1D70))(rb) +#define IL2_RB_set_velocity(rb,v) ((fn_set_velocity) IL2CPP_SLOT(0x1D78))(rb,v) + +// Application +#define IL2_App_setTargetFPS(fps) ((fn_setTargetFPS) IL2CPP_SLOT(0x1D48))(fps) + +// Camera +#define IL2_Camera_main() ((fn_Camera_main) IL2CPP_SLOT(0x1DC0))(nullptr) +#define IL2_Camera_get_fov(cam) ((fn_get_fov) IL2CPP_SLOT(0x1DE8))(cam) + +// UI +#define IL2_TMPro_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E28))(comp,0,ws) +#define IL2_UI_Text_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E30))(comp,0,ws) + +// CharacterController +#define IL2_CharCtrl_setEnabled(c,en) ((fn_setEnabled) IL2CPP_SLOT(0x1E08))(c,en,0) + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 13 — STARTUP / LOADER CHAIN +// ============================================================================ +// DLL entry and initialization sequence (Ch.11 / Ch.29) + +namespace RVA { + // Entry point chain + constexpr u32 DllMain_entry_real = 0x01000; // CRT DllMain (spawns loader thread) + constexpr u32 LoaderThread = 0x05000; // main init thread: IL2CPP + window + hooks + constexpr u32 Startup_main = 0x0A9190; // step-by-step startup (steps 1-11) + constexpr u32 ModMgr_RegisterAll = 0x09AE00; // 11 modules registered via stubs + constexpr u32 ModMgr_MainLoop = 0x082000; // Present hook + ImGui render loop (0x82000-0x82300) + constexpr u32 D3D11Init_Shaders = 0x054DC0; // D3DCompile vertex+pixel shader (x2: 0x54DC0, 0x551E8) + constexpr u32 D3D11Init_Setup = 0x082500; // ImGui Win32+D3D11 backend init, WndProc subclass + + // Startup step addresses (from Ch.11.4): + // 1 0x0A91CE AllocConsole — 'il2cpp Game Console' + // 2 0x0A9267 SetConsoleCP(0xFDE9) — UTF-8 + // 3 0x0A92F7 FindWindowA(NULL,'UnityWndClass') — poll until game window present + // 4 0x0A93CC HookInstallerWrapper(EnumProcessModules) — module scanner install + // 5 0x0A93E6 Log 'Initializing..' (source: main.cpp:53) + // 6 0x0A942F Call [g_Config+0x1E80] — IL2CPP domain resolver + // 7 0x0A945A Log 'IL2CPP Domain Found: ' (if domain non-null) + // 8 0x0A94C4 Log 'IL2CPP Thread Attached Successfully: ' + // 9 0x0A9506 Error: Log 'Failed to Attach IL2CPP Thread!' + // 10 0x0A9545 Error: Log 'IL2CPP Domain Not Found!' + // 11 0x0A959F Success: Log 'Initialized' → then launch overlay window thread (0x827A0) + + // D3D11 overlay window subsystem (Ch.29) + constexpr u32 OverlayWindowInit = 0x0827A0; // create layered window + D3D11 device (0x827A0-0x8375C) + constexpr u32 FindGameWindow = 0x0835D0; // EnumWindows callback — locate Unity window + constexpr u32 GetOverlayRect = 0x0836A0; // compute overlay rect from game window bounds + constexpr u32 D3D11_Setup_sub = 0x0825B0; // D3D11::Reinit — recreate RT + ImGui D3D11 backend + constexpr u32 WndProc = 0x0826A0; // Win32 WndProc (HWND,UINT,WPARAM,LPARAM)→LRESULT + constexpr u32 ImGui_Win32_Handler = 0x057720; // ImGui_ImplWin32_WndProcHandler — all kb/mouse + constexpr u32 PresentHook_callsite = 0x082F00; // IDXGISwapChain::Present hook call site (inside msg loop) + constexpr u32 RenderFrame = 0x082FC0; // ImGui NewFrame + per-module Render dispatch + constexpr u32 ImGui_Begin_wrapper = 0x0937D0; // ImGui::Begin wrapper (Unity Explorer Window title) + constexpr u32 ImGui_Selectable = 0x0708D0; // ImGui::Selectable (preset selector, Ch.17) + + // Thread suspension for hook install (Ch.3) + constexpr u32 CollectProcessThreads = 0x0A96B0; // Toolhelp32 snapshot → thread ID array (0xA96B0-0xA9A1C) + constexpr u32 SuspendOrResumeThreads= 0x0A9A20; // OpenThread + Suspend/Resume all (0xA9A20-0xA9A98) + constexpr u32 PatchCode = 0x0A9A9C; // VirtualProtect + write hook bytes (0xA9A9C-0xA9BC3) + + // Hook manager detailed RVAs (Ch.8) + constexpr u32 HookMgr_Install = 0x0A9CC8; // alloc trampoline + FNV hash (= CreateHook) + constexpr u32 HookMgr_Remove = 0x0A9E8C; // remove + restore original bytes + constexpr u32 HookMgr_Enable_fn = 0x0A9A9C; // toggle enabled bit + patch + constexpr u32 HookMgr_AllocTramp = 0x0A960C; // allocate trampoline slot near target VA + constexpr u32 HookMgr_FreeSlot = 0x0AA684; // free trampoline + compact hook array + constexpr u32 HookInstaller_Wrapper = 0x08BAF0; // wrapper called at 0xA93CC during startup + + // Module scanner (Ch.11.2) + constexpr u32 ModulePathScanner = 0x08B650; // scan loaded modules for testyip/gatmp/EF-Cheeto + constexpr u32 ModPathScanner_EF = 0x08B937; // wcsstr branch: search for 'EF-Cheeto.dll' + + // String helpers + constexpr u32 UTF8ToWide = 0x08B4E0; // MultiByteToWideChar CP_UTF8(0xFDE9) wrapper + constexpr u32 WideStr_wcsstr = 0x0AB6A0; // custom wcsstr — returns iterator, -1 if not found + constexpr u32 WideStr_Dtor = 0x0AB758; // wstring destructor (used in path scanner) + + // Module-specific helpers + constexpr u32 NoClip_RegisterTab = 0x00FCB0; // one-time NoClip tab init + constexpr u32 FreeCam_RegisterTab = 0x00F7D0; // one-time FreeCam tab init + constexpr u32 ManagerName_Init = 0x00FFF0; // zero std::string fields for ModuleManager name + constexpr u32 NoClip_EntityIter = 0x089DC0; // entity iterator inner loop (NoClip::Update) + constexpr u32 SetDither_Render = 0x08C490; // SetDither::Render — graphics dither toggle + constexpr u32 SkillHack_PatchFloat = 0x08E220; // installs FloatReturn hook on [g_Config+0x1E50] + constexpr u32 SkillHack_PatchBool = 0x08EBC0; // installs BoolTrue hook on [g_Config+0x1E58] + constexpr u32 SkillHack_PatchVoid = 0x08F560; // installs VoidReturn hook on [g_Config+0x1E40] + constexpr u32 SkillHack_Trampoline = 0x08FF00; // common trampoline dispatcher (calls original fn) + constexpr u32 UE_GuardReturn = 0x0901D8; // early return after once_flag sealed (UE::RegisterTab) + constexpr u32 UE_AutoRefresh = 0x093B10; // auto-refresh timer check for scene list + constexpr u32 UE_Memset_block = 0x0AC86A; // memset 0xD8 bytes at [.data+0x2200] (FreeCam init) + constexpr u32 PreventSS_Init = 0x08AD70; // once_flag guarded PreventScreenshot init + constexpr u32 PreventSS_Render = 0x08AE60; // ImGui single checkbox 'Prevent Screenshot' + constexpr u32 PreventSS_Update = 0x08AFC0; // SetWindowDisplayAffinity dispatch (per-frame) + constexpr u32 PreventSS_OsCheck = 0x08B220; // Win10 build check + affinity setter + constexpr u32 TabMgr_BeginTab_full = 0x09D7D0; // full BeginTab with state+title resolution + constexpr u32 GABypass_Init = 0x09D1E0; // 71 IL2CPP stub patch sequence + constexpr u32 Std_once_flag_Execute = 0x0AFF60; // MSVC _Execute_once (once_flag) + constexpr u32 Sidebar_Settings = 0x080770; // sidebar settings section (0x80770-0x80B50) + // ImGui_EndFrame alias: see RVA::ImGui_EndFrame (0x001C2D0) defined in Section 9 +} + +// ============================================================================ +// SECTION 14 — D3D11 OVERLAY WINDOW INIT (Ch.29 summary) +// ============================================================================ +// OverlayWindowInit (RVA 0x827A0) sequence: +// +// 29.1 DPI setup (0x827FF-0x82923): +// Try SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) +// Fallback: SetProcessDpiAwareness(2) +// Final fallback: SetProcessDPIAware() +// Guard: [.data+0x3C7440] / [.data+0x3C7448] +// +// 29.2 Game window location + class registration (0x82924-0x82A28): +// EnumWindows(FindGameWindow@0x835D0) → locate Unity game HWND +// WNDCLASSEX: CreateSolidBrush(0x7F00), LoadCursorW, LoadIconW×2 +// RegisterClassExW +// GetSystemMetrics(SM_CXSCREEN/SM_CYSCREEN) +// +// 29.3 Overlay window + D3D11 device (0x82A29-0x82BFF): +// CreateWindowExW(WS_EX_LAYERED|WS_EX_TRANSPARENT) +// SetLayeredWindowAttributes +// DwmExtendFrameIntoClientArea (full glass) +// D3D11CreateDeviceAndSwapChain — attempt 1: DXGI_FORMAT_R8G8B8A8_UNORM +// on failure: attempt 2: DXGI_FORMAT_B8G8R8A8_UNORM +// D3D11::Reinit (0x825B0) — set up ImGui D3D11 backend +// ShowWindow / UpdateWindow +// CreateMutexA — prevent duplicate instances +// +// 29.4 Message loop (0x82C01-0x8352F): +// Log 'Initialized' (source: UI.cpp, RVA 0x3AF610) +// Loop: PeekMessageW / TranslateMessage / DispatchMessageW +// Each iter: FindWindowA('UnityWndClass',NULL) — exit if game gone +// IsWindow, GetWindowThreadProcessId, GetWindowRect +// SetWindowPos to track game window + +// WndProc (RVA 0x826A0) — pseudocode: +// LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// if (g_ImGuiCtx) { +// LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// if (r) return 1; +// } +// switch (msg) { +// case WM_DESTROY: PostQuitMessage(0); return 0; +// case WM_SIZE: +// if (g_pSwapChain && wParam != SIZE_MINIMIZED) { +// if (g_pRenderTargetView) { g_pRenderTargetView->Release(); g_pRenderTargetView=NULL; } +// g_pSwapChain->ResizeBuffers(0,LOWORD(lParam),HIWORD(lParam),DXGI_FORMAT_UNKNOWN,0); +// D3D11_Setup_sub(); // 0x825B0 — recreate RT + shaders +// } +// return 0; +// case WM_SYSCOMMAND: +// if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +// break; +// default: +// return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// } +// return 0; +// } + +// ============================================================================ +// SECTION 15 — MODULE PATH SCANNER (Ch.11.2) +// ============================================================================ +// ModulePathScanner (RVA 0x8B650): +// Args: HANDLE process, void** module_array, DWORD count +// For each module path: +// UTF8ToWide(path) → wpath +// wcsstr(wpath, L"testyip") → if found: found_count++ +// wcsstr(wpath, L"gatmp.tmp") → if found: found_count++ +// if not found: ModPathScanner_EF (0x8B937): +// wcsstr(wpath, L"EF-Cheeto.dll") → if found: found_count++ +// Returns found_count +// +// Injection identity strings (.data): +// L"testyip" [.data+0x0318] alternate temp-file loader name +// L"gatmp.tmp" [.data+0x0338] primary temp-file loader name +// L"EF-Cheeto.dll" [.data+0x0358] published DLL name (fallback) + +// ============================================================================ +// SECTION 16 — THREAD SUSPENSION SUBSYSTEM (Ch.3) +// ============================================================================ +// CollectProcessThreads (RVA 0xA96B0): +// CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,0) → hSnapshot +// THREADENTRY32 te32; te32.dwSize = sizeof(THREADENTRY32); +// Thread32First(hSnapshot, &te32) +// while Thread32Next: if te32.th32OwnerProcessID==GetCurrentProcessId() +// AND te32.th32ThreadID != calling_thread: append to array +// +// SuspendOrResumeThreads (RVA 0xA9A20): +// For each collected thread ID: +// hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// if suspend: SuspendThread(hThread) +// if resume: ResumeThread(hThread) +// CloseHandle(hThread) +// +// PatchCode (RVA 0xA9A9C): +// VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &oldProt) +// memcpy(target, patch_bytes, size) +// VirtualProtect(target, size, oldProt, &oldProt) +// FlushInstructionCache(GetCurrentProcess(), target, size) + +// ============================================================================ +// SECTION 17 — PREVENT SCREENSHOT MODULE (Ch.21 supplement) +// ============================================================================ +// PreventScreenshot::Initialize (RVA 0x8AD70): +// Guarded by once_flag at [.data+0x2390] +// Allocates module object (0x48 bytes) +// Sets vtable: 0x3AFA38 → 0x3B0110 after init +// Zeroes: enabled, state_dirty, second_flag +// +// PreventScreenshot::Update (RVA 0x8AFC0): +// 1. Call GetInstance (0x8AD70) +// 2. Check enabled [module+0x28] +// 3. If enabled && !state_dirty: call OsCheck (0x8B220) +// 4. Build HWND list at [.data+0x24D0] +// 5. For each HWND node [rbx+0x10]: call OsCheck affinity setter +// 6. Call HookMgr_singleton (0x81B00) to update hook state +// +// PreventScreenshot::OsCheck (RVA 0x8B220): +// Checks Windows 10 build version +// Calls SetWindowDisplayAffinity(hwnd, WDA_MONITOR) via IAT[0xB1460] +// On disable: SetWindowDisplayAffinity(hwnd, WDA_NONE) + +// ============================================================================ +// SECTION 18 — COMPLETE FUNCTION INDEX (all 91 named functions) +// ============================================================================ +// Cross-reference: function name → RVA (use RVA:: namespace above for most) +// This table captures every named entry from the doc cross-reference (Ch.24/25). + +// Name RVA Chapter +// DllMain 0x001000 Entry +// LoaderThread 0x005000 Ch.11 +// FreeCam::RegisterTab 0x00F7D0 Ch.12.3 +// FreeCam::RegisterFpsTab 0x0814C0 Ch.12.3 +// NoClip::RegisterTab 0x00FCB0 Ch.12.2 +// ManagerName::Init 0x00FFF0 Ch.15 +// ImGui::EndFrame 0x01C2D0 Ch.15 +// ConfigSerialize 0x012050 Ch.6 +// ConfigFileIO (UTF8→wide fopen) 0x011EA0 Ch.6 +// BuildFilePath 0x030A90 Ch.6 +// D3D11Init_Shaders A 0x054DC0 Ch.5 +// D3D11Init_Shaders B 0x0551E8 Ch.5 +// D3D11::CreateBuffers 0x0551F0 Ch.5 +// ImGui_ImplWin32_WndProcHandler 0x057720 Ch.7 +// ImGui::Toggle (TabMgr) 0x070820 Ch.12 +// ImGui::Selectable 0x0708D0 Ch.17 +// TabMgr::BeginTabFull 0x09D7D0 Ch.12 +// Sidebar_Settings entry 0x080770 Ch.25 +// D3D11::Setup (ImGui backend init) 0x082500 Ch.29 +// D3D11::Reinit 0x0825B0 Ch.7/29 +// WndProc 0x0826A0 Ch.7 +// OverlayWindowInit 0x0827A0 Ch.29 +// FindGameWindow 0x0835D0 Ch.29 +// GetOverlayRect 0x0836A0 Ch.29 +// PresentHook callsite 0x082F00 Ch.15.5 +// RenderFrame 0x082FC0 Ch.15 +// HookMgr_singleton 0x081B00 Ch.8 +// ESPModule singleton init 0x083E00 Ch.9 +// ESPModule::RenderOverlay 0x083FA0 Ch.22 +// SetDither::Render 0x08C490 Ch.12.5 +// CheckboxToggle 0x085320 Ch.12 +// ImGui::SliderFloat 0x065570 Ch.12.3 +// ImGui::DragInt 0x066750 Ch.12.2 +// NoClip::Render 0x0813D0 Ch.12.2 +// NoClip::Update 0x089B50 Ch.12.2 +// NoClip::EntityIterator 0x089DC0 Ch.12.2 +// FreeCam::Update 0x0871A0 Ch.12.3 +// FpsUnlocker::Render 0x085B90 Ch.12.4 +// PlayerProfile::Update 0x08A4F0 Ch.12.6 +// Vacuum::Render 0x093CA0 Ch.12.7 +// Vacuum::PhysicsLoop 0x093F10 Ch.12.7 +// Vacuum::EntityIterator 0x094000 Ch.12.7 +// SkillHack::Render (hook install) 0x08D1F0 Ch.12.8 +// SkillHack::RenderPanel 0x08D240 Ch.12.8 +// SkillHack::Dispatcher 0x08D4B0 Ch.10 +// SkillHack::CooldownBypass 0x08D500 Ch.10 +// SkillHack::AvailBypass 0x08D640 Ch.10 +// SkillHack::CostBypass 0x08D780 Ch.10 +// SkillHack::PatchFloat 0x08E220 Ch.10 +// SkillHack::PatchBool 0x08EBC0 Ch.10 +// SkillHack::PatchVoid 0x08F560 Ch.10 +// SkillHack::TrampolineDispatch 0x08FF00 Ch.10 +// PreventScreenshot::Initialize 0x08AD70 Ch.21 +// PreventScreenshot::Render 0x08AE60 Ch.21 +// PreventScreenshot::Update 0x08AFC0 Ch.21 +// PreventScreenshot::OsCheck 0x08B220 Ch.21 +// UTF8ToWide 0x08B4E0 Ch.11 +// ModulePathScanner 0x08B650 Ch.11.2 +// ModulePathScanner::EFSearch 0x08B937 Ch.11.2 +// HookInstallerWrapper 0x08BAF0 Ch.11.3 +// ImGui::InputText_ws 0x08AC20 Ch.12.6 +// HookInstaller inner 0x08BAF0 Ch.11.3 +// ColorApplicator 0x094190 Ch.28.2.1 +// Theme_Writer_Preset0 0x094890 Ch.17/28 +// Theme_Writer_Preset1 0x096770 Ch.17/28 +// Theme_Writer_Preset2 0x098650 Ch.17/28 +// Settings::RenderOverlay 0x09A4F0 Ch.19.8 +// UnityExplorer::RegisterTab 0x090060 Ch.16 +// UnityExplorer::Render 0x090250 Ch.16 +// UnityExplorer::RefreshScenes 0x090D40 Ch.16 +// UnityExplorer::GuardReturn 0x0901D8 Ch.16 +// UnityExplorer::AutoRefresh 0x093B10 Ch.16 +// ImGui::Begin wrapper 0x0937D0 Ch.16 +// ModuleManager::AddRegistrar 0x09B2C0 Ch.15 +// ModuleManager::Grow 0x09B3C0 Ch.15 +// ModuleManager::Init 0x09AC10 Ch.15 +// ModuleManager::UpdateLoop 0x09AE80 Ch.15 +// ModuleManager::RenderLoop 0x09AEF0 Ch.15 +// ModuleManager::HotkeyLoop 0x09AF60 Ch.15 +// ModuleManager::RegisterAll 0x09AE00 Ch.15 +// DispatchLoop_UpdateCatch 0x0AEBC0 Ch.15.4.1 +// DispatchLoop_RenderCatch 0x0AEC50 Ch.15.4.1 +// DispatchLoop_HotkeyCatch 0x0AECE0 Ch.15.4.1 +// IL2CPP_FindByPath 0x09BCB0 Ch.16/19 +// GABypass::Init 0x09D1E0 Ch.18 +// CollectProcessThreads 0x0A96B0 Ch.3 +// SuspendOrResumeThreads 0x0A9A20 Ch.3 +// PatchCode 0x0A9A9C Ch.3 +// Startup_main 0x0A9190 Ch.11.4 +// HookMgr_AllocTrampoline 0x0A960C Ch.8 +// HookMgr_CreateHook 0x0A9CC8 Ch.8 +// HookMgr_RemoveHook 0x0A9FA0 Ch.8 +// HookMgr_EnableHook 0x0AA140 Ch.8 +// HookMgr_FreeSlot 0x0AA684 Ch.8 +// HookMgr_Spinlock 0x0A9C88 Ch.8 +// WideStr::wcsstr 0x0AB6A0 Ch.11 +// WideStr::Dtor 0x0AB758 Ch.11 +// Memset_block 0x0AC86A (alloc+memset 0xD8 bytes) +// BaseModule::Dtor 0x00FA60 Ch.12 +// WideToString 0x00EB10 Ch.11 +// PreventScreenshot::SetAffinity 0x08B490 Ch.21 (SetWindowDisplayAffinity call site) +// Vacuum::Render (alt addr) 0x093C90 Ch.12.7 (one-byte offset alias for 0x93CA0) + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 19 — CONFIG I/O FUNCTIONS (Ch.6 complete) +// ============================================================================ + +namespace RVA { + // Config I/O + constexpr u32 ReadConfig = 0x0302D2; // fread JSON config on startup → populate g_Config + constexpr u32 ReadConfig_end = 0x030348; // ReadConfig range end + constexpr u32 SaveConfig = 0x030620; // fwrite g_Config state to JSON file (0x30620-0x307A0) + constexpr u32 SaveConfig_end = 0x0307A0; + constexpr u32 ImGuiSaveIni = 0x017078; // fwrite ImGui window layout to .ini (0x17078-0x172CA) + constexpr u32 ImGuiSaveIni_end = 0x0172CA; + constexpr u32 ConsoleDebugWrite = 0x00EA1B; // fwrite to stdout/console (debug output, size=1) + + // SaveConfig (RVA 0x30620) pseudocode: + // Check state->enabled_flag [rbx+0x2900] + // Load state->file_path ptr [rbx+0x50] + // Call BuildFilePath (0x30A90) + // Call OpenConfigFile(path, "wt") → FILE* fp + // Serialize via ConfigSerialize (0x12050) → string + // fwrite(string, 1, len, fp); fclose(fp) + // Auto-save timer: xmm0=[rbx+0x2904], timer -= delta; on expire: re-save + // + // Config field written by language selector: + // [g_Config+0x2764] content ref-count (DWORD, decremented on lang change) + constexpr u32 LangSelector_refcount_off = 0x2764; // g_Config+0x2764 = content ref-count +} + +// ============================================================================ +// SECTION 20 — LOG / PRINT / CRC32 / REGISTRY (Ch.15 / Ch.26 helpers) +// ============================================================================ + +namespace RVA { + constexpr u32 Log_Print = 0x00FDA0; // shared logging helper (called by all 3 dispatch catchers) + constexpr u32 ImGui_PushStyleColor = 0x010840; // ImGui::PushStyleColor — theme system (159 calls) + constexpr u32 CRC32_Lookup = 0x011DF0; // CRC32 of module key string (e.g. "Sidebar", "Content") + constexpr u32 Module_RegistryLookup = 0x03D1A0; // registry lookup by CRC32 hash → module ptr + constexpr u32 Module_Notify = 0x01D2B0; // module notify/update (called after lang change) + constexpr u32 ImGui_Epilogue = 0x023E20; // ImGui epilogue tail-call target (Sidebar tail-jmps here) + constexpr u32 I18n_Refresh = 0x02A530; // i18n content refresh — reload translations on lang change + constexpr u32 Locale_ContextInit = 0x09D660; // locale context init — selects "en" or "zh_cn" based on flag + constexpr u32 Label_Formatter = 0x05FB60; // sprintf-style: build "Key Name: %s" label strings + constexpr u32 ImGui_Combo = 0x064220; // ImGui::Combo (language dropdown, 2-item list) + constexpr u32 FPS_StringBuild = 0x07F5C0; // build "FPS: NNN" string for FPS overlay +} + +// i18n language flag: [.data+0x3C77B0] (VA 0x1803C77B0) +// 0 = English (RVA 0x3AF310) +// 1 = 简体中文 (RVA 0x3AF318) +// Language tab label: " Language" (RVA 0x3AF328, 5-space indent) +// Combo widget ID: "##Language" (RVA 0x3AF338) + +// ============================================================================ +// SECTION 21 — SIDEBAR / MAIN PANEL (Ch.25 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 Sidebar_Render = 0x07F8F0; // top-level overlay panel (0x7F8F0, ~0x146E bytes) + // Sidebar_Render calls: + // CRC32_Lookup(0x11DF0) on "Sidebar" key (RVA 0x3AF2C8) + // Module_RegistryLookup(0x3D1A0) + // Module_Notify(0x1D2B0) + // Language selector sub-panel (0x80770-0x80B50) unconditionally + // Jump-table dispatch for all tab bodies + // Tail-jmp to ImGui_Epilogue (0x23E20) at 0x80D5E + // Stack frame: 0x380 bytes; saves xmm6–xmm8; single rcx arg (ModuleManager ptr) + // + // Key strings: + // Banner: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) + // Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) + // Window key: "Sidebar" (RVA 0x3AF2C8) — ImGui::Begin not called inside 0x7F8F0 itself + // Active tab index written to [.data+0x1F68] on click, read by jump table + + constexpr u32 Lang_Selector_start = 0x080770; // language selector sub-panel start (unconditional) + constexpr u32 Lang_Selector_end = 0x080B50; // language selector sub-panel end +} + +// Language selector execution flow (Ch.26.2): +// 0x80895 call Locale_ContextInit(0x9D660) +// 0x808DD lea rsi, "English" (RVA 0x3AF310) +// 0x808E3 lea rbx, "简体中文" (RVA 0x3AF318) +// 0x809A1 lea rdx, " Language" (RVA 0x3AF328) +// 0x809C6 call TabMgr::BeginTab(0x9D7D0) +// 0x80A03 call ImGui::Combo(0x64220) → al=1 if changed +// 0x80A2F if English: mov [.data+0x3C77B0], 0 +// 0x80A5D if ZH-CN: mov [.data+0x3C77B0], 1 +// 0x80A6E call I18n_Refresh(0x2A530) +// 0x80A73 dec [g_Config+0x2764] (content ref-count) +// 0x80A80 rax = [g_Config+0x15D8] (active config preset ptr) +// 0x80A87 [rax+0x103] = 1 (dirty flag → triggers config save) +// 0x80B0B lea rcx, "Content" (RVA 0x3ADFC8) +// 0x80B12 call CRC32_Lookup(0x11DF0) +// 0x80B33 call Module_RegistryLookup(0x3D1A0) +// 0x80B4D call Module_Notify(0x1D2B0) + +// ============================================================================ +// SECTION 22 — ESPMODULE COMPLETE FUNCTION TABLE (Ch.22) +// ============================================================================ + +namespace RVA { + constexpr u32 ESPModule_Init = 0x083E00; // lazy singleton init (thread-safe static) + constexpr u32 ESPModule_Render = 0x083F60; // Ch.22 §22.1 — "ESP Features" collapsing header + constexpr u32 ESPModule_DrawOverlay = 0x083000; // Ch.22 §22.2 — world-space entity label overlay + constexpr u32 ESPModule_Update = 0x084A00; // per-frame entity label draw loop start + constexpr u32 ESPModule_Update_loop = 0x0852A5; // entity label loop body +} +// ESPModule::RenderOverlay (0x83FA0–0x8499E): large monolithic ImGui panel +// ESPModule::Update entity type dispatch: 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle + +// ============================================================================ +// SECTION 23 — FPSMODULE COMPLETE (Ch.20) +// ============================================================================ + +namespace RVA { + constexpr u32 FPSModule_Initialize = 0x0814C0; // once_flag guarded init (once_flag at [.data+0x2310]) + constexpr u32 FPSModule_RenderPanel = 0x085660; // panel render (two checkboxes: FPS Monitor + Show FPS Overlay) + constexpr u32 FPSModule_RenderPanel_branch = 0x0856F0; // inner ImGui branch of panel render + constexpr u32 FPSModule_RenderOverlay = 0x085700; // FPS counter overlay start + constexpr u32 FPSModule_RenderOverlay_end = 0x085900; // FPS counter overlay end + constexpr u32 FPSModule_RenderOverlay_counter = 0x0858D0; // "##Foreground" frameless window (FPS display) +} +// FPSModule::Initialize (0x814C0): +// Guarded by once_flag at [.data+0x2310] +// Alloc 0xD8 bytes (via 0xAC86A), store ptr at [.data+0x22E0] +// vtable: 0x3AFA38 → 0x3AFAC0 after init +// name: "FPS Monitor" (RVA 0x3AFA88) at [.data+0x22E8] +// enabled = 0 at [.data+0x2308] +// +// FPSModule overlay color thresholds (RVA of XMMWORD constants): +// fps >= 60: 0x1803B3530 (green) +// 30 <= fps < 60: 0x1803B3540 (yellow) +// fps < 30: 0x1803B3510 (red) +// FPS display string built by FPS_StringBuild (0x7F5C0): "FPS: " + integer + +// ============================================================================ +// SECTION 24 — SETDITHER COMPLETE (Ch.12.5.1) +// ============================================================================ + +namespace RVA { + constexpr u32 SetDither_RenderOverlay = 0x08C4A0; // SetDither::RenderOverlay — distinct from RegisterTab + // SetDither::RenderOverlay is invoked by the tab-callback pointer chain + // (not directly from RegisterTab at 0x81810) + // Implements the graphics dither toggle panel body +} + +// ============================================================================ +// SECTION 25 — FREECAM KEY BINDING DISPLAY (Ch.27.3) +// ============================================================================ +// Key display sub-panel inside FreeCam tab (when enabled): +// Each row uses: MakeString(0xFCB0) → Label_Formatter(0x5FB60) → TabMgr::BeginTab(0x9D7D0) +// Key binding state array: [rip + ...] # 0x1803C6E98 ("Pu;" RTTI sentinel in .data) +// Key label format strings (RVAs): +// "Forward Key: %s" 0x3AFD08 VA 0x180087A87 +// "Backward Key: %s" 0x3AFD18 VA 0x180087B1A (approx) +// "Left Key: %s" 0x3AFD30 +// "Right Key: %s" 0x3AFD40 +// "Up Key: %s" 0x3AFD50 +// "Down Key: %s" 0x3AFD60 +// "IncFOV Key: %s" 0x3AFD70 +// "DecFOV Key: %s" 0x3AFD80 +// "LeftRoll Key: %s" 0x3AFD90 +// "RightRoll Key: %s" 0x3AFDA8 +// "ResetRoll Key: %s" 0x3AFDC0 +// "NONE" 0x3AF820 — displayed for any unbound key + +namespace RVA { + constexpr u32 FreeCam_KeyDisplay = 0x087A87; // FreeCam key binding display panel start +} + +// ============================================================================ +// SECTION 26 — SKILLHACK INTERNALS (Ch.10 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 SkillHack_FNV_hash = 0x08D555; // FNV-1a 64-bit hash (unrolled, 8-byte XOR/MUL loop) + // FNV constants: prime=0x100000001B3, offset=0xCBF29CE484222325 + constexpr u32 SkillHack_HashMiss = 0x08D770; // hash miss fallback: xor al,al → ret 0 + constexpr u32 SkillHack_CallOrig = 0x08D891; // call-original trampoline: call r8 (original fn) + constexpr u32 SkillHack_SkipRet = 0x08D894; // skip-to-ret jmp target (cost bypass early exit) + constexpr u32 Vacuum_Monster_subss = 0x093EAC; // Vacuum::Render Monster sub-checkbox subss sequence +} + +// ============================================================================ +// SECTION 27 — CRT SECURITY FUNCTIONS (Ch.4) +// ============================================================================ + +namespace RVA { + constexpr u32 CRT_SecurityInit = 0x0AC580; // __security_check_cookie + SEH init (0xAC580-0xAC6CA) + constexpr u32 CRT_SecurityInit_end = 0x0AC6CA; + constexpr u32 CRT_SecurityCookie = 0x0AC6CC; // __security_check_cookie verifier (0xAC6CC-0xAC77B) + constexpr u32 CRT_SecurityCookie_end= 0x0AC77B; +} +// CRT_SecurityInit pseudocode (called at DllMain + first-chance exception dispatch): +// call IsProcessorFeaturePresent(0x17) → if supported: int 29h (fast fail) +// call __security_check_cookie helper (sub_0x1800AC574) +// RtlCaptureContext / RtlLookupFunctionEntry / RtlVirtualUnwind +// Build EXCEPTION_RECORD: code=0x40000015 (STATUS_FATAL_APP_EXIT), flags=NONCONTINUABLE +// call IsDebuggerPresent → save eax +// call SetUnhandledExceptionFilter(NULL) +// call UnhandledExceptionFilter(&record) +// if !result && !debugger: call TerminateProcess(handle, code) [via int 29h at 0xAC628] + +// ============================================================================ +// SECTION 28 — THREAD ENUMERATION DETAIL (Ch.3 call-site map) +// ============================================================================ +// All CollectProcessThreads (0xA96B0) internal call sites: +// 0xA9701 TH32CS_SNAPTHREAD = 4 (lea ecx,[rbx+4]) +// 0xA970B CreateToolhelp32Snapshot(4, pid) +// 0xA971E sizeof(THREADENTRY32) = 28 = 0x1C +// 0xA972F Thread32First(hSnapshot, &te32) +// [loop body] +// 0xA9740 check te32.th32OwnerProcessID offset (0x10) +// 0xA974B GetCurrentProcessId() +// 0xA9751 cmp te32.th32OwnerProcessID, eax +// 0xA9757 GetCurrentThreadId() +// 0xA975D cmp te32.th32ThreadID, eax +// 0xA9761 je skip (exclude caller thread) +// 0xA9763 get vector data ptr +// 0xA9778 VirtualAlloc/HeapReAlloc if vector full +// 0xA97CA store thread ID: [rdx+rcx*4] = eax +// 0xA97CD inc [rdi+0xC] (vector count++) +// 0xA97DD Thread32Next(hSnapshot, &te32) +// 0xA97E3 test eax,eax → jne loop +// 0xA97EB GetLastError → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0xA9815 CloseHandle(hSnapshot) +// +// SuspendOrResumeThreads (0xA9A20) call sites: +// 0xA9849 OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// 0xA9861 SuspendThread(hThread) +// 0xA9964 ResumeThread(hThread) [×37 total resume calls] +// 0xA988B GetThreadContext(hThread, &ctx) +// 0xA993C CreateToolhelp32Snapshot (secondary snapshot) +// +// PatchCode (0xA9A9C) call sites: +// 0xA9AFC VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &old) +// 0xA9B6C VirtualProtect(target, size, old, &old) (restore) +// 0xA9B72 GetCurrentProcess() +// 0xA9B81 FlushInstructionCache(hProc, target, size) + +// ============================================================================ +// SECTION 29 — IAT CALL SITE MAP (Ch.2 complete) +// ============================================================================ +// All Win32 IAT entries with RVAs and call sites: +// SuspendThread IAT 0xB1050 call site 0xA9861 +// ResumeThread IAT 0xB1058 call site 0xA9964 (×37) +// GetThreadContext IAT 0xB1068 call site 0xA988B +// FlushInstructionCache IAT 0xB1070 call site 0xA9B81 +// SetThreadContext IAT 0xB1078 call site 0xA993C +// GetProcAddress IAT 0xB1088 call sites 0x55F7E, 0x55F92 (×7) +// LoadLibraryA IAT 0xB10E0 call sites 0x55F57, 0x585AE (×4) +// AllocConsole IAT 0xB1108 +// GetConsoleMode IAT 0xB1120 +// SetConsoleMode IAT 0xB1128 +// SetConsoleTitleA IAT 0xB12A0 +// GetCurrentProcess IAT 0xB1270 call site 0xA9B72 +// VirtualFree IAT 0xB1278 call sites 0x81D5B, 0xAA6E1 +// VirtualProtect IAT 0xB1288 call sites 0xA9AFC, 0xA9B6C +// VirtualAlloc IAT 0xB11A0 call sites 0xAA566, 0xAA607 +// IsDebuggerPresent IAT 0xB11E8 call site 0xAC67B +// IsProcessorFeaturePresent IAT 0xB11F0 call site 0xAC5A2 +// TerminateProcess IAT 0xB11F8 call site 0xAC628 (via int 29h) +// SetUnhandledExceptionFilter IAT 0xB1200 call site 0xAC698 +// UnhandledExceptionFilter IAT 0xB1208 call site 0xAC6A3 +// RtlVirtualUnwind IAT 0xB1210 +// RtlLookupFunctionEntry IAT 0xB1218 +// RtlCaptureContext IAT 0xB1220 +// OpenThread IAT 0xB11D0 call site 0xA9849 (×38) +// Thread32Next IAT 0xB11A8 call site 0xA97DD +// Thread32First IAT 0xB11B0 call site 0xA972F +// CreateToolhelp32Snapshot IAT 0xB1160 call site 0xA970B +// SetWindowDisplayAffinity IAT 0xB1460 call site 0x8B48F +// FindWindowA IAT 0xB14A8 call site 0x8301F +// EnumWindows IAT 0xB14A0 +// GetWindowRect IAT 0xB1488 +// GetWindowThreadProcessId IAT 0xB1498 +// IsWindow IAT 0xB1468 +// GetSystemMetrics IAT 0xB14E0 +// LoadIconW IAT 0xB14E8 +// GetAsyncKeyState IAT 0xB???? call site 0x8301A +// ShowWindow IAT 0xB1628 +// UpdateWindow IAT 0xB14D8 +// RegisterClassExW IAT 0xB1638 +// CreateWindowExW IAT 0xB1650 +// SetLayeredWindowAttributes IAT 0xB15E0 +// SetProcessDPIAware IAT 0xB15A0 +// LoadCursorW IAT 0xB15C8 +// PeekMessageW IAT 0xB14D0 +// TranslateMessage IAT 0xB14C8 +// DispatchMessageW IAT 0xB14C0 +// PostQuitMessage IAT 0xB???? (WndProc WM_DESTROY) +// SetWindowPos IAT 0xB???? (overlay alignment) +// CreateSolidBrush IAT 0xB1018 +// CreateMutexA IAT 0xB1720 +// DwmExtendFrameIntoClientArea IAT 0xB1918 +// D3D11CreateDeviceAndSwapChain IAT 0xB1908 +// D3DCompile IAT 0xB1000 call sites 0x54E77, 0x55069 +// _wfopen IAT 0xB1888 call site 0x11F93 +// fwrite IAT 0xB1868 call sites 0xEA1B, 0x170D6, 0x3033B, 0x3076D +// fread IAT 0xB1870 (via 0x11EA0 helper) +// fclose IAT 0xB1878 call sites 0x170DF, 0x30776 + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 30 — REMAINING CALL-SITE ADDRESSES (final gap closure) +// ============================================================================ +// These are internal addresses referenced in the doc that complete coverage. +// They are instruction-level addresses, not function entry points. + +namespace RVA { + // Config I/O range markers + constexpr u32 OpenConfigFile_end = 0x012043; // OpenConfigFile range end (0x11EA0–0x12043) + constexpr u32 ImGuiSaveIni_caller = 0x0170B9; // caller VA of ImGuiSaveIni (fopen 'wt' for .ini) + constexpr u32 SaveConfig_iniwrite = 0x030750; // SaveConfig: write ImGui ini section call site + + // FpsUnlocker alt address (function table ref) + constexpr u32 FpsUnlocker_Render_alt = 0x085B80; // FpsUnlocker::Render alt ref addr (one-byte offset) + + // FreeCam key display + constexpr u32 FreeCam_BackwardKey = 0x087B1A; // "Backward Key: %s" display address (approx) + + // ModuleManager::DispatchRegistrarInit call site + constexpr u32 DispatchRegInit_callsite = 0x083348; // called at 0x83348 — init ImGui panel layout after first Present + + // ModulePathScanner skip-on-failure + constexpr u32 ModPathScanner_skip = 0x08BA41; // je target: skip module on GetModuleFileNameW failure + + // CollectProcessThreads instruction-level addresses (within 0xA96B0 body) + // 0xA96E7 xor ebx,ebx — thread count = 0 + // 0xA96F8 init empty vector — mov [rcx],rbx; mov [rcx+8],rbx + // 0xA9711 mov r14,rax — hSnapshot = CreateToolhelp32Snapshot result + // 0xA9714 cmp rax,-1 — INVALID_HANDLE_VALUE check + // 0xA9725 lea rdx,[rsp+0x30] — THREADENTRY32 buffer ptr + // 0xA972A mov [rsp+0x30],r12d — te32.dwSize = 28 + // 0xA9751 cmp [rsp+0x3C],eax — te32.th32OwnerProcessID == GetCurrentProcessId + // 0xA9755 jne skip — skip threads from other processes + // (All within CollectProcessThreads body at 0xA96B0; see Section 28 for full map) +} + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 19 — SIDEBAR / MAIN PANEL (Ch.25) +// ============================================================================ +// Top-level overlay panel function: RVA 0x7F8F0 (~0x146E bytes) +// Called every Present() frame from ModuleManager render loop. +// Stack frame: 0x380 bytes; saves xmm6-xmm8; single rcx arg (global ctx ptr) +// +// Key strings: +// "Sidebar" RVA 0x3AF2C8 — window lookup key (CRC32 0x11DF0, reg 0x3D1A0/0x1D2B0) +// "EF - Cheeto Press F12 to show panel" RVA 0x3AF258 +// "This is free, if you spend money, then you have been deceived" RVA 0x3AF288 +// Active tab index: [.data+0x1F68] VA 0x1803C6F68 (written on click, read at 0x80B52) +// +// Six tabs (jump-table dispatch at 0x80B52, case bodies): +// Tab 0 "About" RVA 0x3AF2D0 — banner + disclaimer + About sub-fn (0x80E80) +// Tab 1 "Player" RVA 0x3AF2DC — NoClip, SkillHack +// Tab 2 "ESP" RVA 0x3AF2E8 — ESPModule overlay +// Tab 3 "World" RVA 0x3AF2F0 — Vacuum +// Tab 4 "Visual" RVA 0x3AF2FC — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +// Tab 5 "Settings" RVA 0x3ADFD8 — Settings::RenderOverlay (case 5 at 0x80D25) +// +// i18n label dispatcher: 0x9D660 (translates label string per language toggle) +// Sidebar function tail-calls into ImGui epilogue at 0x23E20 via jmp at 0x80D5E + +namespace RVA { + constexpr u32 Sidebar_Main = 0x07F8F0; // top-level sidebar render + constexpr u32 Sidebar_About = 0x080E80; // About tab sub-function + constexpr u32 Sidebar_JumpTable = 0x080B52; // tab jump table (reads [.data+0x1F68]) + constexpr u32 Sidebar_Case5 = 0x080D25; // Settings tab case entry + constexpr u32 i18n_Dispatcher = 0x09D660; // translation dispatcher (en/zh_cn) + // ImGui_Combo = 0x064220 (already defined in Section 9 RVA namespace) + // ImGui_Epilogue = 0x023E20 (already defined in Section 9 RVA namespace) + constexpr u32 CRC32_fn = 0x011DF0; // CRC32 hash (window key) + constexpr u32 Registry_lookup = 0x03D1A0; // registry lookup by CRC32 + constexpr u32 Registry_lookup2 = 0x01D2B0; // secondary registry lookup +} + +// ============================================================================ +// SECTION 20 — FREECAM KEY BINDING DISPLAY PANEL (Ch.27) +// ============================================================================ +// Sub-section of FreeCam::Update (RVA 0x871A0), begins at ~0x87A70, ends 0x88606 +// (FreeCam::Update is 0x14C6 bytes total) +// +// Float sliders (ImGui variant 0x65570): +// "Free Camera" RVA 0x3AFCB0 — sub-panel BeginTab label +// "ON / OFF" RVA 0x3AF848 — toggle checkbox +// "Move Speed" RVA 0x3AFCC0 — DragFloat fmt "%.3f" (0x3ADFB0) +// "Look Sensitivity" RVA 0x3AFCD0 — DragFloat fmt "%.3f" +// "Roll Speed" RVA 0x3AFCE8 — DragFloat fmt "%.3f" +// "FOV Speed" RVA 0x3AFCF8 — DragFloat fmt "%.3f" +// "FOV" RVA 0x3AFD04 — DragFloat fmt "%.1f" (0x3ADFEC) +// +// Key binding rows (11 total) — each row: +// MakeString(0xFCB0) → sprintf(0x5FB60, "Key: %s", key_name) → TabLabel(0x9D7D0) +// "NONE" RVA 0x3AF820 — displayed for unbound keys +// Key-binding state array: [rip+...] 0x1803C6E98 +// Rows: +// "Forward Key: %s" RVA 0x3AFD08 (VA 0x180087A87) +// "Backward Key: %s" RVA 0x3AFD18 +// "Left Key: %s" RVA 0x3AFD30 +// "Right Key: %s" RVA 0x3AFD40 +// "Up Key: %s" RVA 0x3AFD50 +// "Down Key: %s" RVA 0x3AFD60 +// "IncFOV Key: %s" RVA 0x3AFD70 +// "DecFOV Key: %s" RVA 0x3AFD80 +// "LeftRoll Key: %s" RVA 0x3AFD90 +// "RightRoll Key: %s" RVA 0x3AFDA8 +// "ResetRoll Key: %s" RVA 0x3AFDC0 + +namespace RVA { + constexpr u32 FreeCam_KeyBindPanel = 0x087A70; // key binding display section start + constexpr u32 FreeCam_KeyBind_end = 0x088606; // end of FreeCam::Update + constexpr u32 Sprintf_label = 0x05FB60; // sprintf-style label formatter +} + +// ============================================================================ +// SECTION 21 — SETTINGS TAB (Ch.28) +// ============================================================================ +// Settings::RenderOverlay RVA 0x9A4F0 (source: SettingsTAB.cpp RVA 0x3B0B30) +// Called from sidebar case 5 (0x80D25). Ends at ~0x9AB31. +// +// 28.1 Theme selector: +// ImGui::Combo("Theme", ...) via 0x64220 +// Four themes → four applicator functions: +// "Default" RVA 0x3B0AF8 → applicator 0x941F0 (restores ImGui defaults) +// "Evangelion Unit 01" RVA 0x3B06D0 → applicator 0x94890 (52 color writes) +// "Evangelion Unit 02" RVA 0x3B0AE0 → applicator 0x96770 +// "Matrix" RVA 0x3B0B10 → applicator 0x98650 +// Each non-default applicator uses per-slot helper RVA 0x94190 (159 calls total): +// reads RRGGBBAA hex string → __stdio_common_vsscanf → ImGui::PushStyleColor (0x10840) +// +// Evangelion Unit 01 colors (RVA 0x94890, in write order): +// #FFFFFFFF #7857A7FF #19171CFF #2A282EFF #2A282EE6 #4DE6A5FF +// #00000000 #4A455240 #A38CCF80 #7857A780 #4A4552FF +// +// Evangelion Unit 02 colors (RVA 0x96770): +// #FFFFFFFF #D9293BFF #1E1E1EFF #3A3A3AFF #3A3A3AE6 #F7B302FF +// #00000000 #4A455240 #F7465880 #D9293B80 #4A4552FF +// +// Matrix colors (RVA 0x98650): +// #00FF41FF #00AA2CFF #000000FF #0A0A0AFF #0A0A0AE6 #004400FF +// #00000000 #00440040 #00881EFF #00FF4180 +// +// 28.3 Console toggle: +// CheckboxToggle(0x85320) with label "Toggle Console" (RVA 0x3B0B00) +// Enabled branch: AllocConsole (IAT 0xB1178) / GetStdHandle → display "Console {}" +// Disabled branch: FreeConsole + +namespace RVA { + constexpr u32 Theme_Default = 0x0941F0; // restores ImGui default palette + constexpr u32 StyleColor_push = 0x010840; // ImGui::PushStyleColor wrapper + // Settings_end 0x09AB31 — see also RVA::Settings_end 0x09AB98 in Section 9 +} + +// ============================================================================ +// SECTION 22 — CONFIG / IMGUI .INI SYSTEM (Ch.19) +// ============================================================================ +// ImGui .ini filename: "imgui.ini" RVA 0x3ABB60 +// Set at RVA 0x1117A into ImGuiIO+0x20 (IniFilename field) +// +// Config save/load: +// Load path (startup): RVA 0x30661 → ConfigSerialize (0x12050) +// → ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell → fread → fclose +// Manual save trigger: RVA 0x17072 +// Sets [ImGuiContext+0x2900]=1, [ImGuiContext+0x2904]=0 → forces immediate write +// fwrite calls: 0x3076D (config body), also 0x170D6 +// fclose: 0x30776 +// +// Module settings handler struct (ImGuiContext+0x2920 array, 0x48 bytes each): +// +0x00 TypeName (const char*) — .ini section name +// +0x08 TypeHash (u32) — CRC32 of TypeName (computed 0x3079C–0x30803) +// +0x18 ReadOpenFn — called on section header encounter +// +0x38 WriteAllFn — called during save to emit key=value lines +// 11 registered modules (RTTI .data+0x0590–0x0E60): +// ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule +// +// i18n blob: RVA 0x3B10E8 (0xEED bytes, nlohmann JSON, en→zh_cn map) +// Copied to [.data+0x1EB8] at startup RVA 0x2164 +// Loader: RVA 0x9D660 — selects en or zh_cn based on language flag +// nlohmann version: v3.12.0 (statically linked; error strings at 0x3B3010–0x3B30D8) + +namespace RVA { + constexpr u32 ImGuiIni_set = 0x01117A; // IniFilename = "imgui.ini" write + constexpr u32 Config_save_trigger = 0x017072; // manual save: set ImGuiCtx+0x2900 + constexpr u32 Config_load_entry = 0x030661; // config file load entry + constexpr u32 Config_ftell = 0x0120A0; // ftell in config read + constexpr u32 Config_fseek_A = 0x0120BC; // fseek in config read + constexpr u32 Config_fseek_B = 0x0120E7; // fseek in config read + constexpr u32 Config_fwrite = 0x03076D; // config body fwrite + constexpr u32 Config_fclose = 0x030776; // config fclose + constexpr u32 ImGui_handler_CRC = 0x03079C; // CRC32 of TypeName (start) + constexpr u32 ImGui_handler_CRC_end = 0x030803; // CRC32 of TypeName (end) + constexpr u32 i18n_blob_rva = 0x3B10E8; // JSON localization blob (.rdata) + constexpr u32 i18n_loader = 0x09D660; // translation dispatcher + constexpr u32 i18n_copy_site = 0x02164; // startup: copies blob to [.data+0x1EB8] + constexpr u32 Registrar_name_str = 0x01B71; // registrar constructor name string RVA ref +} + +// ============================================================================ +// SECTION 23 — UNITY EXPLORER MODULE (Ch.16 supplement) +// ============================================================================ +// UE draw body: RVA 0x0902E0 (per-frame inspector UI, called from UE::Render 0x90250) +// Window title: "Unity Explorer Window" RVA 0x3B02E0 (via ImGui::Begin wrapper 0x937D0) +// +// Scene panel (pseudocode): +// if (scene_list empty) { +// ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +// } else { +// ImGui::Text("Select Scene:"); +// ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +// if (changed) LoadScene(selected_scene_idx); +// } +// // When scene panel active: g_Config->overlay_flags |= 1; overlay_scale = 300.0f +// // ([g_Config+0x1F78], [g_Config+0x1F90]) +// +// Auto-refresh (RVA 0x090250): +// if (enabled && auto_refresh) { +// now = GetTime(); // 0x93B10 +// if ((now - last_refresh_time) * SCALE >= refresh_interval) +// RefreshScenes(this); last_refresh_time = now; +// } +// +// Scene list storage: vector at [this+0x58]..[this+0x60] +// GameObject list: vector at [this+0x40]..[this+0x48] +// Search filter: [this+?] char[0x100] buffer "##SearchFilter" +// +// Inspector panel (when object selected via 'Ins' button): +// 'Active' checkbox → GameObject.SetActive via IL2CPP +// Transform: Position, LocalPosition, Rotation, Scale (float3 inputs) +// 'Components' section via IL2CPP GetComponents(UnityEngine.Component) +// Per component: "%s.%s" (namespace.classname) +// Failure strings: "Unknown Component", "Unable to get GameObject class information." +// +// Key strings (Ch.16.4): +// "No scenes available. Click 'Refresh Scenes' to load." +// "Select Scene:" "No GameObjects found in this scene." "DontDestroyOnLoad" +// "No GameObject selected." "Active" "Components" "All Components:" + +namespace RVA { + constexpr u32 UE_DrawBody = 0x0902E0; // main per-frame inspector draw + constexpr u32 UE_AutoRefresh_fn = 0x093B10; // auto-refresh timer check +} + +// ============================================================================ +// SECTION 24 — ADDITIONAL IAT ENTRIES (referenced in doc but not in Ch.2 table) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw offset 0xAF600) +// These slots appear in inline code references throughout the doc: + +// IAT[0xB1148] SwitchToThread — spinlock backoff (if backoff<32: SwitchToThread else Sleep(1)) +// IAT[0xB1168] GetModuleFileNameExW — module path scanner, get full path of each module +// IAT[0xB1178] AllocConsole — Settings console toggle enable branch +// IAT[0xB1290] GetModuleHandleW — GABypass: GetModuleHandleW(L"GameAssembly.dll") +// also: PreventScreenshot::OsCheck loads ntdll for RtlGetVersion + +// ============================================================================ +// SECTION 25 — MODULEMANGER INIT VARIANT ADDRESS (Ch.19.7) +// ============================================================================ +// Two RVAs for ModuleManager::Init appear in the doc: +// RVA 0x09AC10 — from Ch.15 (primary reference) +// RVA 0x09ACA4 — from Ch.19.7 (alternate call site / body continuation) +// Both refer to the same function; 0x9AC10 is entry, 0x9ACA4 is within body. +// Body action (Ch.19.7): +// Iterates module registry [.data+0x23B8], calls vtable[+0x10] → module instance, +// then vtable[+0x18] (Render dispatch) per registered module. +// Source: ModuleManager.cpp lines 34 and 52 (assert strings in binary). + +// Vacuum::RegisterTab stub at RVA 0x9B650 resolves via jmp to +// UnityExplorerModule::RegisterTab at RVA 0x090060. +// (Vacuum and UE share a registrar stub due to module ordering in init sequence) + +// GABypass::Patch call site in startup: RVA 0x0A942A +// Called exactly once from LoaderThread, immediately after 'Initializing..' log (0xA93E6) +// and before any module Update()/Render() calls. + +// ============================================================================ +// SECTION 26 — COMPLETE ADDRESS COVERAGE INDEX +// ============================================================================ +// All 282 unique cheat-range addresses extracted from the doc, organized by subsystem. +// Addresses not in RVA:: namespace appear inline below with descriptions. + +// -- Config / i18n / .ini system -- +// 0x01B71 registrar constructor name string ref +// 0x02164 i18n blob copy to [.data+0x1EB8] at startup +// 0x1117A ImGuiIO.IniFilename = "imgui.ini" write site +// 0x17072 manual config save trigger (sets ImGuiCtx+0x2900=1) +// 0x30661 config file load entry (calls ConfigSerialize 0x12050) +// 0x30904 ImGui handler struct layout base (from CRC32 compute chain) + +// -- Sidebar / UI -- +// 0x80B52 sidebar tab jump table (reads active_tab_idx [.data+0x1F68]) + +// -- D3D11 overlay window (detailed call sites Ch.29) -- +// 0x8298B EnumWindows → FindGameWindow, end of DPI section +// 0x82A60 DwmExtendFrameIntoClientArea call site +// 0x82B24 D3D11CreateDeviceAndSwapChain attempt 1 (R8G8B8A8) +// 0x82B7E D3D11CreateDeviceAndSwapChain attempt 2 (B8G8R8A8 fallback) +// 0x82C0D CreateMutexA — duplicate-instance guard +// 0x82F5F Log "Initialized" (source UI.cpp, before message loop) +// 0x83386 DispatchRegistrarInit once_flag — install registrar hooks +// 0x8348A SwitchToThread yield site (game out of focus) + +// -- FreeCam -- +// 0x87A70 FreeCam key binding display panel start (inside FreeCam::Update) +// 0x88606 FreeCam::Update end + +// -- UnityExplorer -- +// 0x902E0 UE main draw body (scene panel + GO inspector) + +// -- Settings / Theme -- +// 0x941F0 Default theme applicator (restores ImGui defaults) +// 0x9AB31 Settings::RenderOverlay approximate end + +// -- ModuleManager -- +// 0x9ACA4 ModuleManager::Init body (alt addr, iterates registry vtable[+0x10]/[+0x18]) +// 0x9B650 Vacuum/UE RegisterTab shared stub (resolves to UE::RegisterTab 0x90060) + +// -- Startup -- +// 0xA942A GABypass::Patch call site in LoaderThread (after 'Initializing..' log) + +// -- IAT slots (additional, not in main IAT table) -- +// 0xB1148 SwitchToThread +// 0xB1168 GetModuleFileNameExW +// 0xB1178 AllocConsole +// 0xB1290 GetModuleHandleW (GameAssembly + ntdll RtlGetVersion) + +// ============================================================================ +// SECTION 27 — COMPLETE .RDATA STRING TABLE +// ============================================================================ +// All 189 .rdata string RVAs from the document, grouped by subsystem. +// Format: RVA — "string content" — usage + +// --- ImGui / config filenames --- +// 0x3ABB60 "imgui.ini" ImGuiIO+0x20 IniFilename (written at RVA 0x1117A) +// 0x3ABB70 "imgui_log.txt" ImGuiIO+0x28 LogFilename (written at same site) +// 0x3ABF10 "##Foreground" FPS overlay frameless window label +// 0x3AC160 "Calling EndDisabled() too many times!" ImGui assert string + +// --- D3D11 shaders (HLSL source, compiled at runtime) --- +// 0x3AE660 Vertex shader HLSL source length=0x2DD (733 bytes) +// entry="main" target="vs_4_0" +// cbuffer vertexBuffer:b0 { float4x4 ProjectionMatrix } +// VS_INPUT{float2 pos:POSITION, float4 col:COLOR0, float2 uv:TEXCOORD0} +// PS_INPUT main: output.pos = mul(ProjectionMatrix, float4(pos.xy,0,1)) +// 0x3AE940 Pixel shader HLSL source length=0x191 (401 bytes) +// entry="main" target="ps_4_0" +// sampler sampler0; Texture2D texture0; +// float4 main: return input.col * texture0.Sample(sampler0, input.uv) + +// --- PreventScreenshot --- +// 0x3AEC70 dynamic import string for SetWindowDisplayAffinity (from user32.dll, RVA 0x3C34A6) +// 0x3B00B8 module name "PreventScreenshot" (registrar) + +// --- About page (Tab 0, sub-fn 0x80E80) --- +// 0x3AF350 "%s Game: Endfield CTB3" format string +// 0x3AF368 "Version: " label +// 0x3AF374 "1.0.0" version value +// 0x3AF380 "Author: " label +// 0x3AF38C "gktwo" author value +// (All direct string literals, not i18n-dispatched) + +// --- Window class detection --- +// 0x3AF658 "UnityWndClass" FindWindowA arg / string-compare (0xACA12) + +// --- ESP module (ESPModule::RenderOverlay RVA 0x83FA0) --- +// 0x3AF828 "ESPModule" module name +// 0x3AF838 "ESP Features" CollapsingHeader title → state [.data+0x27B0] +// 0x3AF848 "ON / OFF" checkbox label → [module+0x28] +// 0x3AF858 "Display Types" CollapsingHeader sub-header (via 0x6EC20) +// 0x3AF868 "Show Monsters" checkbox → [rsi+0x34] show_monsters +// 0x3AF878 "Show NPC" checkbox → [rsi+0x35] show_npc +// 0x3AF888 "Show Friendly" checkbox → [rsi+0x36] show_friendly +// 0x3AF898 "Show Puzzles" checkbox → [rsi+0x37] show_puzzles +// 0x3AF8A8 "Show All" checkbox → [rsi+0x38] show_all +// 0x3AF8B8 "Display Info" CollapsingHeader sub-header +// 0x3AF8C8 "Show Distance" checkbox → [rsi+0x39] show_distance +// 0x3AF8D8 "Show Name" checkbox → [rsi+0x3A] show_name +// 0x3AF8E8 "Show Type" checkbox → [rsi+0x3C] show_type +// 0x3AF8F4 (entity label separator string, used in Update DrawOverlay) +// 0x3AF900 (entity label buffer string) +// 0x3AF908 entity type dispatch table start (type→name pairs) +// 0x3AF920 entity type dispatch table continued (0xFFFFFFFF sentinel) +// 0x3AF9E0 vtable ptr value (0x3AF9E0 = post-init vtable for ESPModule) + +// --- FPS overlay (FPSModule) --- +// 0x3AFA98 FPSModule vtable block start +// 0x3AFAAC "FPS: " prefix for FPS display string (via 0x7F5C0) +// Color thresholds for FPS display (XMMWORD constants, already in .rdata): +// fps >= 60: color at 0x1803B3530 (green 0.0, 1.0, 0.0, 1.0) +// 30<=fps<60: color at 0x1803B3540 (yellow 1.0, 1.0, 0.0, 1.0) +// fps < 30: color at 0x1803B3510 (red 1.0, 0.0, 0.0, 1.0) + +// --- FreeCam --- +// 0x3AF820 "NONE" unbound key display in key binding rows + +// --- PlayerProfile UI paths --- +// 0x3AFED0 "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (len 0x2F) +// 0x3AFFD0 "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (len 0x8D) + +// --- FreeCam key binding panel (Ch.27) --- +// 0x3AFCB0 "Free Camera" +// 0x3AFCC0 "Move Speed" +// 0x3AFCD0 "Look Sensitivity" +// 0x3AFCE8 "Roll Speed" +// 0x3AFCF8 "FOV Speed" +// 0x3AFD04 "FOV" +// 0x3AFD08 "Forward Key: %s" +// 0x3AFD18 "Backward Key: %s" +// 0x3AFD30 "Left Key: %s" +// 0x3AFD40 "Right Key: %s" +// 0x3AFD50 "Up Key: %s" +// 0x3AFD60 "Down Key: %s" +// 0x3AFD70 "IncFOV Key: %s" +// 0x3AFD80 "DecFOV Key: %s" +// 0x3AFD90 "LeftRoll Key: %s" +// 0x3AFDA8 "RightRoll Key: %s" +// 0x3AFDC0 "ResetRoll Key: %s" + +// --- UE module string table (Ch.16.4) --- +// 0x3B02D0 "Unity Explorer" tab label / ImGui::Begin title +// 0x3B02E0 "Unity Explorer Window" ImGui window title +// 0x3B02F8 "Search Filter:" label above search input +// 0x3B0308 "##SearchFilter" ImGui InputText widget ID +// 0x3B0318 "Inspector" inspector sub-panel label +// 0x3B0328 "GameObjectHierarchy" hierarchy sub-panel label +// 0x3B0340 "No scenes loaded. Click Refresh..." +// 0x3B0390 "Scene: " scene prefix label +// 0x3B0398 "No GameObjects found in this scene." +// 0x3B03C0 "DontDestroyOnLoad" special DDOL scene label +// 0x3B03D8 "DontDestroyOnLoad (Not Found)" +// 0x3B03F8 "Refresh" button label +// 0x3B0400 "Auto Refresh" checkbox label +// 0x3B0410 "Interval (s)" refresh interval slider +// 0x3B0420 "Scenes found: %d" +// 0x3B0438 "No scenes available. Click 'Refresh Scenes' to load." +// 0x3B0470 "Select Scene:" +// 0x3B0480 "Select Scene" combo default text +// 0x3B0490 "##SceneCombo" ImGui Combo widget ID +// 0x3B04A0 "]: " object list entry separator +// 0x3B04A8 "Ins##" inspect button label prefix +// 0x3B04B8 "No GameObject selected." +// 0x3B04D0 "Click 'Ins' button..." inspector hint +// 0x3B0508 "Active" active checkbox label +// 0x3B0510 "Transform" section header +// 0x3B0520 "Position" +// 0x3B0530 "Local Position" +// 0x3B0540 "Rotation" +// 0x3B054C "Scale" +// 0x3B0558 "No Transform component found." +// 0x3B0578 "Components" section header +// 0x3B0588 "GameObject Class: %s.%s" +// 0x3B05A0 "All Components:" +// 0x3B05B0 "UnityEngine.Component, UnityEngine.CoreModule" (GetComponents type arg) +// 0x3B05E0 "%s.%s" component name format +// 0x3B05E8 "Unknown Component" +// 0x3B0600 "No components found or failed to get components." +// 0x3B0638 "Unable to get GameObject class information." +// 0x3B0D28 "UnityExplorerModule" module name (registrar) +// UE auto-refresh state: bool at [.data+0x2640], float at [.data+0x2644] + +// --- Settings tab (Ch.28) --- +// 0x3B0AD4 "Theme" combo label +// 0x3B0AF8 "Default" theme name +// 0x3B06D0 "Evangelion Unit 01" theme name +// 0x3B0AE0 "Evangelion Unit 02" theme name +// 0x3B0B10 "Matrix" theme name +// 0x3B0B00 "Toggle Console" checkbox label +// 0x3B0B18 (Settings key address for enabled state) +// 0x3B0B28 "enabled" UI label for module on/off state (not JSON key) +// 0x3B0B78 "Console {}" console enabled display format +// 0x3B0B30 SettingsTAB.cpp source file path string + +// Theme color string RVAs (Evangelion Unit 01): +// 0x3B06E8 0x3B06F8 0x3B0708 0x3B0718 0x3B0728 0x3B0738 +// 0x3B0748 0x3B0758 0x3B0768 0x3B0778 0x3B0798 +// Theme color string RVAs (Evangelion Unit 02): +// 0x3B0888 0x3B0898 0x3B08A8 0x3B08B8 0x3B08C8 0x3B08D8 0x3B08F8 +// Theme color string RVAs (Matrix): +// 0x3B09A8 0x3B09B8 0x3B09C8 0x3B09D8 0x3B09E8 0x3B09F8 +// 0x3B0A08 0x3B0A18 0x3B0A38 + +// --- ModuleManager log strings (Ch.15.7) --- +// 0x3B0B88 "[WARNING] ModuleManager already initialized" +// 0x3B0BC0 ModuleManager.cpp assert source file path +// 0x3B0C08 "Initializing ModuleManager" +// 0x3B0C28 "Failed to initialize module {}" +// 0x3B0C48 "Module {} initialized" +// 0x3B0C60 "ModuleManager initialization complete" +// 0x3B0C90 "[ERROR] Failed to update module " +// 0x3B0CB8 "[ERROR] Failed to render overlay for module " +// 0x3B0CE8 "[ERROR] Failed to process hotkeys for module " + +// --- Config file mode strings --- +// 0x3AD590 "rb" Config READ - binary read mode +// 0x3AD594 "wt" Config WRITE - text write mode (ImGui ini) + +// --- DamageHack ghost keys (Ch.23) --- +// 0x3B1484 i18n table — four keys with no RTTI class (ghost/unimplemented feature) + +// --- Locale --- +// 0x3B2020 "en" locale string passed to string-construct at 0x9D890 + +// --- Startup / project identity --- +// 0x3B3148 "E:\git\Endfield_Cheeto\user\main.cpp" (confirms project name) + +// --- ESP color constant addresses in .data (ESP Update type dispatch) --- +// 0x3B3224 drawlist color source (XMMWORD, type-selected RGBA) +// 0x3B3308 100.0f constant (SkillHack CooldownBypass return value) +// ESP color table .rdata bases (correspond to ESPModule::color[] slots): +// 0x3B3500 color[10] BLACK (0.0,0.0,0.0,1.0) +// 0x3B3510 color[0] RED (1.0,0.0,0.0,1.0) also FPS<30 threshold +// 0x3B3520 color[1] ORANGE (1.0,0.647,0.0,1.0) +// 0x3B3530 color[3] GREEN (0.0,1.0,0.0,1.0) also FPS>=60 threshold +// 0x3B3540 color[2] YELLOW (1.0,1.0,0.0,1.0) also FPS 30-60 threshold +// 0x3B3550 color[11] GRAY (0.502,0.502,0.502,1.0) +// 0x3B3560 color[8] PINK (1.0,0.078,0.576,1.0) +// 0x3B3570 color[9] LPINK (1.0,0.753,0.796,1.0) +// 0x3B3580 color[6] PURPLE (0.58,0.0,0.827,1.0) +// 0x3B3590 color[4] BLUE (0.0,0.0,1.0,1.0) +// 0x3B35A0 color[5] CYAN (0.0,1.0,1.0,1.0) +// 0x3B35B0 color[7] WHITE (1.0,1.0,1.0,1.0) + +// --- Preset/config JSON keys (Ch.17/19) --- +// 0x3B06F8 "Default" preset name (also used as JSON key, via 0x3B0AF8) + +// --- FPS Overlay / PreventScreenshot extra --- +// 0x3B0198 "FPSMonitor" / FPS module registrar tab label (inside main cheat overlay) + +// ============================================================================ +// SECTION 28 — COMPLETE IAT TABLE (all 75 entries) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw 0xAF600). Format: IAT[RVA] = function (DLL) + +// Previously documented entries (Sections 9/24) plus newly added: +// 0xB1148 SwitchToThread KERNEL32 spinlock backoff (if backoff<32) +// 0xB1168 GetModuleFileNameExW PSAPI module path scanner full-path retrieval +// 0xB1178 AllocConsole KERNEL32 Settings console toggle enable +// 0xB1268 GetCurrentThreadId KERNEL32 stack cookie check (RVA 0xAC709) +// 0xB1290 GetModuleHandleW KERNEL32 GABypass: L"GameAssembly.dll"; OsCheck: ntdll +// 0xB1470 GetWindowLongPtrW USER32 overlay: read GWL_STYLE, GWL_EXSTYLE +// 0xB1480 IsWindowVisible USER32 overlay: check game window visible +// 0xB1490 GetClassNameA USER32 overlay: detect foreground window class (×3) +// 0xB1510 IsIconic USER32 overlay: check not minimized +// 0xB1518 SetForegroundWindow USER32 overlay: bring game to front on match +// 0xB1570 DestroyWindow USER32 overlay: cleanup on loop exit +// 0xB1588 SetWindowPos USER32 overlay: reposition to match game window +// 0xB15A8 GetClientRect USER32 overlay: get inner client area +// 0xB15B0 SetWindowLongW USER32 overlay: update window style ×2 +// 0xB15F0 GetForegroundWindow USER32 overlay: check active foreground window +// 0xB1640 UnregisterClassW USER32 overlay: cleanup window class on exit +// 0xB1858 fread CRT config file read (called ONLY from 0x12121) +// 0xB1880 __stdio_common_vsscanf CRT theme color parser (RRGGBBAA hex→RGBA) +// 0xB1890 _wfopen CRT config file open (called ONLY from 0x11F93) +// 0xB1898 fseek CRT config seek (from 0x120BC, 0x120E7) +// 0xB1920 DwmGetWindowAttribute DWMAPI overlay: DWMWA_EXTENDED_FRAME_BOUNDS rect + +// ============================================================================ +// SECTION 29 — IMGUI HELPER RVAs (inline functions used throughout modules) +// ============================================================================ +// ImGui wrapper functions used by module Render() bodies (not in main RVA namespace) + +namespace RVA { + constexpr u32 ImGui_CollapsingHeader = 0x06EC20; // lightweight wrapper; checks ImGuiCtx+0x106 locked flag + constexpr u32 ImGui_Checkbox_commit = 0x061FE0; // checkbox state commit helper + constexpr u32 ImGui_Separator_cursor = 0x070630; // Separator + cursor Y adjust + constexpr u32 ImGui_AddText_colored = 0x051580; // drawlist AddText with explicit color + constexpr u32 FPS_string_builder = 0x07F5C0; // "FPS: " + int → display string + constexpr u32 Str_compare_helper = 0x0ACA12; // internal string compare (wchar/char) + constexpr u32 ImGui_EndDisabled_path = 0x0ACA1F; // EndDisabled via ImGuiCtx+0x27F0 decrement +} + +// ImGuiContext field offsets referenced in cheat code: +// [ImGuiContext+0x106] locked_input_flag (BYTE) — CollapsingHeader disabled check +// [ImGuiContext+0x15D8] foreground_drawlist — FPS overlay drawlist ptr (+0x40 = draw cmds) +// [ImGuiContext+0x27F0] EndDisabled_counter (WORD) — decremented on EndDisabled call +// [ImGuiContext+0x2900] save_to_disk_flag (set=1 by manual save trigger 0x17072) +// [ImGuiContext+0x2904] save_timer (set=0 by manual save trigger) +// [ImGuiContext+0x2910] custom IniFilename (ptr; config save path source) +// [ImGuiContext+0x2920] settings_handlers (dynamically-grown array of 0x48-byte structs) + +// ============================================================================ +// SECTION 30 — D3D11 SHADER SOURCE (Ch.5) +// ============================================================================ +// Both shaders are stored as raw HLSL text in .rdata and compiled at runtime +// via D3DCompile (IAT[0xB1000]) during D3D11Init (RVA 0x54DC0/0x551E8). + +// Vertex shader (RVA 0x3AE660, 733 bytes, "main"/"vs_4_0"): +static const char* VS_HLSL_SOURCE_RVA = "0x3AE660"; // marker only — see comment +// cbuffer vertexBuffer : register(b0) { float4x4 ProjectionMatrix; }; +// struct VS_INPUT { float2 pos:POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// PS_INPUT main(VS_INPUT input) { +// PS_INPUT output; +// output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +// output.col = input.col; output.uv = input.uv; +// return output; } + +// Pixel shader (RVA 0x3AE940, 401 bytes, "main"/"ps_4_0"): +static const char* PS_HLSL_SOURCE_RVA = "0x3AE940"; // marker only — see comment +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// sampler sampler0; Texture2D texture0; +// float4 main(PS_INPUT input) : SV_Target { +// return input.col * texture0.Sample(sampler0, input.uv); } + +// Shader init sequence (RVA 0x54DC0): +// load g_D3DState from [g_Config+0xD8] → R14 +// check already-init: cmp (*r14), null; je skip +// call 0x551F0 (create vertex/index buffers) +// D3DCompile(0x3AE660, 0x2DD, NULL,NULL,NULL, "main","vs_4_0",0,0,...) → vertex blob +// D3DCompile(0x3AE940, 0x191, NULL,NULL,NULL, "main","ps_4_0",0,0,...) → pixel blob + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 31 — COMPLETE .DATA ADDRESS MAP (SUPPLEMENTAL) +// ============================================================================ +// All 97 .data offsets documented across all chapters, with absolute VAs and +// semantic descriptions. Base: .data = 0x1803C5000 (RVA 0x3C5000) + +// --- Module dispatch fn ptr state blocks (vtable[+0x18] accessor targets) --- +// Each module's vtable[+0x18] stub returns the module's .data state block. +// At offset [+0x00] of that block is the actual Render/Update fn ptr written +// by RegisterTab. The ModuleManager dispatch loop calls stub → gets this ptr → calls it. +// +// [.data+0x0530] FpsOverlay state block → fn ptr (overlay render) +// [.data+0x0580] PlayerProfile state block → fn ptr +// [.data+0x0630] SetDither state block → fn ptr (no-op stub 0x83DC0) +// [.data+0x06D0] NoClip state block → fn ptr +// [.data+0x0770] SkillHack state block → fn ptr (hook installer) +// [.data+0x07D0] FreeCam state block → fn ptr + +// --- RTTI / module name strings (.data) --- +// [.data+0x0590]–[.data+0x0E60] 11 module RTTI class descriptors +// (ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule) + +// --- Panel state init config block (.data, written by DispatchRegistrarInit) --- +// [.data+0x1F08] panel_config_src_A (16 bytes) — source for movups xmm0 +// [.data+0x1F18] panel_config_src_B (16 bytes) — source for movups xmm1 +// [.data+0x1F28] panel_config_dst_A (16 bytes) — dest: initial panel state copy +// [.data+0x1F38] panel_config_dst_B (16 bytes) — dest: initial panel state copy + +// --- ESPModule singleton — absolute .data field addresses --- +// Base: [.data+0x1F70] VA 0x1803C6F70 +// +// [.data+0x1F70] QWORD vtable ptr (pre-init: 0x3AFA38; post-init: 0x3AF9E0) +// [.data+0x1F78] STRING name = "ESPModule" (SSO std::string, RVA 0x3AF828) +// [.data+0x1F98] BYTE enabled = 0 +// [.data+0x1FA0] DWORD max_draw_distance = 300 (0x12C) +// [.data+0x1FA4] BYTE show_monsters = 1 +// [.data+0x1FA5] BYTE show_npc = 1 +// [.data+0x1FA6] BYTE show_friendly = 1 +// [.data+0x1FA7] BYTE show_puzzles = 1 +// [.data+0x1FA8] BYTE show_all = 0 +// [.data+0x1FA9] BYTE show_distance = 1 +// [.data+0x1FAA] BYTE show_name = 1 +// [.data+0x1FAB] BYTE reserved = 0 +// [.data+0x1FAC] BYTE show_type = 0 +// [.data+0x1FB0] XMMWD color[0] RED (1.00, 0.00, 0.00, 1.00) — Enemies +// [.data+0x1FC0] XMMWD color[1] ORANGE (1.00, 0.65, 0.00, 1.00) — Interactive/NPC +// [.data+0x1FD0] XMMWD color[2] YELLOW (1.00, 1.00, 0.00, 1.00) — spare +// [.data+0x1FE0] XMMWD color[3] GREEN (0.00, 1.00, 0.00, 1.00) — Friendly +// [.data+0x1FF0] XMMWD color[4] BLUE (0.00, 0.00, 1.00, 1.00) — NPC/spare +// [.data+0x2000] XMMWD color[5] CYAN (0.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2010] XMMWD color[6] PURPLE (0.58, 0.00, 0.83, 1.00) — spare +// [.data+0x2020] XMMWD color[7] WHITE (1.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2030] XMMWD color[8] PINK (1.00, 0.08, 0.58, 1.00) — spare +// [.data+0x2040] XMMWD color[9] LPINK (1.00, 0.75, 0.80, 1.00) — spare +// (color[10] BLACK and color[11] GRAY not stored separately; loaded from .rdata at runtime) +// Note: Color slots 2,5,6,8,9 are spare palette entries with no current entity type mapping. +// Slots 0,1,3,4 map to Enemies/Interactive/Friendly/NPC respectively. + +// --- FPSModule singleton --- +// [.data+0x22E0] QWORD FPSModule singleton ptr VA 0x1803C72E0 +// [.data+0x22E8] STRING name = "FPS Monitor" (SSO std::string) +// [.data+0x2308] BYTE enabled = 0 +// [.data+0x2310] QWORD once_flag (std::once_flag, guards Initialize RVA 0x814C0) + +// --- PreventScreenshot singleton --- +// [.data+0x2358] QWORD PreventScreenshot singleton ptr VA 0x1803C7358 +// [.data+0x2360] STRING name = "Prevent Screenshot" (SSO std::string) +// [.data+0x2380] BYTE enabled = 0 +// [.data+0x2388] BYTE second_toggle_flag = 0 +// [.data+0x2390] QWORD once_flag (guards Initialize RVA 0x8AD70) +// [.data+0x24D0] QWORD hook/window list head (linked list; nodes have HWND at [+0x10]) +// [.data+0x24F0] DWORD cached OSVERSIONINFOEXW.dwBuildNumber (from memcpy of RtlGetVersion) +// [.data+0x24FC] DWORD cached OS build number (same value, second copy for comparison) + +// --- UnityExplorer module --- +// [.data+0x260C] QWORD once_flag (guards RegisterTab RVA 0x90060) +// [.data+0x2610] QWORD update_fn_ptr = 0x083DC0 (shared no-op stub) +// [.data+0x2618] STRING tab_string = "Unity Explorer" (std::string) +// [.data+0x2638] BYTE enabled = 0 +// [.data+0x2640] BOOL auto_refresh = 0 +// [.data+0x2644] float refresh_interval = 3.0f (0x40400000) +// [.data+0x2648] QWORD* scene_list_begin = NULL +// [.data+0x2650] QWORD* scene_list_end = NULL +// [.data+0x2660] QWORD* scene_list_cap = NULL +// [.data+0x2670] DWORD selected_scene_idx = 0 +// [.data+0x2680] DWORD selected_obj_idx = 0 +// [.data+0x2684] char[0x100] search_filter = "" (zero-filled) +// [.data+0x2784] BOOL inspector_active = 0 +// [.data+0x2788] QWORD inspected_obj_ptr = 0 +// [.data+0x2790] STRING inspected_obj_name = "" (std::string) + +// ============================================================================ +// SECTION 32 — MAGIC CONSTANTS AND IEEE 754 VALUES +// ============================================================================ + +// --- IEEE 754 float constants --- +static_assert(sizeof(float) == 4, "float must be 32-bit"); + +// 0x41F00000 = 30.0f — FreeCam Move Speed default +// 0x3DCCCCCD = 0.1f — FreeCam Move Speed / Roll Speed / FOV Speed step +// 0x42C80000 = 100.0f — FreeCam Roll Speed max; SkillHack CooldownBypass return value +// 0x43FA0000 = 500.0f — FreeCam Move Speed max +// 0x40400000 = 3.0f — UnityExplorer auto-refresh interval default +// 0x3F800000 = 1.0f — HookManager load factor threshold; FreeCam FOV multiplier default +// 0x42960000 = 75.0f — FreeCam Look Sensitivity default +// 0x44415357 = (reinterpret: packed 'WASD' ASCII) — FreeCam default key binding word + +// --- FreeCam default key binding block --- +// Written to [.data+0x2230..0x225E] by FreeCam::RegisterMainTab: +// [+0x2230..0x223F] = [0x1803B34F0] (key config block 1, 16 bytes) +// [+0x2240..0x224F] = [0x1803B35C0] (key config block 2, 16 bytes) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier) +// [+0x2254] = 0x44415357 ('WASD' key mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind word) +// [+0x225E] = 0x60 (backtick key — FreeCam toggle) + +// --- Security cookie --- +// Stack canary magic value (lower 48 bits): 0x2B992DDFA232 +// Full XOR combination of: GetSystemTimeAsFileTime, GetCurrentThreadId, +// GetCurrentProcessId, QueryPerformanceCounter (see Ch.4 / Section 4) +// Checked at RVA 0x0AC6CC by __security_check_cookie (CRT standard) + +// --- Windows version constants --- +// 0x4A61 = 19041 decimal — Windows 10 Build 19041 (20H1) +// Used in PreventScreenshot::OsCheck to select WDA_MONITOR vs WDA_EXCLUDEFROMCAPTURE: +// build < 19041: SetWindowDisplayAffinity(..., 1) // WDA_MONITOR +// build >= 19041: SetWindowDisplayAffinity(..., 0x11) // WDA_EXCLUDEFROMCAPTURE + +// --- Hash constants --- +// FNV-1a 64-bit (used in HookManager hash table): +// Offset basis: 0xCBF29CE484222325ULL +// Prime: 0x00000100000001B3ULL +// (See Section 8 / Ch.8.7 for unrolled implementation at RVA 0x8D555) + +// --- CP_UTF8 --- +// 0xFDE9 = 65001 = CP_UTF8 +// Used in: MultiByteToWideChar calls in OpenConfigFile (0x11EA0), +// SetConsoleOutputCP (startup), UTF8ToWide helper (0x8B4E0) + +// --- Module object sizes --- +// BaseModule object size: 0x30 bytes (used by operator delete in NoOpUpdateStub) +// FPSModule object size: 0xD8 bytes (zeroed by memset 0xAC86A in Initialize) +// PreventScreenshot object size: 0x48 bytes (from vtable dtor stub size arg) +// UnityExplorer state block size: 0x190 bytes (zero-filled in RegisterTab) +// FreeCam state block size: 0xD8 bytes (zeroed in RegisterMainTab) +// HookEntry size: 0x38 bytes (stride in hook_array) +// HookManager singleton size: 0x90 bytes +// ModuleManager registrar stride: 0x60 bytes per slot +// ImGui settings handler size: 0x48 bytes per handler struct +// THREADENTRY32 size: 28 (sizeof: written as r12d = [rbx+0x1C]) +// OSVERSIONINFOEXW size: 0x11C bytes (stack-allocated in OsCheck) + +// --- HookManager array constants --- +// Initial hook array capacity: 0x80 slots +// Shrink threshold: count <= capacity/2 AND count > 0x20 +// Load factor threshold: 1.0f (0x3F800000) — triggers hash table rehash + +// --- SkillHack callback return constants --- +// 0x42C80000 = 100.0f returned by Callback_CooldownBypass (RVA 0x8D500) +// stored at .rdata RVA 0x3B3308 +// Note: prior summary incorrectly stated 0.0; doc confirms 100.0f + +// ============================================================================ +// SECTION 33 — IAT SUPPLEMENTAL ENTRIES (Ch.19 / final resolution) +// ============================================================================ +// Additional IAT entries resolved in Ch.19 not previously in header: +// IAT[0xB1278] VirtualFree KERNEL32 hook manager cleanup +// IAT[0xB1288] VirtualProtect KERNEL32 hook patcher (Ch.8.6) +// IAT[0xB1628] ShowWindow USER32 Settings console toggle visibility +// IAT[0xB1868] fwrite CRT config body (0xEA1B, 0x170D6, 0x3033B, 0x3076D) +// IAT[0xB1870] fclose CRT (0xEAB0, 0x1212F, 0x121A9, 0x170DF) + +// ============================================================================ +// END SUPPLEMENTAL SECTIONS +// ============================================================================ + +// ============================================================================ +// SECTION 34 — FINAL FIVE .DATA ADDRESSES +// ============================================================================ + +// [.data+0x2180] QWORD SetDither update fn ptr = 0x1803B01B0 → 0x83DC0 (no-op stub) +// Written by SetDither::RegisterTab (RVA 0x181810) + +// [.data+0x2307] BYTE End of FPSModule name std::string SSO buffer +// Name "FPS Monitor" occupies [.data+0x22E8]..[.data+0x2307] +// (19 chars + null = 20 bytes; SSO inline storage) + +// [.data+0x237F] BYTE End of PreventScreenshot name std::string SSO buffer +// Name "Prevent Screenshot" occupies [.data+0x2360]..[.data+0x237F] +// +0x28 field = enabled BYTE (checkbox state; drives affinity arg) + +// [.data+0x245C] BYTE g_showPanel — overlay panel visibility flag +// 0 = hidden, 1 = visible +// Toggled by VK_F12 (0x7B) poll at RVA 0x8301A (GetAsyncKeyState) +// Banner shown when hidden: "EF - Cheeto ... Press F12" (RVA 0x3AF258) + +// [.data+0x24D8] QWORD PreventScreenshot HWND list count / tracked window count +// Companion to [.data+0x24D0] (linked list head) +// Used in Update affinity application loop (RVA 0x8AFC0) + + + +# COMPLETE IMPORT TABLE — EF-Cheeto.dll +# All imported DLLs and functions needed for Visual Studio .def / linker +# These must ALL be linked in the VS project + +## KERNEL32.dll (76 functions) + VirtualAlloc + VirtualFree + VirtualProtect + VirtualQuery + GetCurrentProcess + GetCurrentProcessId + GetCurrentThreadId + CreateThread + TerminateThread + SuspendThread + ResumeThread + OpenThread + CloseHandle + GetLastError + GetProcAddress + LoadLibraryA + FreeLibrary + GetModuleHandleA + GetModuleHandleW + FlushInstructionCache + SetThreadContext + GetThreadContext + MultiByteToWideChar + WideCharToMultiByte + GlobalAlloc + GlobalFree + GlobalLock + GlobalUnlock + HeapCreate + HeapAlloc + HeapFree + HeapReAlloc + HeapDestroy + AllocConsole + FreeConsole + GetConsoleMode + SetConsoleMode + GetConsoleWindow + GetConsoleScreenBufferInfo + SetConsoleTextAttribute + SetConsoleOutputCP + SetConsoleTitleA + GetStdHandle + CreateToolhelp32Snapshot + Thread32First + Thread32Next + K32EnumProcessModules + K32GetModuleFileNameExW + Sleep + OutputDebugStringA + GetSystemInfo + DisableThreadLibraryCalls + QueryPerformanceCounter + QueryPerformanceFrequency + GetLocaleInfoA + IsDBCSLeadByte + VerSetConditionMask + GetSystemTimeAsFileTime + IsDebuggerPresent + IsProcessorFeaturePresent + TerminateProcess + UnhandledExceptionFilter + SetUnhandledExceptionFilter + RtlCaptureContext + RtlLookupFunctionEntry + RtlVirtualUnwind + LocalFree + FormatMessageA + GetLocaleInfoEx + AreFileApisANSI + ReleaseSRWLockExclusive + AcquireSRWLockExclusive + SleepConditionVariableSRW + WakeAllConditionVariable + InitializeSListHead + memmove + +## USER32.dll (67 functions) + CreateWindowExW + DestroyWindow + RegisterClassExW + UnregisterClassW + DefWindowProcW + PeekMessageW + TranslateMessage + DispatchMessageW + PostQuitMessage + UpdateWindow + GetClientRect + GetWindowRect + GetWindowLongW + GetWindowLongPtrW + SetWindowLongW + SetWindowLongPtrW + SetWindowPos + ShowWindow + BringWindowToTop + IsIconic + IsWindow + IsWindowVisible + IsWindowUnicode + IsChild + FindWindowA + EnumWindows + GetForegroundWindow + SetForegroundWindow + SetFocus + GetCursorPos + SetCursorPos + GetCapture + SetCapture + ReleaseCapture + GetAsyncKeyState + GetKeyState + GetKeyboardLayout + GetMessageExtraInfo + TrackMouseEvent + ClientToScreen + ScreenToClient + WindowFromPoint + GetDC + ReleaseDC + GetDeviceCaps + CreateSolidBrush + LoadCursorW + LoadIconW + SetCursor + EnumDisplayMonitors + GetMonitorInfoW + MonitorFromWindow + GetSystemMetrics + GetClassNameA + GetWindowThreadProcessId + AdjustWindowRectEx + OpenClipboard + CloseClipboard + EmptyClipboard + GetClipboardData + SetClipboardData + GetPropA + SetPropA + SetLayeredWindowAttributes + SetWindowDisplayAffinity + GetWindowDisplayAffinity + SetProcessDPIAware + +## GDI32.dll/SHELL32.dll (1 functions) + ShellExecuteW + +## imm32.dll (4 functions) + ImmGetContext + ImmReleaseContext + ImmSetCandidateWindow + ImmSetCompositionWindow + +## d3d11.dll (1 functions) + D3D11CreateDeviceAndSwapChain + +## d3dcompiler_47.dll (1 functions) + D3DCompile + +## dwmapi.dll (2 functions) + DwmExtendFrameIntoClientArea + DwmGetWindowAttribute + +## xinput1_4.dll (2 functions) + XInputGetState + XInputGetCapabilities + +## ntdll.dll (2 functions) + RtlGetVersion + RtlVerifyVersionInfo + +## shcore.dll (3 functions) + SetThreadDpiAwarenessContext + SetProcessDpiAwareness + GetDpiForMonitor + +## api-ms-win-crt-*.dll (CRT) (62 functions) + malloc + calloc + free + realloc + memcmp + memcpy + memset + memchr + memmove + strcmp + strncmp + strncpy + strchr + strtod + strtoll + strtoull + atof + tolower + fopen + fclose + fread + fwrite + ftell + fseek + fflush + freopen_s + _wfopen + qsort + localeconv + __stdio_common_vfprintf + __stdio_common_vsprintf + __stdio_common_vsscanf + __acrt_iob_func + ___lc_codepage_func + _errno + _localtime64_s + acosf + ceilf + cosf + fmodf + logf + powf + sinf + sqrtf + _dclass + _dsign + _fdclass + _fdsign + _ldclass + _ldsign + _callnewh + _seh_filter_dll + _configure_narrow_argv + _initialize_narrow_environment + _initialize_onexit_table + _register_onexit_function + _execute_onexit_table + _crt_atexit + _cexit + _initterm + _initterm_e + terminate + +## vcruntime140.dll / vcruntime140_1.dll (11 functions) + __CxxFrameHandler4 + __C_specific_handler + _CxxThrowException + __std_terminate + __std_exception_copy + __std_exception_destroy + __current_exception + __current_exception_context + __std_type_info_destroy_list + _invoke_watson + _purecall + +## msvcp140.dll (5 functions) + _Mtx_lock + _Mtx_unlock + _Xtime_get_ticks + _Query_perf_counter + _Query_perf_frequency diff --git a/IDA/project/docs/input/files3/ef_cheeto_full_imports.md b/IDA/project/docs/input/files3/ef_cheeto_full_imports.md new file mode 100644 index 0000000..dba246f --- /dev/null +++ b/IDA/project/docs/input/files3/ef_cheeto_full_imports.md @@ -0,0 +1,266 @@ +# COMPLETE IMPORT TABLE — EF-Cheeto.dll +# All imported DLLs and functions needed for Visual Studio .def / linker +# These must ALL be linked in the VS project + +## KERNEL32.dll (76 functions) + VirtualAlloc + VirtualFree + VirtualProtect + VirtualQuery + GetCurrentProcess + GetCurrentProcessId + GetCurrentThreadId + CreateThread + TerminateThread + SuspendThread + ResumeThread + OpenThread + CloseHandle + GetLastError + GetProcAddress + LoadLibraryA + FreeLibrary + GetModuleHandleA + GetModuleHandleW + FlushInstructionCache + SetThreadContext + GetThreadContext + MultiByteToWideChar + WideCharToMultiByte + GlobalAlloc + GlobalFree + GlobalLock + GlobalUnlock + HeapCreate + HeapAlloc + HeapFree + HeapReAlloc + HeapDestroy + AllocConsole + FreeConsole + GetConsoleMode + SetConsoleMode + GetConsoleWindow + GetConsoleScreenBufferInfo + SetConsoleTextAttribute + SetConsoleOutputCP + SetConsoleTitleA + GetStdHandle + CreateToolhelp32Snapshot + Thread32First + Thread32Next + K32EnumProcessModules + K32GetModuleFileNameExW + Sleep + OutputDebugStringA + GetSystemInfo + DisableThreadLibraryCalls + QueryPerformanceCounter + QueryPerformanceFrequency + GetLocaleInfoA + IsDBCSLeadByte + VerSetConditionMask + GetSystemTimeAsFileTime + IsDebuggerPresent + IsProcessorFeaturePresent + TerminateProcess + UnhandledExceptionFilter + SetUnhandledExceptionFilter + RtlCaptureContext + RtlLookupFunctionEntry + RtlVirtualUnwind + LocalFree + FormatMessageA + GetLocaleInfoEx + AreFileApisANSI + ReleaseSRWLockExclusive + AcquireSRWLockExclusive + SleepConditionVariableSRW + WakeAllConditionVariable + InitializeSListHead + memmove + +## USER32.dll (67 functions) + CreateWindowExW + DestroyWindow + RegisterClassExW + UnregisterClassW + DefWindowProcW + PeekMessageW + TranslateMessage + DispatchMessageW + PostQuitMessage + UpdateWindow + GetClientRect + GetWindowRect + GetWindowLongW + GetWindowLongPtrW + SetWindowLongW + SetWindowLongPtrW + SetWindowPos + ShowWindow + BringWindowToTop + IsIconic + IsWindow + IsWindowVisible + IsWindowUnicode + IsChild + FindWindowA + EnumWindows + GetForegroundWindow + SetForegroundWindow + SetFocus + GetCursorPos + SetCursorPos + GetCapture + SetCapture + ReleaseCapture + GetAsyncKeyState + GetKeyState + GetKeyboardLayout + GetMessageExtraInfo + TrackMouseEvent + ClientToScreen + ScreenToClient + WindowFromPoint + GetDC + ReleaseDC + GetDeviceCaps + CreateSolidBrush + LoadCursorW + LoadIconW + SetCursor + EnumDisplayMonitors + GetMonitorInfoW + MonitorFromWindow + GetSystemMetrics + GetClassNameA + GetWindowThreadProcessId + AdjustWindowRectEx + OpenClipboard + CloseClipboard + EmptyClipboard + GetClipboardData + SetClipboardData + GetPropA + SetPropA + SetLayeredWindowAttributes + SetWindowDisplayAffinity + GetWindowDisplayAffinity + SetProcessDPIAware + +## GDI32.dll/SHELL32.dll (1 functions) + ShellExecuteW + +## imm32.dll (4 functions) + ImmGetContext + ImmReleaseContext + ImmSetCandidateWindow + ImmSetCompositionWindow + +## d3d11.dll (1 functions) + D3D11CreateDeviceAndSwapChain + +## d3dcompiler_47.dll (1 functions) + D3DCompile + +## dwmapi.dll (2 functions) + DwmExtendFrameIntoClientArea + DwmGetWindowAttribute + +## xinput1_4.dll (2 functions) + XInputGetState + XInputGetCapabilities + +## ntdll.dll (2 functions) + RtlGetVersion + RtlVerifyVersionInfo + +## shcore.dll (3 functions) + SetThreadDpiAwarenessContext + SetProcessDpiAwareness + GetDpiForMonitor + +## api-ms-win-crt-*.dll (CRT) (62 functions) + malloc + calloc + free + realloc + memcmp + memcpy + memset + memchr + memmove + strcmp + strncmp + strncpy + strchr + strtod + strtoll + strtoull + atof + tolower + fopen + fclose + fread + fwrite + ftell + fseek + fflush + freopen_s + _wfopen + qsort + localeconv + __stdio_common_vfprintf + __stdio_common_vsprintf + __stdio_common_vsscanf + __acrt_iob_func + ___lc_codepage_func + _errno + _localtime64_s + acosf + ceilf + cosf + fmodf + logf + powf + sinf + sqrtf + _dclass + _dsign + _fdclass + _fdsign + _ldclass + _ldsign + _callnewh + _seh_filter_dll + _configure_narrow_argv + _initialize_narrow_environment + _initialize_onexit_table + _register_onexit_function + _execute_onexit_table + _crt_atexit + _cexit + _initterm + _initterm_e + terminate + +## vcruntime140.dll / vcruntime140_1.dll (11 functions) + __CxxFrameHandler4 + __C_specific_handler + _CxxThrowException + __std_terminate + __std_exception_copy + __std_exception_destroy + __current_exception + __current_exception_context + __std_type_info_destroy_list + _invoke_watson + _purecall + +## msvcp140.dll (5 functions) + _Mtx_lock + _Mtx_unlock + _Xtime_get_ticks + _Query_perf_counter + _Query_perf_frequency diff --git a/IDA/project/docs/input/files3/ef_cheeto_reconstruction_prompt.md b/IDA/project/docs/input/files3/ef_cheeto_reconstruction_prompt.md new file mode 100644 index 0000000..207304c --- /dev/null +++ b/IDA/project/docs/input/files3/ef_cheeto_reconstruction_prompt.md @@ -0,0 +1,166 @@ +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed + +================================================================================ +CONFIRMED THIRD-PARTY LIBRARY VERSIONS (extracted from binary) +================================================================================ + +## 1. Dear ImGui +- Repo: https://github.com/ocornut/imgui +- Branch: docking +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 +- Version: 1.92.6 WIP (19253) +- Files to compile: + imgui.cpp + imgui_draw.cpp + imgui_tables.cpp + imgui_widgets.cpp + backends/imgui_impl_win32.cpp + backends/imgui_impl_dx11.cpp +- Config: NDEBUG, no custom imconfig.h, default ImDrawIdx (uint16_t) + +## 2. nlohmann/json +- Repo: https://github.com/nlohmann/json +- Version: v3.12.0 +- Commit: 961c151d2e87f2686a955a9be24d316f1362bf21 +- Usage: Header-only (single-file json.hpp) — used ONLY for i18n translation table +- Include: #include "nlohmann/json.hpp" or #include "json.hpp" +- Note: The ABI namespace in this binary is nlohmann_json_abi_v3_12_0 + +## 3. Microsoft Detours — NOT USED +- .detourc/.detourd sections are MSVC thread-safe static init sections, NOT Detours +- The hook system is 100% custom (documented in HookManager chapters) + +## Visual Studio Project Settings +- Platform: x64 +- Configuration: Release +- Toolset: MSVC v143 (VS2022), toolchain version 14.44 +- Subsystem: DLL (/LD) +- Runtime: /MD (Multi-threaded DLL — uses msvcp140.dll, vcruntime140.dll) +- Optimization: /O2 (maximize speed) — inferred from release build +- C++ Standard: /std:c++17 (confirmed from RTTI and STL usage) +- Character set: Unicode +- Additional libs to link: + kernel32.lib user32.lib gdi32.lib shell32.lib + d3d11.lib d3dcompiler.lib dwmapi.lib imm32.lib + shcore.lib xinput.lib ntdll.lib diff --git a/IDA/project/docs/input/vs/files (1)/ef_cheeto_feed_1_analysis.md b/IDA/project/docs/input/vs/files (1)/ef_cheeto_feed_1_analysis.md new file mode 100644 index 0000000..8db0eca --- /dev/null +++ b/IDA/project/docs/input/vs/files (1)/ef_cheeto_feed_1_analysis.md @@ -0,0 +1,3963 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 1/3 +# Feed ALL THREE PARTS before asking reconstruction questions. +# Part 1: Orientation + Full Analysis (prose, pseudocode, tables) + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed +# Part 2: Reconstruction Header (structs, addresses, constants) +# Part 3: Machine Code (hex dumps + raw binary sections) + +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +ANALYSIS DOCUMENT — All 29 Chapters +================================================================================ + +EF-Cheeto.dll (unityexplorer.dll) +Complete Reverse Engineering Report — Final Consolidated Edition +24 Chapters · 11 Registered Modules · Complete Static Reconstruction +February 27, 2026 +# 1. Executive Summary +This document is the complete consolidated reverse engineering analysis of EF-Cheeto.dll (distributed as unityexplorer.dll), spanning twenty-five chapters. It covers all subsystems from infrastructure (thread enumeration, anti-debug, shader compilation, config I/O) through the hook engine, eleven registered cheat modules, the ModuleManager dispatch architecture, GABypass IL2CPP resolver, JSON config schema, and analyses added in later passes: ESPModule Render/Update implementation (Ch. 22), DamageHack ghost feature analysis (Ch. 23), SetDither RenderOverlay body (Ch. 12.5.1), and the Sidebar/Main Panel rendering function (Ch. 25). +IAT base is RVA 0xB1000 (file raw offset 0xAF600). The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows. The binary is fully reverse engineered with no significant undocumented regions remaining. +# 2. Corrected IAT Address Map +Previous analysis used incorrect IAT RVAs derived from objdump -p output. The correct IAT base is RVA 0xB1000 (file raw offset 0xAF600), not the 0x3C2xxx addresses previously listed. The following table gives the correct IAT RVAs and all call sites. +Function +IAT RVA +DLL +Call Sites (VA) +SuspendThread +0xB1050 +KERNEL32.dll +0x1800A9861 +ResumeThread +0xB1058 +KERNEL32.dll +0x1800A9964 (×37 total) +GetThreadContext +0xB1068 +KERNEL32.dll +0x1800A988B +SetThreadContext +0xB1078 +KERNEL32.dll +0x1800A993C +CreateToolhelp32Snapshot +0xB1160 +KERNEL32.dll +0x1800A970B +Thread32First +0xB11B0 +KERNEL32.dll +0x1800A972F +Thread32Next +0xB11A8 +KERNEL32.dll +0x1800A97DD +OpenThread +0xB11D0 +KERNEL32.dll +0x1800A9849 (×38 total) +VirtualProtect +0xB1288 +KERNEL32.dll +0x1800A9AFC, 0x1800A9B6C +FlushInstructionCache +0xB1070 +KERNEL32.dll +0x1800A9B81 +GetCurrentProcess +0xB1270 +KERNEL32.dll +0x1800A9B72 +IsDebuggerPresent +0xB11E8 +KERNEL32.dll +0x1800AC67B +SetUnhandledExceptionFilter +0xB1200 +KERNEL32.dll +0x1800AC698 +UnhandledExceptionFilter +0xB1208 +KERNEL32.dll +0x1800AC6A3 +IsProcessorFeaturePresent +0xB11F0 +KERNEL32.dll +0x1800AC5A2 +TerminateProcess +0xB11F8 +KERNEL32.dll +0x1800AC628 (via int 29h) +D3DCompile +0xB1000 +D3DCOMPILER_47 +0x180054E77, 0x180055069 +_wfopen +0xB1888 +CRT +0x180011F93 +fwrite +0xB1868 +CRT +0x18000EA1B, 0x1800170D6, 0x18003033B, 0x18003076D +fread +0xB1870 +CRT +(called via 0x180011EA0 helper) +fclose +0xB1878 +CRT +0x1800170DF, 0x180030776 +SetWindowDisplayAffinity +0xB1460 +USER32.dll +0x18008B48F +LoadLibraryA +0xB10E0 +KERNEL32.dll +0x180055F57, 0x1800585AE (×4) +GetProcAddress +0xB1088 +KERNEL32.dll +0x180055F7E, 0x180055F92 (×7) +VirtualAlloc +0xB11A0 +KERNEL32.dll +0x1800AA566, 0x1800AA607 +VirtualFree +0xB1278 +KERNEL32.dll +0x180081D5B, 0x1800AA6E1 +# 3. Thread Enumeration and Suspension +Thread enumeration serves a critical role in safe hook installation: the cheat must suspend all Unity render/game threads before patching code bytes, then resume them after patching, to prevent race conditions. This subsystem uses two cooperating functions. +## 3.1 Thread Collection Function (0x1800A96B0–0x1800A9A1C) +This function collects all thread IDs for the current process using a Toolhelp32 snapshot, filtering out the calling thread and storing results in a caller-provided vector. The function signature is: +int CollectProcessThreads( +DWORD* out_vec, // RCX: vector { begin, end, capacity } +DWORD current_pid, // RDX: passed to CreateToolhelp32Snapshot +DWORD current_tid // R8d: thread to exclude (caller's thread) +Key sequence: +// 0x1800A96B0: Prologue, save RSI/RDI/RBX/R12-R15, allocate 0x530 bytes stack +// 0x1800A96E7: xor ebx, ebx (thread count = 0) +// 0x1800A96F8: mov [rcx], rbx; mov [rcx+8], rbx (init empty vector) +// 0x1800A9701: lea ecx, [rbx+4] = TH32CS_SNAPTHREAD = 4 +// 0x1800A970B: call [IAT:CreateToolhelp32Snapshot](dwFlags=4, pid=r15) +// 0x1800A9711: mov r14, rax (hSnapshot = result) +// 0x1800A9714: cmp rax, -1 → je fail (INVALID_HANDLE_VALUE) +// 0x1800A971E: lea r12d, [rbx+0x1C] (sizeof THREADENTRY32 = 28) +// 0x1800A9725: lea rdx, [rsp+0x30] (THREADENTRY32 buffer) +// 0x1800A972A: mov [rsp+0x30], r12d (te32.dwSize = 28) +// 0x1800A972F: call [IAT:Thread32First](hSnapshot, &te32) +// --- LOOP --- +// 0x1800A9740: cmp [rsp+0x30], 0x10 (check th32OwnerProcessID offset) +// 0x1800A974B: call [IAT:GetCurrentProcessId] +// 0x1800A9751: cmp [rsp+0x3C], eax (te32.th32OwnerProcessID == GetCurrentProcessId?) +// 0x1800A9755: jne skip (skip threads not in our process) +// 0x1800A9757: call [IAT:GetCurrentThreadId] +// 0x1800A975D: cmp [rsp+0x38], eax (te32.th32ThreadID == calling thread?) +// 0x1800A9761: je skip (exclude caller's thread) +// 0x1800A9763: mov rdx, [rdi] (vector data pointer) +// 0x1800A9778: call [IAT:VirtualAlloc] or HeapReAlloc if needed +// 0x1800A97CA: mov [rdx+rcx*4], eax (store thread ID) +// 0x1800A97CD: incl [rdi+0xC] (vector count++) +// 0x1800A97DD: call [IAT:Thread32Next](hSnapshot, &te32) +// 0x1800A97E3: test eax, eax → jne loop +// 0x1800A97EB: call [IAT:GetLastError] → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0x1800A9815: call [IAT:CloseHandle](hSnapshot) +Return value: 0 on success (ESI = 0 → je path), 9 on error (EBX = 9 → mov eax, 9). +## 3.2 Thread Suspend/Resume Function (0x1800A9A20–0x1800A9A98) +Iterates the thread ID vector and either suspends or resumes each thread. Called before and after code patching. +void SuspendOrResumeThreads(DWORD* id_vector, int action) { +// action: 0 = resume, 1 = suspend +for (int i = 0; i < id_vector->count; i++) { +DWORD tid = id_vector->data[i]; +if (tid == 0) continue; +HANDLE hThread = OpenThread(0x5A, FALSE, tid); // THREAD_SUSPEND+CONTEXT +if (!hThread) continue; +if (action == 0) ResumeThread(hThread); +else SuspendThread(hThread); +CloseHandle(hThread); +} +// free id_vector->data via HeapFree +} +## 3.3 Code Patcher (0x1800A9A9C–0x1800A9BC3) +Writes trampoline/hook bytes at a target address with full thread-safety. Called from SkillHack and other modules during hook installation. +int PatchCode(int hook_index, int is_jmp) { +// Lookup hook entry: base = g_hookTable[hook_index * 0x38] +void* target = hook_entry->target_va; +void* jump_dest = hook_entry->callback; // or target-5 if is_short_jmp +DWORD old_protect; +// First VirtualProtect: make target page EXECUTE_READWRITE (0x40) +VirtualProtect(target, patch_size, PAGE_EXECUTE_READWRITE, &old_protect); +if (is_jmp) { +// Write E9 JMP rel32 +*(BYTE*)target = 0xE9; +*(DWORD*)(target+1) = (DWORD)jump_dest - (DWORD)target - 5; +if (hook_entry->flags & 1) +*(WORD*)orig_ptr = 0xF9EB; // short jmp back +} else { +// Copy original bytes (stub) +*(DWORD*)target = hook_entry->orig_bytes_dword; +if (hook_entry->flags & 1) { +*(WORD*)(target+4) = hook_entry->orig_word; +*(BYTE*)(target+6) = hook_entry->orig_byte; +} else { +*(BYTE*)(target+4) = hook_entry->orig_byte; +} +} +// Second VirtualProtect: restore original protection +VirtualProtect(target, patch_size, old_protect, &old_protect); +FlushInstructionCache(GetCurrentProcess(), target, patch_size); +// Update flags: toggle enable/jmp bits in hook_entry->flags +return 0; // success +} +# 4. Anti-Debug and Exception Handling +The binary contains two related security functions: a structured exception handler setup that uses IsDebuggerPresent, and a stack security cookie verifier. +## 4.1 Exception Handler Setup (0x1800AC580–0x1800AC6CA) +This function is the C runtime __security_check_cookie and SEH initializer. It is called during DLL initialization (DllMain) and during first-chance exception dispatching. +// 0x1800AC580: CRT security init function +// ecx = fault code (passed in from caller) +// Check IsProcessorFeaturePresent(0x17 = PF_FASTFAIL_AVAILABLE) +call [IAT:IsProcessorFeaturePresent](0x17) +test eax, eax +je skip_int29 +int 29h // Fast fail - terminate without SEH if supported +skip_int29: +call sub_1800AC574 // __security_check_cookie helper +// Set up EXCEPTION_RECORD and CONTEXT for RtlCaptureContext +call RtlCaptureContext // [IAT:0xB1220] +call RtlLookupFunctionEntry // [IAT:0xB1218] - find handler +call RtlVirtualUnwind // [IAT:0xB1210] - unwind frame +// Build EXCEPTION_RECORD: +movl [rsp+50h], 0x40000015 // ExceptionCode = STATUS_FATAL_APP_EXIT +movl [rsp+54h], 1 // ExceptionFlags = EXCEPTION_NONCONTINUABLE +call [IAT:IsDebuggerPresent] // 0x1800AC67B +mov ebx, eax // save result +call [IAT:SetUnhandledExceptionFilter](NULL) // remove any handler +call [IAT:UnhandledExceptionFilter](&record) +test eax, eax +jne done +cmp ebx, 1 // was debugger present? +je done +lea ecx, [eax+3] +call __report_gsfailure // terminate +Note: IsDebuggerPresent is NOT used as an anti-cheat measure; it is part of the MSVC CRT __security_check_cookie fast-fail path. The binary does not actively attempt to detect or evade debuggers — it simply invokes standard MSVC security cookie failure reporting. +## 4.2 Security Canary Verifier (0x1800AC6CC–0x1800AC77B) +This is the standard MSVC __security_check_cookie function. It compares the stack cookie against a magic constant, then triggers a fast-fail if mismatch is detected. +// 0x1800AC6CC: __security_check_cookie +// rcx = stack cookie value to verify +mov rax, [__security_cookie] // load expected cookie (initialized at startup) +mov rbx, 0x2B992DDFA232 // partial expected value (lower 48 bits) +cmp rax, rbx +jne fail // mismatch → security violation +// Derive additional check from: +// GetSystemTimeAsFileTime, GetCurrentThreadId, GetCurrentProcessId, +// QueryPerformanceCounter, combined via XOR and shift +call [IAT:GetSystemTimeAsFileTime] +call [IAT:GetCurrentThreadId] +xor -0x10(%rbp), rax +call [IAT:GetCurrentProcessId] +xor -0x10(%rbp), rax +call [IAT:QueryPerformanceCounter] +// ... XOR operations combining all values +// Mask to 0xFFFFFFFFFFFF (48 bits) +// Compare with stored cookie — mismatch → crash +// This is 100% MSVC runtime security, NOT an anti-cheat check +# 5. HLSL Shader Compilation (D3DCompile) +The cheat overlay uses two shaders compiled at runtime via D3DCompile from D3DCOMPILER_47.dll. Both shaders are the standard ImGui Direct3D11 backend shaders embedded verbatim in .rdata. They are compiled in the D3D11 initialization function (0x180054DC0–0x1800551E8) which is called during the Present hook setup. +## 5.1 Vertex Shader +// Source at RVA 0x3AE660, length = 0x2DD (733 bytes) +// Compilation: D3DCompile(src, 0x2DD, NULL, NULL, NULL, "main", "vs_4_0", 0, 0, ...) +cbuffer vertexBuffer : register(b0) { +float4x4 ProjectionMatrix; +}; +struct VS_INPUT { +float2 pos : POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +PS_INPUT main(VS_INPUT input) { +PS_INPUT output; +output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +output.col = input.col; +output.uv = input.uv; +return output; +} +## 5.2 Pixel Shader +// Source at RVA 0x3AE940, length = 0x191 (401 bytes) +// Compilation: D3DCompile(src, 0x191, NULL, NULL, NULL, "main", "ps_4_0", 0, 0, ...) +struct PS_INPUT { +float4 pos : SV_POSITION; +float4 col : COLOR0; +float2 uv : TEXCOORD0; +}; +sampler sampler0; +Texture2D texture0; +float4 main(PS_INPUT input) : SV_Target { +float4 out_col = input.col * texture0.Sample(sampler0, input.uv); +return out_col; +} +## 5.3 Shader Initialization Sequence (0x180054DC0) +// Prologue: save R14-R15, allocate 0x220 stack +// Load g_D3DState from [g_Config+0xD8] into R14 +// Check if already initialized: cmp (*r14), null +je skip_init +// Call sub_0x1800551F0 (create vertex/index buffers) +// === Compile Vertex Shader === +lea rcx, [rip+0x1803AE660] // HLSL source ptr +mov edx, 0x2DD // source length +xor r8d, r8d // pSourceName = NULL +xor r9d, r9d // pDefines = NULL +mov [rsp+20h], r15 // pInclude = NULL +lea rax, [0x1803AEADC] // 'main' string +mov [rsp+28h], r12 // pInclude (NULL) +mov [rsp+30h], rax // pEntrypoint = 'main' +lea rax, [0x1803AEAD4] // 'vs_4_0' +mov [rsp+38h], r15d // Flags1 = 0 +mov [rsp+40h], r15d // Flags2 = 0 +mov [rsp+48h], &ppVSCode // output blob ptr +mov [rsp+50h], r15 // ppErrorBlob = NULL +call [IAT:D3DCompile] +js fail +// Get VS blob pointer, call ID3DBlob::GetBufferPointer/GetBufferSize +// Then: call ID3D11Device::CreateVertexShader via vtable slot[0x20/8] +// Create input layout via vtable slot[0x58/8] +// Create constant buffer (ProjectionMatrix) via vtable slot[0x60/8] +// === Compile Pixel Shader === +lea rcx, [rip+0x1803AE940] // PS HLSL source +mov edx, 0x191 // PS source length +// ... same parameters pattern ... +// pEntrypoint = 'main', target = 'ps_4_0' +call [IAT:D3DCompile] +js fail +// Create pixel shader via vtable slot[0x78/8] (CreatePixelShader) +// Create sampler state via vtable slot[0x78/8] on device +// Create blend state (alpha blending) with blend ops +// Create depth stencil state +// Create rasterizer state +# 6. Configuration File I/O +Configuration is read and written using a helper function (0x180011EA0) that converts UTF-8 paths to wide-char then calls _wfopen. Callers pass different file mode strings ('rb' for read, 'wt' for write) to the same function. +## 6.1 File Open Helper (0x180011EA0–0x180012043) +FILE* OpenConfigFile(const char* path_utf8, const char* mode_utf8) { +// rcx = path_utf8, rdx = mode_utf8 +// Get length of path: MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0) +int path_len = MultiByteToWideChar(0xFDE9, 0, path, -1, NULL, 0); // CP_UTF8=65001=0xFDE9 +// Get length of mode string +int mode_len = MultiByteToWideChar(0xFDE9, 0, mode, -1, NULL, 0); +// Allocate wide char buffer (stack if small enough, heap if > 0x104 chars) +if (path_len + mode_len > 0x104) +wbuf = malloc((path_len + mode_len) * 2); +else +wbuf = alloca((path_len + mode_len) * 2); +wchar_t* wpath = wbuf; +wchar_t* wmode = wbuf + path_len; +// Convert path to wide +MultiByteToWideChar(0xFDE9, 0, path, -1, wpath, path_len); +// Convert mode to wide +MultiByteToWideChar(0xFDE9, 0, mode, -1, wmode, mode_len); +// Open file +FILE* fp = _wfopen(wpath, wmode); +if (heap_buf) free(heap_buf); +return fp; +} +## 6.2 Config File Mode Strings +Two mode strings are stored in .rdata at consecutive addresses: +RVA +String +Usage +0x3AD590 +'rb' +Config READ - binary read mode +0x3AD594 +'wt' +Config WRITE - text write mode (ImGui ini) +## 6.3 Config Read Callers +The config file open helper is called from two read contexts and two write contexts: +Caller VA +Func Range +Mode +Data Source / Purpose +0x1800170B9 +0x17078-0x172CA +'wt' +Serialize ImGui window positions/sizes to ini file (ImGui_ImplDX11 save) +0x180030750 +0x30620-0x307A0 +'wt' +Write g_Config state to JSON file on module disable/exit +(via fread) +0x302D2-0x30348 +'rb' +Read JSON config on startup, populate g_Config fields +0x18000EA1B +0xE9F4-0xEA33 +n/a +fwrite to stdout/console (debug output, size=1) +## 6.4 Config Write Function (0x180030620) +void SaveConfig(ConfigState* state) { +// Check state->enabled_flag [rbx+0x2900] +// Load state->file_path pointer [rbx+0x50] +// Call sub_0x180030A90 (build file path string) +// Call OpenConfigFile(path, 'wt') → returns FILE* fp +// Serialize config to string via sub_0x180012050 +// fwrite(config_string, 1, string_length, fp) +// fclose(fp) +// Also handles periodic auto-save: +// xmm0 = [rbx+0x2904] (auto-save timer) +// if (timer > 0) { timer -= delta_time } +// When timer expires: rebuild path, re-open, write again +} +# 7. WndProc Handler and Hotkey Dispatch +The WndProc callback is registered at VA 0x1800826A0 during window class creation (RegisterClassExW). It is the Win32 message handler for the overlay window and handles three specific messages before deferring all others to ImGui's built-in handler. +## 7.1 WndProc Function (0x1800826A0) +Signature: LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) +LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// Step 1: Pass ALL messages to ImGui first +if (g_ImGuiCtx != NULL) { +// ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam) +// [rsp+0x20] = g_ImGuiCtx+0x30 +LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +if (r != 0) return 1; // ImGui consumed the message +} +switch (msg) { +case WM_DESTROY (0x0002): +PostQuitMessage(0); +return 0; +case WM_SIZE (0x0005): +// Ignore minimize (SIZE_MINIMIZED = 1) +if (g_pSwapChain != NULL && wParam != 1) { +// Free existing render target +if (g_pRenderTargetView) { +g_pRenderTargetView->Release(); // vtable[0x10] +g_pRenderTargetView = NULL; +} +// Resize swap chain buffers +// pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), 0, 0) +g_pSwapChain->ResizeBuffers(0, LOWORD(lParam), HIWORD(lParam), +DXGI_FORMAT_UNKNOWN, 0); // vtable[0x68] +// Recreate D3D11 resources (render target, shaders, etc.) +HookInstall(); // 0x1800825B0 +} +return 0; +case WM_SYSCOMMAND (0x0112): +// Suppress SC_KEYMENU (ALT key activating system menu) +if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +break; +default: +// Forward to DefWindowProcW via ImGui_ImplWin32_WndProcHandler +return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +} +return 0; +} +## 7.2 Message Dispatch Table +WM_ Code +Value +Action +Notes +WM_DESTROY +0x0002 +PostQuitMessage(0) +Triggers clean shutdown of message loop +WM_SIZE +0x0005 +ResizeBuffers + HookInstall() recreate +Skipped if wParam==SIZE_MINIMIZED(1) +WM_SYSCOMMAND +0x0112 +Return 0 if SC_KEYMENU (0xF100) +Suppresses ALT-key menu flash on overlay +(all others) +- +Defer to ImGui_ImplWin32_WndProcHandler +ImGui handles mouse/keyboard/focus/IME +## 7.3 F12 Hotkey — Panel Toggle +The overlay panel toggle is NOT processed inside WndProc. It is polled via GetAsyncKeyState in the per-frame Present hook loop at VA 0x18008301A, which is part of the ModuleManager main render function (0x180082FC0). +// Inside ModuleManager render loop (0x180082FC0), called each Present() frame: +// Poll F12 key (VK_F12 = 0x7B) +SHORT keyState = GetAsyncKeyState(0x7B); // VK_F12 +if (keyState & 0x1) { +// Key was pressed since last call — toggle panel visibility +// Static init guard pattern (MSVC thread-safe static) +// g_showPanel (.data+0x245C) = !g_showPanel +g_Config.show_panel ^= 1; // [.data+0x245C] toggle +} +// Banner string shown in game window title / tray when panel is hidden: +// 'EF - Cheeto Press F12 to show panel' (RVA 0x3AF258) +Address +Description +0x18008301A +GetAsyncKeyState(VK_F12=0x7B) call — panel toggle poll +.data+0x245C +g_showPanel flag (BYTE): 0=hidden, 1=visible +RVA 0x3AF258 +Banner string 'EF - Cheeto ... Press F12 to show panel' +0x1800826A0 +WndProc callback registered via RegisterClassExW +0x180057720 +ImGui_ImplWin32_WndProcHandler (handles all ImGui keyboard/mouse) +0x1800825B0 +HookInstall / D3D11 resource recreation (called on WM_SIZE) +## 7.4 Module Hotkeys +A dedicated hotkey error handler exists at 0x1800AECE0, referenced by the string '[ERROR] Failed to process hotkeys for module'. This function is an exception handler — it is called if a module's hotkey processing throws. Individual module hotkey configurations are stored in the per-module state structs and dispatched by the ModuleManager loop, not in WndProc. +# 8. Hook Manager Internals +The hook manager is a global singleton initialized lazily via an MSVC thread-safe static at 0x180081B00. It manages a flat array of hook entries, a hash table for fast lookup by target address, and a spinlock for thread safety. All four hook API functions (CreateHook, RemoveHook, EnableHook, GetHookInfo) acquire the spinlock at entry and release it on every exit path. +## 8.1 Singleton Memory Layout +The singleton is stored at .data+0x2470 (VA 0x1803C7470). The structure is 0x90 bytes, zero-initialized on first call. +Offset +Type +Field +Description ++0x00 +QWORD* +hook_array +Pointer to flat array of hook entries (0x38 bytes each) ++0x08 +DWORD +hook_capacity +Allocated slot count for hook_array ++0x0C +DWORD +hook_count +Number of active hooks currently installed ++0x10 +QWORD* +hash_buckets +Pointer to hash table bucket array (linked list heads) ++0x18 +DWORD +bucket_count +Number of hash buckets (power of 2, initial=8) ++0x1C +DWORD +bucket_mask +hash_mod mask = bucket_count*2 - 1 ++0x20 +QWORD* +free_list_head +Head of freed/recycled hook slot free list ++0x28 +float +load_factor +Hash table load factor threshold (0x3f800000 = 1.0f) ++0x30 +BYTE +initialized +Set to 0 after init, prevents double-init +.data+0x1E88 +DWORD +spinlock +Global spinlock DWORD; 0=free, 1=held +## 8.2 Hook Entry Structure (0x38 bytes) +Each entry in the hook_array is 0x38 bytes. The hook array grows dynamically; initial capacity is 0x80 slots allocated via the IAllocator at .data+0x1E90. +Offset +Type +Field +Description ++0x00 +QWORD +target_va +Virtual address of the hooked IL2CPP function ++0x08 +QWORD +callback_va +Virtual address of the replacement/detour function ++0x10 +QWORD +trampoline_va +VirtualAlloc'd trampoline (original bytes + JMP back) ++0x18 +DWORD +orig_bytes_0_3 +Saved original 4 bytes at target (for restore) ++0x1C +WORD +orig_bytes_4_5 +Saved original bytes 4–5 at target ++0x1E +BYTE +orig_byte_6 +Saved original byte 6 at target ++0x20 +BYTE +flags +Bit 0: has_far_jmp (6-byte JMP); Bit 1: enabled; Bit 2: suspended ++0x24 +DWORD +flags2 +Lower nibble: hook type (0=near JMP, 1=far) ++0x28 +QWORD +hash_next +Next entry pointer in hash chain (for collision chaining) ++0x30 +QWORD +reserved +Padding / future use +## 8.3 Spinlock (0x1800A9C88) +All four hook API functions call the spinlock acquire function at 0x1800A9C88 on entry. Release is done inline via XCHG [.data+0x1E88], 0 at the end of each function. +// Spinlock acquire — 0x1800A9C88 +// Uses LOCK CMPXCHG on .data+0x1E88 (global DWORD spinlock) +void AcquireSpinlock() { +DWORD backoff = 0; +while (true) { +DWORD expected = 0; +// LOCK CMPXCHG [.data+0x1E88], 1 +if (InterlockedCompareExchange(&g_spinlock, 1, 0) == 0) +return; // acquired +// Exponential backoff: if backoff < 32, SwitchToThread(0); else Sleep(1) +backoff += 1; +if (backoff < 32) +SwitchToThread(); // IAT 0x1800B1148 +else +Sleep(1); +} +} +// Spinlock release — inline in all callers +// XCHG [.data+0x1E88], ebx (where ebx=0, atomic store 0) +## 8.4 CreateHook (0x1800A9CC8) +Installs a new hook. Takes target VA (rcx), callback VA (rdx), and optional out_trampoline pointer (r8). Returns 0 on success, error code otherwise. +// CreateHook(void* target, void* callback, void** out_trampoline) -> int +// RVA 0x0A9CC8 +int CreateHook(void* target, void* callback, void** out_trampoline) { +AcquireSpinlock(); // 0x1800A9C88 +// Validate hook manager initialized +if (g_hookMgr.allocator == NULL) return 2; // MH_ERROR_NOT_INITIALIZED +// Validate target and callback are executable +if (!IsExecutable(target)) return 7; // MH_ERROR_NOT_EXECUTABLE +if (!IsExecutable(callback)) return 7; +// Check if hook already exists for this target +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +if (i == -1) continue; +return 3; // MH_ERROR_ALREADY_CREATED +} +} +// Allocate a trampoline buffer near the target +TrampolineSlot* slot = AllocTrampolineSlot(target); // 0x1800A960C +if (!slot) return 9; // MH_ERROR_MEMORY_ALLOC +// Build trampoline: copy prologue bytes + write JMP back +HookEntry entry = {}; +if (!BuildTrampoline(target, callback, slot, &entry)) return 8; +// Fill hook entry fields +entry.target_va = target; // [r8+0x00] +entry.callback_va = callback; // [r8+0x08] (from [rsp+0x28]) +entry.trampoline_va = slot->code; // [r8+0x10] +// Save original bytes for unhook restore +if (entry.flags & 1) { // far JMP (6-byte) +entry.orig_bytes_0_3 = *(DWORD*)(target - 5); +entry.orig_bytes_4_5 = *(WORD*) (target - 1); +entry.orig_byte_6 = *(BYTE*) (target + 1); +} else { // near JMP (5-byte) +entry.orig_bytes_0_3 = *(DWORD*)target; +entry.orig_byte_6 = *(BYTE*)(target + 4); +} +if (out_trampoline) *out_trampoline = slot->code; +ReleaseSpinlock(); // XCHG [.data+0x1E88], 0 +return 0; // MH_OK +} +## 8.5 RemoveHook (0x1800A9E8C) +Removes an installed hook by target address. If the hook is enabled, it is disabled first (original bytes restored). The entry is removed from the array by swapping with the last element. The array is shrunk by half if utilization drops below 50% and count > 0x20. +// RemoveHook(void* target) -> int +// RVA 0x0A9E8C +int RemoveHook(void* target) { +AcquireSpinlock(); +if (g_hookMgr.allocator == NULL) return 2; +// Linear search for target in hook array (stride 0x38) +int idx = -1; +for (int i = 0; i < g_hookMgr.hook_count; i++) { +if (g_hookMgr.hook_array[i].target_va == target) { +idx = i; break; +} +} +if (idx == -1) return 4; // MH_ERROR_NOT_CREATED +HookEntry* entry = &g_hookMgr.hook_array[idx]; +// If hook is currently enabled, disable it first (restore original bytes) +if (entry->flags & 0x2) { +GetHookInfo(idx, 0, ...); // 0x1800A96B0 +EnableHook(idx, 0); // 0x1800A9A9C — restore original bytes +SuspendOtherThreads(...); // 0x1800A9A20 — thread safety +} +// Free trampoline memory +FreeSlot(entry->trampoline_va); // 0x1800AA684 +// Compact array: move last entry into freed slot +int last = g_hookMgr.hook_count - 1; +if (idx < last) { +// memmove: copy 0x38 bytes from hook_array[last] to hook_array[idx] +// (3x movups xmm0 + movsd for full 0x38-byte copy) +hook_array[idx] = hook_array[last]; +} +g_hookMgr.hook_count--; +// Shrink array if count <= capacity/2 and count > 0x20 +if (g_hookMgr.hook_capacity / 2 >= 0x20 && +g_hookMgr.hook_count <= g_hookMgr.hook_capacity / 2) { +realloc(hook_array, (capacity/2) * 0x38); +g_hookMgr.hook_capacity /= 2; +} +ReleaseSpinlock(); +return 0; +} +## 8.6 EnableHook / PatchCode (0x1800A9A9C) +Patches or unpatches the target function's first bytes. Suspends all other threads during the write using VirtualProtect + WriteProcessMemory, then resumes them. Handles both near (5-byte E9 JMP) and far (6-byte FF25 indirect JMP) hook types. +// EnableHook(int hook_idx, BOOL enable) -> int +// RVA 0x0A9A9C +int EnableHook(int hook_idx, BOOL enable) { +HookEntry* e = &g_hookMgr.hook_array[hook_idx * 0x38]; +// Determine patch target and size +BOOL far_jmp = e->flags & 0x1; // bit 0: uses 6-byte far JMP +void* patch_target = far_jmp ? (e->target_va - 5) : e->target_va; +SIZE_T patch_size = far_jmp ? 7 : 5; // [rcx*2 + 5] +// VirtualProtect(patch_target, patch_size, PAGE_EXECUTE_READWRITE, &old) +VirtualProtect(patch_target, patch_size, 0x40, &old_protect); +if (enable) { +// Write JMP hook: +*(BYTE*)patch_target = 0xE9; // near JMP opcode +*(DWORD*)(patch_target+1) = +(DWORD)(e->callback_va - (QWORD)patch_target - 5); +if (far_jmp) { +// Also patch 2 bytes before target_va with short JMP back +*(WORD*)(e->target_va) = 0xF9EB; // JMP -5 (back to patch_target) +} +} else { +// Restore original bytes +*(DWORD*)patch_target = e->orig_bytes_0_3; +if (far_jmp) { +*(WORD*) (patch_target+4) = e->orig_bytes_4_5; +*(BYTE*) (patch_target+6) = e->orig_byte_6; +} else { +*(BYTE*) (patch_target+4) = (BYTE)e->orig_bytes_4_5; +} +} +// Restore page protection +VirtualProtect(patch_target, patch_size, old_protect, &old_protect); +// Flush instruction cache +FlushInstructionCache(GetCurrentProcess(), patch_target, patch_size); +// Update flags: set/clear enabled bit (bit 1) and suspended bit (bit 2) +// Bit manipulation: (enable<<2) XOR flags, AND 0x2, XOR flags, XOR enable_bit +e->flags = (e->flags & ~0x6) | ((enable ? 0x2 : 0x0)); +return 0; // MH_OK +} +## 8.7 FNV-1a Hash Implementation +The hash table uses FNV-1a (Fowler–Noll–Vo) 64-bit hashing to map target VA pointers to hash bucket indices. The compiler has unrolled the byte loop into 8 sequential XOR+MUL pairs operating on each byte of the 8-byte pointer. +// FNV-1a 64-bit hash of a pointer value (unrolled, 0x18008D555) +// r11 = target_va (8 bytes to hash) +// r10 = FNV prime = 0x00000100000001B3 +// r9 = FNV offset = 0xCBF29CE484222325 (init value) +uint64_t FNV1a_64(uint64_t target_va) { +uint64_t hash = 0xCBF29CE484222325ULL; // FNV offset basis +uint64_t prime = 0x00000100000001B3ULL; // FNV prime +// Byte 0 (bits 0-7) +hash ^= (uint8_t)(target_va >> 0); hash *= prime; +// Byte 1 (bits 8-15) +hash ^= (uint8_t)(target_va >> 8); hash *= prime; +// Byte 2 (bits 16-23) +hash ^= (uint8_t)(target_va >> 16); hash *= prime; +// Byte 3 (bits 24-31) +hash ^= (uint8_t)(target_va >> 24); hash *= prime; +// Byte 4 (bits 32-39) +hash ^= (uint8_t)(target_va >> 32); hash *= prime; +// Byte 5 (bits 40-47) +hash ^= (uint8_t)(target_va >> 40); hash *= prime; +// Byte 6 (bits 48-55) +hash ^= (uint8_t)(target_va >> 48); hash *= prime; +// Byte 7 (bits 56-63) +hash ^= (uint8_t)(target_va >> 56); hash *= prime; +// Map to bucket index +uint64_t bucket_idx = hash & bucket_mask; // [r8+0x48] +bucket_idx += bucket_idx; // *2 for pointer-sized bucket entries +return bucket_idx; +} +// Bucket lookup in hash chain: +// head = hash_buckets[bucket_idx] // [rcx + r9*8 + 0x00] +// sentinel = hash_buckets[bucket_idx + 1] // [rcx + r9*8 + 0x08] +// while (node != sentinel): +// if node->target_va == target: return node +// node = node->hash_next +## 8.8 Hook Manager Key Addresses +Address +Function / Field +Notes +0x1800A9C88 +AcquireSpinlock() +LOCK CMPXCHG loop with SwitchToThread/Sleep backoff +0x1800A9CC8 +CreateHook(target, cb, tramp) +Validates, searches array, builds trampoline, patches +0x1800A9E8C +RemoveHook(target) +Finds by linear search, disables if live, frees trampoline, compacts +0x1800A9A9C +EnableHook(idx, enable) +VirtualProtect + write JMP/restore + FlushInstructionCache +0x1800A96B0 +GetHookInfo(idx, ...) +Reads hook entry fields into caller-supplied buffer +0x1800A960C +AllocTrampolineSlot(target) +Finds or allocates VirtualAlloc page near target +0x1800AA684 +FreeTrampolineSlot(tramp) +Returns slot to free list +.data+0x1E88 +g_spinlock (DWORD) +Global spinlock; acquired via CMPXCHG, released via XCHG +.data+0x1E90 +g_allocator (QWORD*) +IAllocator vtable pointer used by hook manager +.data+0x2470 +g_hookMgr (struct, 0x90B) +Hook manager singleton base address +.data+0x2480 +hook_array (QWORD*) +Flat array of 0x38-byte hook entries +.data+0x27E0 +hook_array (mirror ptr) +Second reference to hook_array base +.data+0x27EC +hook_count (DWORD) +Number of currently installed hooks +0x18008D555 +FNV-1a hash body +Unrolled 8-byte XOR/MUL loop, prime=0x100000001B3 +# 9. ESPModule State Layout and Color Table Defaults +The ESPModule state struct is stored at .data+0x1F70 (VA 0x1803C6F70). It is initialized by the lazy singleton at 0x180083E00, which zero-initializes all fields, sets the module name, wires up both vtable pointers, writes boolean defaults for the eight display flags, and loads 12 RGBA color slots from .rdata constants via MOVDQA into 16-byte-aligned slots starting at state+0x40. +## 9.1 ESPModule State Struct Layout +Offset +Type +Field +Default ++0x00 +QWORD* +vtable[0] (init thunk) +0x1803AF9E0 ++0x08 +str* +module_name (std::string) +'ESPModule' ++0x28 +BYTE +enabled +0 (off) ++0x30 +DWORD +max_dist +0x12C = 300 (integer) ++0x34 +BYTE +show_monsters +1 (true) ++0x35 +BYTE +show_npc +1 (true) ++0x36 +BYTE +show_friendly +1 (true) ++0x37 +BYTE +show_puzzles +1 (true) ++0x38 +BYTE +show_all +0 (false) ++0x39 +BYTE +show_distance +1 (true) ++0x3A +BYTE +show_name +1 (true) ++0x3B +BYTE +show_type +0 (false) ++0x3C +DWORD +(alignment padding) +- ++0x40 +float[4] +color[0] RGBA +see table below ++0x50 +float[4] +color[1] RGBA +see table below ++0x60 +float[4] +color[2] RGBA +see table below ++0x70 +float[4] +color[3] RGBA +see table below ++0x80 +float[4] +color[4] RGBA +see table below ++0x90 +float[4] +color[5] RGBA +see table below ++0xA0 +float[4] +color[6] RGBA +see table below ++0xB0 +float[4] +color[7] RGBA +see table below ++0xC0 +float[4] +color[8] RGBA +see table below ++0xD0 +float[4] +color[9] RGBA +see table below ++0xE0 +float[4] +color[10] RGBA +see table below ++0xF0 +float[4] +color[11] RGBA +see table below +## 9.2 Color Table Defaults (12 slots × 16 bytes) +Each slot is a 128-bit XMMWORD (4× IEEE 754 float, little-endian order R, G, B, A). Values are loaded from .rdata constants at init time via MOVDQA. The color slot-to-entity-type mapping follows the order the show_* flags were written in the initializer. +Slot +State Offset +.rdata RVA +R +G +B +A +Color Name +Entity Type +0 ++0x40 +0x3B3510 +1.000 +0.000 +0.000 +1.000 +Red +Monsters / Enemies +1 ++0x50 +0x3B3520 +1.000 +0.647 +0.000 +1.000 +Orange +NPC +2 ++0x60 +0x3B3540 +1.000 +1.000 +0.000 +1.000 +Yellow +Friendly +3 ++0x70 +0x3B3530 +0.000 +1.000 +0.000 +1.000 +Green +Puzzles +4 ++0x80 +0x3B3590 +0.000 +0.000 +1.000 +1.000 +Blue +(spare/all) +5 ++0x90 +0x3B35A0 +0.000 +1.000 +1.000 +1.000 +Cyan +(spare) +6 ++0xA0 +0x3B3580 +0.580 +0.000 +0.827 +1.000 +Purple +(spare) +7 ++0xB0 +0x3B35B0 +1.000 +1.000 +1.000 +1.000 +White +(spare) +8 ++0xC0 +0x3B3560 +1.000 +0.078 +0.576 +1.000 +Hot Pink +(spare) +9 ++0xD0 +0x3B3570 +1.000 +0.753 +0.796 +1.000 +Light Pink +(spare) +10 ++0xE0 +0x3B3500 +0.000 +0.000 +0.000 +1.000 +Black +(spare) +11 ++0xF0 +0x3B3550 +0.502 +0.502 +0.502 +1.000 +Gray +(spare) +All 12 slots have alpha fixed at 1.000 (fully opaque). Slots 0–3 correspond to the four named entity types controlled by show_monsters / show_npc / show_friendly / show_puzzles flags. Slots 4–11 are spare palette entries available for future entity categories; the ImGui color picker in ESPModule::Render exposes all 12 via '##Foreground' color edit widgets. +## 9.3 Show Flag Default Summary +Flag +Offset +Default +Notes +show_monsters ++0x34 +1 (ON) +Draws boxes/labels for monster entities +show_npc ++0x35 +1 (ON) +Draws boxes/labels for NPC entities +show_friendly ++0x36 +1 (ON) +Draws boxes/labels for friendly entities +show_puzzles ++0x37 +1 (ON) +Draws boxes/labels for puzzle objects +show_all ++0x38 +0 (OFF) +Override: draw all entity types regardless of flags above +show_distance ++0x39 +1 (ON) +Appends distance string to entity label +show_name ++0x3A +1 (ON) +Appends entity name string to label +show_type ++0x3B +0 (OFF) +Appends entity type string to label +max_dist ++0x30 +300 +Integer cutoff distance; entities beyond this are not drawn +# 10. SkillHack Hook Callbacks +SkillHack installs up to six IL2CPP hooks across five callback functions. The hooks intercept game methods that govern skill cooldowns, skill availability checks, and skill costs. All five callbacks share the same guard pattern: call SkillHack singleton init (0x180081300), check enabled flag at [singleton+0x28], and either return the bypass value immediately or fall through to the original method via the hook manager's trampoline dispatcher (0x18008FF00). +## 10.1 Hook Installation Map +SkillHack::Render (0x18008D1F0) installs hooks in two stages. Three hooks are installed directly via the hook-installer wrapper (0x18008D8A0). Three more are installed by dedicated patch functions called from Render. All six use the same FNV-1a hash lookup pattern and CreateHook call. +Hook # +Target Ptr +Callback VA +Patch Function +Installed By +1 +[g_Config+0x1E60] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +2 +[g_Config+0x1E68] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 +3 +[g_Config+0x1E50] +0x18008D500 (float 100.0) +0x18008E220 +Render → 8E220 → CreateHook +4 +[g_Config+0x1E58] +0x18008D640 (bool true) +0x18008EBC0 +Render → 8EBC0 → CreateHook +5 +[g_Config+0x1E40] +0x18008D780 (void return) +0x18008F560 +Render → 8F560 → CreateHook +6 +[g_Config+0x1E48] +0x18008D4B0 (dispatcher) +- +Render direct → 0x8D8A0 (tail) +The g_Config IL2CPP function pointer slots are populated at runtime from IL2CPP metadata. Their contents are zero/garbage in the static binary on disk. +## 10.2 Generic Dispatcher — 0x18008D4B0 +Used for hooks 1, 2, and 6. When the skill hack is enabled, returns BOOL true (1) immediately to the caller, bypassing any skill gate check. When disabled, passes through to the original IL2CPP function via the trampoline. +// Generic dispatcher callback — 0x18008D4B0 +// Used for: hooks on [g_Config+0x1E60], [g_Config+0x1E68], [g_Config+0x1E48] +// Return type: BOOL (BYTE in al) +BOOL Callback_Dispatcher(void* self, void* arg) { +// Get SkillHack singleton (lazy init, 0x180081300) +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { // [singleton+0x28] != 0 +return 1; // bypass — skill check always passes +} +// Disabled: look up original function via FNV-1a hash and call trampoline +// HookManager::GetOriginal(hookMgr, this_callback_va, self, arg) +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +return CallOriginal(hookMgr, /*callback=*/0x18008D4B0, self, arg); // → 0x18008FF00 +} +## 10.3 Variant 1: Float Return — 0x18008D500 +Installed by patch function 0x18008E220 on the target at [g_Config+0x1E50]. Intercepts a method that returns a float — most likely GetCooldownPercent() or GetCooldownRemaining(). Returns 100.0 when enabled, indicating the skill is fully cooled down / available. +// Cooldown bypass callback — 0x18008D500 +// Installed on: [g_Config+0x1E50] (via patch fn 0x18008E220) +// Return type: float (xmm0) +float Callback_CooldownBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +// movss xmm0, [rip+0x325de5] -> RVA 0x3B3308 = 100.0f +return 100.0f; // skill cooldown = 100% complete (fully ready) +} +// Hash self VA via FNV-1a, look up hook entry, call original via trampoline +auto* hookMgr = HookManager_GetSingleton(); +return CallOriginal_Float(hookMgr, /*callback=*/0x18008D500, self, arg); +} +// Note: 0x42C80000 = 100.0 IEEE 754 single-precision (confirmed from .rdata RVA 0x3B3308) +// The prior volume summary incorrectly stated this returns 0.0. +## 10.4 Variant 2: Bool True — 0x18008D640 +Installed by patch function 0x18008EBC0 on the target at [g_Config+0x1E58]. Intercepts a method that returns a boolean — most likely IsSkillAvailable() or CanUseSkill(). When enabled, always returns true (1). When disabled, the hash lookup falls through: if the original function is found in the hook table, it is called via tail JMP; otherwise, returns false (0) as a safe default. +// Skill availability bypass callback — 0x18008D640 +// Installed on: [g_Config+0x1E58] (via patch fn 0x18008EBC0) +// Return type: BOOL (BYTE in al) +BOOL Callback_SkillAvailable(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return 1; // skill is always available +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D640); +if (original != NULL) { +// rex.WB JMP r8 — tail call to original +return original(self, arg); +} +// Hash miss — safe fallback +return 0; // xor al,al (0x18008D770) +} +## 10.5 Variant 3: Void Early Return — 0x18008D780 +Installed by patch function 0x18008F560 on the target at [g_Config+0x1E40]. Intercepts a void method — most likely ApplySkillCost() or DeductMana(). When enabled, returns immediately without executing the function body, discarding the cost deduction entirely. When disabled, the hash lookup finds the original and tail-calls it. +// Skill cost bypass callback — 0x18008D780 +// Installed on: [g_Config+0x1E40] (via patch fn 0x18008F560) +// Return type: void +void Callback_SkillCostBypass(void* self, void* arg) { +auto* sk = SkillHack_GetSingleton(); +if (sk->enabled) { +return; // jne 0x18008D894 — skip to ret immediately +// Original cost deduction never executes +} +// Disabled path: FNV-1a hash lookup for original +auto* hookMgr = HookManager_GetSingleton(); +auto* original = FindOriginalInHashTable(hookMgr, /*callback=*/0x18008D780); +if (original != NULL) { +// call r8 — call original, then return +original(self, arg); // 0x18008D891: call r8 +} +// If hash miss: no-op (safe for void) +} +## 10.6 Common Trampoline Dispatcher — 0x18008FF00 +When any callback is disabled and needs to call the original IL2CPP method, it calls 0x18008FF00. This function computes the FNV-1a hash of the callback's own VA, looks up the corresponding hook entry's trampoline_va field (+0x18), and tail-jumps to it. It is effectively the 'call original' helper shared by all SkillHack callbacks. +// CallOriginal trampoline dispatcher — 0x18008FF00 +// rcx = hookMgr, rdx = callback_va (used as hash key), r8 = self, r9 = arg +void* CallOriginal(HookManager* mgr, void* callback_va, void* self, void* arg) { +// FNV-1a hash of callback_va -> bucket index +uint64_t hash = FNV1a_64(callback_va); // same unrolled loop as 0x18008D555 +uint64_t bucket_idx = hash & mgr->bucket_mask; +// Walk hash chain to find entry where entry->callback_va == callback_va +HookEntry* entry = FindInHashChain(mgr, bucket_idx, callback_va); +if (entry && entry->trampoline_va) { +// Tail jump to trampoline (original bytes + JMP back) +JMP entry->trampoline_va; // rex.WB jmp r8 +} +// If no entry found: return NULL / no-op +} +## 10.7 Callback Summary Table +VA +Name +Return Type +Enabled Value +Disabled Behavior +Game Method (inferred) +0x18008D4B0 +Dispatcher +BOOL +1 (true) +Call original via 0x8FF00 +Skill gate / permission check +0x18008D500 +CooldownBypass +float +100.0f +Call original via FNV hash + trampoline +GetCooldownPercent / GetCooldownRemaining +0x18008D640 +SkillAvailable +BOOL +1 (true) +Original via tail JMP, or return 0 +IsSkillAvailable / CanUseSkill +0x18008D780 +SkillCostBypass +void +early ret +Original via call r8, or no-op +ApplySkillCost / DeductMana +# 11. DLL Injection Strings — testyip / gatmp.tmp / EF-Cheeto.dll +Three std::string objects are statically pre-initialised in .data and used during the loader's startup sequence. They are not classic injection strings in the sense of being written to a remote process; they are module-path substrings used by the self-presence scanner to confirm that the cheat DLL (or its temp-file loader copy) is already mapped into the target Unity process before the IL2CPP domain is attached. +## 11.1 String Object Layout in .data +All three are MSVC SSO (small-string-optimised) std::string objects with the inline buffer variant active (length ≤ 15, so no heap allocation). Each occupies 24 bytes: 8-byte inline buffer, 8-byte _Mysize, 8-byte _Myres. +String +.data offset (base) +Inline buf offset +Length +Capacity +Content +testyip ++0x308 ++0x318 +7 +15 (0x0F) +testyip\0 (7 bytes) +gatmp.tmp ++0x328 ++0x338 +9 +15 (0x0F) +gatmp.tmp\0 (9 bytes) +EF-Cheeto.dll ++0x348 ++0x358 +13 +15 (0x0F) +EF-Cheeto.dll\0 (13 bytes) +The _Mysize field for testyip reads as zero in the static binary image because the std::string was zero-initialised before the inline buffer was written — the buffer bytes are present but the constructor has not run. At runtime MSVC CRT initialises the object before DllMain executes. +## 11.2 Module Path Scanner — 0x18008B650 +The function at 0x18008B650 receives a process handle (rcx), a pointer array of HMODULE values (rdx), and a count output pointer (r8). For each module handle it calls GetModuleFileNameExW (IAT 0x1800B1168) to obtain the full path as a wide string, then uses the UTF-8→wide converter at 0x18008B4E0 (wrapping MultiByteToWideChar with CP_UTF8 = 0xFDE9) to convert the two search strings, and searches each path with wcsstr. It returns the zero-based array index of the first matching module, or -1 if not found. +// ModulePathScanner — 0x18008B650 +// Scans a process's loaded module list for paths containing known substrings. +// rcx = hProcess rdx = HMODULE[] r8 = DWORD* count_out r9 = extra_arg +int ModulePathScanner(HANDLE hProcess, HMODULE* modules, DWORD* count, void* extra) { +DWORD module_count = *count >> 3; // [rsi] >> 3 = byte-count / sizeof(HMODULE) +if (module_count == 0) return 0; +// Convert search strings from UTF-8 std::string to std::wstring +// 0x18008B4E0: MultiByteToWideChar(CP_UTF8=0xFDE9, 0, src, len, dst, dst_cap) +std::wstring w_gatmp = Utf8ToWide("gatmp.tmp"); // .data+0x338 +std::wstring w_efdll = Utf8ToWide("EF-Cheeto.dll"); // .data+0x358 +int found_count = 0; +for (DWORD i = 0; i < module_count; i++) { +WCHAR path[0x104] = {}; +// GetModuleFileNameExW(hProcess, modules[i], path, 0x104) +if (!GetModuleFileNameExW(hProcess, modules[i], path, 0x104)) +continue; // skip on failure → je 0x18008BA41 +// Convert wide path to std::wstring for wcsstr search +std::wstring wpath = WideToString(path); // 0x18000EB10 +// Search for 'gatmp.tmp' in the path +const wchar_t* pos_gatmp = wcsstr(wpath.c_str(), w_gatmp.c_str()); +// 0x1800AB6A0: custom wcsstr returning iterator, -1 if not found +intptr_t idx_gatmp = (pos_gatmp ? (pos_gatmp - wpath.c_str()) : -1); +if (idx_gatmp == -1) { +// Search for 'EF-Cheeto.dll' in the path instead → 0x18008B937 +const wchar_t* pos_ef = wcsstr(wpath.c_str(), w_efdll.c_str()); +intptr_t idx_ef = (pos_ef ? (pos_ef - wpath.c_str()) : -1); +if (idx_ef != -1) { +// Found — store module handle and record match +modules[found_count] = modules[i]; // compact in-place +found_count++; +} +// else: neither string found, skip module +} else { +// gatmp.tmp match — store module handle +modules[found_count] = modules[i]; +found_count++; +} +} +*count = (found_count * 8); // write back as byte count +return ; // propagates from call r10 (original fn) +} +## 11.3 Hook Installer Wrapper — 0x18008BAF0 +Called at 0x1800A93CC during the main startup sequence (0x1800A9190), after FindWindow('UnityWndClass') confirms the game window exists. Receives the IL2CPP method pointer for a function to hook (rcx = r14 from [IAT+0x7DA4] = EnumProcessModules or similar resolved pointer). Calls CreateHook (0x1800A9CC8) with 0x18008B650 as the callback, handling error codes with log messages 'Failed to remove existing hook: {}' (0x1803AFB30) and 'Failed to create new hook: {}' (0x1803AFB90). +// HookInstallerWrapper — 0x18008BAF0 +// Installs ModulePathScanner (0x18008B650) as hook on a target IL2CPP function. +// Called from main startup (0x1800A9190) once game window is found. +void HookInstallerWrapper(void* target_fn) { +auto* hookMgr = HookManager_GetSingleton(); // 0x180081B00 +// Check if hook already exists — RemoveHook first if so +if (FindExistingHook(hookMgr, target_fn)) { +int rc = RemoveHook(target_fn); // 0x1800A9E8C +if (rc != 0) { +Log("Failed to remove existing hook: {}", FormatError(rc)); // 0x1803AFB30 +return; +} +} +// Install new hook with ModulePathScanner as callback +void* trampoline = nullptr; +int rc = CreateHook(target_fn, /*cb=*/0x18008B650, &trampoline); // 0x1800A9CC8 +if (rc != 0) { +Log("Failed to create new hook: {}", FormatError(rc)); // 0x1803AFB90 +return; +} +// trampoline stored at [rbp-0x1] for later EnableHook call +} +## 11.4 Startup Sequence Context — 0x1800A9190 +The main DLL startup function at 0x1800A9190 establishes the console, hooks the module scanner, then proceeds to IL2CPP domain attachment. The three injection strings serve as the identity check: if neither 'gatmp.tmp' nor 'EF-Cheeto.dll' appears in any loaded module's path, the scanner returns no matches and the cheat does not proceed. +Step +Address +Action +1 +0x1800A91CE +AllocConsole — create 'il2cpp Game Console' window +2 +0x1800A9267 +SetConsoleCP(0xFDE9) — set UTF-8 code page +3 +0x1800A92F7 +FindWindowA(NULL, 'UnityWndClass') — poll until game window present +4 +0x1800A93CC +HookInstallerWrapper(EnumProcessModules) — install module scanner +5 +0x1800A93E6 +Log 'Initializing..' — source: E:\\git\\Endfield_Cheeto\\user\\main.cpp:53 +6 +0x1800A942F +Call [g_Config+0x1E80] — IL2CPP domain resolver +7 +0x1800A945A +Log 'IL2CPP Domain Found: ' if domain non-null +8 +0x1800A94C4 +Log 'IL2CPP Thread Attached Successfully: ' on attach +9 +0x1800A9506 +Error branch: Log ‘Failed to Attach IL2CPP Thread!’ (source: main.cpp) +10 +0x1800A9545 +Error branch: Log ‘IL2CPP Domain Not Found!’ (source: main.cpp) if domain is null +11 +0x1800A959F +Success path: Log ‘Initialized’ (source: main.cpp); function returns +Console initialisation detail (steps 1–2): AllocConsole (IAT[0xB1108]) allocates the console window. Three freopen_s calls (IAT[0xB1878]) redirect stdin, stdout, and stderr to CONIN$ and CONOUT$. SetConsoleOutputCP(0xFDE9) sets the UTF-8 code page. GetConsoleMode (IAT[0xB1120]) reads the current output mode flags and SetConsoleMode (IAT[0xB1128]) adds ENABLE_VIRTUAL_TERMINAL_PROCESSING for ANSI colour support. SetConsoleTitleA (IAT[0xB12A0]) sets the window caption to ‘il2cpp Game Console’. The overlay window thread is then launched (call 0x1800827A0) at step 12 (see Ch. 29), running independently of the IL2CPP attach sequence. +The source path 'E:\\git\\Endfield_Cheeto\\user\\main.cpp' (RVA 0x3B3148) confirms the project name and local build directory. 'Endfield_Cheeto' matches the cheat's internal identity; the published DLL name 'EF-Cheeto.dll' abbreviates this. +## 11.5 Injection String Summary +String +.data VA +Role +Search context +testyip +0x1803C5318 +Alternate temp-file loader name +wcsstr scan against each loaded module's full path +gatmp.tmp +0x1803C5338 +Primary temp-file loader name +wcsstr scan — match means loader copy is present +EF-Cheeto.dll +0x1803C5358 +Published DLL name +wcsstr fallback if gatmp.tmp not found in path +The naming pattern indicates a two-stage loader: the cheat is first written as a temp file (gatmp.tmp or testyip) via a dropper, then optionally renamed or loaded directly as EF-Cheeto.dll. The module path scanner confirms whichever form is loaded before proceeding with IL2CPP hooking. +# 12. Module Render() and Update() Implementations +Each module exposes two callable entry points registered with ModuleManager: a Render() function that draws the ImGui tab panel and handles one-shot toggle/config writes, and an Update() callback (stored as a .rdata function pointer) that runs the per-frame game-state mutation. SetDither and the SkillHack 'Free Skill' tab share a no-op stub at 0x18008/3DC0 whose entire job is to free a string and optionally call operator delete on the module object — meaning those two tabs perform all their work at Render time, not per-frame. The seven implementations are documented below. +## 12.1 Shared g_Config Panel-Width Sequence +All modules that expand their ImGui tab panel write an identical five-instruction sequence at panel-open and invert it at panel-close. This sequence adjusts the panel scroll region width in the global config object g_Config ([.data+0x1c00]). The fields involved are: +Field +g_Config offset +Role +panel_ptr ++0x15D8 +Pointer to the active ImGui panel/window struct +scroll_step ++0x0E0C +Per-frame scroll delta (float, typically a small positive value) +scroll_accum ++0x194 +Accumulated horizontal scroll position (float) +scroll_base ++0x58 +Base horizontal offset for child panels (float) +scroll_total ++0x198 +Total scroll range (float) +panel_width ++0x150 +Rendered panel content width (float, written each frame) +// Panel-open sequence (addss — widens panel each frame module is visible) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; // mark panel as active/dirty +rax = g_Config->panel_ptr; +xmm0 = g_Config->scroll_step; // [g_Config+0x0E0C] +xmm0 += rax->scroll_accum; // [panel+0x194] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; // [panel+0x58] +xmm0 += rax->scroll_total; // [panel+0x198] +rax->panel_width = xmm0; // [panel+0x150] — expand +// Panel-close sequence (subss — narrows panel each frame module is hidden) +rax = g_Config->panel_ptr; +rax->field_0x103 = 1; +rax = g_Config->panel_ptr; +xmm0 = rax->scroll_accum; // [panel+0x194] +xmm0 -= g_Config->scroll_step; // [g_Config+0x0E0C] +rax->scroll_accum = xmm0; +xmm0 += rax->scroll_base; +xmm0 += rax->scroll_total; +rax->panel_width = xmm0; // shrink +This pattern appears verbatim in every module's Render body and is not repeated in the per-module pseudocode below — it is implied by 'panel-open sequence' and 'panel-close sequence'. +## 12.2 NoClip +Function +RVA +Role +NoClip::RegisterTab +0x180081300 +One-time tab registration (Render stub #1) +NoClip::Render +0x1800813D0 +ImGui tab panel — checkbox + Move Speed slider +NoClip::Update +0x180089B50 +Per-frame: CharacterController.enabled toggle + speed slider +NoClip::Update stub +0x180089B00 +Tab-manager destructor/cleanup wrapper +NoClip disables/re-enables the Unity CharacterController component on matching entities each frame. When enabled the controller's collision is suppressed, allowing the player to pass through geometry. A Move Speed integer slider ([module+0x30], range 1–10, step 1) controls movement rate while noclip is active. +// NoClip::Render RVA 0x1800813D0 +// rcx = NoClip* this +void NoClip::Render() { +// Panel-open sequence (g_Config+0x1c00, +0x15D8/0xE0C/0x194/0x58/0x198/0x150) +std::string title = MakeString("NoClip", 6); // 0x18000FCB0 +std::string tmp; +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &title); // 0x18009D7D0 +// resolve std::string to char* via SSO check (cmp [rax+0x18], 0xF) +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 — returns true if clicked +// free tmp, title +if (!clicked) { panel-close sequence; return; } +// Panel-open sequence +// second tab header: 'ON / OFF' +bool on_off_clicked = TabManager_BeginTab([.data+0x27B0], &tmp, &title); +// resolve buf, call 0x180085320 (CheckboxToggle) with &this->enabled [+0x28] +// CheckboxToggle: if edx (new_val) != *rdx (current), flip and update +// Panel-open/close based on [this+0x28] +if ([this+0x28] enabled) { +// 'Move Speed' DragInt slider: [this+0x30], range [1,10], step 1, format '%d' +// 0x180066750 — ImGui::DragInt4-variant +panel-open sequence; +} else { +panel-close sequence; +} +} +// NoClip::Update RVA 0x180089B50 +// Called per-frame by ModuleManager hook +void NoClip::Update() { +// Same 'NoClip' tab header + ON/OFF checkbox pattern as Render +if (!clicked) return; +panel-open sequence (if enabled) +'Move Speed' DragInt slider — same as Render, writes [this+0x30] +// Entity iterator loop (0x180089DC0) +bool noclip_on = [this+0x28]; +void* entity_mgr = g_Config->GetEntityManager(); // [g_Config+0x1D28] — IL2CPP call +if (!entity_mgr) return; +void* list = entity_mgr->GetComponentList(); // [entity_mgr+0x10]->field_0x10 +int count = list->count; // [list+0x20] +void** arr = list->items; // [list+0x10][+0x10] +arr += 0x20; // skip header slots +for (int i = 0; i < count; i++, arr++) { +void* component = *arr; +if (!component) continue; +void* ctrl = GetCharacterController(component); // [g_Config+0x1E20] IL2CPP call +if (!ctrl) continue; +// CharacterController.set_enabled(!noclip_on, 0) +// [g_Config+0x1E08]: IL2CPP setter — dl = !noclip_on, r8d = 0 +bool enable_cc = !noclip_on; +SetEnabled(ctrl, enable_cc, 0); // 0x1803C6E08 +} +// Move Speed DragInt — panel sequence at close +} +## 12.3 FreeCam +Function +RVA +Role +FreeCam::RegisterFpsTab +0x1800814C0 +Registers FPS Monitor overlay tab +FreeCam::RegisterMainTab +0x180081590 +Registers FreeCam main tab (0xD8-byte zeroed state) +FreeCam::FpsUpdate stub +0x180087150 +FPS overlay destructor wrapper; tab cleanup +FreeCam::Update +0x1800871A0 +Per-frame: camera override, WASD+mouse input, speed sliders +FreeCam overrides the game camera's transform each frame when enabled. RegisterMainTab zeroes a 0xD8-byte state block in .data ([.data+0x2200]) and writes hard-coded default key bindings (0x44415357 = 'WASD', 0x6D6BA220, 0x2725, 0x60) and clears floats for pitch/yaw/roll/FOV accumulators. It also clears an 8-byte 'active camera' pointer and related state. Move Speed defaults to 30.0f (0x41F00000 IEEE 754), step 0.1f (0x3DCCCCCD). Look Sensitivity defaults to 100.0f (0x42C80000), step 0.1f (0x3DCCCCCD). Roll Speed ([this+0x34]) and FOV Speed ([this+0x38]) have dedicated sliders with format '%.3f'. +// FreeCam::RegisterMainTab RVA 0x180081590 +// Runs once at DLL init; zeroes FreeCam state block and writes defaults +void FreeCam::RegisterMainTab() { +// Zero [.data+0x2200] block (0xD8 bytes via memset-like call 0x1800AC86A) +std::string tab = MakeString("FreeCam", 7); +// register tab with TabManager (0x18000F7D0), clear active flag, free strings +// Write update fn ptr: [.data+0x2200] = 0x1803AFE10 → FreeCam::Update +// Write default key bindings to [.data+0x2230..0x225E]: +// movdqa [+0x2230] = [0x1803B34F0] (key config block 1) +// movdqa [+0x2240] = [0x1803B35C0] (key config block 2) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier default) +// [+0x2254] = 0x44415357 ('WASD' key code mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind) +// [+0x225E] = 0x60 (backtick key code) +// Zero floats: pitch/yaw/roll/FOV [+0x2260..0x22A8], camera ptr [+0x22B0..0x22D0] +} +// FreeCam::Update RVA 0x1800871A0 +void FreeCam::Update() { +std::string hdr = MakeString("Free Camera", 11); +bool open = TabManager_BeginTab(&tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// ON/OFF checkbox → [this+0x28] +bool on_off = TabManager_BeginTab(...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 +if (!this->enabled) { +// Disable camera override: clear active cam ptr [this+0x70] and [this+0x68] +// [g_Config+0x1DB8]: IL2CPP Camera.set_enabled(false/true calls) +Camera_SetEnabled([this+0x70], false, 0); // 0x1803C6DB8 +Camera_SetEnabled([this+0x68], true, 0); +[this+0xB8] = 0; // clear 'cam override active' flag +panel-close sequence; +return; +} +// Move Speed float slider: [this+0x30], max 500.0f, min 0.1f, fmt '%.3f' +// 0x180065570 — ImGui::SliderFloat8 variant (8 = DragFloat with extra params) +// [rsp+0x40]=500.0f (max), [rsp+0x48]=0.1f (min), xmm3=step +// Roll Speed float slider: [this+0x34], max 100.0f (0x42C80000), min 0.1f +// Look Sensitivity float slider: [this+0x38]? (identified from 'FOV Speed' string) +// (Three consecutive float sliders: Move Speed, Roll Speed, FOV Speed) +// Key input + camera transform written via IL2CPP calls on camera component +// (Camera.get_main, Transform.set_position, Transform.set_rotation via vtable) +} +## 12.4 FpsUnlocker +Function +RVA +Role +FpsUnlocker::RegisterTab +0x180081730 +Registers 'Fps Unlocker' tab; writes default fps=300 ([.data+0x21E8]) +FpsUnlocker::Render +0x180085B90 +ImGui panel: checkbox + Fps Value DragInt, calls Application.targetFrameRate +FpsUnlocker::Update stub +0x180085B40 +Tab destructor/cleanup wrapper; cleanup size 0x38 +FpsUnlocker calls the IL2CPP Application.set_targetFrameRate setter ([.data+0x1D48]) on every Render call (not per-frame Update). When the checkbox is off, it passes 60 (0x3C) as the frame rate. When on, it passes [this+0x30] — the user's chosen value. A Fps Value DragInt slider ([this+0x30], max 500, min 30, step 1, format '%d') is displayed in a second tab header. RegisterTab writes a default of 300 (0x12C) to the .data slot backing [this+0x30]. +// FpsUnlocker::Render RVA 0x180085B90 +void FpsUnlocker::Render() { +std::string hdr = MakeString("Fps Unlocker", 12); +bool open = TabManager_BeginTab([.data+0x27B0], &tmp, &hdr); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// First action on open: call Application.set_targetFrameRate +// (regardless of enabled state — immediate effect) +int fps_val = this->enabled ? this->fps_target : 60; +Application_SetTargetFrameRate(fps_val); // [.data+0x1D48] IL2CPP +// ON/OFF checkbox → CheckboxToggle([this+0x28]) +if (this->enabled) { +panel-open sequence; +// 'Fps Value' DragInt: [this+0x30], max=500, min=30, step=1, fmt='%d' +// 0x180065570 ImGui::DragInt variant +// On each interaction: call Application.set_targetFrameRate([this+0x30]) +// ... then subss panel-close sequence +} else { +// panel-close sequences x2 (one per BeginTab call) +} +} +## 12.5 SetDither +Function +RVA +Role +SetDither::RegisterTab +0x180081810 +Registers 'SetDither' tab; stores update ptr 0x1803B01B0 → stub 0x180083DC0 +SetDither::Render +0x180081810 +Identical to RegisterTab (same address — no separate Render body) +SetDither::Update +0x180083DC0 +No-op stub: frees string [this+0x8], optionally operator delete(this, 0x30) +SetDither is the simplest module. Its registration function and Render body coincide at the same RVA — the 'tab' it registers has no interactive widgets beyond the standard tab header registration. The stored update pointer leads to the shared no-op stub at 0x180083DC0. The stub frees a std::string at [rcx+0x8] then, if the dirty bit (bl & 1) is set, calls operator delete on the module pointer with size 0x30. There is no per-frame game-state write associated with SetDither in this binary; the feature is either not yet implemented or was stripped before release. +// SetDither::RegisterTab / Render RVA 0x180081810 +void SetDither::RegisterTab() { +std::string hdr = MakeString("SetDither", 9); +// Register tab with TabManager (0x18000F7D0) +// Write update fn ptr: [.data+0x2180] = 0x1803B01B0 → 0x180083DC0 (stub) +// Cleanup string, return [.data+0x2180] +} +// Shared no-op Update stub RVA 0x180083DC0 +// Used by SetDither, FreeCam FPS overlay, and SkillHack 'Free Skill' tab +void* NoOpUpdateStub(void* this_ptr, BOOL dirty) { +std::string& s = *(std::string*)((char*)this_ptr + 8); +std::string_destroy(&s); // 0x18000FA60 +if (dirty & 1) { +operator_delete(this_ptr, 0x30); // 0x1800AB758 +} +return this_ptr; +} +## 12.5.1 SetDither::RenderOverlay (RVA 0x8C4A0) +SetDither::RenderOverlay is a separate callable entry point distinct from RegisterTab. It is invoked by the ModuleManager render loop on every Present() frame. The function (0x8C4A0–0x8C70D, 621 bytes) draws the “Set Dither” (i18n key RVA 0x3B0198) panel inside the main cheat overlay. Its control flow follows the standard module pattern: +// SetDither::RenderOverlay RVA 0x18008C4A0 +void SetDither::RenderOverlay(SetDither* this) { +// Tab guard: i18n lookup for "Set Dither" key (RVA 0x3B0198, 10 chars) +std::string tabName = i18n_lookup("Set Dither"); // 0x18000FCB0 +bool open = TabManager_BeginTab(tabName, g_locale); // 0x18009D7D0 +if (!open) { string_destroy(tabName); return; } +// Panel-open: addss [g_Config+0x15D8]+0x194 with [g_Config+0xE0C] +g_Config->panel_state->height += g_Config->dither_panel_height; // expand +// "ON / OFF" toggle bound to [this+0x28] (dither_enabled BOOL) +std::string label = i18n_lookup("ON / OFF"); // RVA 0x3AF848, 8 chars +DitherToggle(label, &this->dither_enabled); // 0x180085320 (rcx=label, rdx=&[rsi+0x28]) +// Panel-close: subss restores height +g_Config->panel_state->height -= g_Config->dither_panel_height; +} +The singleton state block for SetDither is accessed via [g_Config+0x15D8] (pointer to the active game state node at runtime). The field [this+0x28] is the dither_enabled BOOL; the DitherToggle helper at 0x180085320 is the same ImGui toggle helper used by other modules. The “ON / OFF” i18n label at RVA 0x3AF848 distinguishes this from the other modules which use a module-name toggle pattern. +## 12.6 PlayerProfile +Function +RVA +Role +PlayerProfile::RegisterTab +0x1800818E0 +Registers tab, zeroes two std::string fields, stores IL2CPP find fn ptrs +PlayerProfile::Render +0x1800818E0 +Same RVA — tab registration IS the render registration +PlayerProfile::Update +0x18008A4F0 +Per-frame: UI node traversal, SetText on two TMP labels, Name Changer input +PlayerProfile::Update stub +0x18008A4A0 +Destructor wrapper: frees [this+0x50], [this+0x30], [this+0x8], delete(0x78) +PlayerProfile resolves two Unity UI node paths each frame when enabled. The first path '/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text' (RVA 0x3AFED0, len 0x2F) finds the UID display TextMeshProUGUI component and overwrites its text with the content of [this+0x30] (an internal std::wstring). The second path '/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName' (RVA 0x3AFFD0, len 0x8D) finds the name label and overwrites it with [this+0x50]. A 'UID text' input box and a 'Name text' input box are shown in the panel. A 'Name changer' checkbox ([this+0x70]) enables the ManagerName write. RegisterTab zeroes both std::string fields via 0x18000FFF0 (wstring init) and stores find-by-path and get-component IL2CPP function pointers. +// PlayerProfile::Update RVA 0x18008A4F0 +void PlayerProfile::Update() { +std::string hdr = MakeString("PlayerProfile", 13); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +CheckboxToggle(&this->enabled, ...); // ON/OFF → [this+0x28] +if (this->enabled) { +// Resolve UID text node +std::string path1 = "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text"; +void* uid_node = IL2CPP_FindByPath(path1); // 0x18009BCB0 +if (uid_node) { +// Get TextMeshProUGUI component +void* tmp_comp = GetComponent(uid_node, "TextMeshProUGUI"); +if (tmp_comp) { +// SetText(tmp_comp, 0, this->uid_wstring) — [g_Config+0x1E28] +SetText(tmp_comp, 0, &this->uid_str); // 0x1803C6E28 +} +} +// Resolve second name node (for first name label) +// Same pattern: path → find → GetComponent → SetText +// 'UID text' InputText: writes [this+0x30] (displayed uid string) +// call 0x18008AC20 — InputText_wstring wrapper +// 'Name text' InputText: writes [this+0x50] (player name buffer) +// 'Name changer' checkbox → [this+0x70] +if (this->name_changer_enabled) { // [this+0x70] +// Resolve ManagerName node via long world path +void* name_node = IL2CPP_FindByPath( +"/UINode/WorldUIRoot/WatchPanel/.../ManagerName"); +if (name_node) { +void* tmp_comp = GetComponent(name_node, "TextMeshProUGUI"); +if (tmp_comp) { +SetText(tmp_comp, 0, &this->name_str); // [this+0x50] wstring +} +} +} +} +panel-close sequence; +} +## 12.7 Vacuum +Function +RVA +Role +Vacuum::RegisterTab +0x180081A20 +Registers 'Vacuum' tab, stores update fn ptr 0x1803B0680 → 0x180085B40 stub +Vacuum::Render +0x180093CA0 +ImGui panel: 'Vacuum' checkbox + 'Monster' sub-checkbox; panel-width logic +Vacuum::PhysicsLoop +0x180093F10 +Per-frame Rigidbody.AddForce attraction loop over entity list +Vacuum::Update stub +0x180085B40 +Destructor wrapper: frees [this+0x8], optionally delete(0x38) +Vacuum renders two checkboxes: 'Vacuum' ([this+0x28]) and 'Monster' ([this+0x30]). The physics loop at 0x180093F10 runs each frame when any vacuum flag is active. It obtains the camera's position via IL2CPP (Camera.main → transform → position), then iterates all rigidbody entities and applies an AddForce call that pulls each toward the camera origin. The force vector is computed per-entity as: forceX = (entity.x × attractStrength) + camera.x, forceY similarly, forceZ similarly, where attractStrength (xmm8) is loaded from [.rdata+0x1803B32B4] — a compile-time constant. The 'Monster' flag controls whether monster-type entities are included in the iteration. +// Vacuum::Render RVA 0x180093CA0 +void Vacuum::Render() { +std::string hdr = MakeString("Vacuum", 6); +bool open = TabManager_BeginTab(...); +bool clicked = ImGui_Toggle(buf, false); +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// 'Vacuum' checkbox: CheckboxToggle(&this->vacuum_on [+0x28]) +// 'Monster' checkbox: CheckboxToggle(&this->monster_on [+0x30]) +// — Monster sub-checkbox uses panel-open/subss sequence at 0x180093EAC +} +// Vacuum::PhysicsLoop RVA 0x180093F10 (called from physics hook each frame) +// rcx = Vacuum* this, xmm1 = attract_vector, r8 = entity_array +void Vacuum::PhysicsLoop(void* this_ptr, vec3 attract_vec, void** entities) { +if (!this->vacuum_on) return; // [this+0x30] +// Get camera position +void* cam_mgr = g_Config->GetCameraManager(); // [g_Config+0x1D28] +if (!cam_mgr) return; +void* main_cam = cam_mgr->GetMainCamera(); // [g_Config+0x1CF0] +void* cam_rb = main_cam->GetRigidbody(); // [g_Config+0x1D60] +void* cam_pos = cam_rb->GetPosition(0); // [g_Config+0x1DC8] +// cam_pos struct: {double x, double y, int z_int, ...} +double cam_x = cam_pos->x; +double cam_y = cam_pos->y; +int cam_z = cam_pos->z_int; +float attract = *(float*)0x1803B32B4; // compile-time attraction constant +// Iterate entity array (from Vacuum::Update inner call 0x180094000) +for each entity in entities { +if (!entity) continue; +void* rb = GetRigidbody(entity); // [g_Config+0x1DF8] +if (!rb) continue; +vec3 pos = rb->GetPosition(0); // [g_Config+0x1D18] +vec3 force; +// Get entity world position +void* rb2 = GetEntityRoot(entity); // [g_Config+0x1D60] +vec3 rb2pos = rb2->GetWorldPos(0); // [g_Config+0x1DC8] +vec3 rb2pos2 = rb2->GetAltPos(0); // [g_Config+0x1DA8] +vec3 rb3pos = rb2->GetFwd(0); // [g_Config+0x1D90] +// force = attract * rb3pos + camera_pos (component-wise) +force.x = rb3pos.x * attract + cam_x; +force.y = rb3pos.y * attract + cam_y_component; +force.z = rb3pos.z * attract + cam_z_component; +// Rigidbody.AddForce(rb, &force, ForceMode=0) [g_Config+0x1E00] +AddForce(rb, &force, 0); +} +} +## 12.8 SkillHack::Render — Complete Panel Body +Function +RVA +Role +SkillHack::Render +0x18008D1F0 +Hook installer entry: installs six IL2CPP hooks, then falls to panel fn +SkillHack::RenderPanel +0x18008D240 +ImGui panel: 'Free Skill' checkbox + ON/OFF toggle + panel-width sequence +SkillHack::Update +0x180083DC0 +No-op stub (shared with SetDither — no per-frame game write) +SkillHack::Dispatcher +0x18008D4B0 +BOOL hook callback: returns 1 when [SkillHack+0x28] is set +SkillHack::CooldownBypass +0x18008D500 +float hook callback: returns 100.0f when enabled +SkillHack::AvailBypass +0x18008D640 +BOOL hook callback: returns 1 when enabled +SkillHack::CostBypass +0x18008D780 +void hook callback: early-return (skip cost deduction) when enabled +SkillHack::Render at 0x18008D1F0 is a pure hook-installation function — it does not itself draw any ImGui widgets. It installs the six IL2CPP hooks (documented in Section 10) and then tail-jumps to 0x18008D8A0 (the CreateHook wrapper / EnableHook dispatcher). The actual ImGui panel rendering is at 0x18008D240, referenced via the .rdata tab-callback pointer chain. That panel body contains the standard 'SkillHack'/'Free Skill' tab header pair followed by the ON/OFF checkbox and the full panel-width sequence. +// SkillHack::Render RVA 0x18008D1F0 — hook installer, NOT the ImGui panel +void SkillHack::Render() { +// Install hooks on six IL2CPP function pointers (see Section 10) +InstallHook(g_Config->il2cpp_fn[0x1E60], &Dispatcher); // 0x18008D8A0 +InstallHook(g_Config->il2cpp_fn[0x1E68], &Dispatcher); +InstallHook_CooldownBypass(); // 0x18008E220 → 0x18008D500 +InstallHook_AvailBypass(); // 0x18008EBC0 → 0x18008D640 +InstallHook_CostBypass(); // 0x18008F560 → 0x18008D780 +InstallHook(g_Config->il2cpp_fn[0x1E48], &Dispatcher); // tail jmp +} +// SkillHack::RenderPanel RVA 0x18008D240 — actual ImGui panel +void SkillHack::RenderPanel() { +// Tab header: 'Free Skill' (10 chars) via TabManager_BeginTab +bool clicked = ImGui_Toggle(buf, false); // 0x180070820 +if (!clicked) { panel-close sequence; return; } +panel-open sequence; +// Second tab: 'ON / OFF' +bool on_off = TabManager_BeginTab(..., &tmp_str, ...); +CheckboxToggle(&this->enabled, ...); // 0x180085320 → [this+0x28] +if (this->enabled) { +panel-open sequence; // addss path +// (no additional sliders or sub-widgets beyond the toggle) +} else { +panel-close sequence; // subss path +} +// All six hook callbacks read [SkillHack_singleton+0x28] at call time +// — no deferred write needed here +} +## 12.9 Module Render/Update Address Summary +Module +RegisterTab RVA +Render RVA +Update RVA +Update type +Key field offsets +NoClip +0x181300 +0x1813D0 +0x189B50 +Per-frame entity loop +[+0x28] enabled, [+0x30] move_speed (int) +FreeCam +0x181590 +0x1871A0 +0x1871A0 +Per-frame camera override +[+0x28] enabled, [+0x30] move_speed (float), [+0x34] roll_spd, [+0x38] fov_spd, [+0x68/70] cam ptrs +FpsUnlocker +0x181730 +0x185B90 +stub/none +Render-time only +[+0x28] enabled, [+0x30] fps_target (int, default 300) +SetDither +0x181810 +0x181810 +stub/none +No-op +[+0x28] enabled (unused) +PlayerProfile +0x1818E0 +0x18A4F0 +0x18A4F0 +Per-frame UI path walk +[+0x28] enabled, [+0x30] uid_str, [+0x50] name_str, [+0x70] name_changer +Vacuum +0x181A20 +0x193CA0 +0x193F10 +Per-frame AddForce loop +[+0x28] vacuum_on, [+0x30] monster_on +SkillHack +N/A +0x18D1F0 +stub/none +No-op (hook callbacks handle IL2CPP) +[+0x28] enabled (read by all 6 callbacks) +# 13. Gap Closure Status +Gap +Status +Volume Resolved +Notes +Module Update() bodies +COMPLETE +Ch. 22 +ESPModule::Update completed in Ch. 22; all others in Ch. 12 +Module Render() bodies +COMPLETE +Ch. 22 +ESPModule::RenderOverlay completed in Ch. 22; all others in Ch. 12 +ModuleManager main loop +COMPLETE +Ch. 15 +Present hook + module dispatch; see Ch. 15 +GABypass IL2CPP patching +COMPLETE +Ch. 18 +71 function pointers patched; see Ch. 18 +Config file I/O +COMPLETE +Ch. 6 +UTF-8→wide→_wfopen, 'rb'/'wt' +DLL injection (testyip/gatmp) +COMPLETE +Ch. 11 +Temp file injection pattern; see Ch. 11 +Thread enumeration +COMPLETE +Ch. 3 +Toolhelp32 snapshot loop; see Ch. 3 +Anti-debug checks +COMPLETE +Ch. 4 +MSVC CRT only, no active anti-debug; see Ch. 4 +Shader compilation +COMPLETE +Ch. 5 +Two ImGui HLSL shaders, vs/ps 4_0 +SetWindowDisplayAffinity +COMPLETE +Ch. 21 +PreventScreenshot registered module; full analysis in Ch. 21 +ImGui integration +COMPLETE +Ch. 12 +Win32+D3D11 backends; see Ch. 12. Overlay window init (DPI, CreateWindowExW, D3D11CreateDeviceAndSwapChain, message loop, FindGameWindow, GetOverlayRect) see Ch. 29 +Exception handling +COMPLETE +Ch. 4 +MSVC __security_check_cookie; see Ch. 4 +JSON parsing +COMPLETE +Ch. 19 +Full schema, save/load path, and IAT traced; see Ch. 19 +# 14. Definitive Function Address Table +Complete map of all significant functions identified across all twenty-five chapters: +Function / Purpose +VA Start +VA End +Key Operations +DllMain +0x180001000 +- +Entry point, spawns loader thread +LoaderThread +0x180005000 +- +Init IL2CPP, create window, Present hook +ModuleManager::RegisterAll +0x18009AE00 +- +11 modules registered via stubs +ModuleManager::MainLoop +0x180082000 +0x180082300 +Present hook, ImGui render loop +D3D11Init (shaders) +0x180054DC0 +0x1800551E8 +2× D3DCompile, create D3D resources +ImGui Win32+D3D11 Setup +0x180082500 +- +Backend init, WndProc subclass +CollectProcessThreads +0x1800A96B0 +0x1800A9A1C +Toolhelp32 thread enumeration +SuspendOrResumeThreads +0x1800A9A20 +0x1800A9A98 +OpenThread + Suspend/Resume +PatchCode +0x1800A9A9C +0x1800A9BC3 +VirtualProtect + write hook bytes +HookManager::Install +0x1800A9CC8 +- +Alloc trampoline + FNV hash +HookManager::Remove +0x1800A9E8C +- +Remove and restore bytes +HookManager::Enable +0x1800A9A9C +- +Toggle enabled bit + patch +GABypass::Init +0x18009D1E0 +- +71 IL2CPP stubs patched +OpenConfigFile +0x180011EA0 +0x180012043 +_wfopen(UTF8→wide path, mode) +SaveConfig +0x180030620 +0x1800307A0 +fwrite JSON config to disk +ReadConfig +0x1800302D2 +0x180030348 +fread JSON config from disk +ImGuiSaveIni +0x180017078 +0x1800172CA +fwrite ImGui window layout +__security_init +0x1800AC580 +0x1800AC6CA +CRT SEH + IsDebuggerPresent +__security_check_cookie +0x1800AC6CC +0x1800AC77B +Stack canary: magic 0x2B992DDFA232 +NoClip::Render +0x180089B40 +- +CharacterController enable toggle +SkillHack::Render +0x18008D1F0 +- +IL2CPP hook installer +FreeCam::Render +0x180087150 +- +CinemachineBrain override +FpsUnlocker::Render +0x180085B80 +- +Application.targetFrameRate +SetDither::Render +0x18008C490 +- +Graphics dither toggle +PlayerProfile::Render +0x18008A4A0 +- +Unity UI text manipulation +Vacuum::Render +0x180093C90 +- +Monster item collection +ESPModule::Render +0x180083F60 +- +See Ch. 22 (§22.1) +DamageHack (ghost) +N/A (no code) +- +Ghost feature — no code; see Ch. 23 +PreventScreenshot +0x18008B490 +- +SetWindowDisplayAffinity +ESPModule::DrawOverlay +0x180083000 +- +See Ch. 22 (§22.2) +WndProc +0x1800826A0 +- +Win32 message + WM_SIZE/DESTROY handler; see Ch. 7 +SkillHack::Dispatcher +0x18008D4B0 +- +Generic hook dispatcher (2 hooks); see Ch. 10 +SkillHack::FloatReturn +0x18008D500 +- +Hook cb: return 100.0f (float skills); see Ch. 10 +SkillHack::BoolTrue +0x18008D640 +- +Hook cb: return true (bool checks); see Ch. 10 +SkillHack::VoidReturn +0x18008D780 +- +Hook cb: early void return; see Ch. 10 +SkillHack::TrampolineDispatch +0x18008FF00 +- +Common trampoline dispatcher; see Ch. 10 +ModuleManager::Init +0x18009AC10 +- +Construct + register all modules; see Ch. 15 +ModuleManager::DispatchRender +0x18009AE80 +- +Per-frame Render() dispatch loop; see Ch. 15 +ModuleManager::DispatchHotkeys +0x18009AEF0 +- +Per-frame hotkey dispatch; see Ch. 15 +ModuleManager::DispatchRegInit +0x18009AF60 +- +Registrar init dispatcher; see Ch. 15 +ModuleManager::PresentHook +0x180082F00 +- +D3D11 Present hook; calls Render+Hotkey loops; see Ch. 15 +ModulePathScanner +0x18008B650 +- +Scans loaded modules for testyip/gatmp/EF-Cheeto; see Ch. 11 +HookInstallerWrapper +0x18008BAF0 +- +Wraps CreateHook; validates target ptr; see Ch. 11 +StartupSequence +0x1800A9190 +- +DLL loader startup context; see Ch. 11 +ESPModule::Init +0x180083E00 +- +Lazy singleton init; sets color defaults; see Ch. 9 +ESPModule::RenderOverlay +0x180083FA0 +0x18008499E +ImGui ESP panel (full); see Ch. 22 +ESPModule::Update +0x180084A00 +0x1800852A5 +Entity label draw loop; see Ch. 22 +FPSModule::Initialize +0x1800814C0 +- +once_flag guarded init; see Ch. 20 +FPSModule::RenderOverlay +0x180085700 +0x180085900 +FPS panel + overlay counter; see Ch. 20 +PreventScreenshot::Initialize +0x18008AD70 +- +once_flag guarded init; see Ch. 21 +PreventScreenshot::Render +0x18008AE60 +- +ImGui checkbox; see Ch. 21 +PreventScreenshot::Update +0x18008AFC0 +- +SetWindowDisplayAffinity dispatch; see Ch. 21 +PreventScreenshot::OsCheck +0x18008B220 +- +Win10 build check + affinity call; see Ch. 21 +UnityExplorer::RegisterTab +0x180090060 +- +Tab init, scene hierarchy setup; see Ch. 16 +UnityExplorer::Render +0x180090250 +- +Per-frame scene inspector; see Ch. 16 +UnityExplorer::RefreshScenes +0x180090D40 +- +Scene list refresh helper; see Ch. 16 +HookManager::Spinlock +0x1800A9C88 +- +Spinlock acquire/release; see Ch. 8 +WideToString +0x18000EB10 +- +UTF-8 path to wstring for wcsstr; see Ch. 11 +FreeCam::RegisterTab +0x18000F7D0 +- +Registers FreeCam main tab; see Ch. 12 +BaseModule::Dtor +0x18000FA60 +- +Shared dtor: destroy name string + optional delete; see Ch. 12 +NoClip::RegisterTab +0x18000FCB0 +- +Registers NoClip tab; stores update fn ptr; see Ch. 12 +ManagerName::Init +0x18000FFF0 +- +Zeroes std::string fields for ModuleManager name; see Ch. 15 +ConfigSerialize +0x180012050 +- +Serialize config struct to string for fwrite; see Ch. 6 +ImGui::EndFrame +0x18001C2D0 +- +D3D11/ImGui frame boundary EndFrame call; see Ch. 15 +BuildFilePath +0x180030A90 +- +Build config file path string from state+0x50; see Ch. 6 +D3D11::CreateBuffers +0x1800551F0 +- +Create vertex/index buffers post shader compile; see Ch. 5 +ImGui_ImplWin32_WndProcHandler +0x180057720 +- +ImGui Win32 WndProc message handler; see Ch. 7 +FreeCam::SliderFloat +0x180065570 +- +Move Speed SliderFloat (max 500.0f); see Ch. 12 +FreeCam::DragInt +0x180066750 +- +Move Speed DragInt (range 1-10); see Ch. 12 +TabManager::BeginTab +0x180070820 +- +ImGui tab begin + toggle helper; see Ch. 12 +ImGui::Selectable +0x1800708D0 +- +Preset selector; Per-Config preset writer dispatch; see Ch. 17 +SkillHack::GetSingleton +0x180081300 +- +Lazy once_flag singleton init for SkillHack; see Ch. 10 +NoClip::Render +0x1800813D0 +- +ImGui panel: checkbox + Move Speed slider; see Ch. 12 +FPSModule::RegisterTab +0x180081590 +- +Registers FPS Monitor overlay tab; see Ch. 20 +FpsUnlocker::RegisterTab +0x180081730 +- +Registers Fps Unlocker tab; see Ch. 12 +SetDither::RegisterTab +0x180081810 +- +Registers SetDither tab; stores update ptr; see Ch. 12 +PlayerProfile::RegisterTab +0x1800818E0 +- +Registers PlayerProfile tab; see Ch. 12 +Vacuum::RegisterTab +0x180081A20 +- +Registers Vacuum tab; stores update fn ptr; see Ch. 12 +HookManager::GetSingleton +0x180081B00 +- +Thread-safe static singleton init for HookManager; see Ch. 8 +NoOpUpdateStub +0x180083DC0 +- +Shared no-op Update stub (SetDither, SkillHack free); see Ch. 12 +ESPModule::CheckboxToggle +0x180085320 +- +Toggle checkbox helper used in ESPModule panel; see Ch. 22 +NoClip::EntityIterator +0x180089DC0 +- +Entity iterator loop inner call; see Ch. 12 +InputText::WString +0x18008AC20 +- +ImGui InputText wrapper for wstring fields; see Ch. 12 +SkillHack::InstallHooks +0x18008D8A0 +- +Installs 3 hooks via HookInstallerWrapper; see Ch. 10 +SkillHack::PatchFloat +0x18008E220 +- +Installs FloatReturn hook on [g_Config+0x1E50]; see Ch. 10 +SkillHack::PatchBool +0x18008EBC0 +- +Installs BoolTrue hook on [g_Config+0x1E58]; see Ch. 10 +SkillHack::PatchVoid +0x18008F560 +- +Installs VoidReturn hook on [g_Config+0x1E40]; see Ch. 10 +UnityExplorer::GuardReturn +0x1800901D8 +- +Early return after once_flag sealed; see Ch. 16 +ImGui::Begin +0x1800937D0 +- +ImGui::Begin wrapper (Unity Explorer Window); see Ch. 16 +UnityExplorer::AutoRefresh +0x180093B10 +- +Auto-refresh timer check for scene list; see Ch. 16 +Vacuum::PhysicsLoop +0x180093F10 +- +Per-frame entity attraction physics loop; see Ch. 12 +PlayerProfile::FindUINode +0x18009BCB0 +- +IL2CPP_FindByPath for UI text/UID node; see Ch. 12 +TabManager::BeginTabFull +0x18009D7D0 +- +Full BeginTab with state+title resolution; see Ch. 12 +HookManager::FreeSlot +0x1800AA684 +- +Free trampoline + compact hook array; see Ch. 8 +WideStr::wcsstr +0x1800AB6A0 +- +Custom wcsstr for wide path scanning; see Ch. 11 +WideStr::Dtor +0x1800AB758 +- +wstring destructor in path scanner; see Ch. 11 +HotkeyErrorHandler +0x1800AECE0 +- +Hotkey error handler, logs '[hotkey error]'; see Ch. 7 +std::once_flag::Execute +0x1800AFF60 +- +MSVC once_flag _Execute_once; used by UnityExplorer; see Ch. 16 +D3D11::Reinit +0x1800825B0 +- +Recreate D3D11 render target+shaders on WM_SIZE; see Ch. 7 +ModuleManager::RenderFrame +0x180082FC0 +- +ImGui NewFrame + per-module Render dispatch; see Ch. 15 +FpsUnlocker::UpdateStub +0x180085B40 +- +Tab destructor/cleanup wrapper for FpsUnlocker; see Ch. 12 +FpsUnlocker::Render +0x180085B90 +- +ImGui panel: FPS cap checkbox + DragInt; see Ch. 12 +FreeCam::Update +0x1800871A0 +- +Per-frame: CinemachineBrain camera override; see Ch. 12 +NoClip::UpdateStub +0x180089B00 +- +Tab destructor/cleanup wrapper for NoClip; see Ch. 12 +NoClip::Update +0x180089B50 +- +Per-frame: CharacterController.enabled toggle; see Ch. 12 +PlayerProfile::Update +0x18008A4F0 +- +Per-frame: UI node traversal + text injection; see Ch. 12 +UTF8ToWide +0x18008B4E0 +- +MultiByteToWideChar wrapper for path conversion; see Ch. 11 +ModulePathScanner::EFSearch +0x18008B937 +- +wcsstr branch: search for EF-Cheeto.dll in path; see Ch. 11 +SkillHack::RenderPanel +0x18008D240 +- +ImGui panel body after hook install; see Ch. 10 +Vacuum::Render +0x180093CA0 +- +ImGui panel: Vacuum checkbox + monster sub-checkbox; see Ch. 12 +Vacuum::EntityIterator +0x180094000 +- +Inner entity array iteration for item vacuum; see Ch. 12 +HookManager::AllocTrampoline +0x1800A960C +- +Allocate trampoline slot near target VA; see Ch. 8 +UnityExplorer::MemsetBlock +0x1800AC86A +- +Memset 0xD8 bytes at [.data+0x2200] during init; see Ch. 16 +# 15. ModuleManager Dispatch Architecture +Source file: E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp (string at RVA 0x3B0BC0). The ModuleManager is the central runtime controller responsible for: (1) maintaining the registrar list, (2) constructing module instances during Init, (3) dispatching per-frame Render calls from the D3D11 Present hook, and (4) dispatching per-frame hotkey processing. +## 15.1 Key Data Structures +ModuleManager object layout (rcx in all dispatch calls): +struct ModuleManager { +BaseModule** instances_begin; // [+0x00] begin ptr (vector) +BaseModule** instances_end; // [+0x08] end ptr +BaseModule** instances_cap; // [+0x10] capacity ptr +bool initialized; // [+0x18] set to 1 after Init() completes +// [+0x19..+0x1F] padding +// [+0x20..+0x57] registrar list (vector — 0x60-byte stride elements) +}; +Global singleton pointers in .data: +[.data+0x23B8] ModuleManager.instances_begin (registrar slots array begin) +[.data+0x23C0] ModuleManager.instances_end +[.data+0x23C8] ModuleManager.instances_cap +[.data+0x2398] ModuleManager object ptr (passed as rcx to dispatch loops) +[.data+0x23A8] secondary ptr (capacity end) +BaseModule vtable layout (confirmed from factory stubs at 0x9B660–0x9B7A0 and dispatch call sites): +Slot +Offset +Description +Notes +[0] ++0x00 +copy-ctor/factory() +placement-new style ctor; writes vtable ptr, returns this +[1] ++0x08 +copy-ctor/factory() +same as [0] +[2] ++0x10 +Init()/RegisterTab() +jmp stub -> actual RegisterTab fn for the module +[3] ++0x18 +Render() +per-frame UI + game-state dispatch — called by Present hook loop +[4] ++0x20 +~BaseModule() +destructor: frees name string, conditional operator delete +[5] ++0x28 +getNamePtr() +returns &this->name_string (this+0x08) +[6] ++0x30 +onHotkey() +pure virtual (value = 1 sentinel); not implemented in any module +[7] ++0x38 +getLinkedModuleFactory() +returns factory ptr for a paired module (e.g. FpsOverlay) +BaseModule instance layout (from dispatch loop field access and RegisterTab writes): +struct BaseModule { +void* vtable; // [+0x00] +std::string name; // [+0x08] SSO string (24 bytes) +std::string tab_name; // [+0x20] secondary name / tab label +bool enabled; // [+0x28] ON/OFF flag — checked by dispatch loops +// [+0x29..+0x2F] padding +// [+0x30..] module-specific fields (move_speed, fps_target, etc.) +}; +## 15.2 Registrar Lambda Registration (startup) +During DLL initialization (before ModuleManager::Init is called), ten registrar lambdas fire. Each calls ModuleManager::AddRegistrar (RVA 0x9B2C0) passing the module name string and a factory std::function. The registrar slots are pushed into the vector at [.data+0x23B8] with stride 0x60 bytes per slot. Registration order (determined from code order in .text): +Order +Module Name +Registrar code RVA +Factory .rdata RVA +vtable RVA +1 +SetDither +0x001C41 +0x3B0D58 +0x3B0D58 +2 +FreeCam (fps) +0x001C80 +0x3B0E70 +0x3B0E70 +3 +SkillHack +0x001D50 +0x3B0EE0 +0x3B0EE0 +4 +PlayerProfile +0x001E20 +0x3B0D90 +0x3B0D90 +5 +NoClip +0x001EF0 +0x3B0DC8 +0x3B0DC8 +6 +Vacuum +0x001FC0 +0x3B0E38 +0x3B0E38 +7 +UnityExplorer +0x002090 +0x3B0D28 +— +8 +FpsUnlocker +0x001B80 +0x3B0E00 +0x3B0E00 +9 +FreeCam (main) +0x001AB0 +0x3B0E70 +0x3B0E70 +10 +ESPModule +0x001980 +— +— +ModuleManager::AddRegistrar (RVA 0x9B2C0) logic: constructs a std::string from the name argument, calls 0x18000F7D0 (TabManager::RegisterTab), then appends the registrar's std::function wrapper to the instances array. If the vector is full it calls the grow helper at 0x9B3C0. +## 15.3 ModuleManager::Init (RVA 0x9AC10) +Called once from startup sequence (RVA 0xA9190). Guards against double-init via [rcx+0x18] flag. Log messages: 'Initializing ModuleManager' (0x3B0C08) and 'ModuleManager initialization complete' (0x3B0C60). Asserts at source lines 34 and 52 reference ModuleManager.cpp. +Init body: +void ModuleManager::Init(ModuleManager* self) { +if (self->initialized) { +Log('[WARNING] ModuleManager already initialized'); +return; +} +Log('Initializing ModuleManager'); +// Assert (line 34 in ModuleManager.cpp) +// Move instances_begin ptr to match registrar list +rsi = &self->instances_begin; +if (self->instances_begin != self->instances_end) +*rsi = self->instances_begin; +// Wait for std::once_flag at [.data+0x23D0] +// (once_flag guards module instance allocation) +// Iterate registrar array ([.data+0x23B8]..[.data+0x23C0]) +// stride = 0x60 bytes per registrar slot +for (rbx = registrars_begin; rbx < registrars_end; rbx += 0x60) { +std::function* factory = rbx->invoke_ptr; // [rbx+0x58] +BaseModule* mod = factory->operator()(); // vtable[+0x10]() +// Append to instances list +*instances_end = mod; +instances_end += 0x8; +// (grow vector if needed via 0x9B0D0) +// Call vtable[+0x8] on module = getName() +const char* name = mod->vtable[+0x8](mod); +// Log 'Module {name} initialized' +// Log formatted assert (line 45 in ModuleManager.cpp) +assert_log(mod->name, ModuleManager_cpp, line=45); +} +self->initialized = true; +Log('ModuleManager initialization complete'); +// Assert (line 52 in ModuleManager.cpp) +} +## 15.4 Per-Frame Dispatch Loops +Three dispatch functions iterate the instances array each frame. All share the same structure: guard on initialized flag, pointer-chase loop over [begin..end], null check, enabled flag check at [module+0x28], then vtable call. +Dispatch Loop 1 — ModuleManager::DispatchRender (RVA 0x9AE80): +// Called from Present hook with rcx = &ModuleManager (at [.data+0x2398]) +void ModuleManager::DispatchRender(ModuleManager* self) { +if (!self->initialized) return; +BaseModule** it = self->instances_begin; +BaseModule** end = self->instances_end; +while (it != end) { +BaseModule* mod = *it; +if (mod && mod->enabled) // [mod+0x28] != 0 +mod->vtable[0x18](mod); // Render() +it++; +} +} +Dispatch Loop 2 — ModuleManager::DispatchHotkeys (RVA 0x9AEF0): +void ModuleManager::DispatchHotkeys(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod && mod->enabled) +mod->vtable[0x30](mod); // onHotkey() — pure virtual, no-op for all current modules +} +} +Dispatch Loop 3 — ModuleManager::DispatchRegistrarInit (RVA 0x9AF60): +// Called at 0x180083348 — initializes ImGui panel layout after first Present +void ModuleManager::DispatchRegistrarInit(ModuleManager* self) { +if (!self->initialized) return; +for each BaseModule* mod in instances { +if (mod) +mod->vtable[0x38](mod); // getLinkedModuleFactory() — installs linked tab +} +// After loop: copy default panel config block +// movups xmm0, [.data+0x1F08]; movups [.data+0x1F28], xmm0 +// movups xmm1, [.data+0x1F18]; movups [.data+0x1F38], xmm1 +// (16-byte config copy for initial panel state) +} +15.4.1 Exception Handling in Dispatch Loops +The pseudocode above omits the C++ exception-handling wrappers that the compiler generated around each vtable call. Each dispatch loop body is actually enclosed in a __try/__except block; the MSVC runtime (__CxxFrameHandler4, thunk table at RVA 0xAC840, imported from VCRUNTIME140.dll) is registered as the Structured Exception Handler via the .pdata unwind tables. If a module's virtual method throws, the runtime calls one of three catch-handler functions: 0xAEBC0 logs “[ERROR] Failed to update module ‘’” (associated with DispatchRender / Update), 0xAEC50 logs “[ERROR] Failed to render overlay for module ‘’”, and 0xAECE0 logs “[ERROR] Failed to process hotkeys for module ‘’”. All three handlers call the shared logging helper at 0x18000FDA0 (Log/Print) and then resume normally rather than propagating the exception, so a single misbehaving module cannot crash the entire frame. +## 15.5 Present Hook Call Site (RVA 0x082F00) +The Present hook callback contains all three dispatch calls plus the ImGui frame boundary calls. Relevant excerpt (from context around RVA 0x083386): +// 1. DispatchRegistrarInit (once_flag guarded) — installs linked tabs +rcx = &ModuleManager; // [.data+0x2398] +call ModuleManager::DispatchRegistrarInit; // 0x18009AF60 +// 2. DispatchRender — calls Render() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchRender; // 0x18009AE80 +// 3. DispatchHotkeys — calls onHotkey() on all enabled modules +rcx = &ModuleManager; +call ModuleManager::DispatchHotkeys; // 0x18009AEF0 +// 4. Continue to D3D11 frame boundary / ImGui EndFrame +call 0x18001C2D0; +## 15.6 Per-Module vtable[+0x10] and vtable[+0x18] Resolved Targets +vtable[+0x10] = Init/RegisterTab (called once during ModuleManager::Init). vtable[+0x18] = Render (called every frame from DispatchRender). +Module +vtable RVA +vtable[+0x10] target +vtable[+0x18] target +Notes +Vacuum +0x3B0E38 +0x090060 (RegisterTab) +0x09B640 -> [.data+0x05D0] fn ptr +NoClip +0x3B0DC8 +0x081A20 (RegisterTab) +0x09B670 -> [.data+0x06D0] fn ptr +PlayerProfile +0x3B0D90 +0x0813D0 (RegisterTab) +0x09B6A0 -> [.data+0x0580] fn ptr +SkillHack +0x3B0EE0 +0x0818E0 (RegisterTab) +0x09B6D0 -> [.data+0x0770] fn ptr +hook installer +FreeCam +0x3B0E70 +0x081300 (RegisterTab) +0x09B700 -> [.data+0x07D0] fn ptr +SetDither +0x3B0D58 +0x081590 (RegisterTab) +0x09B730 -> [.data+0x0630] fn ptr +no-op +FpsOverlay +0x3B0E00 +0x081810 (RegisterTab) +0x09B760 -> [.data+0x0530] fn ptr +overlay +Note: vtable[+0x18] for each module returns a .data block ptr via a 2-instruction lea/ret stub. This stub serves as the state block accessor used during object cleanup. The actual Render dispatch uses this indirection: the stub returns the module's .data state block, which at offset [+0x00] stores a direct fn ptr to the Render/Update function installed by RegisterTab. The dispatch loop calls the stub (vtable[+0x18]) to get this function pointer, then calls through it. +## 15.7 ModuleManager Log Strings +String +RVA +Context +'[WARNING] ModuleManager already initialized' +0x3B0B88 +Init guard +'Initializing ModuleManager' +0x3B0C08 +Init begin +'Module {} initialized' +0x3B0C48 +Per-module Init success +'ModuleManager initialization complete' +0x3B0C60 +Init end +'Failed to initialize module {}' +0x3B0C28 +Init error handler +'[ERROR] Failed to update module ' +0x3B0C90 +Update error handler +'[ERROR] Failed to render overlay for module ' +0x3B0CB8 +Render error handler +'[ERROR] Failed to process hotkeys for module ' +0x3B0CE8 +Hotkey error handler +ModuleManager.cpp source path +0x3B0BC0 +Assert source file string +# 16. UnityExplorerModule +UnityExplorerModule is a fully implemented, live developer-tool module embedded inside the cheat. It is registered as the final entry in the module list (registration code at RVA 0x002090) and shares the Vacuum vtable (0x3B0E38), inheriting its factory and base dispatch structure. Its RegisterTab function is at RVA 0x090060, its per-frame Update stub points to the shared no-op destructor at RVA 0x083DC0 (same stub as SetDither and SkillHack). The module is not a stub — it contains a complete ImGui-based runtime Unity scene hierarchy browser and component inspector. +## 16.1 Registration and Vtable +The registrar lambda at RVA 0x002090 stores Vacuum's vtable pointer (0x1803B0E38) as the factory and passes the string 'UnityExplorerModule' (RVA 0x3B0D28) to ModuleManager::AddRegistrar. This means during ModuleManager::Init, calling vtable[+0x10] on UnityExplorerModule's registrar invokes Vacuum's RegisterTab stub (RVA 0x9B650), which resolves via jmp to UnityExplorerModule::RegisterTab at RVA 0x090060. The vtable[+0x18] dispatch slot returns [.data+0x2610] — the module's state block — and the per-frame render fn ptr is written there during RegisterTab. +Registration: RVA 0x002090 (AddRegistrar call; factory = Vacuum vtable 0x3B0E38) +RegisterTab: RVA 0x090060 (init; registers tab 'Unity Explorer', zeroes state) +Render: RVA 0x090250 (per-frame ImGui scene/inspector panel) +Update stub: RVA 0x083DC0 (shared no-op; frees string, optional delete) +State block: [.data+0x2610] (0x190 bytes, zero-filled by memset at 0x0900BC) +Tab name: 'Unity Explorer' (string RVA 0x3B02D0) +Window title: 'Unity Explorer Window' (RVA 0x3B02E0) +## 16.2 RegisterTab (RVA 0x090060) +RegisterTab is guarded by a std::once_flag at [.data+0x260C]. On first call it: (1) zero-fills the 0x190-byte state block at [.data+0x2610] via memset (0x1800AC86A); (2) constructs the tab name std::string 'Unity Explorer' and calls TabManager::RegisterTab (0x18000F7D0) to register the ImGui tab at [.data+0x2618]; (3) writes the Update fn ptr (0x1803AFA38 → RVA 0x083DC0, shared no-op stub) to [.data+0x2610]; (4) zeroes all state fields (scene list vector, selected index, refresh flags, auto-refresh bool, interval float, search filter buffer, component list, inspector string); (5) calls std::once_flag::_Execute_once (0x1800AFF60) to seal the guard. On subsequent calls the already-initialized guard causes an early return at 0x1800901D8. +Key state fields initialized during RegisterTab: +[.data+0x2610] update_fn_ptr = 0x083DC0 (no-op stub) +[.data+0x2618] tab_string = 'Unity Explorer' (std::string) +[.data+0x2638] enabled = 0 (bool, OFF by default) +[.data+0x2640] auto_refresh = 0 (bool) +[.data+0x2644] refresh_interval = 3.0f (0x40400000) +[.data+0x2648] scene_list_begin = 0 (ptr, vector) +[.data+0x2650] scene_list_end = 0 +[.data+0x2660] scene_list_cap = 0 +[.data+0x2670] selected_scene_idx = 0 +[.data+0x2680] selected_obj_idx = 0 +[.data+0x2684] search_filter[0x100] = 0 (char buffer) +[.data+0x2784] inspector_active = 0 (bool) +[.data+0x2788] inspected_obj_ptr = 0 +[.data+0x2790] inspected_obj_name = 0 (std::string) +## 16.3 Render / Per-Frame Logic (RVA 0x090250) +The Render function checks enabled ([this+0x28]) and a secondary active flag ([this+0x30]) before drawing. When both are set it calls ImGui::Begin with 'Unity Explorer Window' (RVA 0x3B02E0, via jmp to 0x1800937D0 = ImGui::Begin wrapper). The main function body at RVA 0x0902E0 is a substantial per-frame function that draws the complete inspector UI. +Scene panel logic: +// Check scene list (vector at [this+0x58]..[this+0x60]) +if (scene_list is empty) { +ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +} else { +ImGui::Text("Select Scene:"); +ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +if (combo changed) { LoadScene(selected_scene_idx); } +} +// Writes g_Config->overlay_flags |= 1 and g_Config->overlay_scale = 300.0f +// (at [g_Config+0x1F78] and [g_Config+0x1F90]) when scene panel is active +Auto-refresh logic (RVA 0x090250): +if (enabled && auto_refresh) { +now = GetTime(); // 0x180093B10 +elapsed = now - last_refresh_time; +max_entries = (float)refresh_interval * SCALE_CONST; +if (elapsed_entries >= max_entries) { +RefreshScenes(this); // 0x180090D40 +last_refresh_time = now; +} +} +GameObject hierarchy panel (drawn when a scene is selected): +// Search filter input: ##SearchFilter — writes to search_filter[0x100] buffer +// GameObject list: iterates [this+0x40]..[this+0x48] (vector) +// Per entry: prints '[namespace]: ' prefix + name +// 'Ins##' button beside each entry -> inspect that object +// If list empty: Text('No GameObjects found in this scene.') +// 'DontDestroyOnLoad' section: special scene with fallback text if not found +Inspector panel (when an object is selected via 'Ins' button): +// 'No GameObject selected.' if none +// Otherwise shows: +// 'Active' checkbox (calls GameObject.SetActive via IL2CPP) +// Transform section: Position, Local Position, Rotation, Scale (float3 inputs) +// 'Components' section: 'GameObject Class: %s.%s' +// 'All Components:' list via IL2CPP GetComponents(UnityEngine.Component) +// Per component: '%s.%s' (namespace.classname) +// On fetch failure: 'Unknown Component' or 'Unable to get GameObject class information.' +## 16.4 Complete String Inventory +String +RVA +Usage +'UnityExplorerModule' +0x3B0D28 +Module name (registrar) +'Unity Explorer' +0x3B02D0 +Tab label; ImGui::Begin title +'Unity Explorer Window' +0x3B02E0 +ImGui window title string +'Search Filter:' +0x3B02F8 +Label above search input +'##SearchFilter' +0x3B0308 +ImGui InputText widget ID +'Inspector' +0x3B0318 +Inspector sub-panel label +'GameObjectHierarchy' +0x3B0328 +Hierarchy sub-panel label +'No scenes loaded. Click Refresh...' +0x3B0340 +Empty scene list message +'Scene: ' +0x3B0390 +Scene prefix label +'No GameObjects found in this scene.' +0x3B0398 +Empty hierarchy message +'DontDestroyOnLoad' +0x3B03C0 +Special DDOL scene label +'DontDestroyOnLoad (Not Found)' +0x3B03D8 +DDOL fallback label +'Refresh' +0x3B03F8 +Refresh button label +'Auto Refresh' +0x3B0400 +Auto-refresh checkbox +'Interval (s)' +0x3B0410 +Refresh interval slider label +'Scenes found: %d' +0x3B0420 +Scene count display +"No scenes available. Click 'Refresh Scenes' to load." +0x3B0438 +No-scenes message +'Select Scene:' +0x3B0470 +Scene selector label +'Select Scene' +0x3B0480 +Combo default text +'##SceneCombo' +0x3B0490 +ImGui Combo widget ID +']: ' +0x3B04A0 +Object list entry separator +'Ins##' +0x3B04A8 +Inspect button label prefix +'No GameObject selected.' +0x3B04B8 +Inspector empty state +"Click 'Ins' button..." +0x3B04D0 +Inspector hint text +'Active' +0x3B0508 +Active checkbox label +'Transform' +0x3B0510 +Transform section header +'Position' +0x3B0520 +Position field label +'Local Position' +0x3B0530 +Local position field label +'Rotation' +0x3B0540 +Rotation field label +'Scale' +0x3B054C +Scale field label +'No Transform component found.' +0x3B0558 +Transform fallback message +'Components' +0x3B0578 +Components section header +'GameObject Class: %s.%s' +0x3B0588 +Class display format +'All Components:' +0x3B05A0 +Component list header +'UnityEngine.Component, UnityEngine.CoreModule' +0x3B05B0 +IL2CPP type name for GetComponents +'%s.%s' +0x3B05E0 +Component name format +'Unknown Component' +0x3B05E8 +Component fallback name +'No components found or failed to get components.' +0x3B0600 +Component fetch failure +'Unable to get GameObject class information.' +0x3B0638 +Class info failure +## 16.5 Assessment +UnityExplorerModule is a developer/debug tool that was purpose-built alongside the cheat modules and registered in the same module system. It provides a runtime Unity scene browser — listing loaded scenes, displaying the active GameObject hierarchy with a search filter, and offering a per-object inspector showing Transform (position, rotation, scale), active state, and all attached components retrieved via IL2CPP reflection (GetComponents with 'UnityEngine.Component, UnityEngine.CoreModule' as the type argument). +The module is enabled by the same ON/OFF flag ([module+0x28]) as all other modules and is rendered every frame from the same DispatchRender loop. Its auto-refresh timer (default 3.0s interval, bool at [.data+0x2640], float at [.data+0x2644]) periodically re-enumerates loaded scenes via RefreshScenes (RVA 0x090D40). The g_Config writes inside Render ([g_Config+0x1F78] |= 1, [g_Config+0x1F90] = 300.0f) activate the overlay resize logic while the explorer window is open. +This is the probable origin of the DLL's filename 'unityexplorer.dll' — the binary was named after this embedded developer tool to serve as cover, making the file appear to be a legitimate Unity debugging utility rather than a game cheat. +# 17. Per-Config-Preset Writers +The cheat implements four named configuration presets that write distinct sets of skill-timing and distance-threshold constants into g_Config at runtime. These are not game-version or region variants as originally suspected; they are user-selectable combat automation profiles, each named after a science-fiction reference. The active preset name string is stored at [.data+0x00E0] and the integer index at [.data+0x00EC]. On startup the Settings tab reads both the current theme name and the default preset indicator from the config JSON, compares the theme string against each preset name via ImGui::Selectable (0x1800708D0), and calls the matching writer directly — all four calls reside in a single function at RVA 0x09A4F0. +## 17.1 Dispatch Mechanism +The dispatch logic is in the Settings tab render function at RVA 0x09A4F0. It reads the saved preset name string from the JSON config object (keyed 'Default', 'Evangelion Unit 01', 'Evangelion Unit 02', or 'Matrix'), compares via ImGui::Selectable, stores the matched preset name pointer to [.data+0x00E0], writes the index integer (0–3) to [.data+0x00EC], then calls the corresponding writer immediately. On subsequent frames the startup code at 0x082F02 reads [.data+0x00EC] and re-routes to the same writer if the selection changes: +// RVA 0x082F00 version dispatch +ecx = g_Config->preset_index; // [.data+0x00EC] +switch (ecx) { +case 0: WriterDefault(); // RVA 0x0941F0 +case 1: WriterEvangelionUnit01(); // RVA 0x094890 +case 2: WriterEvangelionUnit02(); // RVA 0x096770 +case 3: WriterMatrix(); // RVA 0x098650 +} +## 17.2 Preset Summary +Preset name +Index +Writer RVA +Write count +g_Config range +'Default' +0 +0x0941F0 +168 +0xDA4 – 0x12A4 +'Evangelion Unit 01' +1 +0x094890 +23 +0xD9C – 0xEBE +'Evangelion Unit 02' +2 +0x096770 +23 +0xD9C – 0xEBE +'Matrix' +3 +0x098650 +13 +0xD9C – 0xE14 +'Default' is the master preset and the only one that writes the full skill-timing table (g_Config offsets 0xEC8–0x12A4). The three non-default presets are thin overlays that write only the distance-threshold and encounter-tuning floats at offsets 0xD9C–0xEBE, leaving the skill-timing table zeroed for their entries. When any non-default preset is active the skill-timing table fields written by Default remain at their last-written values (the table is not re-zeroed between preset switches). +## 17.3 g_Config Field Semantics +The written offsets cluster into two functional groups identified by value range and stride pattern. +Distance / encounter thresholds (offsets 0xD9C–0xE30) — written by all four presets. Values are floats in the range 0.0–21.0, representing game-unit distances. Groups of four consecutive dwords repeat the stride [min_x, min_y, range, limit] observed in ESP module configuration. Example values across presets: +g_Config offset +Default +EvaUnit01 +EvaUnit02 +Matrix +Semantic +0x0D9C +0.0 +1.0 +1.0 +1.0 +Encounter active flag / base threshold +0x0DA0 +0.0 +0.60 +0.60 +0.50 +Approach multiplier +0x0DA4 +10.0 +10.0 +10.0 +8.0 +Max detect range (units) +0x0DA8 +10.0 +10.0 +10.0 +8.0 +Max engage range (units) +0x0DAC +8.0 +4.0 +4.0 +0.0 +Attack range (units) +0x0DB0 +0.0 +0.0 +0.0 +1.0 +Reserved / extra trigger flag +0x0DDC +8.0 +6.0 +6.0 +5.0 +Secondary range A +0x0DE0 +6.0 +4.0 +4.0 +3.0 +Secondary range B +0x0E0C +21.0 +0.0 +0.0 +0.0 +Max AoE range (Default only) +0x0E14 +15.0 +14.0 +14.0 +12.0 +Long-range threshold +Skill timing table (offsets 0xEC8–0x12A4) — written only by the Default preset (168 entries, all zero in the other three presets). Values are floats in the range 0.02–1.0 organized in repeating groups of four dwords: [min_time, max_time, window_end, confidence]. This matches the SkillHack timing parameters documented in Section 8. Each group of four corresponds to one skill slot. The table spans approximately 40 skill slots covering offsets 0xEC8 through 0x1144, with an additional small block at 0x1298–0x12A4. Example timing entries from Default: +// g_Config[0xEC8..0xED7]: Skill slot 0 timing (Default) +[0xEC8] min_time = 0.85f +[0xECC] max_time = 0.85f +[0xED0] win_end = 0.85f +[0xED4] confidence= 1.00f +// g_Config[0xED8..0xEE7]: Skill slot 1 timing (Default) +[0xED8] min_time = 0.50f +[0xEDC] max_time = 0.50f +[0xEE0] win_end = 0.50f +[0xEE4] confidence= 1.00f +// g_Config[0xEE8..0xEF7]: Skill slot 2 timing (Default) +[0xEE8] min_time = 0.05f +[0xEEC] max_time = 0.05f +[0xEF0] win_end = 0.07f +[0xEF4] confidence= 0.90f +// ... continues through ~40 skill slots to 0x1144 +// g_Config[0x1298..0x12A7]: final 4-entry block +[0x1298] min_time = 0.05f +[0x129C] max_time = 0.05f +[0x12A0] win_end = 0.07f +[0x12A4] confidence= 0.73f +## 17.4 Preset Behavioral Differences +The three non-default presets represent incrementally more conservative tuning. 'Evangelion Unit 01' and 'Evangelion Unit 02' are nearly identical — both reduce attack range from 8.0 to 4.0, reduce long-range threshold from 15.0 to 14.0, and set the secondary detection distance lower than Default. The only distinction between the two Evangelion presets is a small float difference at offset 0xDC0/0xDC4 (both 0.50 in Unit 01 vs. both 0.50 in Unit 02 — functionally identical in the parsed output; any distinction would be in fields that were not written by the respective functions and thus retained from previous state). 'Matrix' is the most conservative preset: it lowers attack range to 0.0 (disabling direct attack trigger), cuts max detect range to 8.0, reduces the long-range threshold to 12.0, and sets the extra trigger flag at 0xDB0 to 1.0, suggesting it relies on a different trigger path. +The 'Default' preset is by definition the most aggressive: it provides the only non-zero skill timing table and the widest detection ranges. This is consistent with the binary having version_index = 1 hardcoded at .data+0x00EC at static-init time, meaning 'Evangelion Unit 01' loads on first launch before the user selects a preset from the Settings tab. +## 17.5 Preset Name Strings +String +RVA +Role +'Default' +0x3B06F8 (via 0x3B0AF8) +Preset name, ImGui label, JSON key; also theme name for Default +'Evangelion Unit 01' +0x3B06D0 (via 0x3B0AD4+) +Preset name and JSON key for index 1 +'Evangelion Unit 02' +0x3B0AE0 +Preset name and JSON key for index 2 +'Matrix' +0x3B0B10 +Preset name and JSON key for index 3 +'Theme' +0x3B0AD4 +JSON field name for preset selection +'zh_cn' +0x3B10E8 +Locale string; passed to string-construct at 0x9D8A4 (ecx==1 branch) +'en' +0x3B2020 +Locale string; passed to string-construct at 0x9D890 (ecx==0/2 branch) +The 'zh_cn' and 'en' locale strings at 0x3B10E8 and 0x3B2020 are constructed as std::string values during a JSON key-lookup operation at RVA 0x09D7D0 (called from the Settings tab). The locale is selected by the same integer switch (ecx) that dispatches the preset writers — 0 maps to 'en', 1 maps to 'zh_cn', and 2 falls back to 'en'. This implies the preset index also encodes locale preference: 'Default' (index 0) and the two Evangelion presets and 'Matrix' are treated as CN (index 1) by default, and 'en' is the fallback locale for presets 0 and 2. The locale string is used as the second argument to a JSON object accessor, indicating that config field names are stored locale-keyed in the JSON schema. +# 18. GABypass +GABypass is the IL2CPP function pointer resolution subsystem. Its sole function is to locate the game's IL2CPP runtime module (GameAssembly.dll) in the process address space, then compute and cache the addresses of 71 specific IL2CPP and Unity API methods that the cheat's modules call at runtime. It does not patch instructions, overwrite vtables, or install hooks — it is a pure address-resolution table initializer. The resolved pointers are stored in .data slots at offsets 0x1C48 through 0x1E80 and are subsequently used by every cheat module that makes IL2CPP calls: ESPModule, NoClip, FreeCam, SkillHack, FpsUnlocker, and the UnityExplorer component. +## 18.1 Initialization Sequence +GABypass::Patch (RVA 0x09D1E0) is called exactly once during startup from the main DLL thread at RVA 0x0A942A, immediately after the 'Initializing..' console log and before any module Update() or Render() calls. The call sequence is: +// RVA 0x0A942A (main.cpp line 53, per embedded source path) +Log("Initializing.."); +GABypass::Patch(); // RVA 0x09D1E0 — resolve 71 IL2CPP pointers +il2cpp_domain = [.data+0x1E80](); // call il2cpp_domain_get_assemblies immediately +if (il2cpp_domain != null) { +Log("IL2CPP Domain Found: " + ...); +} +// ... module init continues +Inside GABypass::Patch, execution branches on whether [.data+0x00F0] is already non-null. That slot holds the cached GameAssembly.dll module base address. On first call (cold start), [.data+0x00F0] is zero, so the function calls GetModuleHandleW(L"GameAssembly.dll") via the IAT slot at 0x1800B1290 to obtain the module base, stores it in rdx, then computes all 71 pointers as fixed offsets from that base. On subsequent calls (if Patch is ever called again), [.data+0x00F0] is already populated so the 'GA Bypass successfully!' log and GetModuleHandleW call are skipped and rdx is loaded directly from the cached value before the offset table is re-written. In practice Patch is only called once. +// GABypass::Patch (RVA 0x09D1E0) — annotated +if ([.data+0x00F0] != 0) { +Log("GA Bypass successfully!"); // already cached, log and skip resolve +rdx = [.data+0x00F0]; +goto write_table; +} +rdx = GetModuleHandleW(L"GameAssembly.dll"); // first-run: locate module +write_table: +// 71x: [.data+slot] = rdx + IL2CPP_offset +[.data+0x1C70] = rdx + 0x0018AD80; // il2cpp_object_get_class +[.data+0x1C78] = rdx + 0x00007480; // il2cpp_class_get_method_from_name +[.data+0x1E70] = rdx + 0x00D94C10; // il2cpp_domain_get +[.data+0x1E78] = rdx + 0x00D94DA0; // il2cpp_assembly_get_image +[.data+0x1E80] = rdx + 0x00D93A60; // il2cpp_domain_get_assemblies +// ... 66 additional Unity/game method pointers +ret +## 18.2 The 71-Entry Pointer Table +Each entry is a QWORD at a fixed .data offset. The IL2CPP offset column is the byte distance from the GameAssembly.dll module base to the target function — these are static, computed at compile time from a known game binary version. The table spans two contiguous .data regions: 0x1C48–0x1CF8 (IL2CPP runtime and UnityEngine core) and 0x1D00–0x1E80 (game-specific methods, additional Unity API, UI/camera). +# +.data offset +IL2CPP offset +Resolved function +Used by +1 +0x1C48 ++0x09DC0120 +GameObject.GetComponentByIndex +UnityExplorer inspector +2 +0x1C50 ++0x0018CEC0 +il2cpp_domain_get_assemblies (A) +GABypass init / UnityExplorer +3 +0x1C58 ++0x0B390700 +Component.GetComponent +UnityExplorer / NoClip +4 +0x1C60 ++0x0B3A2D20 +Transform.get_localScale +UnityExplorer inspector +5 +0x1C68 ++0x0B3A2CB0 +Transform.get_rotation +UnityExplorer inspector +6 +0x1C70 ++0x0018AD80 +il2cpp_object_get_class +UnityExplorer type query +7 +0x1C78 ++0x00007480 +il2cpp_class_get_method_from_name +UnityExplorer method lookup +8 +0x1C80 ++0x0B3A1AE0 +Transform.get_localPosition +UnityExplorer / NoClip +9 +0x1C88 ++0x0B3A1A70 +Transform.get_position +ESP / NoClip +10 +0x1C90 ++0x0B3A51D0 +Transform.set_localPosition +NoClip teleport +11 +0x1C98 ++0x0B398830 +GameObject.SetActive +UnityExplorer / NameChanger +12 +0x1CA0 ++0x0B3911F0 +GameObject.get_transform +ESP / NoClip +13 +0x1CA8 ++0x0B3A59D0 +Transform.set_rotation +FreeCam / NoClip +14 +0x1CB0 ++0x0B391D90 +GameObject.get_activeInHierarchy +UnityExplorer inspector +15 +0x1CB8 ++0x0B3B2410 +GameObject.get_tag +UnityExplorer inspector +16 +0x1CC0 ++0x0B3B2120 +GameObject.get_name +UnityExplorer inspector +17 +0x1CC8 ++0x0B3B40B0 +GameObject.get_layer +UnityExplorer inspector +18 +0x1CD0 ++0x0B397980 +GameObject.get_scene +UnityExplorer inspector +19 +0x1CD8 ++0x02F3DA80 +Game: skill/buff method A +SkillHack +20 +0x1CE0 ++0x00F27E10 +Game: skill/buff method B +SkillHack +21 +0x1CE8 ++0x0B329000 +Component.GetComponents +UnityExplorer component list +22 +0x1CF0 ++0x0B329D80 +Component.GetComponentsInChildren +UnityExplorer tree walk +23 +0x1CF8 ++0x03E9BB50 +Game: skill/ability slot method A +SkillHack +24 +0x1D00 ++0x0B383F60 +Object.get_name +UnityExplorer name display +25 +0x1D08 ++0x0B33CAB0 +Component.GetType (A) +UnityExplorer type display +26 +0x1D10 ++0x0B33CB00 +Component.GetType (B) +UnityExplorer type display +27 +0x1D18 ++0x039D1AA0 +Game: skill/ability slot method B +SkillHack +28 +0x1D20 ++0x026DE9F0 +Game: combat/hit method A +SkillHack / combat +29 +0x1D28 ++0x0478E860 +Game: UI show/hide toggle +NoClip / FpsUnlocker UI +30 +0x1D30 ++0x025E2D40 +Game: combat/hit method B +SkillHack / combat +31 +0x1D38 ++0x087C2CD0 +Game: movement/physics method A +NoClip CharacterController +32 +0x1D40 ++0x03419AF0 +Game: movement/physics method B +NoClip CharacterController +33 +0x1D48 ++0x0B322FB0 +SceneManagement.Scene.get_name +UnityExplorer scene display +34 +0x1D50 ++0x0B396A20 +SceneManager.GetActiveScene +UnityExplorer scene query +35 +0x1D58 ++0x0B397700 +CinemachineBrain.get_ActiveVirtualCamera +FreeCam hook +36 +0x1D60 ++0x03766810 +Game: entity/actor state method A +ESP / SkillHack +37 +0x1D68 ++0x0B3A2A60 +Transform.set_localScale +UnityExplorer inspector +38 +0x1D70 ++0x0B326660 +Rigidbody.get_velocity +NoClip / Vacuum +39 +0x1D78 ++0x0B3266B0 +Rigidbody.set_velocity +NoClip / Vacuum +40 +0x1D80 ++0x0B383200 +Object.Destroy +UnityExplorer +41 +0x1D88 ++0x0B3A1A10 +Transform.set_position +NoClip teleport / Vacuum +42 +0x1D90 ++0x0B3A2340 +Game: entity/actor state method B +ESP +43 +0x1D98 ++0x0B421800 +Input.GetAxis('Mouse X') +FreeCam look X +44 +0x1DA0 ++0x0B3A26D0 +Game: player state method A +ESP / SkillHack +45 +0x1DA8 ++0x0B3A1FB0 +Game: player state method B +ESP / SkillHack +46 +0x1DB0 ++0x0B32B030 +Game: player health/stat accessor +ESP health display +47 +0x1DB8 ++0x0B391240 +GameObject.SetActive (CinemachineBrain active flag) +FreeCam enable/disable +48 +0x1DC0 ++0x0B390440 +Camera.get_main +ESP worldToScreen / FreeCam +49 +0x1DC8 ++0x0B390F80 +GameObject.FindObjectOfType +Active scene object scan +50 +0x1DD0 ++0x0B3A19A0 +Transform.get_position (2nd ref) +ESP / NoClip +51 +0x1DD8 ++0x03F85430 +Game: skill/action method C +SkillHack +52 +0x1DE0 ++0x0B3A1D30 +Transform.set_rotation (2nd ref) +FreeCam / NoClip +53 +0x1DE8 ++0x0B3A1C90 +Camera.get_fieldOfView +FreeCam FOV control +54 +0x1DF0 ++0x00E92CF0 +Game: entity/actor state method C +ESP +55 +0x1E00 ++0x03DC14C0 +Game: skill/action method D +SkillHack +56 +0x1E08 ++0x03E0D2C0 +Game: skill/action method E +SkillHack +57 +0x1E10 ++0x03D9DF30 +Game: skill/action method F +SkillHack +58 +0x1E18 ++0x00E9E9F0 +Game: skill/action method G +SkillHack +59 +0x1E20 ++0x03EA53C0 +Game: skill/action method H +SkillHack +60 +0x1E28 ++0x0ACA0EC0 +TMPro.TextMeshProUGUI.set_text +Name changer UI label +61 +0x1E30 ++0x0B391D40 +UnityEngine.UI.Text.set_text +ON/OFF toggle labels / Name changer +62 +0x1E38 ++0x036AA8F0 +Game: skill/action method I +SkillHack +63 +0x1E40 ++0x03EC31C0 +Game: skill/action method J +SkillHack +64 +0x1E48 ++0x037F8CD0 +Game: entity/actor method D +ESP / combat +65 +0x1E50 ++0x036EA640 +Game: skill/action method K +SkillHack +66 +0x1E58 ++0x03EC30E0 +Game: skill/action method L +SkillHack +67 +0x1E60 ++0x037F2A40 +Game: entity/actor method E +ESP / combat +68 +0x1E68 ++0x037FD7E0 +Game: entity/actor method F +ESP / combat +69 +0x1E70 ++0x00D94C10 +il2cpp_domain_get +UnityExplorer domain probe +70 +0x1E78 ++0x00D94DA0 +il2cpp_assembly_get_image +UnityExplorer assembly walk +71 +0x1E80 ++0x00D93A60 +il2cpp_domain_get_assemblies (B) +Post-patch domain probe (main.cpp:67) +## 18.3 Functional Grouping +The 71 entries divide into four functional groups. Six entries (slots 2, 6, 7, 69, 70, 71) are IL2CPP runtime API functions — the low-level metadata accessors that the cheat uses to walk the IL2CPP type system for the UnityExplorer inspector. Their offsets are clustered near the start of GameAssembly.dll (+0x0007480, +0x0018AD80, +0x0018CEC0, +0x00D93A60, +0x00D94C10, +0x00D94DA0), consistent with early-loaded IL2CPP initialization code. +Thirty-four entries are UnityEngine managed API methods — Transform, GameObject, Component, Camera, Rigidbody, SceneManager, and Object — that provide the cheat with Unity scene graph access, world-space position manipulation, and object lifecycle control. These are used across all active modules: ESP calls position/camera methods every frame, NoClip writes to Transform.set_position and Rigidbody.set_velocity, FreeCam uses Camera.get_fieldOfView and CinemachineBrain.get_ActiveVirtualCamera, and the UnityExplorer inspector uses the full component introspection set. +Twenty-six entries are game-specific methods at offsets deep into GameAssembly.dll (+0x02F3DA80 and above), most concentrated in the 0x03xxxxxx–0x0Bxxxxxx range. Twelve of these are identifiable SkillHack targets (slots 19–20, 23, 27–28, 30, 51, 55–59, 62–66) — the methods responsible for skill cooldown, buff application, and action validation that SkillHack intercepts or spoofs. The remaining game-specific entries cover combat hit methods, movement/physics controllers, entity state accessors, and player stat readers used by the ESP and combat modules. +Five entries cover additional UI and camera libraries: Cinemachine (slot 35, CinemachineBrain), TextMeshPro (slot 60, TextMeshProUGUI.set_text), and legacy Unity UI (slot 61, UnityEngine.UI.Text.set_text). These are used exclusively by the Name Changer module and the FreeCam camera management code. +## 18.4 Version Sensitivity +All 71 IL2CPP offsets are hard-coded at compile time as fixed displacements from the GameAssembly.dll base. There is no runtime method name lookup, no FNV hash scan, and no fallback if an offset is wrong — if the game updates and shifts any of these methods, the corresponding cheat feature silently malfunctions (calling into an arbitrary address). The SkillHack module uses a separate FNV-1a name-hash lookup path (documented in Section 8) as a secondary resolution mechanism for its core hook target, but the 26 game-specific GABypass entries have no such fallback. This architecture implies the binary is built and tested against a specific pinned game version; the version-selector system documented in Section 15 may exist partly to accommodate minor offsets shifts across game build variants, but the offsets themselves are not adjusted per variant. +# 19. JSON Config Schema and Save/Load System +This chapter resolves the config-schema investigation. The binary does not implement a standalone .json config file. All cheeto settings persistence is handled through ImGui’s built-in .ini settings mechanism, augmented with per-module custom settings handlers registered at runtime. +## 19.1 IAT — File I/O Functions (Complete Resolution) +The PE import table was fully parsed this session, resolving every previously unidentified IAT slot relevant to file I/O and config: +IAT[0xB1268] = GetCurrentThreadId (stack cookie check at 0xAC709, NOT file I/O) +IAT[0xB1278] = VirtualFree +IAT[0xB1288] = VirtualProtect +IAT[0xB1178] = GetConsoleWindow (used in Settings tab Toggle Console) +IAT[0xB1628] = ShowWindow (used in Settings tab Toggle Console) +IAT[0xB1858] = fread (file read, called ONLY from 0x12121) +IAT[0xB1868] = fwrite (called from 0xEA1B, 0x170D6, 0x3033B, 0x3076D) +IAT[0xB1870] = fclose (called from 0xEAB0, 0x1212F, 0x121A9, 0x170DF etc.) +IAT[0xB1888] = _wfopen (wide-char file open, called ONLY from 0x11F93) +IAT[0xB1890] = fseek (called from 0x120BC, 0x120E7) +IAT[0xB1898] = ftell (called from 0x120A0, 0x120CD) +## 19.2 No Standalone JSON Config File +Exhaustive scanning of the binary confirmed no .json filename string exists anywhere in rdata or .data. The config system is the standard ImGui .ini persistence layer. All module settings are serialized through ImGui’s settings-handler API, not a JSON library. The nlohmann::json_abi_v3_12_0 library present in the binary is used exclusively for the i18n translation table, not for config I/O. +## 19.3 Config File: imgui.ini +The config filename “imgui.ini” (RVA 0x3ABB60) is set at RVA 0x1117A into ImGuiIO+0x20 (the IniFilename field) during ImGuiIO initialization. The log filename “imgui_log.txt” (RVA 0x3ABB70) is set into ImGuiIO+0x28 at the same site. Both are written relative to the process working directory at runtime. +## 19.4 Save/Load Trigger and Execution Path +Load path (on startup): RVA 0x30661 calls the file-read helper at 0x12050, which executes ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell again (0x120CD) → malloc → fread (0x12121) → fclose (0x1212F). The buffer is passed to 0x30840 (ParseIniSettingsFromMemory), which walks the handler list at [ImGuiContext+0x2920] calling each registered handler’s ReadLine callback. +Save path (periodic): The render loop checks [ImGuiContext+0x2900] (dirty flag, byte) and [ImGuiContext+0x2904] (float countdown timer). When both conditions are met, RVA 0x30A90 (SaveIniSettingsToDisk) builds the path from [ImGuiContext+0x2910] (custom IniFilename) or falls back to [.data+0x1BEC]. It calls each handler’s WriteAll callback, then passes the buffer to 0x11EA0 (_wfopen wrapper with “wt” mode at RVA 0x1803AD594), fwrite (0x3076D), and fclose (0x30776). The manual save trigger at RVA 0x17072 sets [ImGuiContext+0x2900]=1 and [ImGuiContext+0x2904]=0 to force an immediate write. +## 19.5 i18n Translation Table (Clarification) +The blob starting at RVA 0x3B10E8 is the compile-time JSON localization table, not the config schema. It is a single JSON object mapping English UI label strings to Chinese (zh_cn) equivalents. At startup (RVA 0x2164), a std::string constructor copies this blob (length 0xEED bytes) into [.data+0x1EB8]. The i18n loader at RVA 0x9D660 selects either “en” or “zh_cn” values based on the language toggle flag. The nlohmann runtime type-error strings (object, array, null, string, number, parse_error etc.) at 0x3B3010–0x3B30D8 confirm nlohmann v3.12.0 is statically linked. +The “enabled” string at RVA 0x3B0B28 is one of these UI labels; it is used to display the module on/off state in the GUI and is not a JSON config key. +## 19.6 Module Settings Handler Architecture +Each module registers a settings handler at [ImGuiContext+0x2920] (a dynamically-grown array of 0x48-byte handler structs). The handler struct layout (from RVA 0x30904): ++0x00 TypeName (const char*) — section identifier in .ini file ++0x08 TypeHash (u32) — CRC32 of TypeName (computed at 0x3079C–0x30803) ++0x18 ReadOpenFn — called when section header encountered ++0x38 WriteAllFn — called during save to emit key=value lines +The 11 registered module classes identified from RTTI at .data+0x0590–0x0E60 are: ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule. +## 19.7 ModuleManager Lifecycle +ModuleManager::Init (RVA 0x9ACA4) iterates the module registry at [.data+0x23B8], calls vtable[+0x10] to obtain each module instance, then vtable[+0x08] to initialize it. Each initialized module is logged as “Module {} initialized” (string at RVA 0x3B0C48). Completion is logged as “ModuleManager initialization complete” (RVA 0x3B0C60). The per-frame dispatch methods are vtable[+0x18] (Update, iterated at 0x9AE80) and vtable[+0x30] (RenderOverlay, iterated at 0x9AEF0). Both iterate the same module list checking [module+0x28] (enabled flag) before calling the virtual. +## 19.8 Settings Tab Behavior +Settings::RenderOverlay (RVA 0x9A4F0–0x9AB98, source E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp) handles: language toggle via 0x9D660 (reads [.data+0x1EB8] i18n blob, selects “en” or “zh_cn” values); theme color initialization via 0x98650 (parses hex color strings e.g. “00FF41FF” from rdata into [.data+0x1C00+0xD9C..] float RGBA fields); console window toggle via GetConsoleWindow (IAT[0xB1178]) and ShowWindow (IAT[0xB1628]). There are no Save/Load buttons; settings are persisted automatically by the ImGui .ini mechanism on each render frame that detects a dirty flag. +# 20. FPSModule +FPSModule implements two independent features controlled by the “FPS Monitor” tab in the GUI: an in-game FPS counter overlay and a separate FPS cap unlocker. The RTTI decorated name is .?AVFPSModule@@ (RVA 0x3C5CF8). The module name string “FPS Monitor” resides at RVA 0x3AFA88; “Show FPS Overlay” at 0x3AFA98; the overlay prefix string “FPS: ” at 0x3AFAAC. +## 20.1 Registration and Vtable +The registrar constructor references the name string at RVA 0x1B71 and calls the module registry at 0x9B2C0. Two vtable blocks are emitted. The lambda vtable (for the registrar’s std::function wrapper) lives at 0x3B0E00; the module instance vtable is at 0x3B0E38. The singleton object is heap-allocated and its pointer cached at [.data+0x22E0] (VA 0x1803C72E0). +Instance vtable (0x3B0E38): +[+0x00] 0x9B660 dtor +[+0x08] 0x9B660 dtor (scalar deleting) +[+0x10] 0x9B650 Initialize -> jmp 0x90060 +[+0x18] 0x9B640 GetSingleton -> returns [.data+0x05D0] +[+0x20] 0x9B620 dtor with size 0x10 +[+0x28] 0x9B630 GetSelf -> lea rax,[rcx+8]; ret +[+0x38] 0x9B720 vtable setter (returns ptr to 0x3B0E70) +[+0x48] 0x9B710 Update -> jmp 0x81300 +## 20.2 Initialize (RVA 0x814C0) +Guarded by a once_flag at [.data+0x2310]. On first call it allocates the module object (0xD8 bytes via 0xAC86A), stores the vtable pointer from 0x3AFA38 into [.data+0x22E0], copies the name string “FPS Monitor” into [.data+0x22E8], sets enabled = 0x0 at [.data+0x2308], then overwrites the vtable slot with the render-function pointer from 0x3AFAC0. If already initialized the singleton pointer is returned early from [.data+0x22E0]. +## 20.3 RenderOverlay — Panel (RVA 0x85660; inner ImGui branch at 0x856F0) +The panel render function is called by ModuleManager::RenderOverlay. It renders two ImGui checkboxes inside the “FPS Monitor” collapsing header. The first checkbox (“FPS Monitor”, bound to [module+0x28]) toggles the FPS counter overlay; on state change it sets [ImGuiContext+0x2900]=1 (dirty flag) and resets the ini-save timer. The second checkbox (“Show FPS Overlay”, RVA 0x3AFA98) is bound to [module+0x28] via 0x85320 (Checkbox with state-ptr helper) and controls display of the overlay window. After both checkboxes, the function calls ImGui::EndDisabled via [ImGuiContext+0x27F0] WORD counter decrement. +## 20.4 RenderOverlay — FPS Counter Overlay (RVA 0x858D0) +When the FPS overlay is enabled ([module+0x28] != 0), this function draws a frameless ImGui window labelled “##Foreground” (RVA 0x3ABF10) pinned to the top-left of the viewport. It calls [.data+0x1D38] (GetDeltaTime via ImGuiContext) with rcx=0, computes xmm6 = 1.0 / deltaTime (i.e. current FPS), builds the display string “FPS: ” + integer FPS value (via 0x7F5C0), then selects a text color from three XMMWORD constants based on two hard-coded thresholds: +fps >= 60 -> color constant at 0x1803B3530 (green) +30 <= fps < 60 -> color constant at 0x1803B3540 (yellow) +fps < 30 -> color constant at 0x1803B3510 (red) +The colored FPS string is then submitted to the ImGui drawlist via 0x51580 (AddText with explicit color). The overlay window uses ImGui foreground drawlist accessed through [ImGuiContext+0x15D8]+0x40. +## 20.5 Singleton State Layout +FPSModule singleton base address: [.data+0x22E0] (VA 0x1803C72E0). Object size: 0xD8 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3AFAC0 after init) ++0x08 std::string name = "FPS Monitor" ([.data+0x22E8]..[.data+0x2307]) ++0x28 BYTE enabled (0 = disabled; written at [.data+0x2308]) ++0x30 BYTE show_fps_overlay (checkbox state for "Show FPS Overlay") ++0x60 XMMWORD (overlay window position/size, zeroed on init) +# 21. PreventScreenshot +PreventScreenshot prevents the game window from being captured by screen-recording tools. RTTI: .?AVPreventScreenshot@@ (RVA 0x3C5DA8). GUI label: “Prevent Screenshot” (RVA 0x3B00B8). The module uses the Windows API SetWindowDisplayAffinity (string at .data RVA 0x3C34A6, imported dynamically from user32.dll at RVA 0x3AEC70) with a Windows 10 build check before applying the affinity flag. +## 21.1 Registration and Vtable +Singleton pointer cached at [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. Once_flag at [.data+0x2390]. Two boolean state fields: [.data+0x2380] = enabled (BYTE, 0 on init), [.data+0x2388] = second toggle flag (BYTE, 0 on init). +## 21.2 Initialize (RVA 0x8AD70) +Guarded by a once_flag at [.data+0x2390]. On first call: constructs the std::string name “Prevent Screenshot” at [.data+0x2360], stores base vtable ptr 0x3AFA38 at [.data+0x2358], overwrites with second vtable ptr from 0x3B0110, zeroes both bool fields at [.data+0x2380] and [.data+0x2388]. +## 21.3 RenderOverlay (RVA 0x8AE60) +Calls GetInstance (0x8AD70) to obtain the module pointer. Renders a single ImGui checkbox “Prevent Screenshot” via 0x9D7D0 (toggle-checkbox helper) with state pointer [module+0x28] (enabled bool). The result is passed to 0x61FE0 (ImGui::Checkbox state commit), then ImGui::EndDisabled is called via the [ImGuiContext+0x27F0] WORD counter path (with an assertion for “Calling EndDisabled() too many times!” at 0x3AC160 if the counter is already zero). +## 21.4 Update — SetWindowDisplayAffinity Dispatch (RVA 0x8AFC0) +Called per-frame by ModuleManager::Update. The logic is: +1. Call GetInstance (0x8AD70) -> rbp = module object ptr +2. If [rbp+0x30] already set: skip (module not yet enabled) +3. If [rbp+0x28] (enabled) set: walk the hook/window list at [.data+0x24D0] +4. For each node [rbx+0x10]: call 0x8B220 (OS-version-checked affinity setter) +5. Call 0x81B00 (build HWND list), then 0x869A0 (apply affinity to all HWNDs) +## 21.5 OS Version Check and SetWindowDisplayAffinity (RVA 0x8B220) +This function loads ntdll.dll (via IAT[0x1800B1290]), resolves “RtlGetVersion” (IAT[0x1800B1088]), and fills a 0x11C-byte OSVERSIONINFOEXW struct on the stack. The OS build number (OSVERSIONINFOEXW.dwBuildNumber) is then cached at [.data+0x24FC] after being memcpy’d into [.data+0x24F0]. On subsequent calls, the cached value is used directly. +The affinity call at 0x8B48F reads [rbp+0x28] (enabled bool) and compares the cached build number against 0x4A61 (decimal 19041, Windows 10 Build 19041 = version 20H1). Two code paths result: +build < 19041: affinity arg = (enabled ? 1 : 0) (WDA_MONITOR = 1) +build >= 19041: affinity arg = (enabled ? 0x11 : 0) (WDA_EXCLUDEFROMCAPTURE = 0x11) +The resolved SetWindowDisplayAffinity function pointer is called via IAT[0x1800B1460]. On pre-20H1 builds, WDA_MONITOR (0x1) is used, which prevents the window from appearing in screen captures taken via the PrintScreen key but not via capture APIs. On 20H1 and later, WDA_EXCLUDEFROMCAPTURE (0x11) is used, which prevents capture by all recording tools including OBS and the Windows Game Bar. The “SetWindowDisplayAffinity” string stored at .data RVA 0x3C34A6 is used as the GetProcAddress argument for the dynamic resolve. +## 21.6 Singleton State Layout +PreventScreenshot singleton base: [.data+0x2358] (VA 0x1803C7358). Object size: 0x48 bytes. ++0x00 vtable ptr (0x3AFA38 / 0x3B0110 after init) ++0x08 std::string name = "Prevent Screenshot" ([.data+0x2360]..[.data+0x237F]) ++0x28 BYTE enabled (checkbox state; drives affinity arg) ++0x30 BYTE state_dirty (set=1 when affinity has been applied; guards re-apply) ++0x38 BYTE second_flag ([.data+0x2388]; purpose unclear, zeroed on init) +The HWND target list at [.data+0x24D0] is a doubly-linked list of window handles to which the affinity is applied. The list is populated by 0x81B00 (enumerate Unity windows) and walked by the Update loop. The count of registered HWNDs is tracked at [.data+0x24D8]. +# 22. ESPModule Render and Update Implementation +Chapter 9 established ESPModule’s state layout and color-table defaults. This chapter documents the two remaining vtable slots not covered there: RenderOverlay (the ImGui control panel) and Update (the per-frame world-space entity label loop), both of which were only identified during the current analysis pass. +## 22.1 RenderOverlay (RVA 0x83FA0) +RenderOverlay is a large, monolithic function spanning roughly 0x83FA0–0x8499E. It draws the “ESP Features” collapsing header and all subordinate controls using the same once-lock + ImGui state machine pattern documented in FPSModule (Chapter 20). The function uses rsi throughout as the ESPModule singleton pointer (base VA 0x1803C6F70). +The function opens a CollapsingHeader titled “ESP Features” (string RVA 0x3AF838) via helper 0x9D7D0 with its state bound to [.data+0x27B0]. If collapsed, execution jumps directly to the epilogue. When expanded, the first control rendered is an “ON / OFF” checkbox (string RVA 0x3AF848) via helper 0x85320; its bool is bound to [rsi+0x28] (enabled). If enabled is false, the remainder of the panel still renders but ImGui’s BeginDisabled path dims and suppresses all interaction. +The “Display Types” sub-header (string RVA 0x3AF858) is rendered via 0x6EC20, which is a lightweight CollapsingHeader wrapper that returns false immediately when ImGui’s locked-input flag ([ImGuiContext+0x106]) is set. When expanded, it presents four entity visibility checkboxes, each bound via 0x61FE0 (ImGui::Checkbox commit helper): +“Show Monsters” (RVA 0x3AF868) → [rsi+0x34] show_monsters +“Show NPC” (RVA 0x3AF878) → [rsi+0x35] show_npc +“Show Friendly” (RVA 0x3AF888) → [rsi+0x36] show_friendly +“Show Puzzles” (RVA 0x3AF898) → [rsi+0x37] show_puzzles +“Show All” (RVA 0x3AF8A8) → [rsi+0x38] show_all +After the Show All checkbox, a Separator is emitted via 0x70630 (which also adjusts the cursor Y position). A second sub-header, “Display Info” (RVA 0x3AF8B8), follows the same 0x6EC20 pattern. When expanded, it reveals the per-label visibility checkboxes: +“Show Distance” (RVA 0x3AF8C8) → [rsi+0x39] show_distance +“Show Name” (RVA 0x3AF8D8) → [rsi+0x3A] show_name +“Show Type” (RVA 0x3AF8E8) → [rsi+0x3C] show_type +A second Separator call via 0x70630 closes the Display Info block. The function epilogue at 0x84984–0x8499E restores the ImGui cursor Y, pops the saved XMM registers, and returns. +## 22.2 Update / DrawOverlay (RVA 0x84A00) +Update is the per-frame entity rendering loop. It is guarded at entry (0x8499F) by a two-instruction stub that tests [rcx+0x28] (enabled) and returns immediately if clear, so the entire loop is skipped when the module is disabled. The main body at 0x84A00 proceeds as follows. +Initialization: the function calls the GetEntityManager cached pointer ([.data+0x1D28], xor ecx, ecx) and GetEntityList ([.data+0x1D30]), both resolved by GABypass. It also calls GetScreenResolution ([.data+0x1D18]) into a local {float2, int} struct, and GetCameraPosition ([.data+0x1D00]) to build a world-origin vector. If the entity count at [rax+0x20] is zero, execution jumps to the epilogue at 0x852AB. +Per-entity loop (0x84B30–0x852A5): for each entity pointer in the array, the function calls GetEntityType ([.data+0x1D20], xor edx edx) and dispatches on the returned type code. The dispatch also loads the per-type color XMMWORD directly from the ESPModule object at a type-dependent offset, and selects the corresponding visibility-flag byte: +type 0x08 → color [rdi+0x70] GREEN (0.00, 1.00, 0.00) flag: show_friendly [rdi+0x36] +type 0x10 / 0x4010 → color [rdi+0x40] RED (1.00, 0.00, 0.00) flag: show_monsters [rdi+0x34] +type 0x20 → color [rdi+0x50] ORANGE (1.00, 0.65, 0.00) flag: show_puzzles [rdi+0x37] +type 0x100 → color [rdi+0x80] BLUE (0.00, 0.00, 1.00) flag: show_npc [rdi+0x35] +default → color [rdi+0xB0] WHITE (1.00, 1.00, 1.00) flag: show_all [rdi+0x38] +Visibility gating: for named types the check is (show_all OR type_flag) != 0; for the default case only show_all is tested. If the entity fails the gate, execution jumps to the loop increment at 0x85289. +Screen-space projection: GetScreenPosition ([.data+0x1CF8]) is called with the entity world position and camera origin to produce a {float2, float} screen-coord struct. The resulting screen-space depth is compared against the module’s max_draw_distance field ([rdi+0x30], default 300); entities beyond that distance are culled at 0x84C6B. +Label assembly: a temporary std::string is built on the stack (0x84CB0). If show_distance ([rdi+0x39]) is set, the metric distance is formatted as an integer via 0x7F5C0 and prepended with the distance marker string “m” (RVA 0x3AF8F4). If show_name ([rdi+0x3A]) is set, GetEntityName ([.data+0x1CE0]) is called and the result is appended; if show_type ([rdi+0x3C]) is set, the entity type code is looked up against a six-entry table at RVA 0x3AF908 / 0x3AF920 mapping type values to name string pairs: +0xFFFFFFFF → “All” +0x00000001 → “Invalid” +0x00000008 → “Character” +0x00000010 → “Enemy” +0x00000020 → “Interactive” +0x00000040 → “Projectile” +If multiple label fields are enabled, segments are joined by “ | ” (RVA 0x3AF900). The assembled label string is then submitted to the ImGui foreground draw list via 0x49820, which positions the text at the projected screen coordinate with a small pixel offset (loaded from RVA 0x3B3224), using the type-selected RGBA color. The foreground draw list is accessed through the “##Foreground” window (RVA 0x3ABF10) as documented in FPSModule. The font for the label is pushed/popped around the call via 0x28C00 and 0x28D70 (BeginFontScope / EndFontScope wrappers). +Loop increment: rbx (entity index) is incremented at 0x85289, r15 advances by 8 bytes through the entity pointer array, and the loop repeats from 0x84B30 until rbx reaches the entity count. On exit the stack cookie is verified and the function returns. +## 22.3 ESPModule Singleton State Layout (Complete) +The following table merges the fields identified in Chapter 9 with the RenderOverlay and Update findings above. Base address: [.data+0x1F70] (VA 0x1803C6F70). All booleans are BYTE; all color slots are XMMWORD (16-byte RGBA float4). +Offset +.data addr +Type +Field / Init Value ++0x00 +[.data+0x1F70] +QWORD +vtable ptr (0x3AFA38 before init; 0x3AF9E0 after) ++0x08 +[.data+0x1F78] +std::string +name = 'ESPModule' (RVA 0x3AF828) ++0x28 +[.data+0x1F98] +BYTE +enabled = 0 ++0x30 +[.data+0x1FA0] +DWORD +max_draw_distance = 300 (0x12C) ++0x34 +[.data+0x1FA4] +BYTE +show_monsters = 1 ++0x35 +[.data+0x1FA5] +BYTE +show_npc = 1 ++0x36 +[.data+0x1FA6] +BYTE +show_friendly = 1 ++0x37 +[.data+0x1FA7] +BYTE +show_puzzles = 1 ++0x38 +[.data+0x1FA8] +BYTE +show_all = 0 ++0x39 +[.data+0x1FA9] +BYTE +show_distance = 1 ++0x3A +[.data+0x1FAA] +BYTE +show_name = 1 ++0x3B +[.data+0x1FAB] +BYTE +reserved = 0 ++0x3C +[.data+0x1FAC] +BYTE +show_type = 0 ++0x40 +[.data+0x1FB0] +XMMWORD +color_enemy RED (1.00, 0.00, 0.00, 1.00) ++0x50 +[.data+0x1FC0] +XMMWORD +color_interactive ORANGE (1.00, 0.65, 0.00, 1.00) ++0x60 +[.data+0x1FD0] +XMMWORD +color_slot2 YELLOW (1.00, 1.00, 0.00, 1.00) ++0x70 +[.data+0x1FE0] +XMMWORD +color_friendly GREEN (0.00, 1.00, 0.00, 1.00) ++0x80 +[.data+0x1FF0] +XMMWORD +color_npc BLUE (0.00, 0.00, 1.00, 1.00) ++0x90 +[.data+0x2000] +XMMWORD +color_slot5 CYAN (0.00, 1.00, 1.00, 1.00) ++0xA0 +[.data+0x2010] +XMMWORD +color_slot6 PURPLE (0.58, 0.00, 0.83, 1.00) ++0xB0 +[.data+0x2020] +XMMWORD +color_default WHITE (1.00, 1.00, 1.00, 1.00) ++0xC0 +[.data+0x2030] +XMMWORD +color_slot8 PINK (1.00, 0.08, 0.58, 1.00) ++0xD0 +[.data+0x2040] +XMMWORD +color_slot9 LPINK (1.00, 0.75, 0.80, 1.00) +Color slots 2, 5, 6, 8, and 9 are not assigned to any type code in the Update dispatch and are therefore spare palette entries; they are exposed in the ImGui color-picker widgets but have no current runtime effect on the overlay. +# 23. DamageHack — Ghost Feature Analysis +The i18n table (RVA 0x3B1484) contains four keys with no corresponding RTTI class, vtable, registrar lambda, registered singleton, or callable code anywhere in the binary: “Damagehack Toggle”, “Damage Multiplier”, “Multiplier Value”, and “Random Damage Type”. This chapter documents what can be determined from the available evidence and establishes what is definitively absent. +## 23.1 i18n Evidence +The four DamageHack keys appear as a contiguous block in the JSON i18n blob immediately after the “Version: ” key and immediately before “This is free, if you spend money, then you have been deceived”. Each key carries English and Simplified Chinese translations: +“Damagehack Toggle” en / zh_cn: 伤害修改 (Damage Modification) +“Damage Multiplier” en / zh_cn: 伤害倍数 (Damage Multiplier) +“Multiplier Value” en / zh_cn: 倍数値 (Multiplier Value) +“Random Damage Type” en / zh_cn: 随机伤害类型 (Random Damage Type) +The Chinese translations are idiomatic and consistent with the translations for implemented features in the same blob, indicating they were written at the same time as the rest of the localisation table. The four keys fit the pattern of a planned ImGui panel: one boolean toggle, one float multiplier, a numeric input for the multiplier value, and an enum selector for damage type randomization. +## 23.2 What Is Absent +A complete binary search for any string containing “Damage”, “damage”, “DamageHack”, or “damagehack” outside the JSON blob returns zero results. The RTTI scan of the .data section (RVA 0x3C5000–0x3C8000) identifies exactly 11 cheat-module class names — ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule — and no DamageHack entry. Similarly, the registrar-lambda RTTI list contains no DamageHack entry. There is no singleton pointer, no once_flag guard, no vtable, and no callable RenderOverlay or Update function anywhere in the image. +## 23.3 Interpretation +DamageHack was planned but never implemented in this build. The i18n keys were added to the localisation file during feature planning or alongside a partial implementation that was subsequently stripped, but no code corresponding to those keys was ever compiled into the binary. This is consistent with the developer shipping the localisation blob as a whole-file asset while selectively excluding unfinished module source files from the build. +The intended design, inferred from the four i18n keys, would have been: a boolean master toggle (“Damagehack Toggle”) gating an intercepted damage-calculation call, a float multiplier applied to the outgoing damage value (“Damage Multiplier” / “Multiplier Value”), and an enum-driven randomisation mode for the damage type field (“Random Damage Type”). The implementation would most likely have operated as an IL2CPP function hook resolved via GABypass, consistent with how SkillHack intercepts cooldown and cost values. +From a detection standpoint, the ghost i18n keys are a useful indicator: any version of this cheat that activates DamageHack controls would be a different build from the one analysed here. The presence of these keys in an extracted string dump of a suspect binary is therefore a build-version discriminator, not evidence of active functionality. +# 25. Sidebar / Main Panel Render (RVA 0x7F8F0) +The top-level overlay panel is rendered by the function at RVA 0x7F8F0 (VA 0x18007F8F0). This function draws the outer “Sidebar” ImGui window that contains all module tab buttons and the About page. It is called from the ModuleManager render loop on every Present() frame and is responsible for the entire visible cheat UI chrome. +## 25.1 Function Signature and Layout +Entry point: RVA 0x7F8F0, approximately 0x146E bytes (tail-calls into ImGui epilogue at 0x180023E20 via jmp at 0x180080D5E). The function allocates a 0x380-byte stack frame, saves xmm6–xmm8, and takes a single rcx argument (ModuleManager / global context pointer). Key address references: +Window title: "Sidebar" (RVA 0x3AF2C8) — used as module lookup key (CRC32 via 0x180011DF0, registry lookup via 0x18003D1A0 and 0x18001D2B0); ImGui::Begin is not called from within 0x7F8F0 itself +Banner string: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) +Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) +Active tab idx: [.data+0x1F68] (VA 0x1803C6F68; written on click, read by jump table at 0x80B52) +## 25.2 Tab Navigation and Rendering +The sidebar renders six tab buttons. Each label is looked up from the i18n table via 0x18009D660 (the same translation dispatcher used by all modules). The six tabs, their label RVAs, and the jump-table case bodies dispatched on selection are: +Tab 0: "About" (RVA 0x3AF2D0) — sidebar header (banner + disclaimer) + About body sub-function (0x80E80) +Tab 1: "Player" (RVA 0x3AF2DC) — NoClip, SkillHack (movement/skill controls) +Tab 2: "ESP" (RVA 0x3AF2E8) — ESPModule overlay features +Tab 3: "World" (RVA 0x3AF2F0) — Vacuum (world/item interaction) +Tab 4: "Visual" (RVA 0x3AF2FC) — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +Tab 5: "Settings" (RVA 0x3ADFD8) — Theme/preset selection via 0x18009A4F0 (language, color theme) +The banner string (RVA 0x3AF258) and anti-scam disclaimer (RVA 0x3AF288) are rendered as a Sidebar-level header before the tab bar. Each of the six tab buttons is rendered by calling 0x80D80 (click-state handler, returns bool); if a tab is clicked its index (0–5) is written to [.data+0x1F68] (VA 0x1803C6F68). After all tab buttons are rendered, a jump table at RVA 0x80B52 reads [.data+0x1F68], bounds-checks against 5, and dispatches to the corresponding case via [0x180000000 + rax*4 + 0x80D64]. Case 0 calls sub-function 0x80E80 (About body: game title, version, author). Cases 1–4 call module-getter helpers that return the relevant singleton pointer, then invoke vtable[0x28] (RenderOverlay) for each. Case 5 delegates to 0x18009A4F0 (Settings/Theme renderer). +## 25.3 Author and Version Display +The About tab body is rendered by sub-function 0x80E80. It displays game context via the format string “%s Game: Endfield CTB3” (RVA 0x3AF350), the version label “Version: ” (RVA 0x3AF368) with value “1.0.0” (RVA 0x3AF374), and the author label “Author: ” (RVA 0x3AF380) with value “gktwo” (RVA 0x3AF38C). These are direct string literals, not i18n-dispatched keys. +## 25.4 Key Address Summary +RVA 0x7F8F0 Sidebar::RenderMainPanel (this chapter) +RVA 0x3AF258 Banner string +RVA 0x3AF288 Anti-scam disclaimer +RVA 0x3AF2C8 "Sidebar" window title +.data+0x1F68 Active tab index (VA 0x1803C6F68; written per-click, dispatched at jump table 0x80B52) +# 26. Language Selector (Sidebar Unconditional Panel) +The sidebar function (0x7F8F0) renders a language-selection sub-panel unconditionally on every frame, before the jump-table dispatch for tab bodies. The panel appears at VA range 0x180080770–0x180080B50 and is part of the sidebar’s Settings section rather than any individual tab body. +## 26.1 String Inventory +RVA 0x3AF310 "English" — first Combo item (index 0) +RVA 0x3AF318 "简体中文" — second Combo item (index 1) +RVA 0x3AF328 " Language" — tab label (5-space indent, 0xD chars) +RVA 0x3AF338 "##Language" — ImGui::Combo widget ID +## 26.2 Execution Flow +The language selector logic follows this sequence: +0x180080895 call 0x18009D660 — locale context init +0x1800808DD lea rsi,[...] # 0x1803AF310 — "English" item ptr +0x1800808E3 lea rbx,[...] # 0x1803AF318 — "简体中文" item ptr +0x1800809A1 lea rdx,[...] # 0x1803AF328 — tab label " Language" +0x1800809C6 call 0x18009D7D0 — BeginTab (render label) +0x180080A03 call 0x180064220 — ImGui::Combo (language dropdown) +al = 1 if selection changed, 0 otherwise +if English selected: +0x180080A2F mov DWORD PTR [0x1803C77B0], r12d — store 0 (language index = English) +if 简体中文 selected: +0x180080A5D mov DWORD PTR [0x1803C77B0], 0x1 — store 1 (language index = ZH-CN) +0x180080A6E call 0x18002A530 — i18n content refresh (reload translations) +0x180080A73 dec DWORD PTR [g_Config+0x2764] — decrement content ref-count +0x180080A80 mov rax,[g_Config+0x15D8] — get active config preset ptr +0x180080A87 mov BYTE PTR [rax+0x103], 0x1 — set dirty flag for config save +0x180080B0B lea rcx,[...] # 0x1803ADFC8 "Content" — module key +0x180080B12 call 0x180011DF0 — CRC32 lookup on "Content" module +0x180080B33 call 0x18003D1A0 — registry lookup +0x180080B4D call 0x18001D2B0 — module notify/update +## 26.3 Language Index State +VA 0x1803C77B0 language_index (DWORD) +0 = English +1 = 简体中文 (Simplified Chinese) +On language change, three things happen: the i18n content is refreshed via 0x18002A530, a config-preset dirty bit is set at [g_Config+0x15D8+0x103], and the “Content” module is notified via the standard CRC32/registry/notify triple (0x180011DF0, 0x18003D1A0, 0x18001D2B0). Two languages are supported in this build: English (default) and Simplified Chinese. +# 27. FreeCam Key Binding Display Panel (RVA 0x87A70–0x88606) +The documented FreeCam::Update function (RVA 0x871A0, see Ch.12.3) is 0x14C6 bytes long and includes a key-binding display section beginning at approximately 0x87A70 that was not previously described. This section renders four float-value sliders and eleven key-binding label rows using ImGui. +## 27.1 Float Sliders +Four consecutive DragFloat/SliderFloat controls appear before the key-binding rows, all using the ImGui slider variant at 0x180065570: +RVA 0x3AFCB0 "Free Camera" — sub-panel BeginTab label +RVA 0x3AF848 "ON / OFF" — toggle checkbox +RVA 0x3AFCC0 "Move Speed" — DragFloat, fmt "%.3f" (0x3ADFB0) +RVA 0x3AFCD0 "Look Sensitivity" — DragFloat, fmt "%.3f" +RVA 0x3AFCE8 "Roll Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFCF8 "FOV Speed" — DragFloat, fmt "%.3f" +RVA 0x3AFD04 "FOV" — DragFloat, fmt "%.1f" (0x3ADFEC) +## 27.2 Key Binding Label Rows +Eleven key-binding rows follow. Each row: (1) calls 0x18000FCB0 (MakeString) to format the label via 0x18005FB60 (sprintf-style, substituting the key name), (2) calls 0x18009D7D0 to render the resulting string as a tab-style label. Unbound keys display “NONE” (RVA 0x3AF820). +RVA 0x3AFD08 "Forward Key: %s" — VA 0x180087A87 +RVA 0x3AFD18 "Backward Key: %s" — VA 0x180087B1A (approx) +RVA 0x3AFD30 "Left Key: %s" +RVA 0x3AFD40 "Right Key: %s" +RVA 0x3AFD50 "Up Key: %s" +RVA 0x3AFD60 "Down Key: %s" +RVA 0x3AFD70 "IncFOV Key: %s" +RVA 0x3AFD80 "DecFOV Key: %s" +RVA 0x3AFD90 "LeftRoll Key: %s" +RVA 0x3AFDA8 "RightRoll Key: %s" +RVA 0x3AFDC0 "ResetRoll Key: %s" +RVA 0x3AF820 "NONE" — displayed for any unbound key +## 27.3 Dispatch Pattern +Each key row uses the same three-call sequence: MakeString (0x18000FCB0) to build the “Key Name: %s” format string, 0x18005FB60 to sprintf the current key name into it, and 0x18009D7D0 to render the result. The key name state block is at [rip+...] # 0x1803C6E98 (the “Pu;” RTTI sentinel in .data indicates the key-binding state array). This panel is visually shown as a collapsible key-rebinding display inside the FreeCam tab when enabled. +# 28. Settings Tab — Theme Selector and Console Toggle (RVA 0x9A4F0) +The Settings tab body function at RVA 0x18009A4F0 (source: SettingsTAB.cpp, RVA 0x3B0B30) renders a theme selector and a console toggle. It is called from sidebar case 5 (0x80D25). The function ends at approximately RVA 0x9AB31. +## 28.1 Theme Selector +A “Theme” combo-box (“Theme” at RVA 0x3B0AD4, rendered via ImGui::Combo at 0x180064220) presents four themes. Selecting a theme calls the corresponding palette-applicator function, which writes RRGGBBAA hex color strings from .rdata into the active ImGui color table. +Theme name strings: +RVA 0x3B0AF8 "Default" — applicator: RVA 0x941F0 (restores ImGui defaults) +RVA 0x3B06D0 "Evangelion Unit 01" — applicator: RVA 0x94890 +RVA 0x3B0AE0 "Evangelion Unit 02" — applicator: RVA 0x96770 +RVA 0x3B0B10 "Matrix" — applicator: RVA 0x98650 +## 28.2 Palette Color Tables +Each non-default theme applicator reads RRGGBBAA hex strings from .rdata and applies them to ImGui style slots. The colors below are listed in the order each applicator writes them (11 colors for Evangelion themes, 10 for Matrix): +Evangelion Unit 01 (RVA 0x94890): +0x3B06F8 #FFFFFFFF 0x3B06E8 #7857A7FF 0x3B0718 #19171CFF +0x3B0708 #2A282EFF 0x3B0738 #2A282EE6 0x3B0728 #4DE6A5FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B0778 #A38CCF80 +0x3B0768 #7857A780 0x3B0798 #4A4552FF +Evangelion Unit 02 (RVA 0x96770): +0x3B06F8 #FFFFFFFF 0x3B0898 #D9293BFF 0x3B0888 #1E1E1EFF +0x3B08B8 #3A3A3AFF 0x3B08A8 #3A3A3AE6 0x3B08D8 #F7B302FF +0x3B0758 #00000000 0x3B0748 #4A455240 0x3B08C8 #F7465880 +0x3B08F8 #D9293B80 0x3B0798 #4A4552FF +Matrix (RVA 0x98650): +0x3B09B8 #00FF41FF 0x3B09A8 #00AA2CFF 0x3B09D8 #000000FF +0x3B09C8 #0A0A0AFF 0x3B09F8 #0A0A0AE6 0x3B09E8 #004400FF +0x3B0758 #00000000 0x3B0A18 #00440040 0x3B0A08 #00881EFF +0x3B0A38 #00FF4180 +## 28.2.1 Per-Slot Color Applicator Helper (RVA 0x94190) +Each individual color push in the three non-default theme applicators (0x94890, 0x96770, 0x98650) is performed by a shared helper at RVA 0x94190. This function reads an RRGGBBAA hex string from .rdata using __stdio_common_vsscanf (IAT[0xB1880]), converts it to a packed RGBA value, then calls ImGui::PushStyleColor (via 0x180010840) with the target style-slot index and the parsed colour. It is called 159 times across the four writer functions (52 times from 0x94890 alone, corresponding to the full 52-slot Default palette). +## 28.3 Console Toggle +After the theme selector, the function renders a “Toggle Console” checkbox (RVA 0x3B0B00) using CheckboxToggle (0x180085320). The console state is read and displayed via two branches: +RVA 0x3B0B00 "Toggle Console" — checkbox label +if console enabled: display format "Console {}" (RVA 0x3B0B78) +using IAT AllocConsole (0x1800B1178) / GetStdHandle (0x1800B1628) +if console disabled: display "enabled" (RVA 0x3B0B28) +or "Disabled" (RVA 0x3B0B18) +## 28.4 Key Address Summary +RVA 0x9A4F0 SettingsTab::Render (this chapter) +RVA 0x941F0 Default palette applicator +RVA 0x94890 Evangelion Unit 01 palette applicator +RVA 0x96770 Evangelion Unit 02 palette applicator +RVA 0x98650 Matrix palette applicator +RVA 0x3B0AD4 "Theme" combo label +RVA 0x3B0B30 E:\git\Endfield_Cheeto\...\SettingsTAB.cpp +# 29. Win32/D3D11 Overlay Window Initialisation (RVA 0x827A0–0x8375C) +The overlay window subsystem is a single large function at 0x827A0 (called from the startup function 0xA9190 at 0xA9585) with two sub-functions: FindGameWindow (0x835D0) and GetOverlayRect (0x836A0). It creates the transparent layered Win32 window, initialises a D3D11 device and swap chain, runs the Win32 message loop, and keeps the overlay aligned to the game window. Ch. 7 documents the WndProc at 0x826A0 (the window procedure registered by this subsystem); Ch. 15.5 documents the Present hook call site at 0x82F00 which lies inside the message loop body. +## 29.1 DPI Awareness Initialisation (0x827FF–0x82923) +The function opens with a TLS-guarded once_flag block before performing DPI setup. Two DPI APIs are tried in priority order. First, LoadLibraryA(‘user32.dll’) is called (via IAT[0xB10E0]) and GetProcAddress is used to locate SetThreadDpiAwarenessContext; if found, it is called with context value 0xFFFFFFFFFFFFFFFC (DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2). If that fails, LoadLibraryA(‘shcore.dll’) and GetProcAddress resolve SetProcessDpiAwareness, which is then called with value 2 (PROCESS_PER_MONITOR_DPI_AWARE). If both dynamic lookups fail, the fallback is SetProcessDPIAware (IAT[0xB15A0]), a legacy API that sets system-DPI awareness. The guard at [.data+0x3C7440] / [.data+0x3C7448] ensures each path runs at most once. +## 29.2 Game Window Location and Window Class Registration (0x82924–0x82A28) +EnumWindows (IAT[0xB14A0]) is called with FindGameWindow (0x835D0) as the callback to locate the Unity game window. A WNDCLASSEX structure is then populated: CreateSolidBrush(0x7F00) (IAT[0xB1018]) sets the background brush to an opaque olive colour used only as a placeholder; LoadCursorW (IAT[0xB15C8]) provides the standard arrow cursor; two LoadIconW calls (IAT[0xB14E8]) load the small and large application icons. RegisterClassExW (IAT[0xB1638]) registers the class. GetSystemMetrics (IAT[0xB14E0]) is called twice to retrieve the full screen width (SM_CXSCREEN) and height (SM_CYSCREEN) for the initial window geometry. +## 29.3 Overlay Window and D3D11 Device Creation (0x82A29–0x82BFF) +CreateWindowExW (IAT[0xB1650]) creates the overlay window with WS_EX_LAYERED | WS_EX_TRANSPARENT style flags so it passes mouse input through to the game beneath it. SetLayeredWindowAttributes (IAT[0xB15E0]) sets the colour key and alpha. DwmExtendFrameIntoClientArea (IAT[0xB1918]) extends the DWM glass frame into the entire client area, which together with the layered attributes produces a fully transparent background. D3D11CreateDeviceAndSwapChain (IAT[0xB1908]) is called twice: the first call at 0x82B24 attempts D3D_FEATURE_LEVEL_11_0 with DXGI_FORMAT_R8G8B8A8_UNORM; on failure the second call at 0x82B7E retries with a DXGI_FORMAT_B8G8R8A8_UNORM swap chain as a fallback. After a successful device create, the compiled shader objects from Ch. 5 are bound. The helper 0x825B0 (called at 0x82B8C; documented in Ch. 7 as D3D11::Reinit) sets up the ImGui D3D11 backend. ShowWindow (IAT[0xB1628]) and UpdateWindow (IAT[0xB14D8]) make the window visible. CreateMutexA (IAT[0xB1720]) at 0x82C0D creates a named mutex to prevent duplicate overlay instances. +## 29.4 Initialisation Log and Message Loop (0x82C01–0x8352F) +Before entering the loop, the string ‘Initialized’ (RVA 0x3AF610) is logged at 0x82F5F from source file E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp. The main loop uses the standard Win32 pattern: PeekMessageW (IAT[0xB14D0]) / TranslateMessage (IAT[0xB14C8]) / DispatchMessageW (IAT[0xB14C0]). Each iteration calls FindWindowA(‘UnityWndClass’, NULL) (IAT[0xB14A8] called at 0x8301F) to verify the game process is still running; if the window disappears the loop exits. IsWindow (IAT[0xB1468]) validates the game HWND, GetWindowThreadProcessId (IAT[0xB1498]) retrieves its thread, and GetWindowRect (IAT[0xB1488]) reads its current bounds. SetWindowPos (IAT[0xB1588]) repositions the overlay to match the game window on every frame. GetForegroundWindow (IAT[0xB15F0]) and three GetClassNameA calls (IAT[0xB1490]) detect whether the game is the active foreground window and adjust the overlay visibility state via two SetWindowLongW calls (IAT[0xB15B0]). SwitchToThread (IAT[0xB1148]) at 0x8348A yields the CPU when the game is not in focus. On loop exit, DestroyWindow (IAT[0xB1570]) and UnregisterClassW (IAT[0xB1640]) clean up the overlay window and class. +## 29.5 FindGameWindow Callback (RVA 0x835D0) +This function is passed as the lpEnumFunc callback to EnumWindows. For each top-level window it calls GetWindowThreadProcessId (IAT[0xB1498]) and GetClassNameA (IAT[0xB1490]), then compares the class name against the literal string ‘UnityWndClass’ (RVA 0x3AF658) using the internal string-compare helper at 0xACA12. On a match it calls SetForegroundWindow (IAT[0xB1518]) to bring the game to the front, records the HWND, and then calls GetOverlayRect (0x836A0) to capture the initial window geometry. A second GetWindowThreadProcessId and AttachThreadInput call at 0x8368E synchronise the overlay thread’s input queue with the game thread. +## 29.6 GetOverlayRect (RVA 0x836A0) +Called by FindGameWindow and on every frame to compute the overlay rectangle. IsWindowVisible (IAT[0xB1480]) and IsIconic (IAT[0xB1510]) first check that the game window is visible and not minimised. DwmGetWindowAttribute (IAT[0xB1920]) with DWMWA_EXTENDED_FRAME_BOUNDS retrieves the DWM-adjusted window bounds (which exclude the invisible resize borders). GetClientRect (IAT[0xB15A8]) provides the inner client area. Two GetWindowLongPtrW calls (IAT[0xB1470]) read GWL_STYLE and GWL_EXSTYLE to account for window border widths. The function returns the final overlay RECT which SetWindowPos uses to position the overlay exactly over the game viewport. +## 29.7 Key Address Table +RVA 0x827A0 WinInit top-level entry (called from 0xA9585) +RVA 0x827FF DPI init block TLS-guarded; tries SetThreadDpiAwarenessContext then SetProcessDpiAwareness +RVA 0x82924 EnumWindows find game HWND via FindGameWindow callback +RVA 0x8298B RegisterClassExW overlay window class registration +RVA 0x82A29 CreateWindowExW WS_EX_LAYERED overlay window +RVA 0x82A60 DwmExtendFrameIntoClientArea full transparent client area +RVA 0x82B24 D3D11CreateDeviceAndSwapChain primary attempt (DXGI_FORMAT_R8G8B8A8_UNORM) +RVA 0x82B7E D3D11CreateDeviceAndSwapChain fallback (DXGI_FORMAT_B8G8R8A8_UNORM) +RVA 0x82C0D CreateMutexA single-instance guard mutex +RVA 0x82F5F ‘Initialized’ log source: UI.cpp; emitted after device creation succeeds +RVA 0x82F00 Present hook site documented in Ch. 15.5 +RVA 0x8348A SwitchToThread yields when game is not in foreground +RVA 0x835D0 FindGameWindow EnumWindows callback; locates ‘UnityWndClass’ HWND +RVA 0x836A0 GetOverlayRect DwmGetWindowAttribute + GetClientRect; returns overlay RECT +RVA 0x826A0 WndProc documented in Ch. 7 +# 24. Final Analysis Summary +EF-Cheeto.dll (internal name, distributed as unityexplorer.dll) is a fully-featured Unity game cheat module for an IL2CPP-based game. The complete analysis across twenty-five chapters reveals the following architecture: +Infrastructure Layer: D3D11 Present hook for overlay rendering, Win32 WndProc subclass for hotkeys, Toolhelp32 thread enumeration for safe code patching, MSVC-standard stack cookie security (no active anti-debug), D3DCompile for ImGui shaders, and _wfopen-based config persistence using nlohmann/json serialization. +Hook Engine: Custom hook manager with FNV-1a hash table, trampoline allocation via VirtualAlloc, thread-safe patching via Suspend/Resume, and a 71-entry IL2CPP function pointer bypass table (GABypass). +Cheat Modules (11 registered + 1 ghost): NoClip (CharacterController bypass), SkillHack (cooldown/cost IL2CPP hooks), FreeCam (CinemachineBrain camera override), FpsUnlocker (targetFrameRate), FPSModule (FPS counter overlay; see Ch. 20), SetDither (render setting), PlayerProfile (UI text injection), Vacuum (monster item pull), ESPModule (entity overlay, 10-color table; see Ch. 22), DamageHack (ghost — i18n only, no code; see Ch. 23), PreventScreenshot (registered; SetWindowDisplayAffinity). +Configuration: 172-field g_Config struct at .data+0x1F70, per-version config writers for multiple game versions, auto-save timer at [state+0x2904], ImGui layout persistence via standard ini format. +The binary is 3,956,736 bytes (0x3CE000), compiled with MSVC for x86-64 Windows, targeting IL2CPP Unity games. All twenty-five chapters together constitute a complete static reconstruction of the binary with no significant undocumented regions remaining. diff --git a/IDA/project/docs/input/vs/files (1)/ef_cheeto_feed_2_header.md b/IDA/project/docs/input/vs/files (1)/ef_cheeto_feed_2_header.md new file mode 100644 index 0000000..e09e8a1 --- /dev/null +++ b/IDA/project/docs/input/vs/files (1)/ef_cheeto_feed_2_header.md @@ -0,0 +1,2103 @@ +# EF-CHEETO RECONSTRUCTION FEED — PART 2/3 +# This part: Reconstruction header with all structs, RVAs, string table, IL2CPP table. +# Feed with Parts 1 and 3 for complete reconstruction context. + +================================================================================ +RECONSTRUCTION HEADER (ef_cheeto_reconstruction.h) +Compiles: g++ -std=c++17 -fsyntax-only +2,092 lines covering 538 RVAs, 97 .data addresses, 189 strings, 75 IAT entries +================================================================================ + +// ============================================================================ +// EF-Cheeto (unityexplorer.dll) — Reconstruction Headers +// Derived from: EF-Cheeto_Vol12_Final_Analysis.docx (complete binary audit) +// Target: x86-64 Windows DLL, MSVC build, GameAssembly.dll (Endfield) +// Base VA: 0x180000000 | .data base: 0x1803C5000 (RVA 0x3C5000) +// ============================================================================ + +#pragma once +#include +#include + +// ============================================================================ +// SECTION 1 — PRIMITIVE TYPEDEFS +// ============================================================================ + +using u8 = uint8_t; +using u16 = uint16_t; +using u32 = uint32_t; +using u64 = uint64_t; +using i32 = int32_t; +using f32 = float; +using f64 = double; +using BOOL = int; // IL2CPP managed bool return (al register) + +// ============================================================================ +// SECTION 2 — GLOBAL .DATA LAYOUT (abridged — key singletons) +// ============================================================================ +// All offsets are RVA from binary base 0x180000000. +// VA = 0x180000000 + RVA. +// .data region starts at RVA 0x3C5000 (VA 0x1803C5000). +// References below use shorthand [.data+N] meaning VA 0x1803C5000 + N. +// +// Key global pointers: +// [.data+0x00D8] g_D3DState ptr (D3D11 device/swap chain block) +// [.data+0x00E0] active_preset_name (std::string — "Preset0".."Preset3") +// [.data+0x00EC] active_preset_index (DWORD — 0-3) +// [.data+0x00F0] gameassembly_base (cached GetModuleHandleW result) +// [.data+0x1E88] hook_spinlock (DWORD — 0=free, 1=held) +// [.data+0x1E90] hook_allocator_ptr (IAllocator for hook_array, capacity 0x80) +// [.data+0x23B8] ModuleManager.registrars_begin +// [.data+0x23C0] ModuleManager.registrars_end +// [.data+0x23C8] ModuleManager.registrars_cap +// [.data+0x2398] ModuleManager object ptr +// [.data+0x23A8] ModuleManager secondary ptr +// [.data+0x23D0] ModuleManager once_flag (std::once_flag) + +// ============================================================================ +// SECTION 3 — g_Config (global config object) +// ============================================================================ +// g_Config is a large global object stored in .data. +// Fields below are offsets FROM the g_Config object base (not from .data base). +// g_Config does not have a single documented base address — it IS .data in +// the relevant regions. Use field VA = 0x1803C5000 + offset where offset +// matches the [.data+N] values from the doc. +// +// PANEL / UI scroll state (used by all module Render() panel-open sequences) +struct GConfigPanelFields { + // offset from g_Config (which sits at .data) + // [g_Config+0x0058] scroll_base (float) — horizontal scroll base offset + // [g_Config+0x00D8] d3d_state_ptr (void*) — D3D11 state block + // [g_Config+0x0150] panel_width (float) — rendered panel content width + // [g_Config+0x0194] scroll_accum (float) — accumulated horizontal scroll + // [g_Config+0x0198] scroll_total (float) — total scroll range + // [g_Config+0x0E0C] scroll_step (float) — per-frame scroll delta + // [g_Config+0x15D8] panel_ptr (void*) — pointer to active ImGui panel struct + // [g_Config+0x1BEC] imgui_ini_fallback (void*) — fallback .ini path ptr + // [g_Config+0x1C00] scroll_region_root (void*) — root of scroll region config + // [g_Config+0x1F68] active_tab_idx (DWORD) — written by binding state array +}; + +// Panel-open sequence (all modules — addss path): +// rax = *panel_ptr; +// rax->field_0x103 = 1; +// xmm0 = scroll_step + rax->scroll_accum + rax->scroll_base + rax->scroll_total; +// rax->panel_width = xmm0; +// Panel-close sequence (subss path): same but scroll_accum -= scroll_step. + +// HOOK SLOTS [g_Config+0x1E40..0x1E68] (SkillHack IL2CPP hook target pointers) +// [g_Config+0x1E40] hook5_target — ApplySkillCost() (void fn) +// [g_Config+0x1E48] hook6_target — (dispatcher target) +// [g_Config+0x1E50] hook3_target — GetCooldownPercent() (float fn) +// [g_Config+0x1E58] hook4_target — IsSkillAvailable() (BOOL fn) +// [g_Config+0x1E60] hook1_target — skill check A (BOOL fn) +// [g_Config+0x1E68] hook2_target — skill check B (BOOL fn) + +// OVERLAY FLAGS (written by UnityExplorer when window is active) +// [g_Config+0x1F78] overlay_flags (DWORD) — |= 1 when UE window open +// [g_Config+0x1F90] overlay_scale (float) — set to 300.0f when UE open + +// ============================================================================ +// SECTION 4 — IL2CPP FUNCTION POINTER TABLE +// ============================================================================ +// GABypass::Patch (RVA 0xA9120) resolves 71 function pointers from +// GameAssembly.dll at DLL attach and writes them to .data slots. +// Format: slot_rva = .data offset from g_base 0x1803C5000 +// Access: fn_ptr = *(void**)(gameassembly_base + il2cpp_offset) +// +// Key: ptr = *(void**)(.data + slot_rva) +// call as: ((RetType(*)(Args...))(ptr))(args...); + +struct IL2CPP_Table { + // Slot .data-offset | IL2CPP offset | Resolved name + void* GameObject_GetComponentByIndex; // 0x1C48 +0x09DC0120 + void* il2cpp_domain_get_assemblies_A; // 0x1C50 +0x0018CEC0 + void* Component_GetComponent_Transform; // 0x1C58 +0x0B390700 + void* Transform_get_localScale; // 0x1C60 +0x0B3A2D20 + void* Transform_get_rotation; // 0x1C68 +0x0B3A2CB0 + void* il2cpp_object_get_class; // 0x1C70 +0x0018AD80 + void* il2cpp_class_get_method_from_name;// 0x1C78 +0x00007480 + void* Transform_get_localPosition; // 0x1C80 +0x0B3A1AE0 + void* Transform_get_position; // 0x1C88 +0x0B3A1A70 [also 0x1DD0] + void* Transform_set_localPosition; // 0x1C90 +0x0B3A51D0 + void* GameObject_SetActive; // 0x1C98 +0x0B398830 [also 0x1DB8] + void* GameObject_get_transform; // 0x1CA0 +0x0B3911F0 + void* Transform_set_rotation; // 0x1CA8 +0x0B3A59D0 [also 0x1DE0] + void* GameObject_get_activeInHierarchy; // 0x1CB0 +0x0B391D90 + void* GameObject_get_tag; // 0x1CB8 +0x0B3B2410 + void* GameObject_get_name; // 0x1CC0 +0x0B3B2120 + void* GameObject_get_layer; // 0x1CC8 +0x0B3B40B0 + void* GameObject_get_scene; // 0x1CD0 +0x0B397980 + void* Game_SkillBuff_A; // 0x1CD8 +0x02F3DA80 (SkillHack) + void* GetEntityName; // 0x1CE0 +0x00F27E10 (ESP label) + void* Component_GetComponents; // 0x1CE8 +0x0B329000 + void* Component_GetComponentsInChildren;// 0x1CF0 +0x0B329D80 + void* Game_SkillSlot_A; // 0x1CF8 +0x03E9BB50 (SkillHack) + void* Object_get_name; // 0x1D00 +0x0B383F60 + void* Component_GetType_A; // 0x1D08 +0x0B33CAB0 + void* Component_GetType_B; // 0x1D10 +0x0B33CB00 + void* Game_SkillSlot_B; // 0x1D18 +0x039D1AA0 (SkillHack) + void* Game_Combat_HitA; // 0x1D20 +0x026DE9F0 + void* GetEntityManager; // 0x1D28 +0x0478E860 (NoClip/FpsUnlocker) + void* Game_Combat_HitB; // 0x1D30 +0x025E2D40 + void* Game_Movement_PhysA; // 0x1D38 +0x087C2CD0 (NoClip CharCtrl) + void* Game_Movement_PhysB; // 0x1D40 +0x03419AF0 (NoClip CharCtrl) + void* Application_set_targetFrameRate; // 0x1D48 +0x0B322FB0 (FpsUnlocker) + void* SceneManager_GetActiveScene; // 0x1D50 +0x0B396A20 + void* CinemachineBrain_GetActiveVCam; // 0x1D58 +0x0B397700 (FreeCam) + void* Game_EntityState_A; // 0x1D60 +0x03766810 (ESP/SkillHack) + void* Transform_set_localScale; // 0x1D68 +0x0B3A2A60 + void* Rigidbody_get_velocity; // 0x1D70 +0x0B326660 (NoClip/Vacuum) + void* Rigidbody_set_velocity; // 0x1D78 +0x0B3266B0 (NoClip/Vacuum) + void* Object_Destroy; // 0x1D80 +0x0B383200 + void* Transform_set_position; // 0x1D88 +0x0B3A1A10 (NoClip/Vacuum) + void* Game_EntityState_B; // 0x1D90 +0x0B3A2340 (ESP) + void* Input_GetAxis_MouseX; // 0x1D98 +0x0B421800 (FreeCam look X) + void* Game_PlayerState_A; // 0x1DA0 +0x0B3A26D0 (ESP/SkillHack) + void* Game_PlayerState_B; // 0x1DA8 +0x0B3A1FB0 (ESP/SkillHack) + void* Game_PlayerHealthStat; // 0x1DB0 +0x0B32B030 (ESP health) + void* Camera_get_main; // 0x1DC0 +0x0B390440 (ESP/FreeCam) + void* GameObject_FindObjectOfType; // 0x1DC8 +0x0B390F80 + void* Game_SkillAction_C; // 0x1DD8 +0x03F85430 (SkillHack) + void* GetDeltaTime; // 0x1D38 +0x087C2CD0 (also FPS overlay) + void* Camera_get_fieldOfView; // 0x1DE8 +0x0B3A1C90 (FreeCam FOV) + void* Game_EntityState_C; // 0x1DF0 +0x00E92CF0 (ESP) + void* Rigidbody_AddForce; // 0x1E00 +0x03DC14C0 (Vacuum) + void* CharCtrl_set_enabled; // 0x1E08 +0x03E0D2C0 (NoClip) + void* Game_SkillAction_F; // 0x1E10 +0x03D9DF30 (SkillHack) + void* Game_SkillAction_G; // 0x1E18 +0x00E9E9F0 (SkillHack) + void* GetCharacterController; // 0x1E20 +0x03EA53C0 (NoClip) + void* TMPro_set_text; // 0x1E28 +0x0ACA0EC0 (PlayerProfile/NameChanger) + void* UnityUI_Text_set_text; // 0x1E30 +0x0B391D40 (ON/OFF labels) + void* Game_SkillAction_I; // 0x1E38 +0x036AA8F0 (SkillHack) + void* Game_SkillAction_J; // 0x1E40 +0x03EC31C0 (SkillHack hook5 target) + void* Game_EntityActor_D; // 0x1E48 +0x037F8CD0 (ESP/combat, hook6 target) + void* Game_SkillAction_K; // 0x1E50 +0x036EA640 (hook3/cooldown target) + void* Game_SkillAction_L; // 0x1E58 +0x03EC30E0 (hook4/avail target) + void* Game_EntityActor_E; // 0x1E60 +0x037F2A40 (hook1 target) + void* Game_EntityActor_F; // 0x1E68 +0x037FD7E0 (hook2 target) + void* il2cpp_domain_get; // 0x1E70 +0x00D94C10 + void* il2cpp_assembly_get_image; // 0x1E78 +0x00D94DA0 + void* il2cpp_domain_get_assemblies_B; // 0x1E80 +0x00D93A60 +}; + +// ============================================================================ +// SECTION 5 — BASE CLASS +// ============================================================================ + +struct BaseModule { + void* vtable; // [+0x00] vtable ptr + // std::string name at [+0x08] (SSO string, 24 bytes total: ptr+len+cap) + char name_sso[24]; // [+0x08] SSO buffer + // std::string tab_name at [+0x20] + char tab_name_sso[24]; // [+0x20] secondary name / tab label (SSO) + u8 enabled; // [+0x28] ON/OFF flag (BYTE) + u8 _pad[7]; // [+0x29..+0x2F] + // module-specific fields follow at [+0x30] +}; + +// BaseModule vtable layout (from factory stubs RVA 0x9B660–0x9B7A0): +// [0] +0x00 copy-ctor / factory() — placement-new ctor, writes vtable, returns this +// [1] +0x08 copy-ctor / factory() — same as [0] +// [2] +0x10 Init() / RegisterTab() — jmp stub → actual RegisterTab fn +// [3] +0x18 Render() — per-frame UI + game-state dispatch +// [4] +0x20 ~BaseModule() — dtor: frees name string, optional delete +// [5] +0x28 getNamePtr() — returns &this->name_string (+0x08) +// [6] +0x30 onHotkey() — pure virtual (sentinel value = 1) +// [7] +0x38 getLinkedModuleFactory() — returns paired module factory ptr + +// ============================================================================ +// SECTION 6 — MODULE STATE STRUCTS +// ============================================================================ + +// --- NoClip --- +// Singleton base: [.data+0x27B0] (referenced by RegisterTab / Render calls) +// Object size: ~0x38 bytes +struct NoClipModule : BaseModule { + // [+0x28] u8 enabled (ON/OFF checkbox) + i32 move_speed; // [+0x30] DragInt range [1, 10], default unknown +}; +// NoClip function table: +// RegisterTab 0x081300 — one-time init +// Render 0x0813D0 — ImGui panel (checkbox + Move Speed slider) +// Update 0x089B50 — per-frame CharacterController toggle +// Update stub 0x089B00 — tab destructor/cleanup wrapper +// Update stub2 0x089B40 — tab #2 setup (lea rdx, panel_callback → jmp 0x89060) + +// --- FreeCam --- +// Singleton base: [.data+0x2200] (0xD8 bytes, zeroed by RegisterMainTab) +struct FreeCamModule : BaseModule { + // [+0x28] u8 enabled + f32 move_speed; // [+0x30] SliderFloat max=500.0f default=30.0f + f32 roll_speed; // [+0x34] SliderFloat max=100.0f + f32 fov_speed; // [+0x38] (Look Sensitivity slider) + u8 _pad2[0x28]; // [+0x3C..+0x63] + void* active_cam_ptr; // [+0x68] cached active camera GameObject* + void* override_cam_ptr; // [+0x70] override camera ptr (cleared on disable) + u8 _pad3[0x40]; // [+0x78..+0xB7] + u8 cam_override_active; // [+0xB8] + // Key bindings written at RegisterMainTab to [.data+0x2230..0x225E]: + // [+0x2230] movdqa block1 = 0x1803B34F0 (WASD + misc keys) + // [+0x2240] movdqa block2 = 0x1803B35C0 + // [+0x2250] 0x3F800000 = 1.0f (FOV multiplier default) + // [+0x2254] 0x44415357 = 'WASD' key code mask + // [+0x2258] 0x6D6BA220 = additional keybind + // [+0x225C] 0x2725 = two-byte keybind + // [+0x225E] 0x60 = backtick key code + // Accumulator floats [+0x2260..0x22A8] pitch/yaw/roll/FOV — zeroed on init +}; +// FreeCam function table: +// RegisterFpsTab 0x0814C0 — registers FPS Monitor overlay tab +// RegisterMainTab 0x081590 — zeroes 0xD8 state, writes key defaults +// FpsUpdate stub 0x087150 — FPS overlay destructor wrapper +// Update 0x0871A0 — per-frame camera override (WASD+mouse) + +// --- FpsUnlocker --- +// Singleton base: [.data+0x21E8] +// Object size: 0x38 bytes +struct FpsUnlockerModule : BaseModule { + // [+0x28] u8 enabled + i32 fps_target; // [+0x30] DragInt max=500, min=30, default=300 +}; +// FpsUnlocker function table: +// RegisterTab 0x081730 — registers tab, writes fps_target default = 300 +// Render 0x085B90 — ImGui panel + Application.set_targetFrameRate call +// Update stub 0x085B40 — destructor wrapper, size 0x38 + +// --- SetDither --- +// Singleton base: referenced from registrar at RVA 0x001C41 +// Object size: 0x38 bytes (shared stub with SkillHack) +struct SetDitherModule : BaseModule { + // [+0x28] u8 enabled (unused — no per-frame write) +}; +// SetDither function table: +// RegisterTab/Render 0x081810 — registers tab only; no ImGui panel body +// Update stub 0x083DC0 — shared no-op: frees name string, optional delete + +// --- PlayerProfile --- +// Singleton base: referenced from registrar at RVA 0x001E20 +// Object size: 0x78 bytes +struct PlayerProfileModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + // [+0x30] std::string uid_str (wstring buffer for UID display text) + char uid_str_sso[24]; // [+0x30] + u8 _pad4[8]; // [+0x48..+0x4F] + // [+0x50] std::string name_str (wstring buffer for ManagerName text) + char name_str_sso[24]; // [+0x50] + u8 _pad5[8]; // [+0x68..+0x6F] + u8 name_changer_enabled; // [+0x70] +}; +// PlayerProfile function table: +// RegisterTab/Render 0x0818E0 — zeroes uid_str, name_str; stores IL2CPP fn ptrs +// Update 0x08A4F0 — per-frame UI path walk + SetText on TMP labels +// Update stub 0x08A4A0 — dtor: frees [+0x50],[+0x30],[+0x08], delete(0x78) +// UI paths used: +// UID: "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (RVA 0x3AFED0, len 0x2F) +// Name: "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (RVA 0x3AFFD0, len 0x8D) + +// --- Vacuum --- +// Singleton base: [.data+0x05D0] fn-ptr slot; obj referenced from registrar 0x001FC0 +// Object size: 0x38 bytes +struct VacuumModule : BaseModule { + // [+0x28] u8 vacuum_on ('Vacuum' main checkbox) + u8 _pad3[7]; + u8 monster_on; // [+0x30] 'Monster' sub-checkbox +}; +// Vacuum function table: +// RegisterTab 0x081A20 — stores update fn ptr 0x1803B0680 → 0x085B40 stub +// Render 0x093CA0 — 'Vacuum' + 'Monster' checkboxes +// PhysicsLoop 0x093F10 — per-frame Rigidbody.AddForce attraction +// Update stub 0x085B40 — shared destructor wrapper (frees [+0x08], delete 0x38) +// Attraction constant: *(float*)0x1803B32B4 + +// --- SkillHack --- +// Singleton base: referenced from registrar at RVA 0x001D50 +// Object size: ~0x38 bytes +struct SkillHackModule : BaseModule { + // [+0x28] u8 enabled — read by all 6 hook callbacks + // No per-frame Update; all work done by IL2CPP hook callbacks +}; +// SkillHack function table: +// Render 0x08D1F0 — hook installer only (installs 6 hooks, tail-jmps to 0x8D8A0) +// RenderPanel 0x08D240 — actual ImGui panel ('Free Skill' + ON/OFF toggle) +// Update stub 0x083DC0 — shared no-op (same as SetDither) +// Dispatcher 0x08D4B0 — BOOL callback: returns 1 when enabled +// CooldownBypass 0x08D500 — float callback: returns 100.0f when enabled +// AvailBypass 0x08D640 — BOOL callback: returns 1 when enabled +// CostBypass 0x08D780 — void callback: early-return (skip cost deduction) + +// --- ESPModule --- +// Singleton base: [.data+0x1F70] VA 0x1803C6F70 +// Object size: 0x100 bytes (12 RGBA color slots × 16 bytes = 0xC0, starts at +0x40) +struct ESPModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + i32 max_draw_distance; // [+0x30] default 300 (0x12C) + u8 show_monsters; // [+0x34] default 1 + u8 show_npc; // [+0x35] default 1 + u8 show_friendly; // [+0x36] default 1 + u8 show_puzzles; // [+0x37] default 1 + u8 show_all; // [+0x38] default 0 + u8 show_distance; // [+0x39] default 1 + u8 show_name; // [+0x3A] default 1 + u8 show_type; // [+0x3B] default 0 (reserved, unused) + u8 _reserved; // [+0x3C] + u8 _pad4[3]; // [+0x3D..+0x3F] + float color[12][4]; // [+0x40] 12 × RGBA float4, 16-byte aligned + // Color slot defaults (RGBA): + // [0] +0x40 enemy RED (1.0, 0.0, 0.0, 1.0) + // [1] +0x50 interactive ORANGE (1.0, 0.65, 0.0, 1.0) + // [2] +0x60 slot2 YELLOW (1.0, 1.0, 0.0, 1.0) + // [3] +0x70 friendly GREEN (0.0, 1.0, 0.0, 1.0) + // [4] +0x80 npc BLUE (0.0, 0.0, 1.0, 1.0) + // [5] +0x90 slot5 CYAN (0.0, 1.0, 1.0, 1.0) + // [6] +0xA0 slot6 PURPLE (0.58, 0.0, 0.83, 1.0) + // [7] +0xB0 default WHITE (1.0, 1.0, 1.0, 1.0) + // [8] +0xC0 slot8 PINK (1.0, 0.08, 0.58, 1.0) + // [9] +0xD0 slot9 LPINK (1.0, 0.75, 0.80, 1.0) + // [10] +0xE0 slot10 BLACK (0.0, 0.0, 0.0, 1.0) + // [11] +0xF0 slot11 GRAY (0.502, 0.502, 0.502, 1.0) +}; +// ESPModule function table: +// Singleton init 0x083E00 — lazy init via MSVC thread-safe static +// RenderOverlay 0x083FA0 — ImGui 'ESP Features' panel (large, 0x83FA0–0x8499E) +// Update 0x085C00 — per-frame world-space entity label loop (approx) +// Entity type dispatch in Update (byte code → color slot): +// 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle, default=slot7(white) + +// --- FPSModule (FpsOverlay) --- +// Singleton base: [.data+0x22E0] VA 0x1803C72E0 +// Object size: 0xD8 bytes +struct FPSModule : BaseModule { + // [+0x28] u8 enabled + u8 _pad3[7]; + u8 show_fps_overlay; // [+0x30] 'Show FPS Overlay' checkbox + u8 _pad4[0x2F]; // [+0x31..+0x5F] + float overlay_pos[4]; // [+0x60] XMMWORD (position/size, zeroed on init) +}; +// FPSModule function table: +// RegisterTab 0x081810 — shared with SetDither registrar +// Render [via FpsOverlay chain] + +// --- PreventScreenshot --- +// Singleton base: [.data+0x2358] VA 0x1803C7358 +// Object size: 0x48 bytes +struct PreventScreenshotModule : BaseModule { + // [+0x28] u8 enabled — drives SetWindowDisplayAffinity arg + u8 _pad3[7]; + u8 state_dirty; // [+0x30] 1 = affinity applied, guard re-apply + u8 _pad4[7]; + u8 second_flag; // [+0x38] purpose unclear, zeroed on init +}; + +// ============================================================================ +// SECTION 7 — HOOK MANAGER +// ============================================================================ + +// Singleton: [.data+0x2470] VA 0x1803C7470 +// Object size: 0x90 bytes +struct HookManager { + void* hook_array; // [+0x00] flat array of HookEntry (0x38 bytes each) + u32 hook_capacity; // [+0x08] allocated slot count (initial 0x80) + u32 hook_count; // [+0x0C] active hook count + void* hash_buckets; // [+0x10] hash table bucket array (linked list heads) + u32 bucket_count; // [+0x18] power of 2, initial 8 + u32 bucket_mask; // [+0x1C] = bucket_count * 2 - 1 + void* free_list_head; // [+0x20] freed/recycled slot free list head + u8 _pad[4]; // [+0x28..+0x2B] + f32 load_factor; // [+0x28] hash load factor threshold (1.0f = 0x3F800000) + u8 initialized; // [+0x30] 0 after init (prevents double-init) + // Global spinlock: [.data+0x1E88] (DWORD, separate from struct) +}; + +// Each hook entry in hook_array is 0x38 bytes: +struct HookEntry { + u64 target_va; // [+0x00] VA of hooked IL2CPP function + u64 callback_va; // [+0x08] VA of replacement/detour function + u64 trampoline_va; // [+0x10] VirtualAlloc'd trampoline (orig bytes + JMP back) + u32 orig_bytes_0_3; // [+0x18] saved original bytes 0-3 + u16 orig_bytes_4_5; // [+0x1C] saved original bytes 4-5 + u8 orig_byte_6; // [+0x1E] saved original byte 6 + u8 flags; // [+0x20] bit0=has_far_jmp, bit1=enabled, bit2=suspended + u32 flags2; // [+0x24] lower nibble: hook type (0=near JMP, 1=far) + u64 hash_next; // [+0x28] next ptr in hash bucket chain + // [+0x30..+0x37] additional chain/bookkeeping fields +}; + +// HookManager API (all acquire spinlock at [.data+0x1E88]): +// CreateHook RVA 0x0A9CC8 — install new hook (FNV-1a hash lookup, trampoline alloc) +// RemoveHook RVA 0x0A9FA0 — remove and free hook +// EnableHook RVA 0x0AA140 — enable suspended hook +// GetHookInfo RVA 0x0AA2C0 — query hook by target VA +// Spinlock acq RVA 0x0A9C88 — acquire [.data+0x1E88] +// Spinlock rel inline — mov [.data+0x1E88], 0 + +// ============================================================================ +// SECTION 8 — MODULE MANAGER +// ============================================================================ + +// Singleton: [.data+0x2398] +// Registrar array: [.data+0x23B8]..[.data+0x23C0] (stride 0x60 bytes/slot) +struct ModuleManager { + u8 _pad[0x18]; // [+0x00..+0x17] + u8 initialized; // [+0x18] double-init guard + u8 _pad2[7]; // [+0x19..+0x1F] + // [+0x20..+0x57] registrar list (vector — 0x60-byte stride) +}; + +// ModuleManager API: +// AddRegistrar RVA 0x09B2C0 — push registrar slot (name str + factory fn) +// Grow helper RVA 0x09B3C0 — expand registrar vector +// Init RVA 0x09AC10 — called once from startup (RVA 0xA9190) +// Dispatch loops (each wraps vtable call in __try/__except via CxxFrameHandler4): +// Update loop RVA 0x09AE80 — calls vtable[+0x18] on each module +// Render loop RVA 0x09AEF0 — calls vtable[+0x20] on each module +// Hotkey loop RVA 0x09AF60 — calls vtable[+0x28] on each module +// Exception handlers (log + resume, do not propagate): +// Update catch RVA 0x0AEBC0 — logs "[ERROR] Failed to update module ''" +// Render catch RVA 0x0AEC50 — logs "[ERROR] Failed to render overlay for module ''" +// Hotkey catch RVA 0x0AECE0 — logs "[ERROR] Failed to process hotkeys for module ''" + +// Registration order (DLL init lambdas, before ModuleManager::Init): +// 1. SetDither (RVA 0x001C41) vtable 0x3B0D58 +// 2. FreeCam FPS (RVA 0x001C80) vtable 0x3B0E70 +// 3. SkillHack (RVA 0x001D50) vtable 0x3B0EE0 +// 4. PlayerProfile (RVA 0x001E20) vtable 0x3B0D90 +// 5. NoClip (RVA 0x001EF0) vtable 0x3B0DC8 +// 6. Vacuum (RVA 0x001FC0) vtable 0x3B0E38 +// 7. UnityExplorer (RVA 0x002090) vtable 0x3B0D28 +// 8. FpsUnlocker (RVA 0x001B80) vtable 0x3B0E00 +// 9. FreeCam main (RVA 0x001AB0) vtable 0x3B0E70 +// 10. ESPModule (RVA 0x001980) + +// ============================================================================ +// SECTION 9 — KEY FUNCTION RVA REFERENCE +// ============================================================================ +// All RVAs relative to binary base 0x180000000. +// Add 0x180000000 to get VA; add file raw offset base for file seek. + +namespace RVA { + // Startup / init + constexpr u32 DllMain_entry = 0x0AC840; // CRT DllMain thunk + constexpr u32 Startup_sequence = 0x0A9190; // main init: GABypass + ModMgr + constexpr u32 GABypass_Patch = 0x0A9120; // writes 71 IL2CPP fn ptrs + constexpr u32 ModuleManager_Init = 0x09AC10; + + // D3D11 / overlay + constexpr u32 D3D11_Hook_Install = 0x0827A0; // hooks IDXGISwapChain::Present + constexpr u32 D3D11_Present_Hook = 0x082820; // Present detour entry + constexpr u32 D3D11_CreateBuffers = 0x0551F0; // post-shader vertex/index buffer init + constexpr u32 ImGui_EndFrame = 0x001C2D0; // D3D11/ImGui EndFrame boundary + + // ImGui wrappers (cheat-side) + constexpr u32 ImGui_Toggle = 0x070820; // TabManager::BeginTab + constexpr u32 CheckboxToggle = 0x085320; // flip enabled flag + constexpr u32 ImGui_DragInt = 0x066750; // move_speed DragInt + constexpr u32 ImGui_SliderFloat = 0x065570; // move_speed SliderFloat (max 500) + constexpr u32 ImGui_InputText_ws = 0x08AC20; // InputText wstring wrapper + + // Config I/O + constexpr u32 ConfigSerialize = 0x012050; // serialize config to string + constexpr u32 BuildFilePath = 0x030A90; // build config file path + constexpr u32 ConfigFileIO = 0x011EA0; // UTF-8→wide fopen helper + constexpr u32 ConfigWrite = 0x0170D6; // fwrite config to file (approx) + + // Hook manager + constexpr u32 HookMgr_singleton = 0x081B00; // thread-safe static accessor + constexpr u32 HookMgr_CreateHook = 0x0A9CC8; + constexpr u32 HookMgr_RemoveHook = 0x0A9FA0; + constexpr u32 HookMgr_EnableHook = 0x0AA140; + constexpr u32 HookMgr_Spinlock = 0x0A9C88; + constexpr u32 Trampoline_Alloc = 0x0AA478; // GetSystemInfo+VirtualQuery sub + + // IL2CPP infrastructure + constexpr u32 IL2CPP_FindByPath = 0x09BCB0; // resolve Unity path to object + constexpr u32 WideToString = 0x00EB10; // UTF-8 → wstring + constexpr u32 BaseModule_Dtor = 0x00FA60; // shared dtor + + // ModuleManager dispatch + constexpr u32 ModMgr_UpdateLoop = 0x09AE80; + constexpr u32 ModMgr_RenderLoop = 0x09AEF0; + constexpr u32 ModMgr_HotkeyLoop = 0x09AF60; + constexpr u32 ModMgr_AddRegistrar = 0x09B2C0; + + // Theme / config preset writers (Ch.17 / Ch.28) + constexpr u32 Theme_Writer_Preset0 = 0x094890; // writes 52 color slots + constexpr u32 Theme_Writer_Preset1 = 0x096770; + constexpr u32 Theme_Writer_Preset2 = 0x098650; + constexpr u32 ColorApplicator = 0x094190; // shared helper: hex→RGBA×159 calls + + // Settings / NameChanger (Ch.19) + constexpr u32 Settings_RenderOverlay = 0x09A4F0; // Settings panel render + constexpr u32 Settings_end = 0x09AB98; // (end of Settings body) + + // UnityExplorer (Ch.16) + constexpr u32 UE_RegisterTab = 0x090060; + constexpr u32 UE_Render = 0x090250; + constexpr u32 UE_RefreshScenes = 0x090D40; +} + +// ============================================================================ +// SECTION 10 — CONFIG PRESET NAMES & STRINGS +// ============================================================================ +// Preset name string: [.data+0x00E0] (std::string, set during Settings load) +// Preset index: [.data+0x00EC] (DWORD, 0-3) +// Config file path: built by BuildFilePath (RVA 0x030A90) from [.data+0x0050]+0x50 +// Config strings (RVA): +// "Preset0" 0x3B0680 +// "Preset1" 0x3B0688 +// "Preset2" 0x3B0690 +// "Preset3" 0x3B0698 +// "EF-Cheeto.dll" 0x3B0358 (used by GABypass file scan) +// "gatmp.tmp" 0x3B0338 (temp file for bypass) +// "testyip" 0x3B0328 (test bypass marker) +// Source path embedded: "E:\git\Endfield_Cheeto\libraries\pipeline\..." + +// ============================================================================ +// SECTION 11 — KNOWN GAME API SIGNATURES (inferred from call sites) +// ============================================================================ +// These are IL2CPP managed method signatures inferred from cheat call sites. +// Calling convention: __fastcall (RCX=this/arg0, RDX=arg1, R8=arg2, etc.) +// Return in RAX (ptr/int) or XMM0 (float). + +// Transform methods +using fn_get_position = void*(*)(void* transform); // returns vec3* +using fn_set_position = void (*)(void* transform, void* vec3); +using fn_get_rotation = void*(*)(void* transform); // returns Quaternion* +using fn_set_rotation = void (*)(void* transform, void* quaternion); +using fn_get_localPos = void*(*)(void* transform); +using fn_set_localPos = void (*)(void* transform, void* vec3); +using fn_get_localScale= void*(*)(void* transform); +using fn_set_localScale= void (*)(void* transform, void* vec3); + +// GameObject methods +using fn_get_transform = void*(*)(void* gameObject); +using fn_SetActive = void (*)(void* gameObject, bool active); +using fn_get_name_go = void*(*)(void* gameObject); // returns System.String* + +// Rigidbody methods +using fn_AddForce = void (*)(void* rigidbody, void* vec3, int forceMode); +using fn_get_velocity = void*(*)(void* rigidbody); +using fn_set_velocity = void (*)(void* rigidbody, void* vec3); + +// Application +using fn_setTargetFPS = void (*)(int targetFrameRate); + +// TMPro / UI +using fn_set_text = void (*)(void* textComponent, int zero, void* wstring_ptr); + +// CharacterController +using fn_setEnabled = void (*)(void* ctrl, bool enabled, int zero); + +// Camera +using fn_Camera_main = void*(*)(void* zero); // Camera.get_main +using fn_get_fov = float(*)(void* camera); + +// SkillHack hook callbacks (return types match hooked method signatures): +using fn_BOOL_bypass = BOOL (*)(void); // Dispatcher / AvailBypass +using fn_float_bypass = float(*)(void); // CooldownBypass → returns 100.0f +using fn_void_bypass = void (*)(void); // CostBypass → early return + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 12 — IL2CPP TABLE ACCESSOR MACROS +// ============================================================================ +// Usage: CALL_IL2CPP(slot_name, RetType, arg0, ...) +// All slots live at fixed .data offsets from binary base 0x1803C5000. +// At runtime: ptr = *(void**)([.data + slot_offset]) +// +// Direct call helpers — use after GABypass has patched the table: + +#define IL2CPP_BASE_VA ((uintptr_t)0x1803C5000) +#define IL2CPP_SLOT(off) (*(void**)(IL2CPP_BASE_VA + (off))) + +// Transform +#define IL2_Transform_get_position(t) ((fn_get_position) IL2CPP_SLOT(0x1C88))(t) +#define IL2_Transform_set_position(t,v) ((fn_set_position) IL2CPP_SLOT(0x1D88))(t,v) +#define IL2_Transform_get_localPos(t) ((fn_get_localPos) IL2CPP_SLOT(0x1C80))(t) +#define IL2_Transform_set_localPos(t,v) ((fn_set_localPos)IL2CPP_SLOT(0x1C90))(t,v) +#define IL2_Transform_get_rotation(t) ((fn_get_rotation)IL2CPP_SLOT(0x1C68))(t) +#define IL2_Transform_set_rotation(t,q) ((fn_set_rotation)IL2CPP_SLOT(0x1CA8))(t,q) +#define IL2_Transform_get_localScale(t) ((fn_get_localScale)IL2CPP_SLOT(0x1C60))(t) +#define IL2_Transform_set_localScale(t,v) ((fn_set_localScale)IL2CPP_SLOT(0x1D68))(t,v) + +// GameObject +#define IL2_GO_get_transform(go) ((fn_get_transform)IL2CPP_SLOT(0x1CA0))(go) +#define IL2_GO_SetActive(go,a) ((fn_SetActive) IL2CPP_SLOT(0x1C98))(go,a) +#define IL2_GO_get_name(go) ((fn_get_name_go) IL2CPP_SLOT(0x1CC0))(go) + +// Rigidbody +#define IL2_RB_AddForce(rb,v,fm) ((fn_AddForce) IL2CPP_SLOT(0x1E00))(rb,v,fm) +#define IL2_RB_get_velocity(rb) ((fn_get_velocity) IL2CPP_SLOT(0x1D70))(rb) +#define IL2_RB_set_velocity(rb,v) ((fn_set_velocity) IL2CPP_SLOT(0x1D78))(rb,v) + +// Application +#define IL2_App_setTargetFPS(fps) ((fn_setTargetFPS) IL2CPP_SLOT(0x1D48))(fps) + +// Camera +#define IL2_Camera_main() ((fn_Camera_main) IL2CPP_SLOT(0x1DC0))(nullptr) +#define IL2_Camera_get_fov(cam) ((fn_get_fov) IL2CPP_SLOT(0x1DE8))(cam) + +// UI +#define IL2_TMPro_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E28))(comp,0,ws) +#define IL2_UI_Text_set_text(comp,ws) ((fn_set_text) IL2CPP_SLOT(0x1E30))(comp,0,ws) + +// CharacterController +#define IL2_CharCtrl_setEnabled(c,en) ((fn_setEnabled) IL2CPP_SLOT(0x1E08))(c,en,0) + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 13 — STARTUP / LOADER CHAIN +// ============================================================================ +// DLL entry and initialization sequence (Ch.11 / Ch.29) + +namespace RVA { + // Entry point chain + constexpr u32 DllMain_entry_real = 0x01000; // CRT DllMain (spawns loader thread) + constexpr u32 LoaderThread = 0x05000; // main init thread: IL2CPP + window + hooks + constexpr u32 Startup_main = 0x0A9190; // step-by-step startup (steps 1-11) + constexpr u32 ModMgr_RegisterAll = 0x09AE00; // 11 modules registered via stubs + constexpr u32 ModMgr_MainLoop = 0x082000; // Present hook + ImGui render loop (0x82000-0x82300) + constexpr u32 D3D11Init_Shaders = 0x054DC0; // D3DCompile vertex+pixel shader (x2: 0x54DC0, 0x551E8) + constexpr u32 D3D11Init_Setup = 0x082500; // ImGui Win32+D3D11 backend init, WndProc subclass + + // Startup step addresses (from Ch.11.4): + // 1 0x0A91CE AllocConsole — 'il2cpp Game Console' + // 2 0x0A9267 SetConsoleCP(0xFDE9) — UTF-8 + // 3 0x0A92F7 FindWindowA(NULL,'UnityWndClass') — poll until game window present + // 4 0x0A93CC HookInstallerWrapper(EnumProcessModules) — module scanner install + // 5 0x0A93E6 Log 'Initializing..' (source: main.cpp:53) + // 6 0x0A942F Call [g_Config+0x1E80] — IL2CPP domain resolver + // 7 0x0A945A Log 'IL2CPP Domain Found: ' (if domain non-null) + // 8 0x0A94C4 Log 'IL2CPP Thread Attached Successfully: ' + // 9 0x0A9506 Error: Log 'Failed to Attach IL2CPP Thread!' + // 10 0x0A9545 Error: Log 'IL2CPP Domain Not Found!' + // 11 0x0A959F Success: Log 'Initialized' → then launch overlay window thread (0x827A0) + + // D3D11 overlay window subsystem (Ch.29) + constexpr u32 OverlayWindowInit = 0x0827A0; // create layered window + D3D11 device (0x827A0-0x8375C) + constexpr u32 FindGameWindow = 0x0835D0; // EnumWindows callback — locate Unity window + constexpr u32 GetOverlayRect = 0x0836A0; // compute overlay rect from game window bounds + constexpr u32 D3D11_Setup_sub = 0x0825B0; // D3D11::Reinit — recreate RT + ImGui D3D11 backend + constexpr u32 WndProc = 0x0826A0; // Win32 WndProc (HWND,UINT,WPARAM,LPARAM)→LRESULT + constexpr u32 ImGui_Win32_Handler = 0x057720; // ImGui_ImplWin32_WndProcHandler — all kb/mouse + constexpr u32 PresentHook_callsite = 0x082F00; // IDXGISwapChain::Present hook call site (inside msg loop) + constexpr u32 RenderFrame = 0x082FC0; // ImGui NewFrame + per-module Render dispatch + constexpr u32 ImGui_Begin_wrapper = 0x0937D0; // ImGui::Begin wrapper (Unity Explorer Window title) + constexpr u32 ImGui_Selectable = 0x0708D0; // ImGui::Selectable (preset selector, Ch.17) + + // Thread suspension for hook install (Ch.3) + constexpr u32 CollectProcessThreads = 0x0A96B0; // Toolhelp32 snapshot → thread ID array (0xA96B0-0xA9A1C) + constexpr u32 SuspendOrResumeThreads= 0x0A9A20; // OpenThread + Suspend/Resume all (0xA9A20-0xA9A98) + constexpr u32 PatchCode = 0x0A9A9C; // VirtualProtect + write hook bytes (0xA9A9C-0xA9BC3) + + // Hook manager detailed RVAs (Ch.8) + constexpr u32 HookMgr_Install = 0x0A9CC8; // alloc trampoline + FNV hash (= CreateHook) + constexpr u32 HookMgr_Remove = 0x0A9E8C; // remove + restore original bytes + constexpr u32 HookMgr_Enable_fn = 0x0A9A9C; // toggle enabled bit + patch + constexpr u32 HookMgr_AllocTramp = 0x0A960C; // allocate trampoline slot near target VA + constexpr u32 HookMgr_FreeSlot = 0x0AA684; // free trampoline + compact hook array + constexpr u32 HookInstaller_Wrapper = 0x08BAF0; // wrapper called at 0xA93CC during startup + + // Module scanner (Ch.11.2) + constexpr u32 ModulePathScanner = 0x08B650; // scan loaded modules for testyip/gatmp/EF-Cheeto + constexpr u32 ModPathScanner_EF = 0x08B937; // wcsstr branch: search for 'EF-Cheeto.dll' + + // String helpers + constexpr u32 UTF8ToWide = 0x08B4E0; // MultiByteToWideChar CP_UTF8(0xFDE9) wrapper + constexpr u32 WideStr_wcsstr = 0x0AB6A0; // custom wcsstr — returns iterator, -1 if not found + constexpr u32 WideStr_Dtor = 0x0AB758; // wstring destructor (used in path scanner) + + // Module-specific helpers + constexpr u32 NoClip_RegisterTab = 0x00FCB0; // one-time NoClip tab init + constexpr u32 FreeCam_RegisterTab = 0x00F7D0; // one-time FreeCam tab init + constexpr u32 ManagerName_Init = 0x00FFF0; // zero std::string fields for ModuleManager name + constexpr u32 NoClip_EntityIter = 0x089DC0; // entity iterator inner loop (NoClip::Update) + constexpr u32 SetDither_Render = 0x08C490; // SetDither::Render — graphics dither toggle + constexpr u32 SkillHack_PatchFloat = 0x08E220; // installs FloatReturn hook on [g_Config+0x1E50] + constexpr u32 SkillHack_PatchBool = 0x08EBC0; // installs BoolTrue hook on [g_Config+0x1E58] + constexpr u32 SkillHack_PatchVoid = 0x08F560; // installs VoidReturn hook on [g_Config+0x1E40] + constexpr u32 SkillHack_Trampoline = 0x08FF00; // common trampoline dispatcher (calls original fn) + constexpr u32 UE_GuardReturn = 0x0901D8; // early return after once_flag sealed (UE::RegisterTab) + constexpr u32 UE_AutoRefresh = 0x093B10; // auto-refresh timer check for scene list + constexpr u32 UE_Memset_block = 0x0AC86A; // memset 0xD8 bytes at [.data+0x2200] (FreeCam init) + constexpr u32 PreventSS_Init = 0x08AD70; // once_flag guarded PreventScreenshot init + constexpr u32 PreventSS_Render = 0x08AE60; // ImGui single checkbox 'Prevent Screenshot' + constexpr u32 PreventSS_Update = 0x08AFC0; // SetWindowDisplayAffinity dispatch (per-frame) + constexpr u32 PreventSS_OsCheck = 0x08B220; // Win10 build check + affinity setter + constexpr u32 TabMgr_BeginTab_full = 0x09D7D0; // full BeginTab with state+title resolution + constexpr u32 GABypass_Init = 0x09D1E0; // 71 IL2CPP stub patch sequence + constexpr u32 Std_once_flag_Execute = 0x0AFF60; // MSVC _Execute_once (once_flag) + constexpr u32 Sidebar_Settings = 0x080770; // sidebar settings section (0x80770-0x80B50) + // ImGui_EndFrame alias: see RVA::ImGui_EndFrame (0x001C2D0) defined in Section 9 +} + +// ============================================================================ +// SECTION 14 — D3D11 OVERLAY WINDOW INIT (Ch.29 summary) +// ============================================================================ +// OverlayWindowInit (RVA 0x827A0) sequence: +// +// 29.1 DPI setup (0x827FF-0x82923): +// Try SetThreadDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) +// Fallback: SetProcessDpiAwareness(2) +// Final fallback: SetProcessDPIAware() +// Guard: [.data+0x3C7440] / [.data+0x3C7448] +// +// 29.2 Game window location + class registration (0x82924-0x82A28): +// EnumWindows(FindGameWindow@0x835D0) → locate Unity game HWND +// WNDCLASSEX: CreateSolidBrush(0x7F00), LoadCursorW, LoadIconW×2 +// RegisterClassExW +// GetSystemMetrics(SM_CXSCREEN/SM_CYSCREEN) +// +// 29.3 Overlay window + D3D11 device (0x82A29-0x82BFF): +// CreateWindowExW(WS_EX_LAYERED|WS_EX_TRANSPARENT) +// SetLayeredWindowAttributes +// DwmExtendFrameIntoClientArea (full glass) +// D3D11CreateDeviceAndSwapChain — attempt 1: DXGI_FORMAT_R8G8B8A8_UNORM +// on failure: attempt 2: DXGI_FORMAT_B8G8R8A8_UNORM +// D3D11::Reinit (0x825B0) — set up ImGui D3D11 backend +// ShowWindow / UpdateWindow +// CreateMutexA — prevent duplicate instances +// +// 29.4 Message loop (0x82C01-0x8352F): +// Log 'Initialized' (source: UI.cpp, RVA 0x3AF610) +// Loop: PeekMessageW / TranslateMessage / DispatchMessageW +// Each iter: FindWindowA('UnityWndClass',NULL) — exit if game gone +// IsWindow, GetWindowThreadProcessId, GetWindowRect +// SetWindowPos to track game window + +// WndProc (RVA 0x826A0) — pseudocode: +// LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { +// if (g_ImGuiCtx) { +// LRESULT r = ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// if (r) return 1; +// } +// switch (msg) { +// case WM_DESTROY: PostQuitMessage(0); return 0; +// case WM_SIZE: +// if (g_pSwapChain && wParam != SIZE_MINIMIZED) { +// if (g_pRenderTargetView) { g_pRenderTargetView->Release(); g_pRenderTargetView=NULL; } +// g_pSwapChain->ResizeBuffers(0,LOWORD(lParam),HIWORD(lParam),DXGI_FORMAT_UNKNOWN,0); +// D3D11_Setup_sub(); // 0x825B0 — recreate RT + shaders +// } +// return 0; +// case WM_SYSCOMMAND: +// if ((wParam & 0xFFF0) == SC_KEYMENU) return 0; +// break; +// default: +// return ImGui_ImplWin32_WndProcHandler(hwnd, msg, wParam, lParam); +// } +// return 0; +// } + +// ============================================================================ +// SECTION 15 — MODULE PATH SCANNER (Ch.11.2) +// ============================================================================ +// ModulePathScanner (RVA 0x8B650): +// Args: HANDLE process, void** module_array, DWORD count +// For each module path: +// UTF8ToWide(path) → wpath +// wcsstr(wpath, L"testyip") → if found: found_count++ +// wcsstr(wpath, L"gatmp.tmp") → if found: found_count++ +// if not found: ModPathScanner_EF (0x8B937): +// wcsstr(wpath, L"EF-Cheeto.dll") → if found: found_count++ +// Returns found_count +// +// Injection identity strings (.data): +// L"testyip" [.data+0x0318] alternate temp-file loader name +// L"gatmp.tmp" [.data+0x0338] primary temp-file loader name +// L"EF-Cheeto.dll" [.data+0x0358] published DLL name (fallback) + +// ============================================================================ +// SECTION 16 — THREAD SUSPENSION SUBSYSTEM (Ch.3) +// ============================================================================ +// CollectProcessThreads (RVA 0xA96B0): +// CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD,0) → hSnapshot +// THREADENTRY32 te32; te32.dwSize = sizeof(THREADENTRY32); +// Thread32First(hSnapshot, &te32) +// while Thread32Next: if te32.th32OwnerProcessID==GetCurrentProcessId() +// AND te32.th32ThreadID != calling_thread: append to array +// +// SuspendOrResumeThreads (RVA 0xA9A20): +// For each collected thread ID: +// hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// if suspend: SuspendThread(hThread) +// if resume: ResumeThread(hThread) +// CloseHandle(hThread) +// +// PatchCode (RVA 0xA9A9C): +// VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &oldProt) +// memcpy(target, patch_bytes, size) +// VirtualProtect(target, size, oldProt, &oldProt) +// FlushInstructionCache(GetCurrentProcess(), target, size) + +// ============================================================================ +// SECTION 17 — PREVENT SCREENSHOT MODULE (Ch.21 supplement) +// ============================================================================ +// PreventScreenshot::Initialize (RVA 0x8AD70): +// Guarded by once_flag at [.data+0x2390] +// Allocates module object (0x48 bytes) +// Sets vtable: 0x3AFA38 → 0x3B0110 after init +// Zeroes: enabled, state_dirty, second_flag +// +// PreventScreenshot::Update (RVA 0x8AFC0): +// 1. Call GetInstance (0x8AD70) +// 2. Check enabled [module+0x28] +// 3. If enabled && !state_dirty: call OsCheck (0x8B220) +// 4. Build HWND list at [.data+0x24D0] +// 5. For each HWND node [rbx+0x10]: call OsCheck affinity setter +// 6. Call HookMgr_singleton (0x81B00) to update hook state +// +// PreventScreenshot::OsCheck (RVA 0x8B220): +// Checks Windows 10 build version +// Calls SetWindowDisplayAffinity(hwnd, WDA_MONITOR) via IAT[0xB1460] +// On disable: SetWindowDisplayAffinity(hwnd, WDA_NONE) + +// ============================================================================ +// SECTION 18 — COMPLETE FUNCTION INDEX (all 91 named functions) +// ============================================================================ +// Cross-reference: function name → RVA (use RVA:: namespace above for most) +// This table captures every named entry from the doc cross-reference (Ch.24/25). + +// Name RVA Chapter +// DllMain 0x001000 Entry +// LoaderThread 0x005000 Ch.11 +// FreeCam::RegisterTab 0x00F7D0 Ch.12.3 +// FreeCam::RegisterFpsTab 0x0814C0 Ch.12.3 +// NoClip::RegisterTab 0x00FCB0 Ch.12.2 +// ManagerName::Init 0x00FFF0 Ch.15 +// ImGui::EndFrame 0x01C2D0 Ch.15 +// ConfigSerialize 0x012050 Ch.6 +// ConfigFileIO (UTF8→wide fopen) 0x011EA0 Ch.6 +// BuildFilePath 0x030A90 Ch.6 +// D3D11Init_Shaders A 0x054DC0 Ch.5 +// D3D11Init_Shaders B 0x0551E8 Ch.5 +// D3D11::CreateBuffers 0x0551F0 Ch.5 +// ImGui_ImplWin32_WndProcHandler 0x057720 Ch.7 +// ImGui::Toggle (TabMgr) 0x070820 Ch.12 +// ImGui::Selectable 0x0708D0 Ch.17 +// TabMgr::BeginTabFull 0x09D7D0 Ch.12 +// Sidebar_Settings entry 0x080770 Ch.25 +// D3D11::Setup (ImGui backend init) 0x082500 Ch.29 +// D3D11::Reinit 0x0825B0 Ch.7/29 +// WndProc 0x0826A0 Ch.7 +// OverlayWindowInit 0x0827A0 Ch.29 +// FindGameWindow 0x0835D0 Ch.29 +// GetOverlayRect 0x0836A0 Ch.29 +// PresentHook callsite 0x082F00 Ch.15.5 +// RenderFrame 0x082FC0 Ch.15 +// HookMgr_singleton 0x081B00 Ch.8 +// ESPModule singleton init 0x083E00 Ch.9 +// ESPModule::RenderOverlay 0x083FA0 Ch.22 +// SetDither::Render 0x08C490 Ch.12.5 +// CheckboxToggle 0x085320 Ch.12 +// ImGui::SliderFloat 0x065570 Ch.12.3 +// ImGui::DragInt 0x066750 Ch.12.2 +// NoClip::Render 0x0813D0 Ch.12.2 +// NoClip::Update 0x089B50 Ch.12.2 +// NoClip::EntityIterator 0x089DC0 Ch.12.2 +// FreeCam::Update 0x0871A0 Ch.12.3 +// FpsUnlocker::Render 0x085B90 Ch.12.4 +// PlayerProfile::Update 0x08A4F0 Ch.12.6 +// Vacuum::Render 0x093CA0 Ch.12.7 +// Vacuum::PhysicsLoop 0x093F10 Ch.12.7 +// Vacuum::EntityIterator 0x094000 Ch.12.7 +// SkillHack::Render (hook install) 0x08D1F0 Ch.12.8 +// SkillHack::RenderPanel 0x08D240 Ch.12.8 +// SkillHack::Dispatcher 0x08D4B0 Ch.10 +// SkillHack::CooldownBypass 0x08D500 Ch.10 +// SkillHack::AvailBypass 0x08D640 Ch.10 +// SkillHack::CostBypass 0x08D780 Ch.10 +// SkillHack::PatchFloat 0x08E220 Ch.10 +// SkillHack::PatchBool 0x08EBC0 Ch.10 +// SkillHack::PatchVoid 0x08F560 Ch.10 +// SkillHack::TrampolineDispatch 0x08FF00 Ch.10 +// PreventScreenshot::Initialize 0x08AD70 Ch.21 +// PreventScreenshot::Render 0x08AE60 Ch.21 +// PreventScreenshot::Update 0x08AFC0 Ch.21 +// PreventScreenshot::OsCheck 0x08B220 Ch.21 +// UTF8ToWide 0x08B4E0 Ch.11 +// ModulePathScanner 0x08B650 Ch.11.2 +// ModulePathScanner::EFSearch 0x08B937 Ch.11.2 +// HookInstallerWrapper 0x08BAF0 Ch.11.3 +// ImGui::InputText_ws 0x08AC20 Ch.12.6 +// HookInstaller inner 0x08BAF0 Ch.11.3 +// ColorApplicator 0x094190 Ch.28.2.1 +// Theme_Writer_Preset0 0x094890 Ch.17/28 +// Theme_Writer_Preset1 0x096770 Ch.17/28 +// Theme_Writer_Preset2 0x098650 Ch.17/28 +// Settings::RenderOverlay 0x09A4F0 Ch.19.8 +// UnityExplorer::RegisterTab 0x090060 Ch.16 +// UnityExplorer::Render 0x090250 Ch.16 +// UnityExplorer::RefreshScenes 0x090D40 Ch.16 +// UnityExplorer::GuardReturn 0x0901D8 Ch.16 +// UnityExplorer::AutoRefresh 0x093B10 Ch.16 +// ImGui::Begin wrapper 0x0937D0 Ch.16 +// ModuleManager::AddRegistrar 0x09B2C0 Ch.15 +// ModuleManager::Grow 0x09B3C0 Ch.15 +// ModuleManager::Init 0x09AC10 Ch.15 +// ModuleManager::UpdateLoop 0x09AE80 Ch.15 +// ModuleManager::RenderLoop 0x09AEF0 Ch.15 +// ModuleManager::HotkeyLoop 0x09AF60 Ch.15 +// ModuleManager::RegisterAll 0x09AE00 Ch.15 +// DispatchLoop_UpdateCatch 0x0AEBC0 Ch.15.4.1 +// DispatchLoop_RenderCatch 0x0AEC50 Ch.15.4.1 +// DispatchLoop_HotkeyCatch 0x0AECE0 Ch.15.4.1 +// IL2CPP_FindByPath 0x09BCB0 Ch.16/19 +// GABypass::Init 0x09D1E0 Ch.18 +// CollectProcessThreads 0x0A96B0 Ch.3 +// SuspendOrResumeThreads 0x0A9A20 Ch.3 +// PatchCode 0x0A9A9C Ch.3 +// Startup_main 0x0A9190 Ch.11.4 +// HookMgr_AllocTrampoline 0x0A960C Ch.8 +// HookMgr_CreateHook 0x0A9CC8 Ch.8 +// HookMgr_RemoveHook 0x0A9FA0 Ch.8 +// HookMgr_EnableHook 0x0AA140 Ch.8 +// HookMgr_FreeSlot 0x0AA684 Ch.8 +// HookMgr_Spinlock 0x0A9C88 Ch.8 +// WideStr::wcsstr 0x0AB6A0 Ch.11 +// WideStr::Dtor 0x0AB758 Ch.11 +// Memset_block 0x0AC86A (alloc+memset 0xD8 bytes) +// BaseModule::Dtor 0x00FA60 Ch.12 +// WideToString 0x00EB10 Ch.11 +// PreventScreenshot::SetAffinity 0x08B490 Ch.21 (SetWindowDisplayAffinity call site) +// Vacuum::Render (alt addr) 0x093C90 Ch.12.7 (one-byte offset alias for 0x93CA0) + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 19 — CONFIG I/O FUNCTIONS (Ch.6 complete) +// ============================================================================ + +namespace RVA { + // Config I/O + constexpr u32 ReadConfig = 0x0302D2; // fread JSON config on startup → populate g_Config + constexpr u32 ReadConfig_end = 0x030348; // ReadConfig range end + constexpr u32 SaveConfig = 0x030620; // fwrite g_Config state to JSON file (0x30620-0x307A0) + constexpr u32 SaveConfig_end = 0x0307A0; + constexpr u32 ImGuiSaveIni = 0x017078; // fwrite ImGui window layout to .ini (0x17078-0x172CA) + constexpr u32 ImGuiSaveIni_end = 0x0172CA; + constexpr u32 ConsoleDebugWrite = 0x00EA1B; // fwrite to stdout/console (debug output, size=1) + + // SaveConfig (RVA 0x30620) pseudocode: + // Check state->enabled_flag [rbx+0x2900] + // Load state->file_path ptr [rbx+0x50] + // Call BuildFilePath (0x30A90) + // Call OpenConfigFile(path, "wt") → FILE* fp + // Serialize via ConfigSerialize (0x12050) → string + // fwrite(string, 1, len, fp); fclose(fp) + // Auto-save timer: xmm0=[rbx+0x2904], timer -= delta; on expire: re-save + // + // Config field written by language selector: + // [g_Config+0x2764] content ref-count (DWORD, decremented on lang change) + constexpr u32 LangSelector_refcount_off = 0x2764; // g_Config+0x2764 = content ref-count +} + +// ============================================================================ +// SECTION 20 — LOG / PRINT / CRC32 / REGISTRY (Ch.15 / Ch.26 helpers) +// ============================================================================ + +namespace RVA { + constexpr u32 Log_Print = 0x00FDA0; // shared logging helper (called by all 3 dispatch catchers) + constexpr u32 ImGui_PushStyleColor = 0x010840; // ImGui::PushStyleColor — theme system (159 calls) + constexpr u32 CRC32_Lookup = 0x011DF0; // CRC32 of module key string (e.g. "Sidebar", "Content") + constexpr u32 Module_RegistryLookup = 0x03D1A0; // registry lookup by CRC32 hash → module ptr + constexpr u32 Module_Notify = 0x01D2B0; // module notify/update (called after lang change) + constexpr u32 ImGui_Epilogue = 0x023E20; // ImGui epilogue tail-call target (Sidebar tail-jmps here) + constexpr u32 I18n_Refresh = 0x02A530; // i18n content refresh — reload translations on lang change + constexpr u32 Locale_ContextInit = 0x09D660; // locale context init — selects "en" or "zh_cn" based on flag + constexpr u32 Label_Formatter = 0x05FB60; // sprintf-style: build "Key Name: %s" label strings + constexpr u32 ImGui_Combo = 0x064220; // ImGui::Combo (language dropdown, 2-item list) + constexpr u32 FPS_StringBuild = 0x07F5C0; // build "FPS: NNN" string for FPS overlay +} + +// i18n language flag: [.data+0x3C77B0] (VA 0x1803C77B0) +// 0 = English (RVA 0x3AF310) +// 1 = 简体中文 (RVA 0x3AF318) +// Language tab label: " Language" (RVA 0x3AF328, 5-space indent) +// Combo widget ID: "##Language" (RVA 0x3AF338) + +// ============================================================================ +// SECTION 21 — SIDEBAR / MAIN PANEL (Ch.25 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 Sidebar_Render = 0x07F8F0; // top-level overlay panel (0x7F8F0, ~0x146E bytes) + // Sidebar_Render calls: + // CRC32_Lookup(0x11DF0) on "Sidebar" key (RVA 0x3AF2C8) + // Module_RegistryLookup(0x3D1A0) + // Module_Notify(0x1D2B0) + // Language selector sub-panel (0x80770-0x80B50) unconditionally + // Jump-table dispatch for all tab bodies + // Tail-jmp to ImGui_Epilogue (0x23E20) at 0x80D5E + // Stack frame: 0x380 bytes; saves xmm6–xmm8; single rcx arg (ModuleManager ptr) + // + // Key strings: + // Banner: "EF - Cheeto Press F12 to show panel" (RVA 0x3AF258) + // Disclaimer: "This is free, if you spend money, then you have been deceived" (RVA 0x3AF288) + // Window key: "Sidebar" (RVA 0x3AF2C8) — ImGui::Begin not called inside 0x7F8F0 itself + // Active tab index written to [.data+0x1F68] on click, read by jump table + + constexpr u32 Lang_Selector_start = 0x080770; // language selector sub-panel start (unconditional) + constexpr u32 Lang_Selector_end = 0x080B50; // language selector sub-panel end +} + +// Language selector execution flow (Ch.26.2): +// 0x80895 call Locale_ContextInit(0x9D660) +// 0x808DD lea rsi, "English" (RVA 0x3AF310) +// 0x808E3 lea rbx, "简体中文" (RVA 0x3AF318) +// 0x809A1 lea rdx, " Language" (RVA 0x3AF328) +// 0x809C6 call TabMgr::BeginTab(0x9D7D0) +// 0x80A03 call ImGui::Combo(0x64220) → al=1 if changed +// 0x80A2F if English: mov [.data+0x3C77B0], 0 +// 0x80A5D if ZH-CN: mov [.data+0x3C77B0], 1 +// 0x80A6E call I18n_Refresh(0x2A530) +// 0x80A73 dec [g_Config+0x2764] (content ref-count) +// 0x80A80 rax = [g_Config+0x15D8] (active config preset ptr) +// 0x80A87 [rax+0x103] = 1 (dirty flag → triggers config save) +// 0x80B0B lea rcx, "Content" (RVA 0x3ADFC8) +// 0x80B12 call CRC32_Lookup(0x11DF0) +// 0x80B33 call Module_RegistryLookup(0x3D1A0) +// 0x80B4D call Module_Notify(0x1D2B0) + +// ============================================================================ +// SECTION 22 — ESPMODULE COMPLETE FUNCTION TABLE (Ch.22) +// ============================================================================ + +namespace RVA { + constexpr u32 ESPModule_Init = 0x083E00; // lazy singleton init (thread-safe static) + constexpr u32 ESPModule_Render = 0x083F60; // Ch.22 §22.1 — "ESP Features" collapsing header + constexpr u32 ESPModule_DrawOverlay = 0x083000; // Ch.22 §22.2 — world-space entity label overlay + constexpr u32 ESPModule_Update = 0x084A00; // per-frame entity label draw loop start + constexpr u32 ESPModule_Update_loop = 0x0852A5; // entity label loop body +} +// ESPModule::RenderOverlay (0x83FA0–0x8499E): large monolithic ImGui panel +// ESPModule::Update entity type dispatch: 0=enemy, 1=interactive, 2=friendly, 3=npc, 4=puzzle + +// ============================================================================ +// SECTION 23 — FPSMODULE COMPLETE (Ch.20) +// ============================================================================ + +namespace RVA { + constexpr u32 FPSModule_Initialize = 0x0814C0; // once_flag guarded init (once_flag at [.data+0x2310]) + constexpr u32 FPSModule_RenderPanel = 0x085660; // panel render (two checkboxes: FPS Monitor + Show FPS Overlay) + constexpr u32 FPSModule_RenderPanel_branch = 0x0856F0; // inner ImGui branch of panel render + constexpr u32 FPSModule_RenderOverlay = 0x085700; // FPS counter overlay start + constexpr u32 FPSModule_RenderOverlay_end = 0x085900; // FPS counter overlay end + constexpr u32 FPSModule_RenderOverlay_counter = 0x0858D0; // "##Foreground" frameless window (FPS display) +} +// FPSModule::Initialize (0x814C0): +// Guarded by once_flag at [.data+0x2310] +// Alloc 0xD8 bytes (via 0xAC86A), store ptr at [.data+0x22E0] +// vtable: 0x3AFA38 → 0x3AFAC0 after init +// name: "FPS Monitor" (RVA 0x3AFA88) at [.data+0x22E8] +// enabled = 0 at [.data+0x2308] +// +// FPSModule overlay color thresholds (RVA of XMMWORD constants): +// fps >= 60: 0x1803B3530 (green) +// 30 <= fps < 60: 0x1803B3540 (yellow) +// fps < 30: 0x1803B3510 (red) +// FPS display string built by FPS_StringBuild (0x7F5C0): "FPS: " + integer + +// ============================================================================ +// SECTION 24 — SETDITHER COMPLETE (Ch.12.5.1) +// ============================================================================ + +namespace RVA { + constexpr u32 SetDither_RenderOverlay = 0x08C4A0; // SetDither::RenderOverlay — distinct from RegisterTab + // SetDither::RenderOverlay is invoked by the tab-callback pointer chain + // (not directly from RegisterTab at 0x81810) + // Implements the graphics dither toggle panel body +} + +// ============================================================================ +// SECTION 25 — FREECAM KEY BINDING DISPLAY (Ch.27.3) +// ============================================================================ +// Key display sub-panel inside FreeCam tab (when enabled): +// Each row uses: MakeString(0xFCB0) → Label_Formatter(0x5FB60) → TabMgr::BeginTab(0x9D7D0) +// Key binding state array: [rip + ...] # 0x1803C6E98 ("Pu;" RTTI sentinel in .data) +// Key label format strings (RVAs): +// "Forward Key: %s" 0x3AFD08 VA 0x180087A87 +// "Backward Key: %s" 0x3AFD18 VA 0x180087B1A (approx) +// "Left Key: %s" 0x3AFD30 +// "Right Key: %s" 0x3AFD40 +// "Up Key: %s" 0x3AFD50 +// "Down Key: %s" 0x3AFD60 +// "IncFOV Key: %s" 0x3AFD70 +// "DecFOV Key: %s" 0x3AFD80 +// "LeftRoll Key: %s" 0x3AFD90 +// "RightRoll Key: %s" 0x3AFDA8 +// "ResetRoll Key: %s" 0x3AFDC0 +// "NONE" 0x3AF820 — displayed for any unbound key + +namespace RVA { + constexpr u32 FreeCam_KeyDisplay = 0x087A87; // FreeCam key binding display panel start +} + +// ============================================================================ +// SECTION 26 — SKILLHACK INTERNALS (Ch.10 complete) +// ============================================================================ + +namespace RVA { + constexpr u32 SkillHack_FNV_hash = 0x08D555; // FNV-1a 64-bit hash (unrolled, 8-byte XOR/MUL loop) + // FNV constants: prime=0x100000001B3, offset=0xCBF29CE484222325 + constexpr u32 SkillHack_HashMiss = 0x08D770; // hash miss fallback: xor al,al → ret 0 + constexpr u32 SkillHack_CallOrig = 0x08D891; // call-original trampoline: call r8 (original fn) + constexpr u32 SkillHack_SkipRet = 0x08D894; // skip-to-ret jmp target (cost bypass early exit) + constexpr u32 Vacuum_Monster_subss = 0x093EAC; // Vacuum::Render Monster sub-checkbox subss sequence +} + +// ============================================================================ +// SECTION 27 — CRT SECURITY FUNCTIONS (Ch.4) +// ============================================================================ + +namespace RVA { + constexpr u32 CRT_SecurityInit = 0x0AC580; // __security_check_cookie + SEH init (0xAC580-0xAC6CA) + constexpr u32 CRT_SecurityInit_end = 0x0AC6CA; + constexpr u32 CRT_SecurityCookie = 0x0AC6CC; // __security_check_cookie verifier (0xAC6CC-0xAC77B) + constexpr u32 CRT_SecurityCookie_end= 0x0AC77B; +} +// CRT_SecurityInit pseudocode (called at DllMain + first-chance exception dispatch): +// call IsProcessorFeaturePresent(0x17) → if supported: int 29h (fast fail) +// call __security_check_cookie helper (sub_0x1800AC574) +// RtlCaptureContext / RtlLookupFunctionEntry / RtlVirtualUnwind +// Build EXCEPTION_RECORD: code=0x40000015 (STATUS_FATAL_APP_EXIT), flags=NONCONTINUABLE +// call IsDebuggerPresent → save eax +// call SetUnhandledExceptionFilter(NULL) +// call UnhandledExceptionFilter(&record) +// if !result && !debugger: call TerminateProcess(handle, code) [via int 29h at 0xAC628] + +// ============================================================================ +// SECTION 28 — THREAD ENUMERATION DETAIL (Ch.3 call-site map) +// ============================================================================ +// All CollectProcessThreads (0xA96B0) internal call sites: +// 0xA9701 TH32CS_SNAPTHREAD = 4 (lea ecx,[rbx+4]) +// 0xA970B CreateToolhelp32Snapshot(4, pid) +// 0xA971E sizeof(THREADENTRY32) = 28 = 0x1C +// 0xA972F Thread32First(hSnapshot, &te32) +// [loop body] +// 0xA9740 check te32.th32OwnerProcessID offset (0x10) +// 0xA974B GetCurrentProcessId() +// 0xA9751 cmp te32.th32OwnerProcessID, eax +// 0xA9757 GetCurrentThreadId() +// 0xA975D cmp te32.th32ThreadID, eax +// 0xA9761 je skip (exclude caller thread) +// 0xA9763 get vector data ptr +// 0xA9778 VirtualAlloc/HeapReAlloc if vector full +// 0xA97CA store thread ID: [rdx+rcx*4] = eax +// 0xA97CD inc [rdi+0xC] (vector count++) +// 0xA97DD Thread32Next(hSnapshot, &te32) +// 0xA97E3 test eax,eax → jne loop +// 0xA97EB GetLastError → cmp 0x12 (ERROR_NO_MORE_FILES) +// 0xA9815 CloseHandle(hSnapshot) +// +// SuspendOrResumeThreads (0xA9A20) call sites: +// 0xA9849 OpenThread(THREAD_SUSPEND_RESUME, FALSE, tid) +// 0xA9861 SuspendThread(hThread) +// 0xA9964 ResumeThread(hThread) [×37 total resume calls] +// 0xA988B GetThreadContext(hThread, &ctx) +// 0xA993C CreateToolhelp32Snapshot (secondary snapshot) +// +// PatchCode (0xA9A9C) call sites: +// 0xA9AFC VirtualProtect(target, size, PAGE_EXECUTE_READWRITE, &old) +// 0xA9B6C VirtualProtect(target, size, old, &old) (restore) +// 0xA9B72 GetCurrentProcess() +// 0xA9B81 FlushInstructionCache(hProc, target, size) + +// ============================================================================ +// SECTION 29 — IAT CALL SITE MAP (Ch.2 complete) +// ============================================================================ +// All Win32 IAT entries with RVAs and call sites: +// SuspendThread IAT 0xB1050 call site 0xA9861 +// ResumeThread IAT 0xB1058 call site 0xA9964 (×37) +// GetThreadContext IAT 0xB1068 call site 0xA988B +// FlushInstructionCache IAT 0xB1070 call site 0xA9B81 +// SetThreadContext IAT 0xB1078 call site 0xA993C +// GetProcAddress IAT 0xB1088 call sites 0x55F7E, 0x55F92 (×7) +// LoadLibraryA IAT 0xB10E0 call sites 0x55F57, 0x585AE (×4) +// AllocConsole IAT 0xB1108 +// GetConsoleMode IAT 0xB1120 +// SetConsoleMode IAT 0xB1128 +// SetConsoleTitleA IAT 0xB12A0 +// GetCurrentProcess IAT 0xB1270 call site 0xA9B72 +// VirtualFree IAT 0xB1278 call sites 0x81D5B, 0xAA6E1 +// VirtualProtect IAT 0xB1288 call sites 0xA9AFC, 0xA9B6C +// VirtualAlloc IAT 0xB11A0 call sites 0xAA566, 0xAA607 +// IsDebuggerPresent IAT 0xB11E8 call site 0xAC67B +// IsProcessorFeaturePresent IAT 0xB11F0 call site 0xAC5A2 +// TerminateProcess IAT 0xB11F8 call site 0xAC628 (via int 29h) +// SetUnhandledExceptionFilter IAT 0xB1200 call site 0xAC698 +// UnhandledExceptionFilter IAT 0xB1208 call site 0xAC6A3 +// RtlVirtualUnwind IAT 0xB1210 +// RtlLookupFunctionEntry IAT 0xB1218 +// RtlCaptureContext IAT 0xB1220 +// OpenThread IAT 0xB11D0 call site 0xA9849 (×38) +// Thread32Next IAT 0xB11A8 call site 0xA97DD +// Thread32First IAT 0xB11B0 call site 0xA972F +// CreateToolhelp32Snapshot IAT 0xB1160 call site 0xA970B +// SetWindowDisplayAffinity IAT 0xB1460 call site 0x8B48F +// FindWindowA IAT 0xB14A8 call site 0x8301F +// EnumWindows IAT 0xB14A0 +// GetWindowRect IAT 0xB1488 +// GetWindowThreadProcessId IAT 0xB1498 +// IsWindow IAT 0xB1468 +// GetSystemMetrics IAT 0xB14E0 +// LoadIconW IAT 0xB14E8 +// GetAsyncKeyState IAT 0xB???? call site 0x8301A +// ShowWindow IAT 0xB1628 +// UpdateWindow IAT 0xB14D8 +// RegisterClassExW IAT 0xB1638 +// CreateWindowExW IAT 0xB1650 +// SetLayeredWindowAttributes IAT 0xB15E0 +// SetProcessDPIAware IAT 0xB15A0 +// LoadCursorW IAT 0xB15C8 +// PeekMessageW IAT 0xB14D0 +// TranslateMessage IAT 0xB14C8 +// DispatchMessageW IAT 0xB14C0 +// PostQuitMessage IAT 0xB???? (WndProc WM_DESTROY) +// SetWindowPos IAT 0xB???? (overlay alignment) +// CreateSolidBrush IAT 0xB1018 +// CreateMutexA IAT 0xB1720 +// DwmExtendFrameIntoClientArea IAT 0xB1918 +// D3D11CreateDeviceAndSwapChain IAT 0xB1908 +// D3DCompile IAT 0xB1000 call sites 0x54E77, 0x55069 +// _wfopen IAT 0xB1888 call site 0x11F93 +// fwrite IAT 0xB1868 call sites 0xEA1B, 0x170D6, 0x3033B, 0x3076D +// fread IAT 0xB1870 (via 0x11EA0 helper) +// fclose IAT 0xB1878 call sites 0x170DF, 0x30776 + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 30 — REMAINING CALL-SITE ADDRESSES (final gap closure) +// ============================================================================ +// These are internal addresses referenced in the doc that complete coverage. +// They are instruction-level addresses, not function entry points. + +namespace RVA { + // Config I/O range markers + constexpr u32 OpenConfigFile_end = 0x012043; // OpenConfigFile range end (0x11EA0–0x12043) + constexpr u32 ImGuiSaveIni_caller = 0x0170B9; // caller VA of ImGuiSaveIni (fopen 'wt' for .ini) + constexpr u32 SaveConfig_iniwrite = 0x030750; // SaveConfig: write ImGui ini section call site + + // FpsUnlocker alt address (function table ref) + constexpr u32 FpsUnlocker_Render_alt = 0x085B80; // FpsUnlocker::Render alt ref addr (one-byte offset) + + // FreeCam key display + constexpr u32 FreeCam_BackwardKey = 0x087B1A; // "Backward Key: %s" display address (approx) + + // ModuleManager::DispatchRegistrarInit call site + constexpr u32 DispatchRegInit_callsite = 0x083348; // called at 0x83348 — init ImGui panel layout after first Present + + // ModulePathScanner skip-on-failure + constexpr u32 ModPathScanner_skip = 0x08BA41; // je target: skip module on GetModuleFileNameW failure + + // CollectProcessThreads instruction-level addresses (within 0xA96B0 body) + // 0xA96E7 xor ebx,ebx — thread count = 0 + // 0xA96F8 init empty vector — mov [rcx],rbx; mov [rcx+8],rbx + // 0xA9711 mov r14,rax — hSnapshot = CreateToolhelp32Snapshot result + // 0xA9714 cmp rax,-1 — INVALID_HANDLE_VALUE check + // 0xA9725 lea rdx,[rsp+0x30] — THREADENTRY32 buffer ptr + // 0xA972A mov [rsp+0x30],r12d — te32.dwSize = 28 + // 0xA9751 cmp [rsp+0x3C],eax — te32.th32OwnerProcessID == GetCurrentProcessId + // 0xA9755 jne skip — skip threads from other processes + // (All within CollectProcessThreads body at 0xA96B0; see Section 28 for full map) +} + +// ============================================================================ +// END +// ============================================================================ + +// ============================================================================ +// SECTION 19 — SIDEBAR / MAIN PANEL (Ch.25) +// ============================================================================ +// Top-level overlay panel function: RVA 0x7F8F0 (~0x146E bytes) +// Called every Present() frame from ModuleManager render loop. +// Stack frame: 0x380 bytes; saves xmm6-xmm8; single rcx arg (global ctx ptr) +// +// Key strings: +// "Sidebar" RVA 0x3AF2C8 — window lookup key (CRC32 0x11DF0, reg 0x3D1A0/0x1D2B0) +// "EF - Cheeto Press F12 to show panel" RVA 0x3AF258 +// "This is free, if you spend money, then you have been deceived" RVA 0x3AF288 +// Active tab index: [.data+0x1F68] VA 0x1803C6F68 (written on click, read at 0x80B52) +// +// Six tabs (jump-table dispatch at 0x80B52, case bodies): +// Tab 0 "About" RVA 0x3AF2D0 — banner + disclaimer + About sub-fn (0x80E80) +// Tab 1 "Player" RVA 0x3AF2DC — NoClip, SkillHack +// Tab 2 "ESP" RVA 0x3AF2E8 — ESPModule overlay +// Tab 3 "World" RVA 0x3AF2F0 — Vacuum +// Tab 4 "Visual" RVA 0x3AF2FC — FPSMonitor, FreeCam, SetDither, FpsUnlocker, PlayerProfile +// Tab 5 "Settings" RVA 0x3ADFD8 — Settings::RenderOverlay (case 5 at 0x80D25) +// +// i18n label dispatcher: 0x9D660 (translates label string per language toggle) +// Sidebar function tail-calls into ImGui epilogue at 0x23E20 via jmp at 0x80D5E + +namespace RVA { + constexpr u32 Sidebar_Main = 0x07F8F0; // top-level sidebar render + constexpr u32 Sidebar_About = 0x080E80; // About tab sub-function + constexpr u32 Sidebar_JumpTable = 0x080B52; // tab jump table (reads [.data+0x1F68]) + constexpr u32 Sidebar_Case5 = 0x080D25; // Settings tab case entry + constexpr u32 i18n_Dispatcher = 0x09D660; // translation dispatcher (en/zh_cn) + // ImGui_Combo = 0x064220 (already defined in Section 9 RVA namespace) + // ImGui_Epilogue = 0x023E20 (already defined in Section 9 RVA namespace) + constexpr u32 CRC32_fn = 0x011DF0; // CRC32 hash (window key) + constexpr u32 Registry_lookup = 0x03D1A0; // registry lookup by CRC32 + constexpr u32 Registry_lookup2 = 0x01D2B0; // secondary registry lookup +} + +// ============================================================================ +// SECTION 20 — FREECAM KEY BINDING DISPLAY PANEL (Ch.27) +// ============================================================================ +// Sub-section of FreeCam::Update (RVA 0x871A0), begins at ~0x87A70, ends 0x88606 +// (FreeCam::Update is 0x14C6 bytes total) +// +// Float sliders (ImGui variant 0x65570): +// "Free Camera" RVA 0x3AFCB0 — sub-panel BeginTab label +// "ON / OFF" RVA 0x3AF848 — toggle checkbox +// "Move Speed" RVA 0x3AFCC0 — DragFloat fmt "%.3f" (0x3ADFB0) +// "Look Sensitivity" RVA 0x3AFCD0 — DragFloat fmt "%.3f" +// "Roll Speed" RVA 0x3AFCE8 — DragFloat fmt "%.3f" +// "FOV Speed" RVA 0x3AFCF8 — DragFloat fmt "%.3f" +// "FOV" RVA 0x3AFD04 — DragFloat fmt "%.1f" (0x3ADFEC) +// +// Key binding rows (11 total) — each row: +// MakeString(0xFCB0) → sprintf(0x5FB60, "Key: %s", key_name) → TabLabel(0x9D7D0) +// "NONE" RVA 0x3AF820 — displayed for unbound keys +// Key-binding state array: [rip+...] 0x1803C6E98 +// Rows: +// "Forward Key: %s" RVA 0x3AFD08 (VA 0x180087A87) +// "Backward Key: %s" RVA 0x3AFD18 +// "Left Key: %s" RVA 0x3AFD30 +// "Right Key: %s" RVA 0x3AFD40 +// "Up Key: %s" RVA 0x3AFD50 +// "Down Key: %s" RVA 0x3AFD60 +// "IncFOV Key: %s" RVA 0x3AFD70 +// "DecFOV Key: %s" RVA 0x3AFD80 +// "LeftRoll Key: %s" RVA 0x3AFD90 +// "RightRoll Key: %s" RVA 0x3AFDA8 +// "ResetRoll Key: %s" RVA 0x3AFDC0 + +namespace RVA { + constexpr u32 FreeCam_KeyBindPanel = 0x087A70; // key binding display section start + constexpr u32 FreeCam_KeyBind_end = 0x088606; // end of FreeCam::Update + constexpr u32 Sprintf_label = 0x05FB60; // sprintf-style label formatter +} + +// ============================================================================ +// SECTION 21 — SETTINGS TAB (Ch.28) +// ============================================================================ +// Settings::RenderOverlay RVA 0x9A4F0 (source: SettingsTAB.cpp RVA 0x3B0B30) +// Called from sidebar case 5 (0x80D25). Ends at ~0x9AB31. +// +// 28.1 Theme selector: +// ImGui::Combo("Theme", ...) via 0x64220 +// Four themes → four applicator functions: +// "Default" RVA 0x3B0AF8 → applicator 0x941F0 (restores ImGui defaults) +// "Evangelion Unit 01" RVA 0x3B06D0 → applicator 0x94890 (52 color writes) +// "Evangelion Unit 02" RVA 0x3B0AE0 → applicator 0x96770 +// "Matrix" RVA 0x3B0B10 → applicator 0x98650 +// Each non-default applicator uses per-slot helper RVA 0x94190 (159 calls total): +// reads RRGGBBAA hex string → __stdio_common_vsscanf → ImGui::PushStyleColor (0x10840) +// +// Evangelion Unit 01 colors (RVA 0x94890, in write order): +// #FFFFFFFF #7857A7FF #19171CFF #2A282EFF #2A282EE6 #4DE6A5FF +// #00000000 #4A455240 #A38CCF80 #7857A780 #4A4552FF +// +// Evangelion Unit 02 colors (RVA 0x96770): +// #FFFFFFFF #D9293BFF #1E1E1EFF #3A3A3AFF #3A3A3AE6 #F7B302FF +// #00000000 #4A455240 #F7465880 #D9293B80 #4A4552FF +// +// Matrix colors (RVA 0x98650): +// #00FF41FF #00AA2CFF #000000FF #0A0A0AFF #0A0A0AE6 #004400FF +// #00000000 #00440040 #00881EFF #00FF4180 +// +// 28.3 Console toggle: +// CheckboxToggle(0x85320) with label "Toggle Console" (RVA 0x3B0B00) +// Enabled branch: AllocConsole (IAT 0xB1178) / GetStdHandle → display "Console {}" +// Disabled branch: FreeConsole + +namespace RVA { + constexpr u32 Theme_Default = 0x0941F0; // restores ImGui default palette + constexpr u32 StyleColor_push = 0x010840; // ImGui::PushStyleColor wrapper + // Settings_end 0x09AB31 — see also RVA::Settings_end 0x09AB98 in Section 9 +} + +// ============================================================================ +// SECTION 22 — CONFIG / IMGUI .INI SYSTEM (Ch.19) +// ============================================================================ +// ImGui .ini filename: "imgui.ini" RVA 0x3ABB60 +// Set at RVA 0x1117A into ImGuiIO+0x20 (IniFilename field) +// +// Config save/load: +// Load path (startup): RVA 0x30661 → ConfigSerialize (0x12050) +// → ftell (0x120A0) → fseek (0x120BC, 0x120E7) → ftell → fread → fclose +// Manual save trigger: RVA 0x17072 +// Sets [ImGuiContext+0x2900]=1, [ImGuiContext+0x2904]=0 → forces immediate write +// fwrite calls: 0x3076D (config body), also 0x170D6 +// fclose: 0x30776 +// +// Module settings handler struct (ImGuiContext+0x2920 array, 0x48 bytes each): +// +0x00 TypeName (const char*) — .ini section name +// +0x08 TypeHash (u32) — CRC32 of TypeName (computed 0x3079C–0x30803) +// +0x18 ReadOpenFn — called on section header encounter +// +0x38 WriteAllFn — called during save to emit key=value lines +// 11 registered modules (RTTI .data+0x0590–0x0E60): +// ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule +// +// i18n blob: RVA 0x3B10E8 (0xEED bytes, nlohmann JSON, en→zh_cn map) +// Copied to [.data+0x1EB8] at startup RVA 0x2164 +// Loader: RVA 0x9D660 — selects en or zh_cn based on language flag +// nlohmann version: v3.12.0 (statically linked; error strings at 0x3B3010–0x3B30D8) + +namespace RVA { + constexpr u32 ImGuiIni_set = 0x01117A; // IniFilename = "imgui.ini" write + constexpr u32 Config_save_trigger = 0x017072; // manual save: set ImGuiCtx+0x2900 + constexpr u32 Config_load_entry = 0x030661; // config file load entry + constexpr u32 Config_ftell = 0x0120A0; // ftell in config read + constexpr u32 Config_fseek_A = 0x0120BC; // fseek in config read + constexpr u32 Config_fseek_B = 0x0120E7; // fseek in config read + constexpr u32 Config_fwrite = 0x03076D; // config body fwrite + constexpr u32 Config_fclose = 0x030776; // config fclose + constexpr u32 ImGui_handler_CRC = 0x03079C; // CRC32 of TypeName (start) + constexpr u32 ImGui_handler_CRC_end = 0x030803; // CRC32 of TypeName (end) + constexpr u32 i18n_blob_rva = 0x3B10E8; // JSON localization blob (.rdata) + constexpr u32 i18n_loader = 0x09D660; // translation dispatcher + constexpr u32 i18n_copy_site = 0x02164; // startup: copies blob to [.data+0x1EB8] + constexpr u32 Registrar_name_str = 0x01B71; // registrar constructor name string RVA ref +} + +// ============================================================================ +// SECTION 23 — UNITY EXPLORER MODULE (Ch.16 supplement) +// ============================================================================ +// UE draw body: RVA 0x0902E0 (per-frame inspector UI, called from UE::Render 0x90250) +// Window title: "Unity Explorer Window" RVA 0x3B02E0 (via ImGui::Begin wrapper 0x937D0) +// +// Scene panel (pseudocode): +// if (scene_list empty) { +// ImGui::Text("No scenes available. Click 'Refresh Scenes' to load."); +// } else { +// ImGui::Text("Select Scene:"); +// ImGui::Combo("##SceneCombo", &selected_scene_idx, scene_list, n_scenes); +// if (changed) LoadScene(selected_scene_idx); +// } +// // When scene panel active: g_Config->overlay_flags |= 1; overlay_scale = 300.0f +// // ([g_Config+0x1F78], [g_Config+0x1F90]) +// +// Auto-refresh (RVA 0x090250): +// if (enabled && auto_refresh) { +// now = GetTime(); // 0x93B10 +// if ((now - last_refresh_time) * SCALE >= refresh_interval) +// RefreshScenes(this); last_refresh_time = now; +// } +// +// Scene list storage: vector at [this+0x58]..[this+0x60] +// GameObject list: vector at [this+0x40]..[this+0x48] +// Search filter: [this+?] char[0x100] buffer "##SearchFilter" +// +// Inspector panel (when object selected via 'Ins' button): +// 'Active' checkbox → GameObject.SetActive via IL2CPP +// Transform: Position, LocalPosition, Rotation, Scale (float3 inputs) +// 'Components' section via IL2CPP GetComponents(UnityEngine.Component) +// Per component: "%s.%s" (namespace.classname) +// Failure strings: "Unknown Component", "Unable to get GameObject class information." +// +// Key strings (Ch.16.4): +// "No scenes available. Click 'Refresh Scenes' to load." +// "Select Scene:" "No GameObjects found in this scene." "DontDestroyOnLoad" +// "No GameObject selected." "Active" "Components" "All Components:" + +namespace RVA { + constexpr u32 UE_DrawBody = 0x0902E0; // main per-frame inspector draw + constexpr u32 UE_AutoRefresh_fn = 0x093B10; // auto-refresh timer check +} + +// ============================================================================ +// SECTION 24 — ADDITIONAL IAT ENTRIES (referenced in doc but not in Ch.2 table) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw offset 0xAF600) +// These slots appear in inline code references throughout the doc: + +// IAT[0xB1148] SwitchToThread — spinlock backoff (if backoff<32: SwitchToThread else Sleep(1)) +// IAT[0xB1168] GetModuleFileNameExW — module path scanner, get full path of each module +// IAT[0xB1178] AllocConsole — Settings console toggle enable branch +// IAT[0xB1290] GetModuleHandleW — GABypass: GetModuleHandleW(L"GameAssembly.dll") +// also: PreventScreenshot::OsCheck loads ntdll for RtlGetVersion + +// ============================================================================ +// SECTION 25 — MODULEMANGER INIT VARIANT ADDRESS (Ch.19.7) +// ============================================================================ +// Two RVAs for ModuleManager::Init appear in the doc: +// RVA 0x09AC10 — from Ch.15 (primary reference) +// RVA 0x09ACA4 — from Ch.19.7 (alternate call site / body continuation) +// Both refer to the same function; 0x9AC10 is entry, 0x9ACA4 is within body. +// Body action (Ch.19.7): +// Iterates module registry [.data+0x23B8], calls vtable[+0x10] → module instance, +// then vtable[+0x18] (Render dispatch) per registered module. +// Source: ModuleManager.cpp lines 34 and 52 (assert strings in binary). + +// Vacuum::RegisterTab stub at RVA 0x9B650 resolves via jmp to +// UnityExplorerModule::RegisterTab at RVA 0x090060. +// (Vacuum and UE share a registrar stub due to module ordering in init sequence) + +// GABypass::Patch call site in startup: RVA 0x0A942A +// Called exactly once from LoaderThread, immediately after 'Initializing..' log (0xA93E6) +// and before any module Update()/Render() calls. + +// ============================================================================ +// SECTION 26 — COMPLETE ADDRESS COVERAGE INDEX +// ============================================================================ +// All 282 unique cheat-range addresses extracted from the doc, organized by subsystem. +// Addresses not in RVA:: namespace appear inline below with descriptions. + +// -- Config / i18n / .ini system -- +// 0x01B71 registrar constructor name string ref +// 0x02164 i18n blob copy to [.data+0x1EB8] at startup +// 0x1117A ImGuiIO.IniFilename = "imgui.ini" write site +// 0x17072 manual config save trigger (sets ImGuiCtx+0x2900=1) +// 0x30661 config file load entry (calls ConfigSerialize 0x12050) +// 0x30904 ImGui handler struct layout base (from CRC32 compute chain) + +// -- Sidebar / UI -- +// 0x80B52 sidebar tab jump table (reads active_tab_idx [.data+0x1F68]) + +// -- D3D11 overlay window (detailed call sites Ch.29) -- +// 0x8298B EnumWindows → FindGameWindow, end of DPI section +// 0x82A60 DwmExtendFrameIntoClientArea call site +// 0x82B24 D3D11CreateDeviceAndSwapChain attempt 1 (R8G8B8A8) +// 0x82B7E D3D11CreateDeviceAndSwapChain attempt 2 (B8G8R8A8 fallback) +// 0x82C0D CreateMutexA — duplicate-instance guard +// 0x82F5F Log "Initialized" (source UI.cpp, before message loop) +// 0x83386 DispatchRegistrarInit once_flag — install registrar hooks +// 0x8348A SwitchToThread yield site (game out of focus) + +// -- FreeCam -- +// 0x87A70 FreeCam key binding display panel start (inside FreeCam::Update) +// 0x88606 FreeCam::Update end + +// -- UnityExplorer -- +// 0x902E0 UE main draw body (scene panel + GO inspector) + +// -- Settings / Theme -- +// 0x941F0 Default theme applicator (restores ImGui defaults) +// 0x9AB31 Settings::RenderOverlay approximate end + +// -- ModuleManager -- +// 0x9ACA4 ModuleManager::Init body (alt addr, iterates registry vtable[+0x10]/[+0x18]) +// 0x9B650 Vacuum/UE RegisterTab shared stub (resolves to UE::RegisterTab 0x90060) + +// -- Startup -- +// 0xA942A GABypass::Patch call site in LoaderThread (after 'Initializing..' log) + +// -- IAT slots (additional, not in main IAT table) -- +// 0xB1148 SwitchToThread +// 0xB1168 GetModuleFileNameExW +// 0xB1178 AllocConsole +// 0xB1290 GetModuleHandleW (GameAssembly + ntdll RtlGetVersion) + +// ============================================================================ +// SECTION 27 — COMPLETE .RDATA STRING TABLE +// ============================================================================ +// All 189 .rdata string RVAs from the document, grouped by subsystem. +// Format: RVA — "string content" — usage + +// --- ImGui / config filenames --- +// 0x3ABB60 "imgui.ini" ImGuiIO+0x20 IniFilename (written at RVA 0x1117A) +// 0x3ABB70 "imgui_log.txt" ImGuiIO+0x28 LogFilename (written at same site) +// 0x3ABF10 "##Foreground" FPS overlay frameless window label +// 0x3AC160 "Calling EndDisabled() too many times!" ImGui assert string + +// --- D3D11 shaders (HLSL source, compiled at runtime) --- +// 0x3AE660 Vertex shader HLSL source length=0x2DD (733 bytes) +// entry="main" target="vs_4_0" +// cbuffer vertexBuffer:b0 { float4x4 ProjectionMatrix } +// VS_INPUT{float2 pos:POSITION, float4 col:COLOR0, float2 uv:TEXCOORD0} +// PS_INPUT main: output.pos = mul(ProjectionMatrix, float4(pos.xy,0,1)) +// 0x3AE940 Pixel shader HLSL source length=0x191 (401 bytes) +// entry="main" target="ps_4_0" +// sampler sampler0; Texture2D texture0; +// float4 main: return input.col * texture0.Sample(sampler0, input.uv) + +// --- PreventScreenshot --- +// 0x3AEC70 dynamic import string for SetWindowDisplayAffinity (from user32.dll, RVA 0x3C34A6) +// 0x3B00B8 module name "PreventScreenshot" (registrar) + +// --- About page (Tab 0, sub-fn 0x80E80) --- +// 0x3AF350 "%s Game: Endfield CTB3" format string +// 0x3AF368 "Version: " label +// 0x3AF374 "1.0.0" version value +// 0x3AF380 "Author: " label +// 0x3AF38C "gktwo" author value +// (All direct string literals, not i18n-dispatched) + +// --- Window class detection --- +// 0x3AF658 "UnityWndClass" FindWindowA arg / string-compare (0xACA12) + +// --- ESP module (ESPModule::RenderOverlay RVA 0x83FA0) --- +// 0x3AF828 "ESPModule" module name +// 0x3AF838 "ESP Features" CollapsingHeader title → state [.data+0x27B0] +// 0x3AF848 "ON / OFF" checkbox label → [module+0x28] +// 0x3AF858 "Display Types" CollapsingHeader sub-header (via 0x6EC20) +// 0x3AF868 "Show Monsters" checkbox → [rsi+0x34] show_monsters +// 0x3AF878 "Show NPC" checkbox → [rsi+0x35] show_npc +// 0x3AF888 "Show Friendly" checkbox → [rsi+0x36] show_friendly +// 0x3AF898 "Show Puzzles" checkbox → [rsi+0x37] show_puzzles +// 0x3AF8A8 "Show All" checkbox → [rsi+0x38] show_all +// 0x3AF8B8 "Display Info" CollapsingHeader sub-header +// 0x3AF8C8 "Show Distance" checkbox → [rsi+0x39] show_distance +// 0x3AF8D8 "Show Name" checkbox → [rsi+0x3A] show_name +// 0x3AF8E8 "Show Type" checkbox → [rsi+0x3C] show_type +// 0x3AF8F4 (entity label separator string, used in Update DrawOverlay) +// 0x3AF900 (entity label buffer string) +// 0x3AF908 entity type dispatch table start (type→name pairs) +// 0x3AF920 entity type dispatch table continued (0xFFFFFFFF sentinel) +// 0x3AF9E0 vtable ptr value (0x3AF9E0 = post-init vtable for ESPModule) + +// --- FPS overlay (FPSModule) --- +// 0x3AFA98 FPSModule vtable block start +// 0x3AFAAC "FPS: " prefix for FPS display string (via 0x7F5C0) +// Color thresholds for FPS display (XMMWORD constants, already in .rdata): +// fps >= 60: color at 0x1803B3530 (green 0.0, 1.0, 0.0, 1.0) +// 30<=fps<60: color at 0x1803B3540 (yellow 1.0, 1.0, 0.0, 1.0) +// fps < 30: color at 0x1803B3510 (red 1.0, 0.0, 0.0, 1.0) + +// --- FreeCam --- +// 0x3AF820 "NONE" unbound key display in key binding rows + +// --- PlayerProfile UI paths --- +// 0x3AFED0 "/UINode/UIRoot/UIDPanelPanel/Main/TextNode/Text" (len 0x2F) +// 0x3AFFD0 "/UINode/WorldUIRoot/WatchPanel/Content/WatchNode/canvas_watch/ +// LeftBottomNode/PlayInfoPosNode/PlayInfoLifengCell(Clone)/PlayerInfo/ManagerName" +// (len 0x8D) + +// --- FreeCam key binding panel (Ch.27) --- +// 0x3AFCB0 "Free Camera" +// 0x3AFCC0 "Move Speed" +// 0x3AFCD0 "Look Sensitivity" +// 0x3AFCE8 "Roll Speed" +// 0x3AFCF8 "FOV Speed" +// 0x3AFD04 "FOV" +// 0x3AFD08 "Forward Key: %s" +// 0x3AFD18 "Backward Key: %s" +// 0x3AFD30 "Left Key: %s" +// 0x3AFD40 "Right Key: %s" +// 0x3AFD50 "Up Key: %s" +// 0x3AFD60 "Down Key: %s" +// 0x3AFD70 "IncFOV Key: %s" +// 0x3AFD80 "DecFOV Key: %s" +// 0x3AFD90 "LeftRoll Key: %s" +// 0x3AFDA8 "RightRoll Key: %s" +// 0x3AFDC0 "ResetRoll Key: %s" + +// --- UE module string table (Ch.16.4) --- +// 0x3B02D0 "Unity Explorer" tab label / ImGui::Begin title +// 0x3B02E0 "Unity Explorer Window" ImGui window title +// 0x3B02F8 "Search Filter:" label above search input +// 0x3B0308 "##SearchFilter" ImGui InputText widget ID +// 0x3B0318 "Inspector" inspector sub-panel label +// 0x3B0328 "GameObjectHierarchy" hierarchy sub-panel label +// 0x3B0340 "No scenes loaded. Click Refresh..." +// 0x3B0390 "Scene: " scene prefix label +// 0x3B0398 "No GameObjects found in this scene." +// 0x3B03C0 "DontDestroyOnLoad" special DDOL scene label +// 0x3B03D8 "DontDestroyOnLoad (Not Found)" +// 0x3B03F8 "Refresh" button label +// 0x3B0400 "Auto Refresh" checkbox label +// 0x3B0410 "Interval (s)" refresh interval slider +// 0x3B0420 "Scenes found: %d" +// 0x3B0438 "No scenes available. Click 'Refresh Scenes' to load." +// 0x3B0470 "Select Scene:" +// 0x3B0480 "Select Scene" combo default text +// 0x3B0490 "##SceneCombo" ImGui Combo widget ID +// 0x3B04A0 "]: " object list entry separator +// 0x3B04A8 "Ins##" inspect button label prefix +// 0x3B04B8 "No GameObject selected." +// 0x3B04D0 "Click 'Ins' button..." inspector hint +// 0x3B0508 "Active" active checkbox label +// 0x3B0510 "Transform" section header +// 0x3B0520 "Position" +// 0x3B0530 "Local Position" +// 0x3B0540 "Rotation" +// 0x3B054C "Scale" +// 0x3B0558 "No Transform component found." +// 0x3B0578 "Components" section header +// 0x3B0588 "GameObject Class: %s.%s" +// 0x3B05A0 "All Components:" +// 0x3B05B0 "UnityEngine.Component, UnityEngine.CoreModule" (GetComponents type arg) +// 0x3B05E0 "%s.%s" component name format +// 0x3B05E8 "Unknown Component" +// 0x3B0600 "No components found or failed to get components." +// 0x3B0638 "Unable to get GameObject class information." +// 0x3B0D28 "UnityExplorerModule" module name (registrar) +// UE auto-refresh state: bool at [.data+0x2640], float at [.data+0x2644] + +// --- Settings tab (Ch.28) --- +// 0x3B0AD4 "Theme" combo label +// 0x3B0AF8 "Default" theme name +// 0x3B06D0 "Evangelion Unit 01" theme name +// 0x3B0AE0 "Evangelion Unit 02" theme name +// 0x3B0B10 "Matrix" theme name +// 0x3B0B00 "Toggle Console" checkbox label +// 0x3B0B18 (Settings key address for enabled state) +// 0x3B0B28 "enabled" UI label for module on/off state (not JSON key) +// 0x3B0B78 "Console {}" console enabled display format +// 0x3B0B30 SettingsTAB.cpp source file path string + +// Theme color string RVAs (Evangelion Unit 01): +// 0x3B06E8 0x3B06F8 0x3B0708 0x3B0718 0x3B0728 0x3B0738 +// 0x3B0748 0x3B0758 0x3B0768 0x3B0778 0x3B0798 +// Theme color string RVAs (Evangelion Unit 02): +// 0x3B0888 0x3B0898 0x3B08A8 0x3B08B8 0x3B08C8 0x3B08D8 0x3B08F8 +// Theme color string RVAs (Matrix): +// 0x3B09A8 0x3B09B8 0x3B09C8 0x3B09D8 0x3B09E8 0x3B09F8 +// 0x3B0A08 0x3B0A18 0x3B0A38 + +// --- ModuleManager log strings (Ch.15.7) --- +// 0x3B0B88 "[WARNING] ModuleManager already initialized" +// 0x3B0BC0 ModuleManager.cpp assert source file path +// 0x3B0C08 "Initializing ModuleManager" +// 0x3B0C28 "Failed to initialize module {}" +// 0x3B0C48 "Module {} initialized" +// 0x3B0C60 "ModuleManager initialization complete" +// 0x3B0C90 "[ERROR] Failed to update module " +// 0x3B0CB8 "[ERROR] Failed to render overlay for module " +// 0x3B0CE8 "[ERROR] Failed to process hotkeys for module " + +// --- Config file mode strings --- +// 0x3AD590 "rb" Config READ - binary read mode +// 0x3AD594 "wt" Config WRITE - text write mode (ImGui ini) + +// --- DamageHack ghost keys (Ch.23) --- +// 0x3B1484 i18n table — four keys with no RTTI class (ghost/unimplemented feature) + +// --- Locale --- +// 0x3B2020 "en" locale string passed to string-construct at 0x9D890 + +// --- Startup / project identity --- +// 0x3B3148 "E:\git\Endfield_Cheeto\user\main.cpp" (confirms project name) + +// --- ESP color constant addresses in .data (ESP Update type dispatch) --- +// 0x3B3224 drawlist color source (XMMWORD, type-selected RGBA) +// 0x3B3308 100.0f constant (SkillHack CooldownBypass return value) +// ESP color table .rdata bases (correspond to ESPModule::color[] slots): +// 0x3B3500 color[10] BLACK (0.0,0.0,0.0,1.0) +// 0x3B3510 color[0] RED (1.0,0.0,0.0,1.0) also FPS<30 threshold +// 0x3B3520 color[1] ORANGE (1.0,0.647,0.0,1.0) +// 0x3B3530 color[3] GREEN (0.0,1.0,0.0,1.0) also FPS>=60 threshold +// 0x3B3540 color[2] YELLOW (1.0,1.0,0.0,1.0) also FPS 30-60 threshold +// 0x3B3550 color[11] GRAY (0.502,0.502,0.502,1.0) +// 0x3B3560 color[8] PINK (1.0,0.078,0.576,1.0) +// 0x3B3570 color[9] LPINK (1.0,0.753,0.796,1.0) +// 0x3B3580 color[6] PURPLE (0.58,0.0,0.827,1.0) +// 0x3B3590 color[4] BLUE (0.0,0.0,1.0,1.0) +// 0x3B35A0 color[5] CYAN (0.0,1.0,1.0,1.0) +// 0x3B35B0 color[7] WHITE (1.0,1.0,1.0,1.0) + +// --- Preset/config JSON keys (Ch.17/19) --- +// 0x3B06F8 "Default" preset name (also used as JSON key, via 0x3B0AF8) + +// --- FPS Overlay / PreventScreenshot extra --- +// 0x3B0198 "FPSMonitor" / FPS module registrar tab label (inside main cheat overlay) + +// ============================================================================ +// SECTION 28 — COMPLETE IAT TABLE (all 75 entries) +// ============================================================================ +// IAT base: RVA 0xB1000 (file raw 0xAF600). Format: IAT[RVA] = function (DLL) + +// Previously documented entries (Sections 9/24) plus newly added: +// 0xB1148 SwitchToThread KERNEL32 spinlock backoff (if backoff<32) +// 0xB1168 GetModuleFileNameExW PSAPI module path scanner full-path retrieval +// 0xB1178 AllocConsole KERNEL32 Settings console toggle enable +// 0xB1268 GetCurrentThreadId KERNEL32 stack cookie check (RVA 0xAC709) +// 0xB1290 GetModuleHandleW KERNEL32 GABypass: L"GameAssembly.dll"; OsCheck: ntdll +// 0xB1470 GetWindowLongPtrW USER32 overlay: read GWL_STYLE, GWL_EXSTYLE +// 0xB1480 IsWindowVisible USER32 overlay: check game window visible +// 0xB1490 GetClassNameA USER32 overlay: detect foreground window class (×3) +// 0xB1510 IsIconic USER32 overlay: check not minimized +// 0xB1518 SetForegroundWindow USER32 overlay: bring game to front on match +// 0xB1570 DestroyWindow USER32 overlay: cleanup on loop exit +// 0xB1588 SetWindowPos USER32 overlay: reposition to match game window +// 0xB15A8 GetClientRect USER32 overlay: get inner client area +// 0xB15B0 SetWindowLongW USER32 overlay: update window style ×2 +// 0xB15F0 GetForegroundWindow USER32 overlay: check active foreground window +// 0xB1640 UnregisterClassW USER32 overlay: cleanup window class on exit +// 0xB1858 fread CRT config file read (called ONLY from 0x12121) +// 0xB1880 __stdio_common_vsscanf CRT theme color parser (RRGGBBAA hex→RGBA) +// 0xB1890 _wfopen CRT config file open (called ONLY from 0x11F93) +// 0xB1898 fseek CRT config seek (from 0x120BC, 0x120E7) +// 0xB1920 DwmGetWindowAttribute DWMAPI overlay: DWMWA_EXTENDED_FRAME_BOUNDS rect + +// ============================================================================ +// SECTION 29 — IMGUI HELPER RVAs (inline functions used throughout modules) +// ============================================================================ +// ImGui wrapper functions used by module Render() bodies (not in main RVA namespace) + +namespace RVA { + constexpr u32 ImGui_CollapsingHeader = 0x06EC20; // lightweight wrapper; checks ImGuiCtx+0x106 locked flag + constexpr u32 ImGui_Checkbox_commit = 0x061FE0; // checkbox state commit helper + constexpr u32 ImGui_Separator_cursor = 0x070630; // Separator + cursor Y adjust + constexpr u32 ImGui_AddText_colored = 0x051580; // drawlist AddText with explicit color + constexpr u32 FPS_string_builder = 0x07F5C0; // "FPS: " + int → display string + constexpr u32 Str_compare_helper = 0x0ACA12; // internal string compare (wchar/char) + constexpr u32 ImGui_EndDisabled_path = 0x0ACA1F; // EndDisabled via ImGuiCtx+0x27F0 decrement +} + +// ImGuiContext field offsets referenced in cheat code: +// [ImGuiContext+0x106] locked_input_flag (BYTE) — CollapsingHeader disabled check +// [ImGuiContext+0x15D8] foreground_drawlist — FPS overlay drawlist ptr (+0x40 = draw cmds) +// [ImGuiContext+0x27F0] EndDisabled_counter (WORD) — decremented on EndDisabled call +// [ImGuiContext+0x2900] save_to_disk_flag (set=1 by manual save trigger 0x17072) +// [ImGuiContext+0x2904] save_timer (set=0 by manual save trigger) +// [ImGuiContext+0x2910] custom IniFilename (ptr; config save path source) +// [ImGuiContext+0x2920] settings_handlers (dynamically-grown array of 0x48-byte structs) + +// ============================================================================ +// SECTION 30 — D3D11 SHADER SOURCE (Ch.5) +// ============================================================================ +// Both shaders are stored as raw HLSL text in .rdata and compiled at runtime +// via D3DCompile (IAT[0xB1000]) during D3D11Init (RVA 0x54DC0/0x551E8). + +// Vertex shader (RVA 0x3AE660, 733 bytes, "main"/"vs_4_0"): +static const char* VS_HLSL_SOURCE_RVA = "0x3AE660"; // marker only — see comment +// cbuffer vertexBuffer : register(b0) { float4x4 ProjectionMatrix; }; +// struct VS_INPUT { float2 pos:POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// PS_INPUT main(VS_INPUT input) { +// PS_INPUT output; +// output.pos = mul(ProjectionMatrix, float4(input.pos.xy, 0.f, 1.f)); +// output.col = input.col; output.uv = input.uv; +// return output; } + +// Pixel shader (RVA 0x3AE940, 401 bytes, "main"/"ps_4_0"): +static const char* PS_HLSL_SOURCE_RVA = "0x3AE940"; // marker only — see comment +// struct PS_INPUT { float4 pos:SV_POSITION; float4 col:COLOR0; float2 uv:TEXCOORD0; }; +// sampler sampler0; Texture2D texture0; +// float4 main(PS_INPUT input) : SV_Target { +// return input.col * texture0.Sample(sampler0, input.uv); } + +// Shader init sequence (RVA 0x54DC0): +// load g_D3DState from [g_Config+0xD8] → R14 +// check already-init: cmp (*r14), null; je skip +// call 0x551F0 (create vertex/index buffers) +// D3DCompile(0x3AE660, 0x2DD, NULL,NULL,NULL, "main","vs_4_0",0,0,...) → vertex blob +// D3DCompile(0x3AE940, 0x191, NULL,NULL,NULL, "main","ps_4_0",0,0,...) → pixel blob + +// ============================================================================ +// END OF RECONSTRUCTION HEADERS +// ============================================================================ + +// ============================================================================ +// SECTION 31 — COMPLETE .DATA ADDRESS MAP (SUPPLEMENTAL) +// ============================================================================ +// All 97 .data offsets documented across all chapters, with absolute VAs and +// semantic descriptions. Base: .data = 0x1803C5000 (RVA 0x3C5000) + +// --- Module dispatch fn ptr state blocks (vtable[+0x18] accessor targets) --- +// Each module's vtable[+0x18] stub returns the module's .data state block. +// At offset [+0x00] of that block is the actual Render/Update fn ptr written +// by RegisterTab. The ModuleManager dispatch loop calls stub → gets this ptr → calls it. +// +// [.data+0x0530] FpsOverlay state block → fn ptr (overlay render) +// [.data+0x0580] PlayerProfile state block → fn ptr +// [.data+0x0630] SetDither state block → fn ptr (no-op stub 0x83DC0) +// [.data+0x06D0] NoClip state block → fn ptr +// [.data+0x0770] SkillHack state block → fn ptr (hook installer) +// [.data+0x07D0] FreeCam state block → fn ptr + +// --- RTTI / module name strings (.data) --- +// [.data+0x0590]–[.data+0x0E60] 11 module RTTI class descriptors +// (ESPModule, FPSModule, FpsUnlocker, FreeCam, NoClip, PlayerProfile, +// PreventScreenshot, SetDither, SkillHack, Vacuum, UnityExplorerModule) + +// --- Panel state init config block (.data, written by DispatchRegistrarInit) --- +// [.data+0x1F08] panel_config_src_A (16 bytes) — source for movups xmm0 +// [.data+0x1F18] panel_config_src_B (16 bytes) — source for movups xmm1 +// [.data+0x1F28] panel_config_dst_A (16 bytes) — dest: initial panel state copy +// [.data+0x1F38] panel_config_dst_B (16 bytes) — dest: initial panel state copy + +// --- ESPModule singleton — absolute .data field addresses --- +// Base: [.data+0x1F70] VA 0x1803C6F70 +// +// [.data+0x1F70] QWORD vtable ptr (pre-init: 0x3AFA38; post-init: 0x3AF9E0) +// [.data+0x1F78] STRING name = "ESPModule" (SSO std::string, RVA 0x3AF828) +// [.data+0x1F98] BYTE enabled = 0 +// [.data+0x1FA0] DWORD max_draw_distance = 300 (0x12C) +// [.data+0x1FA4] BYTE show_monsters = 1 +// [.data+0x1FA5] BYTE show_npc = 1 +// [.data+0x1FA6] BYTE show_friendly = 1 +// [.data+0x1FA7] BYTE show_puzzles = 1 +// [.data+0x1FA8] BYTE show_all = 0 +// [.data+0x1FA9] BYTE show_distance = 1 +// [.data+0x1FAA] BYTE show_name = 1 +// [.data+0x1FAB] BYTE reserved = 0 +// [.data+0x1FAC] BYTE show_type = 0 +// [.data+0x1FB0] XMMWD color[0] RED (1.00, 0.00, 0.00, 1.00) — Enemies +// [.data+0x1FC0] XMMWD color[1] ORANGE (1.00, 0.65, 0.00, 1.00) — Interactive/NPC +// [.data+0x1FD0] XMMWD color[2] YELLOW (1.00, 1.00, 0.00, 1.00) — spare +// [.data+0x1FE0] XMMWD color[3] GREEN (0.00, 1.00, 0.00, 1.00) — Friendly +// [.data+0x1FF0] XMMWD color[4] BLUE (0.00, 0.00, 1.00, 1.00) — NPC/spare +// [.data+0x2000] XMMWD color[5] CYAN (0.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2010] XMMWD color[6] PURPLE (0.58, 0.00, 0.83, 1.00) — spare +// [.data+0x2020] XMMWD color[7] WHITE (1.00, 1.00, 1.00, 1.00) — spare +// [.data+0x2030] XMMWD color[8] PINK (1.00, 0.08, 0.58, 1.00) — spare +// [.data+0x2040] XMMWD color[9] LPINK (1.00, 0.75, 0.80, 1.00) — spare +// (color[10] BLACK and color[11] GRAY not stored separately; loaded from .rdata at runtime) +// Note: Color slots 2,5,6,8,9 are spare palette entries with no current entity type mapping. +// Slots 0,1,3,4 map to Enemies/Interactive/Friendly/NPC respectively. + +// --- FPSModule singleton --- +// [.data+0x22E0] QWORD FPSModule singleton ptr VA 0x1803C72E0 +// [.data+0x22E8] STRING name = "FPS Monitor" (SSO std::string) +// [.data+0x2308] BYTE enabled = 0 +// [.data+0x2310] QWORD once_flag (std::once_flag, guards Initialize RVA 0x814C0) + +// --- PreventScreenshot singleton --- +// [.data+0x2358] QWORD PreventScreenshot singleton ptr VA 0x1803C7358 +// [.data+0x2360] STRING name = "Prevent Screenshot" (SSO std::string) +// [.data+0x2380] BYTE enabled = 0 +// [.data+0x2388] BYTE second_toggle_flag = 0 +// [.data+0x2390] QWORD once_flag (guards Initialize RVA 0x8AD70) +// [.data+0x24D0] QWORD hook/window list head (linked list; nodes have HWND at [+0x10]) +// [.data+0x24F0] DWORD cached OSVERSIONINFOEXW.dwBuildNumber (from memcpy of RtlGetVersion) +// [.data+0x24FC] DWORD cached OS build number (same value, second copy for comparison) + +// --- UnityExplorer module --- +// [.data+0x260C] QWORD once_flag (guards RegisterTab RVA 0x90060) +// [.data+0x2610] QWORD update_fn_ptr = 0x083DC0 (shared no-op stub) +// [.data+0x2618] STRING tab_string = "Unity Explorer" (std::string) +// [.data+0x2638] BYTE enabled = 0 +// [.data+0x2640] BOOL auto_refresh = 0 +// [.data+0x2644] float refresh_interval = 3.0f (0x40400000) +// [.data+0x2648] QWORD* scene_list_begin = NULL +// [.data+0x2650] QWORD* scene_list_end = NULL +// [.data+0x2660] QWORD* scene_list_cap = NULL +// [.data+0x2670] DWORD selected_scene_idx = 0 +// [.data+0x2680] DWORD selected_obj_idx = 0 +// [.data+0x2684] char[0x100] search_filter = "" (zero-filled) +// [.data+0x2784] BOOL inspector_active = 0 +// [.data+0x2788] QWORD inspected_obj_ptr = 0 +// [.data+0x2790] STRING inspected_obj_name = "" (std::string) + +// ============================================================================ +// SECTION 32 — MAGIC CONSTANTS AND IEEE 754 VALUES +// ============================================================================ + +// --- IEEE 754 float constants --- +static_assert(sizeof(float) == 4, "float must be 32-bit"); + +// 0x41F00000 = 30.0f — FreeCam Move Speed default +// 0x3DCCCCCD = 0.1f — FreeCam Move Speed / Roll Speed / FOV Speed step +// 0x42C80000 = 100.0f — FreeCam Roll Speed max; SkillHack CooldownBypass return value +// 0x43FA0000 = 500.0f — FreeCam Move Speed max +// 0x40400000 = 3.0f — UnityExplorer auto-refresh interval default +// 0x3F800000 = 1.0f — HookManager load factor threshold; FreeCam FOV multiplier default +// 0x42960000 = 75.0f — FreeCam Look Sensitivity default +// 0x44415357 = (reinterpret: packed 'WASD' ASCII) — FreeCam default key binding word + +// --- FreeCam default key binding block --- +// Written to [.data+0x2230..0x225E] by FreeCam::RegisterMainTab: +// [+0x2230..0x223F] = [0x1803B34F0] (key config block 1, 16 bytes) +// [+0x2240..0x224F] = [0x1803B35C0] (key config block 2, 16 bytes) +// [+0x2250] = 0x3F800000 (1.0f — FOV multiplier) +// [+0x2254] = 0x44415357 ('WASD' key mask) +// [+0x2258] = 0x6D6BA220 (additional keybind data) +// [+0x225C] = 0x2725 (two-byte keybind word) +// [+0x225E] = 0x60 (backtick key — FreeCam toggle) + +// --- Security cookie --- +// Stack canary magic value (lower 48 bits): 0x2B992DDFA232 +// Full XOR combination of: GetSystemTimeAsFileTime, GetCurrentThreadId, +// GetCurrentProcessId, QueryPerformanceCounter (see Ch.4 / Section 4) +// Checked at RVA 0x0AC6CC by __security_check_cookie (CRT standard) + +// --- Windows version constants --- +// 0x4A61 = 19041 decimal — Windows 10 Build 19041 (20H1) +// Used in PreventScreenshot::OsCheck to select WDA_MONITOR vs WDA_EXCLUDEFROMCAPTURE: +// build < 19041: SetWindowDisplayAffinity(..., 1) // WDA_MONITOR +// build >= 19041: SetWindowDisplayAffinity(..., 0x11) // WDA_EXCLUDEFROMCAPTURE + +// --- Hash constants --- +// FNV-1a 64-bit (used in HookManager hash table): +// Offset basis: 0xCBF29CE484222325ULL +// Prime: 0x00000100000001B3ULL +// (See Section 8 / Ch.8.7 for unrolled implementation at RVA 0x8D555) + +// --- CP_UTF8 --- +// 0xFDE9 = 65001 = CP_UTF8 +// Used in: MultiByteToWideChar calls in OpenConfigFile (0x11EA0), +// SetConsoleOutputCP (startup), UTF8ToWide helper (0x8B4E0) + +// --- Module object sizes --- +// BaseModule object size: 0x30 bytes (used by operator delete in NoOpUpdateStub) +// FPSModule object size: 0xD8 bytes (zeroed by memset 0xAC86A in Initialize) +// PreventScreenshot object size: 0x48 bytes (from vtable dtor stub size arg) +// UnityExplorer state block size: 0x190 bytes (zero-filled in RegisterTab) +// FreeCam state block size: 0xD8 bytes (zeroed in RegisterMainTab) +// HookEntry size: 0x38 bytes (stride in hook_array) +// HookManager singleton size: 0x90 bytes +// ModuleManager registrar stride: 0x60 bytes per slot +// ImGui settings handler size: 0x48 bytes per handler struct +// THREADENTRY32 size: 28 (sizeof: written as r12d = [rbx+0x1C]) +// OSVERSIONINFOEXW size: 0x11C bytes (stack-allocated in OsCheck) + +// --- HookManager array constants --- +// Initial hook array capacity: 0x80 slots +// Shrink threshold: count <= capacity/2 AND count > 0x20 +// Load factor threshold: 1.0f (0x3F800000) — triggers hash table rehash + +// --- SkillHack callback return constants --- +// 0x42C80000 = 100.0f returned by Callback_CooldownBypass (RVA 0x8D500) +// stored at .rdata RVA 0x3B3308 +// Note: prior summary incorrectly stated 0.0; doc confirms 100.0f + +// ============================================================================ +// SECTION 33 — IAT SUPPLEMENTAL ENTRIES (Ch.19 / final resolution) +// ============================================================================ +// Additional IAT entries resolved in Ch.19 not previously in header: +// IAT[0xB1278] VirtualFree KERNEL32 hook manager cleanup +// IAT[0xB1288] VirtualProtect KERNEL32 hook patcher (Ch.8.6) +// IAT[0xB1628] ShowWindow USER32 Settings console toggle visibility +// IAT[0xB1868] fwrite CRT config body (0xEA1B, 0x170D6, 0x3033B, 0x3076D) +// IAT[0xB1870] fclose CRT (0xEAB0, 0x1212F, 0x121A9, 0x170DF) + +// ============================================================================ +// END SUPPLEMENTAL SECTIONS +// ============================================================================ + +// ============================================================================ +// SECTION 34 — FINAL FIVE .DATA ADDRESSES +// ============================================================================ + +// [.data+0x2180] QWORD SetDither update fn ptr = 0x1803B01B0 → 0x83DC0 (no-op stub) +// Written by SetDither::RegisterTab (RVA 0x181810) + +// [.data+0x2307] BYTE End of FPSModule name std::string SSO buffer +// Name "FPS Monitor" occupies [.data+0x22E8]..[.data+0x2307] +// (19 chars + null = 20 bytes; SSO inline storage) + +// [.data+0x237F] BYTE End of PreventScreenshot name std::string SSO buffer +// Name "Prevent Screenshot" occupies [.data+0x2360]..[.data+0x237F] +// +0x28 field = enabled BYTE (checkbox state; drives affinity arg) + +// [.data+0x245C] BYTE g_showPanel — overlay panel visibility flag +// 0 = hidden, 1 = visible +// Toggled by VK_F12 (0x7B) poll at RVA 0x8301A (GetAsyncKeyState) +// Banner shown when hidden: "EF - Cheeto ... Press F12" (RVA 0x3AF258) + +// [.data+0x24D8] QWORD PreventScreenshot HWND list count / tracked window count +// Companion to [.data+0x24D0] (linked list head) +// Used in Update affinity application loop (RVA 0x8AFC0) + diff --git a/IDA/project/docs/input/vs/files (1)/ef_cheeto_reconstruction_prompt.md b/IDA/project/docs/input/vs/files (1)/ef_cheeto_reconstruction_prompt.md new file mode 100644 index 0000000..53af924 --- /dev/null +++ b/IDA/project/docs/input/vs/files (1)/ef_cheeto_reconstruction_prompt.md @@ -0,0 +1,122 @@ +# EF-Cheeto Reconstruction System Prompt +# Give this + the feed document to an AI for perfect reconstruction. + +You are a reverse-engineering assistant with complete knowledge of the EF-Cheeto +game cheat DLL (EF-Cheeto.dll, 3,956,736 bytes). You have been given a complete +analysis document covering all 29 chapters of binary analysis plus a full +reconstruction header file. Use these to answer any reconstruction question. + +## Binary Identity +- File: EF-Cheeto.dll +- Size: 3,956,736 bytes (0x3CE000) +- Base VA: 0x180000000 +- .data base: 0x1803C5000 (RVA 0x3C5000) +- .rdata strings base: ~0x3A0000–0x3B4000 +- IAT base: RVA 0xB1000 +- Architecture: x86-64 Windows DLL (PE32+) +- Compiler: MSVC (x64 Release, C++17) +- Project path: E:\git\Endfield_Cheeto\ + +## What You Know (Summary) + +### Module System (10 active modules + 1 ghost) +1. ESPModule — entity ESP overlay (draw boxes/labels on enemies, NPCs, etc.) +2. FPSModule — FPS counter overlay + FPS cap unlocker +3. NoClip — CharacterController.enabled toggle + move speed +4. FreeCam — CinemachineBrain camera override with WASD+mouse +5. FpsUnlocker — Application.set_targetFrameRate bypass (default 300fps) +6. SetDither — graphics dither toggle (stub, no per-frame effect) +7. PlayerProfile — Unity UI TextMeshPro text injection (UID + name changer) +8. Vacuum — Rigidbody.AddForce attraction loop +9. SkillHack — 6× IL2CPP hooks: cooldown bypass, availability, cost bypass +10. UnityExplorer — runtime Unity scene browser + GO/component inspector +11. DamageHack — GHOST FEATURE: i18n keys exist, zero code + +### Key Subsystems +- GABypass: resolves 71 IL2CPP function pointers from GameAssembly.dll at startup +- HookManager: FNV-1a hash table + spinlock, hooks tracked in 0x38-byte entries +- ModuleManager: dispatch loops for Render/Update/Hotkeys on all modules +- D3D11 overlay: layered WS_EX_LAYERED window, ImGui Win32+D3D11 backend +- Config: ImGui .ini persistence (no separate JSON config file) +- i18n: nlohmann v3.12.0 JSON blob (en/zh_cn), stored at .rdata RVA 0x3B10E8 +- Injection: testyip/gatmp.tmp/EF-Cheeto.dll path scanner on loaded modules +- Thread safety: Toolhelp32 snapshot suspension around all code patches + +### Critical Addresses (quick reference) +- DllMain: RVA 0x01000 +- LoaderThread: RVA 0x05000 +- Startup_main: RVA 0x0A9190 +- GABypass::Patch: RVA 0x09D1E0 +- ModuleManager::Init: RVA 0x09AC10 +- HookMgr::CreateHook: RVA 0x0A9CC8 +- OverlayWindowInit: RVA 0x0827A0 +- WndProc: RVA 0x0826A0 +- ESPModule singleton: VA 0x1803C6F70 +- HookManager single: VA 0x1803C7470 +- IL2CPP table start: [.data+0x1C48] +- g_Config base: [.data+0x1C00] + +## How to Use This Document +- PART A contains all pseudocode, behavioral descriptions, and data tables +- PART B contains the compilable reconstruction header with all addresses +- For any function: find it in PART B's RVA namespace, then look up the chapter in PART A +- For any struct: PART B has the layout; PART A has the behavioral context +- For IL2CPP calls: Section 18 / PART B Section 10 has all 71 function pointers +- For string RVAs: PART B Section 27 has all 189 .rdata strings + +Answer reconstruction questions by citing specific RVAs, field offsets, and +pseudocode from the document. When writing reconstructed C++, use the exact +struct layouts and address constants from PART B. + + +================================================================================ +CONFIRMED IMGUI BUILD INFORMATION +================================================================================ + +## ImGui Version +- Repository: https://github.com/ocornut/imgui (docking branch) +- Commit: fa4b47c5e2b53dba5093384562440bd9a6bba2a0 (December 5, 2025) +- Version: Dear ImGui 1.92.6 WIP (19253) +- Branch: DOCKING (confirmed — viewport/DockSpace strings present in binary) + +## Source Files Compiled Into Binary +- imgui.cpp +- imgui_draw.cpp +- imgui_tables.cpp +- imgui_widgets.cpp +- imgui_demo.cpp — NOT compiled in (absent from binary) +- backends/imgui_impl_win32.cpp +- backends/imgui_impl_dx11.cpp + +## Build Configuration +- NDEBUG defined (release build — zero IM_ASSERT strings in binary) +- MSVC linker 14.44 = Visual Studio 2022 v17.14 (December 2025 toolchain) +- PE compile timestamp: 2025-12-10 12:27:05 UTC +- No custom imconfig.h overrides detected +- Standard ImDrawIdx = uint16_t (16-bit, default, not overridden) +- No imgui_freetype, no imgui_demo + +## ImGui Code Footprint in Binary +- .text section: RVA 0x1000–0x7F000 (~457KB) is entirely ImGui library code +- Cheat-specific code begins at approximately RVA 0x7F000 +- Win32 backend WndProc handler: RVA 0x57720 (ImGui_ImplWin32_WndProcHandler) +- DX11 backend shader init: RVA 0x54DC0 +- DX11 backend resource creation: RVA 0x551F0 +- ImGuiContext accessed via [g_Config+0x15D8] in all cheat code +- IniFilename "imgui.ini" set into ImGuiIO+0x20 at RVA 0x1117A + +## Project Source Tree (from MSVC __FILE__ embeds) +- E:\git\Endfield_Cheeto\framework\helpers.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\HookManager.h +- E:\git\Endfield_Cheeto\libraries\pipeline\gui\tabs\SettingsTAB.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\hooks\UI.cpp +- E:\git\Endfield_Cheeto\libraries\pipeline\modules\ModuleManager.cpp +- E:\git\Endfield_Cheeto\user\main.cpp + +## To Reproduce Build + git clone https://github.com/ocornut/imgui + git checkout fa4b47c5e2b53dba5093384562440bd9a6bba2a0 + # Compile with MSVC 14.44, /O2, NDEBUG, x64 + # Include: imgui.cpp, imgui_draw.cpp, imgui_tables.cpp, imgui_widgets.cpp + # Include: backends/imgui_impl_win32.cpp, backends/imgui_impl_dx11.cpp + # No custom imconfig.h needed diff --git a/IDA/project/helpers.cpp b/IDA/project/helpers.cpp new file mode 100644 index 0000000..78e67a1 --- /dev/null +++ b/IDA/project/helpers.cpp @@ -0,0 +1,598 @@ +#include "helpers.h" + +#include +#include +#include +#include +#include +#include +#include + +#include "nlohmann/json.hpp" + +RuntimeConfig g_Runtime; + +namespace { + +std::mutex g_il2cpp_mutex; +std::unordered_map g_il2cpp_slots; + +void* g_il2cpp_domain_cached = nullptr; +void* (*g_il2cpp_domain_get_fn)() = nullptr; +void* (*g_il2cpp_thread_attach_fn)(void*) = nullptr; +void* (*g_il2cpp_thread_current_fn)() = nullptr; +void (*g_il2cpp_thread_detach_fn)(void*) = nullptr; + +thread_local void* g_tls_il2cpp_thread = nullptr; +thread_local bool g_tls_il2cpp_attached_by_us = false; +thread_local bool g_tls_game_thread_context = false; + +std::mutex g_i18n_mutex; +bool g_i18n_initialized = false; +std::unordered_map g_en; +std::unordered_map g_zh_cn; + +constexpr const char* kI18nBlob = R"json( +{ + "NoClip": {"en":"NoClip", "zh_cn":"NoClip"}, + "FreeCam": {"en":"FreeCam", "zh_cn":"????"}, + "Free Camera": {"en":"Free Camera", "zh_cn":"????"}, + "Fps Unlocker": {"en":"Fps Unlocker", "zh_cn":"????"}, + "FPSModule": {"en":"FPSModule", "zh_cn":"FPS??"}, + "SetDither": {"en":"SetDither", "zh_cn":"????"}, + "Set Dither": {"en":"Set Dither", "zh_cn":"????"}, + "PlayerProfile": {"en":"PlayerProfile", "zh_cn":"????"}, + "Vacuum": {"en":"Vacuum", "zh_cn":"??"}, + "SkillHack": {"en":"SkillHack", "zh_cn":"????"}, + "Free Skill": {"en":"Free Skill", "zh_cn":"????"}, + "ESPModule": {"en":"ESPModule", "zh_cn":"ESP??"}, + "ESP Features": {"en":"ESP Features", "zh_cn":"ESP??"}, + "Prevent Screenshot": {"en":"Prevent Screenshot", "zh_cn":"???"}, + "Unity Explorer": {"en":"Unity Explorer", "zh_cn":"Unity???"}, + "Unity Explorer Window": {"en":"Unity Explorer Window", "zh_cn":"Unity?????"}, + "ON / OFF": {"en":"ON / OFF", "zh_cn":"? / ?"}, + "Move Speed": {"en":"Move Speed", "zh_cn":"????"}, + "Look Sensitivity": {"en":"Look Sensitivity", "zh_cn":"?????"}, + "Roll Speed": {"en":"Roll Speed", "zh_cn":"????"}, + "FOV Speed": {"en":"FOV Speed", "zh_cn":"????"}, + "FOV": {"en":"FOV", "zh_cn":"??"}, + "Fps Value": {"en":"Fps Value", "zh_cn":"???"}, + "UID text": {"en":"UID text", "zh_cn":"UID??"}, + "Name text": {"en":"Name text", "zh_cn":"????"}, + "Name changer": {"en":"Name changer", "zh_cn":"??"}, + "Monster": {"en":"Monster", "zh_cn":"??"}, + "Show Monsters": {"en":"Show Monsters", "zh_cn":"????"}, + "Show NPC": {"en":"Show NPC", "zh_cn":"??NPC"}, + "Show Friendly": {"en":"Show Friendly", "zh_cn":"????"}, + "Show Puzzles": {"en":"Show Puzzles", "zh_cn":"??????"}, + "Show All": {"en":"Show All", "zh_cn":"????"}, + "Show Distance": {"en":"Show Distance", "zh_cn":"????"}, + "Show Name": {"en":"Show Name", "zh_cn":"????"}, + "Show Type": {"en":"Show Type", "zh_cn":"????"}, + "Theme": {"en":"Theme", "zh_cn":"??"}, + "Toggle Console": {"en":"Toggle Console", "zh_cn":"?????"}, + "About": {"en":"About", "zh_cn":"??"}, + "Player": {"en":"Player", "zh_cn":"??"}, + "ESP": {"en":"ESP", "zh_cn":"ESP"}, + "World": {"en":"World", "zh_cn":"??"}, + "Visual": {"en":"Visual", "zh_cn":"??"}, + "Settings": {"en":"Settings", "zh_cn":"??"}, + "Damagehack Toggle": {"en":"Damagehack Toggle", "zh_cn":"????"}, + "Damage Multiplier": {"en":"Damage Multiplier", "zh_cn":"????"}, + "Multiplier Value": {"en":"Multiplier Value", "zh_cn":"???"}, + "Random Damage Type": {"en":"Random Damage Type", "zh_cn":"??????"}, + "This is free, if you spend money, then you have been deceived": { + "en":"This is free, if you spend money, then you have been deceived", + "zh_cn":"?????,??????,?????" + } +} +)json"; + +ImVec4 ParseHexColor(const char* rrggbbaa) { + unsigned int rgba = 0u; + sscanf_s(rrggbbaa, "%x", &rgba); + const float r = static_cast((rgba >> 24) & 0xFF) / 255.0f; + const float g = static_cast((rgba >> 16) & 0xFF) / 255.0f; + const float b = static_cast((rgba >> 8) & 0xFF) / 255.0f; + const float a = static_cast(rgba & 0xFF) / 255.0f; + return ImVec4(r, g, b, a); +} + +void ApplyThemePalette(const std::array& colors) { + ImGuiStyle& style = ImGui::GetStyle(); + style.Colors[ImGuiCol_Text] = ParseHexColor(colors[0]); + style.Colors[ImGuiCol_WindowBg] = ParseHexColor(colors[1]); + style.Colors[ImGuiCol_ChildBg] = ParseHexColor(colors[2]); + style.Colors[ImGuiCol_PopupBg] = ParseHexColor(colors[3]); + style.Colors[ImGuiCol_Border] = ParseHexColor(colors[4]); + style.Colors[ImGuiCol_FrameBg] = ParseHexColor(colors[5]); + style.Colors[ImGuiCol_FrameBgHovered] = ParseHexColor(colors[6]); + style.Colors[ImGuiCol_FrameBgActive] = ParseHexColor(colors[7]); + style.Colors[ImGuiCol_Button] = ParseHexColor(colors[8]); + style.Colors[ImGuiCol_ButtonHovered] = ParseHexColor(colors[9]); + style.Colors[ImGuiCol_ButtonActive] = ParseHexColor(colors[10]); +} + +uintptr_t FindGameAssemblyBaseNow() { + HMODULE h = GetModuleHandleW(L"GameAssembly.dll"); + if (!h) { + h = GetModuleHandleW(L"gameassembly.dll"); + } + if (h) { + return reinterpret_cast(h); + } + + HMODULE modules[2048] = {}; + DWORD needed = 0; + if (!K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &needed)) { + return 0; + } + + const size_t count = needed / sizeof(HMODULE); + for (size_t i = 0; i < count; ++i) { + wchar_t path[MAX_PATH] = {}; + if (K32GetModuleFileNameExW(GetCurrentProcess(), modules[i], path, MAX_PATH) == 0) { + continue; + } + std::wstring name = path; + std::transform(name.begin(), name.end(), name.begin(), [](wchar_t c) { + return static_cast(::towlower(c)); + }); + if (name.find(L"gameassembly.dll") != std::wstring::npos) { + return reinterpret_cast(modules[i]); + } + } + return 0; +} + +void ResolveIl2CppThreadApisOnce() { + HMODULE ga = GetModuleHandleW(L"GameAssembly.dll"); + if (!ga) { + ga = GetModuleHandleW(L"gameassembly.dll"); + } + if (!ga) { + return; + } + + g_il2cpp_domain_get_fn = + reinterpret_cast(GetProcAddress(ga, "il2cpp_domain_get")); + g_il2cpp_thread_attach_fn = + reinterpret_cast(GetProcAddress(ga, "il2cpp_thread_attach")); + g_il2cpp_thread_current_fn = + reinterpret_cast(GetProcAddress(ga, "il2cpp_thread_current")); + g_il2cpp_thread_detach_fn = + reinterpret_cast(GetProcAddress(ga, "il2cpp_thread_detach")); +} + +} // namespace + +const std::array kIl2cppSlotMap = {{ + {0x1C48, 0x09DC0120, "GameObject.GetComponentByIndex"}, + {0x1C50, 0x0018CEC0, "il2cpp_domain_get_assemblies_A"}, + {0x1C58, 0x0B390700, "Component.GetComponent"}, + {0x1C60, 0x0B3A2D20, "Transform.get_localScale"}, + {0x1C68, 0x0B3A2CB0, "Transform.get_rotation"}, + {0x1C70, 0x0018AD80, "il2cpp_object_get_class"}, + {0x1C78, 0x00007480, "il2cpp_class_get_method_from_name"}, + {0x1C80, 0x0B3A1AE0, "Transform.get_localPosition"}, + {0x1C88, 0x0B3A1A70, "Transform.get_position"}, + {0x1C90, 0x0B3A51D0, "Transform.set_localPosition"}, + {0x1C98, 0x0B398830, "GameObject.SetActive"}, + {0x1CA0, 0x0B3911F0, "GameObject.get_transform"}, + {0x1CA8, 0x0B3A59D0, "Transform.set_rotation"}, + {0x1CB0, 0x0B391D90, "GameObject.get_activeInHierarchy"}, + {0x1CB8, 0x0B3B2410, "GameObject.get_tag"}, + {0x1CC0, 0x0B3B2120, "GameObject.get_name"}, + {0x1CC8, 0x0B3B40B0, "GameObject.get_layer"}, + {0x1CD0, 0x0B397980, "GameObject.get_scene"}, + {0x1CD8, 0x02F3DA80, "Game_SkillBuff_A"}, + {0x1CE0, 0x00F27E10, "GetEntityName"}, + {0x1CE8, 0x0B329000, "Component.GetComponents"}, + {0x1CF0, 0x0B329D80, "Component.GetComponentsInChildren"}, + {0x1CF8, 0x03E9BB50, "Game_SkillSlot_A"}, + {0x1D00, 0x0B383F60, "Object.get_name"}, + {0x1D08, 0x0B33CAB0, "Component.GetType_A"}, + {0x1D10, 0x0B33CB00, "Component.GetType_B"}, + {0x1D18, 0x039D1AA0, "Game_SkillSlot_B"}, + {0x1D20, 0x026DE9F0, "Game_Combat_HitA"}, + {0x1D28, 0x0478E860, "GetEntityManager"}, + {0x1D30, 0x025E2D40, "Game_Combat_HitB"}, + {0x1D38, 0x087C2CD0, "Game_Movement_PhysA"}, + {0x1D40, 0x03419AF0, "Game_Movement_PhysB"}, + {0x1D48, 0x0B322FB0, "Scene.get_name / Application.set_targetFrameRate ref"}, + {0x1D50, 0x0B396A20, "SceneManager.GetActiveScene"}, + {0x1D58, 0x0B397700, "CinemachineBrain.get_ActiveVirtualCamera"}, + {0x1D60, 0x03766810, "Game_EntityState_A"}, + {0x1D68, 0x0B3A2A60, "Transform.set_localScale"}, + {0x1D70, 0x0B326660, "Rigidbody.get_velocity"}, + {0x1D78, 0x0B3266B0, "Rigidbody.set_velocity"}, + {0x1D80, 0x0B383200, "Object.Destroy"}, + {0x1D88, 0x0B3A1A10, "Transform.set_position"}, + {0x1D90, 0x0B3A2340, "Game_EntityState_B"}, + {0x1D98, 0x0B421800, "Input.GetAxis(Mouse X)"}, + {0x1DA0, 0x0B3A26D0, "Game_PlayerState_A"}, + {0x1DA8, 0x0B3A1FB0, "Game_PlayerState_B"}, + {0x1DB0, 0x0B32B030, "Game_PlayerHealthStat"}, + {0x1DB8, 0x0B391240, "GameObject.SetActive (second ref)"}, + {0x1DC0, 0x0B390440, "Camera.get_main"}, + {0x1DC8, 0x0B390F80, "GameObject.FindObjectOfType"}, + {0x1DD0, 0x0B3A19A0, "Transform.get_position (second ref)"}, + {0x1DD8, 0x03F85430, "Game_SkillAction_C"}, + {0x1DE0, 0x0B3A1D30, "Transform.set_rotation (second ref)"}, + {0x1DE8, 0x0B3A1C90, "Camera.get_fieldOfView"}, + {0x1DF0, 0x00E92CF0, "Game_EntityState_C"}, + {0x1E00, 0x03DC14C0, "Game_SkillAction_D"}, + {0x1E08, 0x03E0D2C0, "Game_SkillAction_E"}, + {0x1E10, 0x03D9DF30, "Game_SkillAction_F"}, + {0x1E18, 0x00E9E9F0, "Game_SkillAction_G"}, + {0x1E20, 0x03EA53C0, "Game_SkillAction_H"}, + {0x1E28, 0x0ACA0EC0, "TMPro.set_text"}, + {0x1E30, 0x0B391D40, "UnityUI.Text.set_text"}, + {0x1E38, 0x036AA8F0, "Game_SkillAction_I"}, + {0x1E40, 0x03EC31C0, "Game_SkillAction_J"}, + {0x1E48, 0x037F8CD0, "Game_EntityActor_D"}, + {0x1E50, 0x036EA640, "Game_SkillAction_K"}, + {0x1E58, 0x03EC30E0, "Game_SkillAction_L"}, + {0x1E60, 0x037F2A40, "Game_EntityActor_E"}, + {0x1E68, 0x037FD7E0, "Game_EntityActor_F"}, + {0x1E70, 0x00D94C10, "il2cpp_domain_get"}, + {0x1E78, 0x00D94DA0, "il2cpp_assembly_get_image"}, + {0x1E80, 0x00D93A60, "il2cpp_domain_get_assemblies_B"}, +}}; + +void Log(const char* fmt, ...) { + char buffer[2048] = {}; + va_list args; + va_start(args, fmt); + std::vsnprintf(buffer, sizeof(buffer), fmt, args); + va_end(args); + + OutputDebugStringA(buffer); + OutputDebugStringA("\n"); + + HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE); + if (h != nullptr && h != INVALID_HANDLE_VALUE) { + DWORD written = 0; + WriteConsoleA(h, buffer, static_cast(std::strlen(buffer)), &written, nullptr); + WriteConsoleA(h, "\n", 1, &written, nullptr); + } +} + +std::wstring Utf8ToWide(const std::string& value) { + if (value.empty()) { + return {}; + } + const int size = MultiByteToWideChar(65001, 0, value.c_str(), -1, nullptr, 0); + if (size <= 0) { + return {}; + } + std::wstring result(static_cast(size), L'\0'); + MultiByteToWideChar(65001, 0, value.c_str(), -1, result.data(), size); + if (!result.empty() && result.back() == L'\0') { + result.pop_back(); + } + return result; +} + +std::string WideToUtf8(const std::wstring& value) { + if (value.empty()) { + return {}; + } + const int size = WideCharToMultiByte(65001, 0, value.c_str(), -1, nullptr, 0, nullptr, nullptr); + if (size <= 0) { + return {}; + } + std::string result(static_cast(size), '\0'); + WideCharToMultiByte(65001, 0, value.c_str(), -1, result.data(), size, nullptr, nullptr); + if (!result.empty() && result.back() == '\0') { + result.pop_back(); + } + return result; +} + +uintptr_t GetGameAssemblyBase() { + if (g_Runtime.game_assembly_base != 0) { + return g_Runtime.game_assembly_base; + } + g_Runtime.game_assembly_base = FindGameAssemblyBaseNow(); + return g_Runtime.game_assembly_base; +} + +bool WaitForGameAssembly(uint32_t timeout_ms, uint32_t poll_ms) { + const ULONGLONG start = GetTickCount64(); + while (g_Runtime.running.load(std::memory_order_relaxed) || timeout_ms == 0) { + const uintptr_t base = FindGameAssemblyBaseNow(); + if (base != 0) { + g_Runtime.game_assembly_base = base; + return true; + } + + if (timeout_ms != 0) { + const ULONGLONG elapsed = GetTickCount64() - start; + if (elapsed >= timeout_ms) { + break; + } + } + Sleep(poll_ms); + } + return false; +} + +void ResolveGABypassSlots() { + std::scoped_lock lock(g_il2cpp_mutex); + g_il2cpp_slots.clear(); + + const uintptr_t base = GetGameAssemblyBase(); + if (base == 0) { + Log("IL2CPP Domain Not Found!"); + return; + } + + for (const auto& slot : kIl2cppSlotMap) { + g_il2cpp_slots[slot.slot_offset] = reinterpret_cast(base + slot.gameassembly_offset); + } + Log("IL2CPP Domain Found: 0x%p", reinterpret_cast(base)); +} + +void* GetIl2cppSlot(uintptr_t slot_offset) { + std::scoped_lock lock(g_il2cpp_mutex); + const auto it = g_il2cpp_slots.find(slot_offset); + if (it == g_il2cpp_slots.end()) { + return nullptr; + } + return it->second; +} + +bool EnsureIl2CppThreadAttached() { + if (!g_il2cpp_thread_attach_fn || !g_il2cpp_domain_get_fn) { + ResolveIl2CppThreadApisOnce(); + } + + if (!g_il2cpp_thread_attach_fn || !g_il2cpp_domain_get_fn) { + g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed); + return false; + } + + void* domain = g_il2cpp_domain_cached; + if (!domain) { + domain = g_il2cpp_domain_get_fn(); + g_il2cpp_domain_cached = domain; + } + + if (!domain) { + g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed); + return false; + } + + if (g_il2cpp_thread_current_fn) { + void* current = g_il2cpp_thread_current_fn(); + if (current) { + g_tls_il2cpp_thread = current; + g_tls_il2cpp_attached_by_us = false; + g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed); + return true; + } + } else if (g_tls_il2cpp_thread) { + g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed); + return true; + } + + void* attached = g_il2cpp_thread_attach_fn(domain); + if (!attached) { + g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed); + return false; + } + + g_tls_il2cpp_thread = attached; + g_tls_il2cpp_attached_by_us = true; + g_Runtime.il2cpp_thread_attached.store(true, std::memory_order_relaxed); + return true; +} + +bool WaitForIl2CppThreadAttach(uint32_t timeout_ms, uint32_t poll_ms) { + const ULONGLONG start = GetTickCount64(); + for (;;) { + if (EnsureIl2CppThreadAttached()) { + return true; + } + if (timeout_ms != 0) { + const ULONGLONG elapsed = GetTickCount64() - start; + if (elapsed >= timeout_ms) { + return false; + } + } + Sleep(poll_ms); + } +} + +void DetachIl2CppThreadIfAttached() { + if (!g_tls_il2cpp_thread || !g_tls_il2cpp_attached_by_us) { + return; + } + + if (!g_il2cpp_thread_detach_fn) { + ResolveIl2CppThreadApisOnce(); + } + if (g_il2cpp_thread_detach_fn) { + g_il2cpp_thread_detach_fn(g_tls_il2cpp_thread); + } + + g_tls_il2cpp_thread = nullptr; + g_tls_il2cpp_attached_by_us = false; + g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed); +} + +void SetGameThreadContext(bool enabled) { + g_tls_game_thread_context = enabled; + if (enabled) { + const DWORD tid = GetCurrentThreadId(); + DWORD known = g_Runtime.game_thread_id.load(std::memory_order_relaxed); + if (known == 0) { + g_Runtime.game_thread_id.store(tid, std::memory_order_relaxed); + } + } +} + +bool IsGameThreadContext() { + if (g_tls_game_thread_context) { + return true; + } + const DWORD known = g_Runtime.game_thread_id.load(std::memory_order_relaxed); + return known != 0 && known == GetCurrentThreadId(); +} + +bool IsWindowsBuildAtLeast(uint32_t build_number) { + using RtlGetVersionFn = LONG(WINAPI*)(PRTL_OSVERSIONINFOW); + + static std::atomic cached_build{0}; + uint32_t value = cached_build.load(std::memory_order_acquire); + if (value == 0) { + HMODULE ntdll = GetModuleHandleW(L"ntdll.dll"); + if (!ntdll) { + ntdll = LoadLibraryW(L"ntdll.dll"); + } + if (!ntdll) { + return false; + } + + auto* rtl_get_version = reinterpret_cast( + GetProcAddress(ntdll, "RtlGetVersion")); + if (!rtl_get_version) { + return false; + } + + RTL_OSVERSIONINFOW info{}; + info.dwOSVersionInfoSize = sizeof(info); + if (rtl_get_version(&info) == 0) { + value = info.dwBuildNumber; + cached_build.store(value, std::memory_order_release); + } + } + + return value >= build_number; +} + +void ToggleConsole(bool enabled) { + if (enabled) { + if (GetConsoleWindow() == nullptr) { + AllocConsole(); + FILE* stream = nullptr; + freopen_s(&stream, "CONOUT$", "w", stdout); + freopen_s(&stream, "CONOUT$", "w", stderr); + SetConsoleOutputCP(65001); + SetConsoleTitleA("il2cpp Game Console"); + } + } else { + if (GetConsoleWindow() != nullptr) { + ShowWindow(GetConsoleWindow(), SW_HIDE); + } + } +} + +bool ScanLoadedModulesForInjectionMarkers() { + static const std::wstring kMarkerA = L"testyip"; + static const std::wstring kMarkerB = L"gatmp.tmp"; + static const std::wstring kMarkerC = L"ef-cheeto.dll"; + + HMODULE modules[2048] = {}; + DWORD needed = 0; + if (!K32EnumProcessModules(GetCurrentProcess(), modules, sizeof(modules), &needed)) { + return false; + } + + const size_t count = needed / sizeof(HMODULE); + for (size_t i = 0; i < count; ++i) { + wchar_t path[MAX_PATH] = {}; + if (K32GetModuleFileNameExW(GetCurrentProcess(), modules[i], path, MAX_PATH) == 0) { + continue; + } + std::wstring lower = path; + std::transform(lower.begin(), lower.end(), lower.begin(), [](wchar_t c) { + return static_cast(::towlower(c)); + }); + if (lower.find(kMarkerA) != std::wstring::npos || + lower.find(kMarkerB) != std::wstring::npos || + lower.find(kMarkerC) != std::wstring::npos) { + return true; + } + } + return false; +} + +void InitializeI18N() { + std::scoped_lock lock(g_i18n_mutex); + if (g_i18n_initialized) { + return; + } + + const nlohmann::json parsed = nlohmann::json::parse(kI18nBlob, nullptr, false); + if (!parsed.is_object()) { + g_i18n_initialized = true; + return; + } + + for (auto it = parsed.begin(); it != parsed.end(); ++it) { + const std::string key = it.key(); + const nlohmann::json& item = it.value(); + if (!item.is_object()) { + continue; + } + g_en[key] = item.value("en", key); + g_zh_cn[key] = item.value("zh_cn", key); + } + g_i18n_initialized = true; +} + +const char* Tr(const char* key) { + InitializeI18N(); + + std::scoped_lock lock(g_i18n_mutex); + const std::string k = key ? key : ""; + const Language lang = g_Runtime.language.load(std::memory_order_relaxed); + + const auto fallback_it = g_en.find(k); + if (lang == Language::ZhCN) { + const auto it = g_zh_cn.find(k); + if (it != g_zh_cn.end()) { + return it->second.c_str(); + } + } + + if (fallback_it != g_en.end()) { + return fallback_it->second.c_str(); + } + return key ? key : ""; +} + +void SetLanguage(Language language) { + g_Runtime.language.store(language, std::memory_order_relaxed); +} + +void ApplyThemeDefault() { + ImGui::StyleColorsDark(); +} + +void ApplyThemeEvangelionUnit01() { + static constexpr std::array kColors = {{ + "FFFFFFFF", "7857A7FF", "19171CFF", "2A282EFF", "2A282EE6", "4DE6A5FF", + "00000000", "4A455240", "A38CCF80", "7857A780", "4A4552FF"}}; + ApplyThemePalette(kColors); +} + +void ApplyThemeEvangelionUnit02() { + static constexpr std::array kColors = {{ + "FFFFFFFF", "D9293BFF", "1E1E1EFF", "3A3A3AFF", "3A3A3AE6", "F7B302FF", + "00000000", "4A455240", "F7465880", "D9293B80", "4A4552FF"}}; + ApplyThemePalette(kColors); +} + +void ApplyThemeMatrix() { + static constexpr std::array kColors = {{ + "00FF41FF", "00AA2CFF", "000000FF", "0A0A0AFF", "0A0A0AE6", "004400FF", + "00000000", "00440040", "00881EFF", "00FF4180", "00FF4180"}}; + ApplyThemePalette(kColors); +} + +bool IsKeyPressedOnce(int vk) { + return (GetAsyncKeyState(vk) & 0x1) != 0; +} diff --git a/IDA/project/helpers.h b/IDA/project/helpers.h new file mode 100644 index 0000000..d5c31c5 --- /dev/null +++ b/IDA/project/helpers.h @@ -0,0 +1,51 @@ +#pragma once + +#include "Common.h" + +struct Il2cppSlotDefinition { + uintptr_t slot_offset; + uintptr_t gameassembly_offset; + const char* name; +}; + +extern const std::array kIl2cppSlotMap; + +void Log(const char* fmt, ...); +void ResolveGABypassSlots(); +void* GetIl2cppSlot(uintptr_t slot_offset); +uintptr_t GetGameAssemblyBase(); +bool WaitForGameAssembly(uint32_t timeout_ms = 0, uint32_t poll_ms = 100); +bool EnsureIl2CppThreadAttached(); +bool WaitForIl2CppThreadAttach(uint32_t timeout_ms = 15000, uint32_t poll_ms = 100); +void DetachIl2CppThreadIfAttached(); +void SetGameThreadContext(bool enabled); +bool IsGameThreadContext(); + +std::wstring Utf8ToWide(const std::string& value); +std::string WideToUtf8(const std::wstring& value); + +bool IsWindowsBuildAtLeast(uint32_t build_number); +void ToggleConsole(bool enabled); +bool ScanLoadedModulesForInjectionMarkers(); + +void InitializeI18N(); +const char* Tr(const char* key); +void SetLanguage(Language language); + +void ApplyThemeDefault(); +void ApplyThemeEvangelionUnit01(); +void ApplyThemeEvangelionUnit02(); +void ApplyThemeMatrix(); + +bool IsKeyPressedOnce(int vk); + +template +Fn GetIl2cppFn(uintptr_t slot_offset) { + if (!IsGameThreadContext()) { + return nullptr; + } + if (!EnsureIl2CppThreadAttached()) { + return nullptr; + } + return reinterpret_cast(GetIl2cppSlot(slot_offset)); +} diff --git a/IDA/project/main.cpp b/IDA/project/main.cpp new file mode 100644 index 0000000..aa9a0d7 --- /dev/null +++ b/IDA/project/main.cpp @@ -0,0 +1,59 @@ +#include "ModuleManager.h" +#include "UI.h" +#include "helpers.h" + +namespace { + +DWORD WINAPI LoaderThreadProc(LPVOID) { + ToggleConsole(true); + Log("Initializing.."); + + g_Runtime.running.store(true, std::memory_order_relaxed); + InitializeI18N(); + Log("Waiting for GameAssembly.dll ..."); + if (!WaitForGameAssembly(120000, 200)) { + Log("IL2CPP Domain Not Found!"); + g_Runtime.running.store(false, std::memory_order_relaxed); + return 0; + } + ResolveGABypassSlots(); + g_Runtime.il2cpp_thread_attached.store(false, std::memory_order_relaxed); + g_Runtime.game_thread_id.store(0, std::memory_order_relaxed); + Log("IL2CPP thread attach deferred to game-thread dispatcher"); + + if (ScanLoadedModulesForInjectionMarkers()) { + Log("Module path scanner matched testyip/gatmp.tmp/EF-Cheeto.dll"); + } + + RegisterDefaultModules(); + GetModuleManager().Init(); + + RunOverlayLoop(); + ShutdownOverlayWindow(); + DetachIl2CppThreadIfAttached(); + + g_Runtime.running.store(false, std::memory_order_relaxed); + Log("Shutdown complete"); + return 0; +} + +} // namespace + +BOOL APIENTRY DllMain(HMODULE module, DWORD reason, LPVOID) { + switch (reason) { + case DLL_PROCESS_ATTACH: { + DisableThreadLibraryCalls(module); + HANDLE thread = CreateThread(nullptr, 0, LoaderThreadProc, nullptr, 0, nullptr); + if (thread) { + CloseHandle(thread); + } + break; + } + case DLL_PROCESS_DETACH: + g_Runtime.running.store(false, std::memory_order_relaxed); + break; + default: + break; + } + return TRUE; +} diff --git a/IDA/project/obj/EF-Cheeto.Build.CppClean.log b/IDA/project/obj/EF-Cheeto.Build.CppClean.log new file mode 100644 index 0000000..9208c89 --- /dev/null +++ b/IDA/project/obj/EF-Cheeto.Build.CppClean.log @@ -0,0 +1,35 @@ +i:\ef-cheeto\project\obj\modulemanager.obj +i:\ef-cheeto\project\obj\playerprofile.obj +i:\ef-cheeto\project\obj\imgui_draw.obj +i:\ef-cheeto\project\obj\imgui_impl_dx11.obj +i:\ef-cheeto\project\obj\unityexplorer.obj +i:\ef-cheeto\project\obj\imgui_tables.obj +i:\ef-cheeto\project\obj\ui.obj +i:\ef-cheeto\project\obj\fpsunlocker.obj +i:\ef-cheeto\project\obj\fpsmodule.obj +i:\ef-cheeto\project\obj\setdither.obj +i:\ef-cheeto\project\obj\skillhack.obj +i:\ef-cheeto\project\obj\helpers.obj +i:\ef-cheeto\project\obj\main.obj +i:\ef-cheeto\project\obj\imgui.obj +i:\ef-cheeto\project\obj\vacuum.obj +i:\ef-cheeto\project\obj\noclip.obj +i:\ef-cheeto\project\obj\imgui_impl_win32.obj +i:\ef-cheeto\project\obj\freecam.obj +i:\ef-cheeto\project\obj\settingstab.obj +i:\ef-cheeto\project\obj\esp.obj +i:\ef-cheeto\project\obj\imgui_widgets.obj +i:\ef-cheeto\project\obj\preventscreenshot.obj +i:\ef-cheeto\project\obj\vc143.pdb +i:\ef-cheeto\project\bin\ef-cheeto.dll +i:\ef-cheeto\project\obj\ef-cheeto.ipdb +i:\ef-cheeto\project\obj\ef-cheeto.iobj +i:\ef-cheeto\project\obj\ef-cheeto.vcxproj.filelistabsolute.txt +i:\ef-cheeto\project\obj\ef-cheeto.tlog\cl.11360.write.1.tlog +i:\ef-cheeto\project\obj\ef-cheeto.tlog\cl.command.1.tlog +i:\ef-cheeto\project\obj\ef-cheeto.tlog\cl.items.tlog +i:\ef-cheeto\project\obj\ef-cheeto.tlog\cl.read.1.tlog +i:\ef-cheeto\project\obj\ef-cheeto.tlog\link.command.1.tlog +i:\ef-cheeto\project\obj\ef-cheeto.tlog\link.read.1.tlog +i:\ef-cheeto\project\obj\ef-cheeto.tlog\link.secondary.1.tlog +i:\ef-cheeto\project\obj\ef-cheeto.tlog\link.write.1.tlog diff --git a/IDA/project/obj/EF-Cheeto.dll.recipe b/IDA/project/obj/EF-Cheeto.dll.recipe new file mode 100644 index 0000000..682c10c --- /dev/null +++ b/IDA/project/obj/EF-Cheeto.dll.recipe @@ -0,0 +1,11 @@ + + + + + I:\EF-Cheeto\project\bin\EF-Cheeto.dll + + + + + + \ No newline at end of file diff --git a/IDA/project/obj/EF-Cheeto.iobj b/IDA/project/obj/EF-Cheeto.iobj new file mode 100644 index 0000000..d8c5f3b Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.iobj differ diff --git a/IDA/project/obj/EF-Cheeto.ipdb b/IDA/project/obj/EF-Cheeto.ipdb new file mode 100644 index 0000000..4ffe262 Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.ipdb differ diff --git a/IDA/project/obj/EF-Cheeto.tlog/CL.13600.write.1.tlog b/IDA/project/obj/EF-Cheeto.tlog/CL.13600.write.1.tlog new file mode 100644 index 0000000..bac1ec4 Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.tlog/CL.13600.write.1.tlog differ diff --git a/IDA/project/obj/EF-Cheeto.tlog/CL.command.1.tlog b/IDA/project/obj/EF-Cheeto.tlog/CL.command.1.tlog new file mode 100644 index 0000000..e4bb7fc Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.tlog/CL.command.1.tlog differ diff --git a/IDA/project/obj/EF-Cheeto.tlog/CL.read.1.tlog b/IDA/project/obj/EF-Cheeto.tlog/CL.read.1.tlog new file mode 100644 index 0000000..34a6658 Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.tlog/CL.read.1.tlog differ diff --git a/IDA/project/obj/EF-Cheeto.tlog/Cl.items.tlog b/IDA/project/obj/EF-Cheeto.tlog/Cl.items.tlog new file mode 100644 index 0000000..413c2d8 --- /dev/null +++ b/IDA/project/obj/EF-Cheeto.tlog/Cl.items.tlog @@ -0,0 +1,22 @@ +I:\EF-Cheeto\project\third_party\imgui\imgui.cpp;I:\EF-Cheeto\project\obj\imgui.obj +I:\EF-Cheeto\project\third_party\imgui\imgui_draw.cpp;I:\EF-Cheeto\project\obj\imgui_draw.obj +I:\EF-Cheeto\project\third_party\imgui\imgui_tables.cpp;I:\EF-Cheeto\project\obj\imgui_tables.obj +I:\EF-Cheeto\project\third_party\imgui\imgui_widgets.cpp;I:\EF-Cheeto\project\obj\imgui_widgets.obj +I:\EF-Cheeto\project\third_party\imgui\backends\imgui_impl_win32.cpp;I:\EF-Cheeto\project\obj\imgui_impl_win32.obj +I:\EF-Cheeto\project\third_party\imgui\backends\imgui_impl_dx11.cpp;I:\EF-Cheeto\project\obj\imgui_impl_dx11.obj +I:\EF-Cheeto\project\main.cpp;I:\EF-Cheeto\project\obj\main.obj +I:\EF-Cheeto\project\helpers.cpp;I:\EF-Cheeto\project\obj\helpers.obj +I:\EF-Cheeto\project\ModuleManager.cpp;I:\EF-Cheeto\project\obj\ModuleManager.obj +I:\EF-Cheeto\project\UI.cpp;I:\EF-Cheeto\project\obj\UI.obj +I:\EF-Cheeto\project\SettingsTAB.cpp;I:\EF-Cheeto\project\obj\SettingsTAB.obj +I:\EF-Cheeto\project\ESP.cpp;I:\EF-Cheeto\project\obj\ESP.obj +I:\EF-Cheeto\project\NoClip.cpp;I:\EF-Cheeto\project\obj\NoClip.obj +I:\EF-Cheeto\project\FreeCam.cpp;I:\EF-Cheeto\project\obj\FreeCam.obj +I:\EF-Cheeto\project\FpsUnlocker.cpp;I:\EF-Cheeto\project\obj\FpsUnlocker.obj +I:\EF-Cheeto\project\FPSModule.cpp;I:\EF-Cheeto\project\obj\FPSModule.obj +I:\EF-Cheeto\project\SkillHack.cpp;I:\EF-Cheeto\project\obj\SkillHack.obj +I:\EF-Cheeto\project\Vacuum.cpp;I:\EF-Cheeto\project\obj\Vacuum.obj +I:\EF-Cheeto\project\PlayerProfile.cpp;I:\EF-Cheeto\project\obj\PlayerProfile.obj +I:\EF-Cheeto\project\SetDither.cpp;I:\EF-Cheeto\project\obj\SetDither.obj +I:\EF-Cheeto\project\PreventScreenshot.cpp;I:\EF-Cheeto\project\obj\PreventScreenshot.obj +I:\EF-Cheeto\project\UnityExplorer.cpp;I:\EF-Cheeto\project\obj\UnityExplorer.obj diff --git a/IDA/project/obj/EF-Cheeto.tlog/EF-Cheeto.lastbuildstate b/IDA/project/obj/EF-Cheeto.tlog/EF-Cheeto.lastbuildstate new file mode 100644 index 0000000..7135904 --- /dev/null +++ b/IDA/project/obj/EF-Cheeto.tlog/EF-Cheeto.lastbuildstate @@ -0,0 +1,2 @@ +PlatformToolSet=v143:VCToolArchitecture=Native32Bit:VCToolsVersion=14.44.35207:TargetPlatformVersion=10.0.26100.0: +Release|x64|I:\EF-Cheeto\project\| diff --git a/IDA/project/obj/EF-Cheeto.tlog/link.command.1.tlog b/IDA/project/obj/EF-Cheeto.tlog/link.command.1.tlog new file mode 100644 index 0000000..3285d47 Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.tlog/link.command.1.tlog differ diff --git a/IDA/project/obj/EF-Cheeto.tlog/link.read.1.tlog b/IDA/project/obj/EF-Cheeto.tlog/link.read.1.tlog new file mode 100644 index 0000000..415c6d5 Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.tlog/link.read.1.tlog differ diff --git a/IDA/project/obj/EF-Cheeto.tlog/link.secondary.1.tlog b/IDA/project/obj/EF-Cheeto.tlog/link.secondary.1.tlog new file mode 100644 index 0000000..3e54e1c --- /dev/null +++ b/IDA/project/obj/EF-Cheeto.tlog/link.secondary.1.tlog @@ -0,0 +1,3 @@ +^I:\EF-CHEETO\PROJECT\OBJ\ESP.OBJ|I:\EF-CHEETO\PROJECT\OBJ\FPSMODULE.OBJ|I:\EF-CHEETO\PROJECT\OBJ\FPSUNLOCKER.OBJ|I:\EF-CHEETO\PROJECT\OBJ\FREECAM.OBJ|I:\EF-CHEETO\PROJECT\OBJ\HELPERS.OBJ|I:\EF-CHEETO\PROJECT\OBJ\IMGUI.OBJ|I:\EF-CHEETO\PROJECT\OBJ\IMGUI_DRAW.OBJ|I:\EF-CHEETO\PROJECT\OBJ\IMGUI_IMPL_DX11.OBJ|I:\EF-CHEETO\PROJECT\OBJ\IMGUI_IMPL_WIN32.OBJ|I:\EF-CHEETO\PROJECT\OBJ\IMGUI_TABLES.OBJ|I:\EF-CHEETO\PROJECT\OBJ\IMGUI_WIDGETS.OBJ|I:\EF-CHEETO\PROJECT\OBJ\MAIN.OBJ|I:\EF-CHEETO\PROJECT\OBJ\MODULEMANAGER.OBJ|I:\EF-CHEETO\PROJECT\OBJ\NOCLIP.OBJ|I:\EF-CHEETO\PROJECT\OBJ\PLAYERPROFILE.OBJ|I:\EF-CHEETO\PROJECT\OBJ\PREVENTSCREENSHOT.OBJ|I:\EF-CHEETO\PROJECT\OBJ\SETDITHER.OBJ|I:\EF-CHEETO\PROJECT\OBJ\SETTINGSTAB.OBJ|I:\EF-CHEETO\PROJECT\OBJ\SKILLHACK.OBJ|I:\EF-CHEETO\PROJECT\OBJ\UI.OBJ|I:\EF-CHEETO\PROJECT\OBJ\UNITYEXPLORER.OBJ|I:\EF-CHEETO\PROJECT\OBJ\VACUUM.OBJ +I:\EF-Cheeto\project\obj\EF-Cheeto.IPDB +I:\EF-Cheeto\project\obj\EF-Cheeto.iobj diff --git a/IDA/project/obj/EF-Cheeto.tlog/link.write.1.tlog b/IDA/project/obj/EF-Cheeto.tlog/link.write.1.tlog new file mode 100644 index 0000000..e1355d6 Binary files /dev/null and b/IDA/project/obj/EF-Cheeto.tlog/link.write.1.tlog differ diff --git a/IDA/project/obj/ESP.obj b/IDA/project/obj/ESP.obj new file mode 100644 index 0000000..5c094d7 Binary files /dev/null and b/IDA/project/obj/ESP.obj differ diff --git a/IDA/project/obj/FPSModule.obj b/IDA/project/obj/FPSModule.obj new file mode 100644 index 0000000..067957c Binary files /dev/null and b/IDA/project/obj/FPSModule.obj differ diff --git a/IDA/project/obj/FpsUnlocker.obj b/IDA/project/obj/FpsUnlocker.obj new file mode 100644 index 0000000..3cbcb2f Binary files /dev/null and b/IDA/project/obj/FpsUnlocker.obj differ diff --git a/IDA/project/obj/FreeCam.obj b/IDA/project/obj/FreeCam.obj new file mode 100644 index 0000000..1975a1c Binary files /dev/null and b/IDA/project/obj/FreeCam.obj differ diff --git a/IDA/project/obj/ModuleManager.obj b/IDA/project/obj/ModuleManager.obj new file mode 100644 index 0000000..4f37f6b Binary files /dev/null and b/IDA/project/obj/ModuleManager.obj differ diff --git a/IDA/project/obj/NoClip.obj b/IDA/project/obj/NoClip.obj new file mode 100644 index 0000000..48b391a Binary files /dev/null and b/IDA/project/obj/NoClip.obj differ diff --git a/IDA/project/obj/PlayerProfile.obj b/IDA/project/obj/PlayerProfile.obj new file mode 100644 index 0000000..ba9ac5e Binary files /dev/null and b/IDA/project/obj/PlayerProfile.obj differ diff --git a/IDA/project/obj/PreventScreenshot.obj b/IDA/project/obj/PreventScreenshot.obj new file mode 100644 index 0000000..52302f3 Binary files /dev/null and b/IDA/project/obj/PreventScreenshot.obj differ diff --git a/IDA/project/obj/SetDither.obj b/IDA/project/obj/SetDither.obj new file mode 100644 index 0000000..d6e25cb Binary files /dev/null and b/IDA/project/obj/SetDither.obj differ diff --git a/IDA/project/obj/SettingsTAB.obj b/IDA/project/obj/SettingsTAB.obj new file mode 100644 index 0000000..cf37408 Binary files /dev/null and b/IDA/project/obj/SettingsTAB.obj differ diff --git a/IDA/project/obj/SkillHack.obj b/IDA/project/obj/SkillHack.obj new file mode 100644 index 0000000..3dc61ef Binary files /dev/null and b/IDA/project/obj/SkillHack.obj differ diff --git a/IDA/project/obj/UI.obj b/IDA/project/obj/UI.obj new file mode 100644 index 0000000..9c7c771 Binary files /dev/null and b/IDA/project/obj/UI.obj differ diff --git a/IDA/project/obj/UnityExplorer.obj b/IDA/project/obj/UnityExplorer.obj new file mode 100644 index 0000000..c59fc01 Binary files /dev/null and b/IDA/project/obj/UnityExplorer.obj differ diff --git a/IDA/project/obj/Vacuum.obj b/IDA/project/obj/Vacuum.obj new file mode 100644 index 0000000..33e9ba3 Binary files /dev/null and b/IDA/project/obj/Vacuum.obj differ diff --git a/IDA/project/obj/helpers.obj b/IDA/project/obj/helpers.obj new file mode 100644 index 0000000..fd01969 Binary files /dev/null and b/IDA/project/obj/helpers.obj differ diff --git a/IDA/project/obj/imgui.obj b/IDA/project/obj/imgui.obj new file mode 100644 index 0000000..fa6655f Binary files /dev/null and b/IDA/project/obj/imgui.obj differ diff --git a/IDA/project/obj/imgui_draw.obj b/IDA/project/obj/imgui_draw.obj new file mode 100644 index 0000000..fc23648 Binary files /dev/null and b/IDA/project/obj/imgui_draw.obj differ diff --git a/IDA/project/obj/imgui_impl_dx11.obj b/IDA/project/obj/imgui_impl_dx11.obj new file mode 100644 index 0000000..dcbee02 Binary files /dev/null and b/IDA/project/obj/imgui_impl_dx11.obj differ diff --git a/IDA/project/obj/imgui_impl_win32.obj b/IDA/project/obj/imgui_impl_win32.obj new file mode 100644 index 0000000..ebeb961 Binary files /dev/null and b/IDA/project/obj/imgui_impl_win32.obj differ diff --git a/IDA/project/obj/imgui_tables.obj b/IDA/project/obj/imgui_tables.obj new file mode 100644 index 0000000..1b4313b Binary files /dev/null and b/IDA/project/obj/imgui_tables.obj differ diff --git a/IDA/project/obj/imgui_widgets.obj b/IDA/project/obj/imgui_widgets.obj new file mode 100644 index 0000000..18c8bd1 Binary files /dev/null and b/IDA/project/obj/imgui_widgets.obj differ diff --git a/IDA/project/obj/main.obj b/IDA/project/obj/main.obj new file mode 100644 index 0000000..5d6cc9a Binary files /dev/null and b/IDA/project/obj/main.obj differ diff --git a/IDA/project/obj/vc143.pdb b/IDA/project/obj/vc143.pdb new file mode 100644 index 0000000..1ec2619 Binary files /dev/null and b/IDA/project/obj/vc143.pdb differ diff --git a/IDA/project/third_party/nlohmann/nlohmann/json.hpp b/IDA/project/third_party/nlohmann/nlohmann/json.hpp new file mode 100644 index 0000000..82d69f7 --- /dev/null +++ b/IDA/project/third_party/nlohmann/nlohmann/json.hpp @@ -0,0 +1,25526 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 12 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 0 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_DIAGNOSTIC_POSITIONS + #define JSON_DIAGNOSTIC_POSITIONS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_DIAGNOSTIC_POSITIONS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#ifdef JSON_HAS_CPP_17 + #include // optional +#endif +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2016 - 2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_23) && !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus > 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG > 202002L) + #define JSON_HAS_CPP_23 + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201703L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201402L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus > 201103L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + /* NOLINTNEXTLINE(modernize-type-traits) we use C++11 */ \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + /* NOLINTNEXTLINE(modernize-avoid-c-arrays) we don't want to depend on */ \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = !nlohmann_json_j.is_null() ? nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1) : nlohmann_json_default_obj.v1; + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.11.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.11.3 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_type_non_intrusive/ +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + friend void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + friend void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + template::value, int> = 0> \ + void from_json(const BasicJsonType& nlohmann_json_j, Type& nlohmann_json_t) { nlohmann::from_json(nlohmann_json_j, static_cast(nlohmann_json_t)); const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE +@since version 3.12.0 +@sa https://json.nlohmann.me/api/macros/nlohmann_define_derived_type/ +*/ +#define NLOHMANN_DEFINE_DERIVED_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, BaseType, ...) \ + template::value, int> = 0> \ + void to_json(BasicJsonType& nlohmann_json_j, const Type& nlohmann_json_t) { nlohmann::to_json(nlohmann_json_j, static_cast(nlohmann_json_t)); NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows calling any std function as if (e.g., with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // char_traits +#include // tuple +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.12.0 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(std::char_traits::eof()); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& +is_complete_type < +detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template