From 0be6edbbb96146af6df8e4b0723c810cab414d69 Mon Sep 17 00:00:00 2001 From: Half People <56476339+Half-People@users.noreply.github.com> Date: Wed, 8 Nov 2023 06:57:34 +0800 Subject: [PATCH] Add files via upload --- HPCS2.sln | 31 + HPCS2/HPCS2.vcxproj | 173 + HPCS2/HPCS2.vcxproj.filters | 90 + HPCS2/HPCS2.vcxproj.user | 4 + HPCS2/Source.cpp | 1610 ++++ HPCS2/api/ini.h | 789 ++ HPCS2/handle_hijack.hpp | 287 + HPCS2/memory.cpp | 255 + HPCS2/memory.hpp | 124 + HPCS2/offset/animationsystem.dll.hpp | 2579 ++++++ HPCS2/offset/client.dll.hpp | 4159 ++++++++++ HPCS2/offset/engine2.dll.hpp | 244 + HPCS2/offset/host.dll.hpp | 16 + HPCS2/offset/interfaces.hpp | 244 + HPCS2/offset/materialsystem2.dll.hpp | 115 + HPCS2/offset/networksystem.dll.hpp | 12 + HPCS2/offset/offsets.hpp | 49 + HPCS2/offset/particles.dll.hpp | 4037 ++++++++++ HPCS2/offset/pulse_system.dll.hpp | 352 + HPCS2/offset/rendersystemdx11.dll.hpp | 29 + HPCS2/offset/resourcesystem.dll.hpp | 213 + HPCS2/offset/scenesystem.dll.hpp | 61 + HPCS2/offset/schemasystem.dll.hpp | 57 + HPCS2/offset/server.dll.hpp | 7168 +++++++++++++++++ HPCS2/offset/soundsystem.dll.hpp | 313 + HPCS2/offset/vphysics2.dll.hpp | 755 ++ HPCS2/offset/worldrenderer.dll.hpp | 233 + HPCS2/x64/Release/HPCS2.Build.CppClean.log | 13 + HPCS2/x64/Release/HPCS2.exe.recipe | 11 + HPCS2/x64/Release/HPCS2.iobj | Bin 0 -> 3209041 bytes HPCS2/x64/Release/HPCS2.ipdb | Bin 0 -> 1021440 bytes HPCS2/x64/Release/HPCS2.log | 6 + .../x64/Release/HPCS2.tlog/CL.command.1.tlog | Bin 0 -> 1534 bytes HPCS2/x64/Release/HPCS2.tlog/CL.read.1.tlog | Bin 0 -> 94420 bytes HPCS2/x64/Release/HPCS2.tlog/CL.write.1.tlog | Bin 0 -> 1244 bytes .../Release/HPCS2.tlog/HPCS2.lastbuildstate | 2 + .../Release/HPCS2.tlog/link.command.1.tlog | Bin 0 -> 1554 bytes HPCS2/x64/Release/HPCS2.tlog/link.read.1.tlog | Bin 0 -> 4730 bytes .../x64/Release/HPCS2.tlog/link.write.1.tlog | Bin 0 -> 778 bytes .../HPCS2.vcxproj.FileListAbsolute.txt | 0 HPCS2/x64/Release/Source.obj | Bin 0 -> 3505506 bytes HPCS2/x64/Release/memory.obj | Bin 0 -> 1381483 bytes HPCS2/x64/Release/vc142.pdb | Bin 0 -> 1191936 bytes x64/Release/Configuration.ini | 16 + x64/Release/HPCS2.exe | Bin 0 -> 123904 bytes x64/Release/HPCS2.pdb | Bin 0 -> 2404352 bytes 46 files changed, 24047 insertions(+) create mode 100644 HPCS2.sln create mode 100644 HPCS2/HPCS2.vcxproj create mode 100644 HPCS2/HPCS2.vcxproj.filters create mode 100644 HPCS2/HPCS2.vcxproj.user create mode 100644 HPCS2/Source.cpp create mode 100644 HPCS2/api/ini.h create mode 100644 HPCS2/handle_hijack.hpp create mode 100644 HPCS2/memory.cpp create mode 100644 HPCS2/memory.hpp create mode 100644 HPCS2/offset/animationsystem.dll.hpp create mode 100644 HPCS2/offset/client.dll.hpp create mode 100644 HPCS2/offset/engine2.dll.hpp create mode 100644 HPCS2/offset/host.dll.hpp create mode 100644 HPCS2/offset/interfaces.hpp create mode 100644 HPCS2/offset/materialsystem2.dll.hpp create mode 100644 HPCS2/offset/networksystem.dll.hpp create mode 100644 HPCS2/offset/offsets.hpp create mode 100644 HPCS2/offset/particles.dll.hpp create mode 100644 HPCS2/offset/pulse_system.dll.hpp create mode 100644 HPCS2/offset/rendersystemdx11.dll.hpp create mode 100644 HPCS2/offset/resourcesystem.dll.hpp create mode 100644 HPCS2/offset/scenesystem.dll.hpp create mode 100644 HPCS2/offset/schemasystem.dll.hpp create mode 100644 HPCS2/offset/server.dll.hpp create mode 100644 HPCS2/offset/soundsystem.dll.hpp create mode 100644 HPCS2/offset/vphysics2.dll.hpp create mode 100644 HPCS2/offset/worldrenderer.dll.hpp create mode 100644 HPCS2/x64/Release/HPCS2.Build.CppClean.log create mode 100644 HPCS2/x64/Release/HPCS2.exe.recipe create mode 100644 HPCS2/x64/Release/HPCS2.iobj create mode 100644 HPCS2/x64/Release/HPCS2.ipdb create mode 100644 HPCS2/x64/Release/HPCS2.log create mode 100644 HPCS2/x64/Release/HPCS2.tlog/CL.command.1.tlog create mode 100644 HPCS2/x64/Release/HPCS2.tlog/CL.read.1.tlog create mode 100644 HPCS2/x64/Release/HPCS2.tlog/CL.write.1.tlog create mode 100644 HPCS2/x64/Release/HPCS2.tlog/HPCS2.lastbuildstate create mode 100644 HPCS2/x64/Release/HPCS2.tlog/link.command.1.tlog create mode 100644 HPCS2/x64/Release/HPCS2.tlog/link.read.1.tlog create mode 100644 HPCS2/x64/Release/HPCS2.tlog/link.write.1.tlog create mode 100644 HPCS2/x64/Release/HPCS2.vcxproj.FileListAbsolute.txt create mode 100644 HPCS2/x64/Release/Source.obj create mode 100644 HPCS2/x64/Release/memory.obj create mode 100644 HPCS2/x64/Release/vc142.pdb create mode 100644 x64/Release/Configuration.ini create mode 100644 x64/Release/HPCS2.exe create mode 100644 x64/Release/HPCS2.pdb diff --git a/HPCS2.sln b/HPCS2.sln new file mode 100644 index 0000000..4143814 --- /dev/null +++ b/HPCS2.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.32106.194 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "HPCS2", "HPCS2\HPCS2.vcxproj", "{9A02F163-AEBD-431B-8E0E-53C246BC27A8}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x64.ActiveCfg = Debug|x64 + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x64.Build.0 = Debug|x64 + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x86.ActiveCfg = Debug|Win32 + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Debug|x86.Build.0 = Debug|Win32 + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x64.ActiveCfg = Release|x64 + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x64.Build.0 = Release|x64 + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x86.ActiveCfg = Release|Win32 + {9A02F163-AEBD-431B-8E0E-53C246BC27A8}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {BC3F94B4-62FD-46DF-891E-E98FB39ADFF2} + EndGlobalSection +EndGlobal diff --git a/HPCS2/HPCS2.vcxproj b/HPCS2/HPCS2.vcxproj new file mode 100644 index 0000000..0bae54c --- /dev/null +++ b/HPCS2/HPCS2.vcxproj @@ -0,0 +1,173 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + Win32Proj + {9a02f163-aebd-431b-8e0e-53c246bc27a8} + HPCS2 + 10.0 + + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + Application + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + false + + + true + + + false + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + stdcpp20 + + + Console + true + true + true + RequireAdministrator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/HPCS2/HPCS2.vcxproj.filters b/HPCS2/HPCS2.vcxproj.filters new file mode 100644 index 0000000..1dea11f --- /dev/null +++ b/HPCS2/HPCS2.vcxproj.filters @@ -0,0 +1,90 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + 資源檔 + + + 來源檔案 + + + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 標頭檔 + + + 來源檔案 + + + 來源檔案 + + + 來源檔案 + + + \ No newline at end of file diff --git a/HPCS2/HPCS2.vcxproj.user b/HPCS2/HPCS2.vcxproj.user new file mode 100644 index 0000000..0f14913 --- /dev/null +++ b/HPCS2/HPCS2.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/HPCS2/Source.cpp b/HPCS2/Source.cpp new file mode 100644 index 0000000..170aea6 --- /dev/null +++ b/HPCS2/Source.cpp @@ -0,0 +1,1610 @@ +#include "offset/offsets.hpp" +#include "offset/client.dll.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "memory.hpp" +#include "api/ini.h" +int render_distance = -1; +bool show_extra = true; +bool ShowViewAngle = false; +bool ShowAimBotFov = true; +int flag_render_distance = 70; +int ShowBoneDistance = 1000; +int TextSize = 15; +int BoomSize = 100; +#define BonesColor RGB(200, 200, 200) +float FOV = 15;//2 +bool DrawESP = true; +bool brecoilControl = true; +bool AimBot = true; +bool AimBotHot = true; +bool AimTeam = false; +bool bTriggerbot = false; +bool bBunnyHop = false; +bool OnlyAttackVisible = true; +bool DrawESPLine = true; +bool MenuDrawBorder = false; +int TriggerDelay_ms = 90; +float AimSmoothing = 2; +int AimBones = 5; + +HANDLE cs2_process_handle; +ProcessModule cs2_module_client; +ProcessModule base_engine; + +std::shared_ptr process; +struct C_UTL_VECTOR +{ + DWORD_PTR count = 0; + DWORD_PTR data = 0; +}; +namespace render +{ + void DrawBorderBox(HDC hdc, int x, int y, int w, int h, COLORREF borderColor) + { + HBRUSH hBorderBrush = CreateSolidBrush(borderColor); + HBRUSH hOldBrush = (HBRUSH)SelectObject(hdc, hBorderBrush); + + RECT rect = { x, y, x + w, y + h }; + FrameRect(hdc, &rect, hBorderBrush); + + SelectObject(hdc, hOldBrush); // Restore the original brush + DeleteObject(hBorderBrush); // Delete the temporary brush + } + + void DrawCircle(HDC hdc, int centerX, int centerY, int radius, COLORREF color) { + HPEN hPen = CreatePen(PS_DASH, 2, color); // ʹúɫΪ1أʵʽĻ + SelectObject(hdc, hPen); + Ellipse(hdc, centerX - radius, centerY - radius, centerX + radius, centerY + radius); + DeleteObject(hPen); + } + + void DrawFilledBox(HDC hdc, int x, int y, int width, int height, COLORREF color) + { + HBRUSH hBrush = CreateSolidBrush(color); + RECT rect = { x, y, x + width, y + height }; + FillRect(hdc, &rect, hBrush); + DeleteObject(hBrush); + } + + void SetTextSize(HDC hdc, int textSize) + { + LOGFONT lf; + HFONT hFont, hOldFont; + + // Initialize the LOGFONT structure + ZeroMemory(&lf, sizeof(LOGFONT)); + lf.lfHeight = -textSize; // Set the desired text height (negative for height) + lf.lfWeight = FW_NORMAL; // Set the font weight (e.g., FW_NORMAL for normal) + lf.lfQuality = ANTIALIASED_QUALITY; // Enable anti-aliasing + + // Create a new font based on the LOGFONT structure + hFont = CreateFontIndirect(&lf); + + // Select the new font into the device context and save the old font + hOldFont = (HFONT)SelectObject(hdc, hFont); + + // Clean up the old font (when done using it) + DeleteObject(hOldFont); + } + + void RenderLine(HDC hdc, float p1x, float p1y, float p2x, float p2y, COLORREF borderColor) + { + HPEN hPen = CreatePen(PS_DASH, 2, borderColor); // ʹúɫΪ1أʵʽĻ + SelectObject(hdc, hPen); + MoveToEx(hdc, (int)p1x, (int)p1y, (LPPOINT)NULL); + LineTo(hdc, (int)p2x, (int)p2y); + DeleteObject(hPen); + } + + void RenderText(HDC hdc, int x, int y, const char* text, COLORREF textColor, int textSize) + { + SetTextSize(hdc, textSize); + SetTextColor(hdc, textColor); + + int len = MultiByteToWideChar(CP_UTF8, 0, text, -1, NULL, 0); + wchar_t* wide_text = new wchar_t[len]; + MultiByteToWideChar(CP_UTF8, 0, text, -1, wide_text, len); + + TextOutW(hdc, x, y, wide_text, len - 1); + + delete[] wide_text; + } +} +namespace g { + inline HDC hdcBuffer = NULL; + inline HBITMAP hbmBuffer = NULL; + + RECT gameBounds; +} +enum bones : int { + head = 6, + neck = 5, + chest = 4, + shoulderRight = 8, + shoulderLeft = 13, + elbowRight = 9, + elbowLeft = 14, + handRight = 11, + handLeft = 16, + crotch = 0, + kneeRight = 23, + kneeLeft = 26, + ankleRight = 24, + ankleLeft = 27, +}; + +inline namespace boneGroups { + inline std::vector mid = { bones::head,bones::neck,bones::chest,bones::crotch }; + inline std::vector leftArm = { bones::neck,bones::shoulderLeft,bones::elbowLeft,bones::handLeft }; + inline std::vector righttArm = { bones::neck,bones::shoulderRight,bones::elbowRight,bones::handRight }; + inline std::vector leftLeg = { bones::crotch,bones::kneeLeft,bones::ankleLeft }; + inline std::vector rightLeg = { bones::crotch,bones::kneeRight,bones::ankleRight }; + inline std::map mid_Name = { {bones::head,"head"}, {bones::neck,"neck"}, {bones::chest,"chest"}, {bones::crotch,"crotch"} }; + + inline std::vector> allGroups = { mid,leftArm,righttArm,leftLeg,rightLeg }; +} +void loop(); + +void FunctionT(); +void USETLOOP() +{ + while (true) + FunctionT(); +} +LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) +{ + switch (message) + { + case WM_CREATE: + { + g::hdcBuffer = CreateCompatibleDC(NULL); + g::hbmBuffer = CreateCompatibleBitmap(GetDC(hWnd), g::gameBounds.right, g::gameBounds.bottom); + SelectObject(g::hdcBuffer, g::hbmBuffer); + + SetWindowLong(hWnd, GWL_EXSTYLE, GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_LAYERED); + + SetLayeredWindowAttributes(hWnd, RGB(255, 255, 255), 0, LWA_COLORKEY); + + //std::cout << "[overlay] Window created successfully" << std::endl; + Beep(500, 100); + break; + } + case WM_ERASEBKGND: // We handle this message to avoid flickering + return TRUE; + case WM_PAINT: + { + PAINTSTRUCT ps; + HDC hdc = BeginPaint(hWnd, &ps); + + //DOUBLE BUFFERING + FillRect(g::hdcBuffer, &ps.rcPaint, (HBRUSH)GetStockObject(WHITE_BRUSH)); + + if (GetForegroundWindow() == process->hwnd_) { + //render::RenderText(g::hdcBuffer, 10, 10, "cs2 | ESP", RGB(75, 175, 175), 15); + loop(); + } + + BitBlt(hdc, 0, 0, g::gameBounds.right, g::gameBounds.bottom, g::hdcBuffer, 0, 0, SRCCOPY); + + EndPaint(hWnd, &ps); + InvalidateRect(hWnd, NULL, TRUE); + break; + } + case WM_DESTROY: + DeleteDC(g::hdcBuffer); + DeleteObject(g::hbmBuffer); + + PostQuitMessage(0); + break; + default: + return DefWindowProc(hWnd, message, wParam, lParam); + } + return 0; +} + +struct view_matrix_t { + float* operator[ ](int index) { + return matrix[index]; + } + + float matrix[4][4]; +}; + +struct Vector3 +{ + // constructor + constexpr Vector3( + const float x = 0.f, + const float y = 0.f, + const float z = 0.f) noexcept : + x(x), y(y), z(z) { } + + // operator overloads + constexpr const Vector3& operator-(const Vector3& other) const noexcept + { + return Vector3{ x - other.x, y - other.y, z - other.z }; + } + + constexpr const Vector3& operator+(const Vector3& other) const noexcept + { + return Vector3{ x + other.x, y + other.y, z + other.z }; + } + + constexpr const Vector3& operator/(const float factor) const noexcept + { + return Vector3{ x / factor, y / factor, z / factor }; + } + + constexpr const Vector3& operator*(const float factor) const noexcept + { + return Vector3{ x * factor, y * factor, z * factor }; + } + + constexpr const bool operator>(const Vector3& other) const noexcept { + return x > other.x && y > other.y && z > other.z; + } + + constexpr const bool operator>=(const Vector3& other) const noexcept { + return x >= other.x && y >= other.y && z >= other.z; + } + + constexpr const bool operator<(const Vector3& other) const noexcept { + return x < other.x&& y < other.y&& z < other.z; + } + + constexpr const bool operator<=(const Vector3& other) const noexcept { + return x <= other.x && y <= other.y && z <= other.z; + } + + constexpr const Vector3& ToAngle() const noexcept + { + return Vector3{ + std::atan2(-z, std::hypot(x, y)) * (180.0f / std::numbers::pi_v), + std::atan2(y, x) * (180.0f / std::numbers::pi_v), + 0.0f + }; + } + + void Print()const + { + std::cout << "\n x : " << x << " y :" << y << "z :" << z; + return; + } + + constexpr const bool IsZero() const noexcept + { + return x == 0.f && y == 0.f && z == 0.f; + } + + float length() const { + return std::sqrt(x * x + y * y + z * z); + } + + float length2d() const { + return std::sqrt(x * x + y * y); + } + + Vector3 limit(float limit) + { + Vector3 T; + if (x > limit)//|| In.x < -limit) + { + T.x = limit; + } + else + { + if (x < 0 - limit) + { + T.x = -limit; + } + else + { + T.x = x; + } + } + + if (y > limit)//|| In.y < -limit) + { + T.y = limit; + } + else + { + if (y < -limit) + { + T.y = 0 - limit; + } + else + { + T.y = y; + } + } + + T.z = z; + return T; + } + + Vector3 world_to_screen(view_matrix_t matrix) const { + float _x = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z + matrix[0][3]; + float _y = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z + matrix[1][3]; + float w = matrix[3][0] * x + matrix[3][1] * y + matrix[3][2] * z + matrix[3][3]; + + float inv_w = 1.f / w; + _x *= inv_w; + _y *= inv_w; + + float x = g::gameBounds.right * .5f; + float y = g::gameBounds.bottom * .5f; + + x += 0.5f * _x * g::gameBounds.right + 0.5f; + y -= 0.5f * _y * g::gameBounds.bottom + 0.5f; + + return { x, y, w }; + } + + float calculate_distance(const Vector3& point) const { + float dx = point.x - x; + float dy = point.y - y; + float dz = point.z - z; + + return std::sqrt(dx * dx + dy * dy + dz * dz); + } + + // struct data + float x, y, z; +}; + +inline constexpr Vector3 CalculateAngle( + const Vector3& localPosition, + const Vector3& enemyPosition, + const Vector3& viewAngles) noexcept +{ + return ((enemyPosition - localPosition).ToAngle() - viewAngles); +}; + +inline Vector3 clampAngles(Vector3 angles) { + if (angles.x > 89.0f && angles.x <= 180.0f) { + angles.x = 89.0f; + } + + if (angles.x > 180.0f) { + angles.x -= 360.0f; + } + + if (angles.x < -89.0f) { + angles.x = -89.0f; + } + + if (angles.y > 180.0f) { + angles.y -= 360.0f; + } + + if (angles.y < -180.0f) { + angles.y += 360.0f; + } + angles.z = 0; + + return angles; +}; + +inline Vector3 normalizeAngles(Vector3 angle) { + while (angle.x > 180.f) + angle.x -= 360.0f; + + while (angle.x < -180.0f) + angle.x += 360.0f; + + while (angle.y > 180.0f) + angle.y -= 360.0f; + + while (angle.y < -180.0f) + angle.y += 360.0f; + + return angle; +}; + +inline Vector3 calculateBestAngle(Vector3 angle, float& configFov) { + Vector3 newAngle = 0; + + float fov = std::hypot(angle.x, angle.y); + + if (fov <= configFov) { + configFov = fov; + newAngle = angle; + } + return newAngle; +} + +uintptr_t TraceAddress(uintptr_t BaseAddress, std::vector Offsets) +{ + uintptr_t Address = 0; + + if (Offsets.size() == 0) + return BaseAddress; + Address = process->read(BaseAddress); + if (!Address) + return 0; + + for (int i = 0; i < Offsets.size() - 1; i++) + { + Address = process->read(Address + Offsets[i]); + if (!Address) + return 0; + } + return Address == 0 ? 0 : Address + Offsets[Offsets.size() - 1]; +} + +int localTeam; + +void Triggerbot() +{ + uintptr_t player = process->read(cs2_module_client.base + client_dll::dwLocalPlayerPawn); + unsigned long iIDEntIndex = process->read(player + C_CSPlayerPawnBase::m_iIDEntIndex); + //std::cout << "\n " << iIDEntIndex; + if (iIDEntIndex == -1) + return; + + const uintptr_t ListEntry = TraceAddress(cs2_module_client.base + client_dll::dwEntityList, { 0x8 * (iIDEntIndex >> 9) + 0x10,0x0 }); + if (ListEntry == 0) + return; + + uintptr_t PawnAddress = process->read(ListEntry + 0x78 * (iIDEntIndex & 0x1FF)); + if (!PawnAddress) + return; + + bool AllowShoot = false; + + //std::cout << "\n " << process->read(PawnAddress + C_BaseEntity::m_iHealth); + + if (!AimTeam) + AllowShoot = process->read(PawnAddress + C_BaseEntity::m_iTeamNum) != localTeam && process->read(PawnAddress + C_BaseEntity::m_iHealth) > 0; + else + AllowShoot = process->read(PawnAddress + C_BaseEntity::m_iHealth) > 0; + + if (!AllowShoot) + return; + + static std::chrono::time_point LastTimePoint = std::chrono::steady_clock::now(); + auto CurTimePoint = std::chrono::steady_clock::now(); + if (CurTimePoint - LastTimePoint >= std::chrono::milliseconds(TriggerDelay_ms/*ms TriggerDelay*/)) + { + const bool isAlreadyShooting = GetAsyncKeyState(VK_LBUTTON) < 0; + if (!isAlreadyShooting) + { + mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0); + mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); + } + + LastTimePoint = CurTimePoint; + } + + //mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0); + //mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); + return; +} + +void Bunnyhop(uintptr_t player) +{ + const bool hasFlagInAir = process->read(player + C_BaseEntity::m_fFlags) & (1 << 0); + if (GetAsyncKeyState(VK_SPACE) && hasFlagInAir) + { + process->write(cs2_module_client.base + client_dll::dwForceJump, 65537); + } + else if (GetAsyncKeyState(VK_SPACE) && !hasFlagInAir) + { + process->write(cs2_module_client.base + client_dll::dwForceJump, 256); + process->write(cs2_module_client.base + client_dll::dwForceJump, 65537); + process->write(cs2_module_client.base + client_dll::dwForceJump, 256); + } + else + { + process->write(cs2_module_client.base + client_dll::dwForceJump, 256); + } +} + +Vector3 aimBot(C_UTL_VECTOR aimPunchCache, int getShotsFired, Vector3& cameraPos, float& fov, bool isHot, Vector3 baseViewAngles, uintptr_t boneArray) { + Vector3 aimPos; + Vector3 newAngle; + + aimPos = process->read(boneArray + AimBones/*head*/ * 32); + //aimPos.Print(); + const Vector3 angle = CalculateAngle(cameraPos, aimPos, baseViewAngles); + + newAngle = calculateBestAngle(angle, fov/*fov*/); + + if (newAngle.IsZero()) { + return 0; + } + + if (isHot) { + if (GetAsyncKeyState(VK_SHIFT) & 0x8000) { + if (brecoilControl) + { + Vector3 aimPunchAngle = process->read(aimPunchCache.data + (aimPunchCache.count - 1) * sizeof(Vector3)); + + if (getShotsFired > 1) { + newAngle.x = newAngle.x - aimPunchAngle.x * 2.f; + newAngle.y = newAngle.y - aimPunchAngle.y * 2.f; + } + } + + newAngle = clampAngles(newAngle); + //if (AimSmoothing != 0) + // newAngle = newAngle.limit(AimSmoothing); + + if (AimSmoothing != 0) + newAngle = newAngle / AimSmoothing; + + if (!newAngle.IsZero()) + return newAngle + baseViewAngles;//baseViewAngles; + //Triggerbot(); + } + } + else { + if (getShotsFired > 1) { + Vector3 aimPunchAngle = process->read(aimPunchCache.data + (aimPunchCache.count - 1) * sizeof(Vector3)); + newAngle.x = newAngle.x - aimPunchAngle.x * 2.f; + newAngle.y = newAngle.y - aimPunchAngle.y * 2.f; + //newAngle = clampAngles(newAngle); + + //newAngle.x = newAngle.x / AimSmoothing;//smoothing + //newAngle.y = newAngle.y / AimSmoothing;//smoothing + + if (AimSmoothing != 0) + newAngle = newAngle.limit(AimSmoothing); + + return newAngle + baseViewAngles; + } + } + return 0; +} + +void recoilControl(Vector3& ViewAngle, C_UTL_VECTOR aimPunchCache, int getShotsFired, DWORD_PTR baseViewAnglesAddy) { + static Vector3 oldPunch; + if (getShotsFired > 1) { + Vector3 aimPunchAngle = process->read(aimPunchCache.data + (aimPunchCache.count - 1) * sizeof(Vector3)); + Vector3 recoilVector = { + ViewAngle.x + oldPunch.x - aimPunchAngle.x * 2.f, + ViewAngle.y + oldPunch.y - aimPunchAngle.y * 2.f + }; + recoilVector = clampAngles(recoilVector); + + oldPunch = aimPunchAngle * 2.f; + process->write(baseViewAnglesAddy, recoilVector); + } + else + oldPunch = 0; +} + +int main(int argc, char* argv[]) +{ + SetConsoleTitleW(L"cs2-HalfPeople-esp"); + + process = std::make_shared(); + + while (!process->AttachProcessHj("cs2.exe")) + std::this_thread::sleep_for(std::chrono::seconds(1)); + + do { + cs2_module_client = process->GetModule("client.dll"); + base_engine = process->GetModule("engine2.dll"); + if (cs2_module_client.base == 0 || base_engine.base == 0) { + std::this_thread::sleep_for(std::chrono::seconds(1)); + std::cout << " Failed to find module client.dll/engine2.dll, waiting for the game to load it..." << std::endl; + } + } while (cs2_module_client.base == 0 || base_engine.base == 0); + + const uintptr_t buildNumber = process->read(base_engine.base + engine2_dll::dwBuildNumber); + std::cout << "\n build number : " << buildNumber; + + std::cout << " Make sure your game is in \"Full Screen Windowed\"" << std::endl; + while (GetForegroundWindow() != process->hwnd_) { + std::this_thread::sleep_for(std::chrono::seconds(1)); + process->UpdateHWND(); + ShowWindow(process->hwnd_, TRUE); + } + std::cout << "Creating window overlay" << std::endl; + + WNDCLASSEXA wc = { 0 }; + wc.cbSize = sizeof(WNDCLASSEXA); + wc.lpfnWndProc = WndProc; + wc.style = CS_HREDRAW | CS_VREDRAW; + wc.hbrBackground = WHITE_BRUSH; + wc.hInstance = reinterpret_cast(GetWindowLongA(process->hwnd_, (-6))); // GWL_HINSTANCE)); + wc.lpszMenuName = " "; + wc.lpszClassName = " "; + + RegisterClassExA(&wc); + + GetClientRect(process->hwnd_, &g::gameBounds); + + // Create the window + HINSTANCE hInstance = NULL; + HWND hWnd = CreateWindowExA(WS_EX_TRANSPARENT | WS_EX_TOPMOST | WS_EX_LAYERED | WS_EX_TOOLWINDOW, " ", "cs2-HalfPeople-esp", WS_POPUP, + g::gameBounds.left, g::gameBounds.top, g::gameBounds.right - g::gameBounds.left, g::gameBounds.bottom + g::gameBounds.left, NULL, NULL, hInstance, NULL); // NULL, NULL); + + if (hWnd == NULL) + return 0; + + SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); + ShowWindow(hWnd, TRUE); + //SetActiveWindow(hack::process->hwnd_); + std::thread T(USETLOOP); + // Message loop + MSG msg; + while (GetMessage(&msg, NULL, 0, 0)) + { + //std::thread T(FunctionT); + if (GetAsyncKeyState(VK_END) & 0x8000) break; + + TranslateMessage(&msg); + DispatchMessage(&msg); + + //T.join(); + //std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + + DeleteDC(g::hdcBuffer); + DeleteObject(g::hbmBuffer); + + DestroyWindow(hWnd); + + process->Close(); + + system("pause"); + + return 0; +} +uintptr_t entity_list; +uintptr_t localpCSPlayerPawn; +uintptr_t localPlayerController; + +//Vector3 TEST_CAMEPOS, TEST_CAMEANGLE, TEST_VIEWANGLE; + +#define MenuOffset 100 +#define MenuItemSelectColor RGB(100,200,200) +#define MenuItemColor RGB(200,200,200) +#define MenuItemMaxIndex 22 +#define MenuTitleColor RGB(195,125,255) +int ApplayItem = false; +bool isDrawMenu = false; + +void MenuTitle(int& MenuTitleIndexOffset, int index, const char* Text) +{ + render::RenderText(g::hdcBuffer, 0, MenuOffset + 5 + MenuTitleIndexOffset + TextSize * index, Text, MenuTitleColor, TextSize + 5); + MenuTitleIndexOffset += (TextSize + 15); +} +bool MenuItem(int Offset, int& SelectIndex, int& index, const char* text) +{ + bool R = SelectIndex == index; + render::RenderText(g::hdcBuffer, 0, MenuOffset + 5 + Offset + TextSize * index, text, (R ? MenuItemSelectColor : MenuItemColor), TextSize); + index++; + return R && ApplayItem > 0; +} + +void DrawMenu() +{ + int MenuTitleIndexOffset = 0; + static int MenuSelectIndex = 0; + int index = 0; + static int MenuHight = 0; + if (GetKeyState(VK_UP) & 0x8000) + { + if (MenuSelectIndex - 1 < 0) + MenuSelectIndex = MenuItemMaxIndex; + MenuSelectIndex--; + Beep(500, 90); + } + + if (GetKeyState(VK_DOWN) & 0x8000) + { + if (MenuSelectIndex + 1 > MenuItemMaxIndex) + MenuSelectIndex = 0; + MenuSelectIndex++; + Beep(500, 90); + } + ApplayItem = 0; + if (GetKeyState(VK_RIGHT) & 0x8000) + { + ApplayItem = 1; + + Beep(600, 90); + } + + if (GetKeyState(VK_LEFT) & 0x8000) + { + ApplayItem = 2; + + Beep(600, 90); + } + + render::DrawFilledBox(g::hdcBuffer, 0, MenuOffset, TextSize * 15, MenuHight, RGB(0, 0, 0)); + + SetBkColor(g::hdcBuffer, RGB(0, 0, 0)); + + MenuTitle(MenuTitleIndexOffset, index, "F1 - Hide Menu"); + MenuTitle(MenuTitleIndexOffset, index, "-----Function-----"); + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("RecoilControl -> ").append((brecoilControl ? "true" : "false")).c_str())) + { + brecoilControl = !brecoilControl; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("AimBot -> ").append((AimBot ? "true" : "false")).c_str())) + { + AimBot = !AimBot; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("Triggerbot -> ").append((bTriggerbot ? "true" : "false")).c_str())) + { + bTriggerbot = !bTriggerbot; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("BunnyHop -> ").append((bBunnyHop ? "true" : "false")).c_str())) + { + bBunnyHop = !bBunnyHop; + } + + MenuTitle(MenuTitleIndexOffset, index, "-------ESP-------"); + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("Draw ESP -> ").append((DrawESP ? "true" : "false")).c_str())) + { + DrawESP = !DrawESP; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("Draw ESP Line -> ").append((DrawESPLine ? "true" : "false")).c_str())) + { + DrawESPLine = !DrawESPLine; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("ShowViewAngle -> ").append((ShowViewAngle ? "true" : "false")).c_str())) + { + ShowViewAngle = !ShowViewAngle; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("show_extra -> ").append((show_extra ? "true" : "false")).c_str())) + { + show_extra = !show_extra; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("TextSize -> ").append(std::to_string(TextSize)).c_str())) + { + MenuHight = 0; + if (ApplayItem == 1) + { + TextSize++; + } + else + if (TextSize - 1 > 0) + TextSize--; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("ShowBoneDistance -> ").append(std::to_string(ShowBoneDistance)).c_str())) + { + if (ApplayItem == 1) + { + ShowBoneDistance += 10; + } + else + if (ShowBoneDistance - 10 > 0) + ShowBoneDistance -= 10; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("flag_render_distance -> ").append(std::to_string(flag_render_distance)).c_str())) + { + if (ApplayItem == 1) + { + flag_render_distance += 10; + } + else + if (flag_render_distance - 10 > 0) + flag_render_distance -= 10; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("render_distance -> ").append(std::to_string(render_distance)).c_str())) + { + if (ApplayItem == 1) + { + render_distance += 10; + } + else + if (render_distance - 10 > -1) + render_distance -= 10; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("Draw Boom MaxSize -> ").append(std::to_string(BoomSize)).c_str())) + { + if (ApplayItem == 1) + { + BoomSize += 10; + } + else + if (BoomSize - 10 > -1) + BoomSize -= 10; + + render::DrawFilledBox( + g::hdcBuffer, + 25, + 25, + BoomSize, + BoomSize * 1.4, + RGB(175, 75, 75) + ); + } + + MenuTitle(MenuTitleIndexOffset, index, "-----AimBot-----"); + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("AimTeam -> ").append((AimTeam ? "true" : "false")).c_str())) + { + AimTeam = !AimTeam; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("AimBotHot -> ").append((AimBotHot ? "true" : "false")).c_str())) + { + AimBotHot = !AimBotHot; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("OnlyAttackVisible -> ").append((OnlyAttackVisible ? "true" : "false")).c_str())) + { + OnlyAttackVisible = !OnlyAttackVisible; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("AimBot FOV -> ").append(std::to_string(FOV)).c_str())) + { + if (ApplayItem == 1) + { + FOV++; + } + else + if (FOV - 1 > 0) + FOV -= 1; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("AimBot Smoothing -> ").append(std::to_string(AimSmoothing)).c_str())) + { + if (ApplayItem == 1) + { + AimSmoothing += 0.5; + } + else + if (AimSmoothing - 0.5 > 1) + AimSmoothing -= 0.5; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("AimBot AimBone -> ").append(boneGroups::mid_Name.find(AimBones)->second).c_str())) + { + if (ApplayItem == 1) + { + for (size_t i = 0; i < boneGroups::mid.size(); i++) + { + if (boneGroups::mid[i] == AimBones) + { + if (i + 1 < boneGroups::mid.size()) + { + AimBones = boneGroups::mid.at(i + 1); + } + else + AimBones = boneGroups::mid.front(); + + i = boneGroups::mid.size(); + } + } + } + else + if (AimSmoothing - 1 > -1) + for (size_t i = 0; i < boneGroups::mid.size(); i++) + { + if (boneGroups::mid[i] == AimBones) + { + if (i - 1 > 0) + { + AimBones = boneGroups::mid.at(i - 1); + } + else + AimBones = boneGroups::mid.back(); + + i = boneGroups::mid.size(); + } + } + } + + MenuTitle(MenuTitleIndexOffset, index, "-----Misc-----"); + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("Menu Draw Border -> ").append((MenuDrawBorder ? "true" : "false")).c_str())) + { + MenuDrawBorder = !MenuDrawBorder; + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, std::string("TriggerDelay -> ").append(std::to_string(TriggerDelay_ms)).append(" ms").c_str())) + { + if (ApplayItem == 1) + { + TriggerDelay_ms++; + } + else + if (TriggerDelay_ms - 1 > 0) + TriggerDelay_ms -= 1; + } // << + + MenuTitle(MenuTitleIndexOffset, index, "-----File-----"); + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, "Save Setting")) + { + // first, create a file instance + mINI::INIFile file("Configuration.ini"); + mINI::INIStructure ini; + file.read(ini); + ini["Function"]["brecoilControl"] = std::to_string(brecoilControl); + ini["Function"]["AimBot"] = std::to_string(AimBot); + ini["Function"]["DrawESP"] = std::to_string(DrawESP); + ini["Function"]["bTriggerbot"] = std::to_string(bTriggerbot); + ini["Function"]["bBunnyHop"] = std::to_string(bBunnyHop); + + ini["AimBot"]["AimBotHot"] = std::to_string(AimBotHot); + ini["AimBot"]["AimTeam"] = std::to_string(AimTeam); + ini["AimBot"]["AimBone"] = std::to_string(AimBones); + ini["AimBot"]["FOV"] = std::to_string(FOV); + ini["AimBot"]["Smoothing"] = std::to_string((int)AimSmoothing); + ini["AimBot"]["OnlyAttackVisible"] = std::to_string(OnlyAttackVisible); + + ini["TriggerBot"]["TriggerDelay"] = std::to_string(TriggerDelay_ms); + ini["Menu"]["MenuDrawBorder"] = std::to_string(MenuDrawBorder); + + ini["ESP"]["show_extra"] = std::to_string(show_extra); + ini["ESP"]["ShowViewAngle"] = std::to_string(ShowViewAngle); + ini["ESP"]["TextSize"] = std::to_string(TextSize); + ini["ESP"]["ShowBoneDistance"] = std::to_string(ShowBoneDistance); + ini["ESP"]["flag_render_distance"] = std::to_string(flag_render_distance); + ini["ESP"]["render_distance"] = std::to_string(render_distance); + ini["ESP"]["BoomSize"] = std::to_string(BoomSize); + ini["ESP"]["DrawESPLine"] = std::to_string(DrawESPLine); + std::cout << "\n Save :" << file.write(ini); + } + + if (MenuItem(MenuTitleIndexOffset, MenuSelectIndex, index, "Load Setting")) + { + mINI::INIFile file("Configuration.ini"); + mINI::INIStructure ini; + std::cout << "\n Load :" << file.read(ini); + brecoilControl = atoi(ini["Function"]["brecoilControl"].c_str()); + AimBot = atoi(ini["Function"]["AimBot"].c_str()); + DrawESP = atoi(ini["Function"]["DrawESP"].c_str()); + bTriggerbot = atoi(ini["Function"]["bTriggerbot"].c_str()); + bBunnyHop = atoi(ini["Function"]["bBunnyHop"].c_str()); + + AimTeam = atoi(ini["AimBot"]["AimTeam"].c_str()); + AimBotHot = atoi(ini["AimBot"]["AimBotHot"].c_str()); + FOV = atof(ini["AimBot"]["FOV"].c_str()); + AimSmoothing = atoi(ini["AimBot"]["Smoothing"].c_str()); + AimBones = atoi(ini["AimBot"]["AimBone"].c_str()); + OnlyAttackVisible = atoi(ini["AimBot"]["OnlyAttackVisible"].c_str()); + + TriggerDelay_ms = atoi(ini["TriggerBot"]["TriggerDelay"].c_str()); + + MenuDrawBorder = atoi(ini["Menu"]["MenuDrawBorder"].c_str()); + + show_extra = atoi(ini["ESP"]["show_extra"].c_str()); + TextSize = atoi(ini["ESP"]["TextSize"].c_str()); + ShowViewAngle = atoi(ini["ESP"]["ShowViewAngle"].c_str()); + ShowBoneDistance = atoi(ini["ESP"]["ShowBoneDistance"].c_str()); + flag_render_distance = atoi(ini["ESP"]["flag_render_distance"].c_str()); + render_distance = atoi(ini["ESP"]["render_distance"].c_str()); + BoomSize = atoi(ini["ESP"]["BoomSize"].c_str()); + DrawESPLine = atoi(ini["ESP"]["DrawESPLine"].c_str()); + } + + if (MenuHight == 0) + MenuHight = MenuTitleIndexOffset + (index + 1) * TextSize; + + SetBkColor(g::hdcBuffer, RGB(255, 255, 255)); +} + +void DrawAimBotFOV(float Fov) +{ + float Radius = tan(FOV / 180.f * std::numbers::pi_v / 2.f) / tan(Fov / 180.f * std::numbers::pi_v / 2.f) * g::gameBounds.right; + render::DrawCircle(g::hdcBuffer, g::gameBounds.right / 2, g::gameBounds.bottom / 2, Radius, RGB(134, 133, 218)); + + float Length; + float radian; + Vector3 LineEndPoint[2]; + Vector3 Pos;// = Gui.Window.Size / 2; + Pos.x = g::gameBounds.right / 2; + Pos.y = g::gameBounds.bottom / 2; + + radian = (Fov / 2) * std::numbers::pi_v / 180; + + LineEndPoint[0].y = Pos.y - 60/*FovLineSize */; + LineEndPoint[1].y = LineEndPoint[0].y; + + Length = 60/*FovLineSize */ * tan(radian); + + LineEndPoint[0].x = Pos.x - Length; + LineEndPoint[1].x = Pos.x + Length; + + //Gui.Line(Pos, LineEndPoint[0], Color, 1.5); + //Gui.Line(Pos, LineEndPoint[1], Color, 1.5); + + render::RenderLine(g::hdcBuffer, Pos.x, Pos.y, LineEndPoint[0].x, LineEndPoint[0].y, RGB(134, 133, 218)); + render::RenderLine(g::hdcBuffer, Pos.x, Pos.y, LineEndPoint[1].x, LineEndPoint[1].y, RGB(134, 133, 218)); +} + +void loop() +{ + static int indirectUpdate = 0; + uintptr_t localPlayer; + if (GetKeyState(VK_F1) & 0x8000) + { + Sleep(100); + isDrawMenu = !isDrawMenu; + } + if (isDrawMenu) + DrawMenu(); + else + render::RenderText(g::hdcBuffer, 0, MenuOffset, "F1 - Show Menu", RGB(200, 200, 200), TextSize); + + //render::RenderText(g::hdcBuffer, 0, MenuOffset + 500, std::string("TEST_CAMEPOS : ").append(std::to_string(TEST_CAMEPOS.x)).append(",").append(std::to_string(TEST_CAMEPOS.y)).append(",").append(std::to_string(TEST_CAMEPOS.z)).c_str(), RGB(200, 0, 0), TextSize); + //render::RenderText(g::hdcBuffer, 0, MenuOffset + 500 + TextSize, std::string("TEST_CAMEANGLE : ").append(std::to_string(TEST_CAMEANGLE.x)).append(",").append(std::to_string(TEST_CAMEANGLE.y)).append(",").append(std::to_string(TEST_CAMEANGLE.z)).c_str(), RGB(200, 0, 0), TextSize); + //render::RenderText(g::hdcBuffer, 0, MenuOffset + 500 + TextSize * 2, std::string("TEST_VIEWANGLE : ").append(std::to_string(TEST_VIEWANGLE.x)).append(",").append(std::to_string(TEST_VIEWANGLE.y)).append(",").append(std::to_string(TEST_VIEWANGLE.z)).c_str(), RGB(200, 0, 0), TextSize); + //localPlayerController = process->read(cs2_module_client.base + client_dll::dwLocalPlayerController); + + static float PlayerFov; + if (indirectUpdate == 0) + { + indirectUpdate++; + entity_list = process->read(cs2_module_client.base + client_dll::dwEntityList); + + //localPlayer = process->read(localPlayerController + CCSPlayerController::m_hPlayerPawn); + localPlayer = process->read(cs2_module_client.base + client_dll::dwLocalPlayerPawn); + if (!localPlayer) + return; + + localTeam = process->read(localPlayer + C_BaseEntity::m_iTeamNum); + + if (ShowAimBotFov) + { + const DWORD64 CameraServices = process->read(localPlayer + C_BasePlayerPawn::m_pCameraServices); + if (CameraServices) + PlayerFov = process->read(CameraServices + CCSPlayerBase_CameraServices::m_iFOVStart); + } + } + else if (indirectUpdate > 10) + { + indirectUpdate = 0; + } + else + { + indirectUpdate++; + } + + if (ShowAimBotFov) + DrawAimBotFOV(PlayerFov); + + if (!DrawESP) + return; + const view_matrix_t view_matrix = process->read(cs2_module_client.base + client_dll::dwViewMatrix); + + int playerIndex = 0; + uintptr_t list_entry; + + static uintptr_t localCGameSceneNode; + static bool c4IsPlanted; + if (indirectUpdate == 0) + { + localCGameSceneNode = process->read(localPlayer + C_BaseEntity::m_pGameSceneNode); + c4IsPlanted = process->read(cs2_module_client.base + client_dll::dwPlantedC4 - 0x8); + } + + const Vector3 localOrigin = process->read(localCGameSceneNode + CGameSceneNode::m_vecOrigin); + + render::RenderText(g::hdcBuffer, 50, 50, "HalfPeople CSGO 2 GameHack Test", RGB(200, 200, 200), 30); + if (c4IsPlanted) + { + const uintptr_t planted_c4 = process->read(process->read(cs2_module_client.base + client_dll::dwPlantedC4)); + + const uintptr_t c4Node = process->read(planted_c4 + C_BaseEntity::m_pGameSceneNode); + + const Vector3 c4Origin = process->read(c4Node + CGameSceneNode::m_vecAbsOrigin); + + const Vector3 c4ScreenPos = c4Origin.world_to_screen(view_matrix); + + if (c4ScreenPos.z >= 0.01f) { + float c4Distance = localOrigin.calculate_distance(c4Origin); + float c4RoundedDistance = std::round(c4Distance / 500.f); + + float height = BoomSize - c4RoundedDistance; + float width = height * 1.4f; + + if (DrawESPLine) + render::RenderLine(g::hdcBuffer, 0, 0, c4ScreenPos.x, c4ScreenPos.y, RGB(175, 75, 75)); + + render::DrawFilledBox( + g::hdcBuffer, + c4ScreenPos.x - (width / 2), + c4ScreenPos.y - (height / 2), + width, + height, + RGB(175, 75, 75) + ); + + render::RenderText( + g::hdcBuffer, + c4ScreenPos.x + (width / 2 + 5), + c4ScreenPos.y, + "C4", + RGB(75, 75, 175), + TextSize + ); + } + } + while (true) + { + playerIndex++; + list_entry = process->read(entity_list + (8 * (playerIndex & 0x7FFF) >> 9) + 16); + if (!list_entry) + break; + + const uintptr_t player = process->read(list_entry + 120 * (playerIndex & 0x1FF)); + if (!player) + continue; + + const int playerTeam = process->read(player + C_BaseEntity::m_iTeamNum); + + const std::uint32_t playerPawn = process->read(player + CCSPlayerController::m_hPlayerPawn); + + const uintptr_t list_entry2 = process->read(entity_list + 0x8 * ((playerPawn & 0x7FFF) >> 9) + 16); + if (!list_entry2) + continue; + + const uintptr_t pCSPlayerPawn = process->read(list_entry2 + 120 * (playerPawn & 0x1FF)); + + const int playerArmor = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_ArmorValue); + const int playerHealth = process->read(pCSPlayerPawn + C_BaseEntity::m_iHealth); + if (playerHealth <= 0 || playerHealth > 100) + continue; + + if (pCSPlayerPawn == localPlayer) + continue; + + std::string playerName = "Invalid Name"; + const DWORD64 playerNameAddress = process->read(player + CCSPlayerController::m_sSanitizedPlayerName); + if (playerNameAddress) { + char buf[256]; + process->read_raw(playerNameAddress, buf, sizeof(buf)); + playerName = std::string(buf); + } + + const uintptr_t CGameSceneNode = process->read(pCSPlayerPawn + C_BaseEntity::m_pGameSceneNode); + const Vector3 origin = process->read(CGameSceneNode + CGameSceneNode::m_vecOrigin); + const Vector3 head = { origin.x, origin.y, origin.z + 75.f }; + + if (render_distance != -1 && (localOrigin - origin).length2d() > render_distance) + continue; + + const Vector3 screenPos = origin.world_to_screen(view_matrix); + if (screenPos.z < 0) + continue; + const Vector3 screenHead = head.world_to_screen(view_matrix); + + if (screenPos.z >= 0.01f) { + const float height = screenPos.y - screenHead.y; + const float width = height / 2.4f; + const float head_height = (screenPos.y - screenHead.y) / 8; + const float head_width = (height / 2.4f) / 4; + + float distance = localOrigin.calculate_distance(origin); + int roundedDistance = std::round(distance / 10.f); + + render::DrawBorderBox( + g::hdcBuffer, + screenHead.x - width / 2, + screenHead.y, + width, + height, + (localTeam == playerTeam ? RGB(75, 175, 75) : RGB(175, 75, 75)) + ); + if (DrawESPLine) + render::RenderLine(g::hdcBuffer, screenHead.x, screenHead.y + height, g::gameBounds.right / 2, g::gameBounds.bottom * 0.8, (localTeam == playerTeam ? RGB(75, 175, 75) : RGB(175, 75, 75))); + + render::DrawBorderBox( + g::hdcBuffer, + screenHead.x - (width / 2 + 10), + screenHead.y + (height * (100 - playerArmor) / 100), + 2, + height - (height * (100 - playerArmor) / 100), + RGB(0, 185, 255) + ); + + render::DrawBorderBox( + g::hdcBuffer, + screenHead.x - (width / 2 + 5), + screenHead.y + (height * (100 - playerHealth) / 100), + 2, + height - (height * (100 - playerHealth) / 100), + RGB( + (255 - playerHealth), + (55 + playerHealth * 2), + 75 + ) + ); + + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y, + playerName.c_str(), + RGB(75, 75, 175), + TextSize + ); + + /** + * I know is not the best way but a simple way to not saturate the screen with a ton of information + */ + if (roundedDistance > flag_render_distance) + continue; + + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + TextSize, + (std::to_string(playerHealth) + "hp").c_str(), + RGB( + (255 - playerHealth), + (55 + playerHealth * 2), + 75 + ), + TextSize + ); + + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + TextSize * 2, + (std::to_string(playerArmor) + "armor").c_str(), + RGB( + (255 - playerArmor), + (55 + playerArmor * 2), + 75 + ), + TextSize + ); + + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + TextSize * 8, + (std::to_string((int)distance) + "cm").c_str(), + RGB( + (255 - playerArmor), + (55 + playerArmor * 2), + 75 + ), + TextSize + ); + + if (show_extra) + { + /* + * Reading values for extra flags is now seperated from the other reads + * This removes unnecessary memory reads, improving performance when not showing extra flags + */ + const bool isDefusing = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_bIsDefusing); + const uintptr_t playerMoneyServices = process->read(player + CCSPlayerController::m_pInGameMoneyServices); + const int32_t money = process->read(playerMoneyServices + CCSPlayerController_InGameMoneyServices::m_iAccount); + const float flashAlpha = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_flFlashOverlayAlpha); + + const auto clippingWeapon = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_pClippingWeapon); + const auto weaponData = process->read(clippingWeapon + 0x360); + const auto weaponNameAddress = process->read(weaponData + CCSWeaponBaseVData::m_szName); + std::string weaponName = "Invalid Weapon Name"; + + if (!weaponNameAddress) { + weaponName = "Invalid Weapon Name"; + } + else { + char buf[32]; + process->read_raw(weaponNameAddress, buf, sizeof(buf)); + weaponName = std::string(buf); + if (weaponName.compare(0, 7, "weapon_") == 0) + weaponName = weaponName.substr(7, weaponName.length()); // Remove weapon_ prefix + } + + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + TextSize * 3, + weaponName.c_str(), + RGB(75, 75, 175), + TextSize + ); + + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + TextSize * 4, + (std::to_string(roundedDistance) + "m away").c_str(), + RGB(75, 75, 175), + TextSize + ); + + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + TextSize * 5, + ("$" + std::to_string(money)).c_str(), + RGB(0, 125, 0), + TextSize + ); + + if (flashAlpha > 100) + { + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + TextSize * 6, + "Player is flashed", + RGB(75, 75, 175), + TextSize + ); + } + + if (isDefusing) + { + const std::string defuText = "Player is defusing"; + render::RenderText( + g::hdcBuffer, + screenHead.x + (width / 2 + 5), + screenHead.y + 60, + defuText.c_str(), + RGB(75, 75, 175), + TextSize + ); + } + } + + if (distance > ShowBoneDistance) + { + continue; + } + + // const uintptr_t CGameSceneNode = process->read( pCSPlayerPawn + C_BaseEntity::m_pGameSceneNode); + const uintptr_t boneArray = process->read(CGameSceneNode + CSkeletonInstance::m_modelState + CGameSceneNode::m_vecOrigin); + + Vector3 head_ = process->read(boneArray + 6 * 32); + Vector3 cou = process->read(boneArray + 5 * 32); + Vector3 shoulderR = process->read(boneArray + 8 * 32); + Vector3 shoulderL = process->read(boneArray + 13 * 32); + Vector3 brasR = process->read(boneArray + 9 * 32); + Vector3 brasL = process->read(boneArray + 14 * 32); + Vector3 handR = process->read(boneArray + 11 * 32); + Vector3 handL = process->read(boneArray + 16 * 32); + Vector3 cock = process->read(boneArray + 0 * 32); + Vector3 kneesR = process->read(boneArray + 23 * 32); + Vector3 kneesL = process->read(boneArray + 26 * 32); + Vector3 feetR = process->read(boneArray + 24 * 32); + Vector3 feetL = process->read(boneArray + 27 * 32); + + Vector3 Ahead; + Vector3 Acou; + Vector3 AshoulderR; + Vector3 AshoulderL; + Vector3 AbrasR; + Vector3 AbrasL; + Vector3 AhandR; + Vector3 AhandL; + Vector3 Acock; + Vector3 AkneesR; + Vector3 AkneesL; + Vector3 AfeetR; + Vector3 AfeetL; + + Ahead = head_.world_to_screen(view_matrix); + if (Ahead.z < 0) + continue; + + if (ShowViewAngle) + { + Vector3 EyeAngle = process->read(player + C_CSPlayerPawnBase::m_angEyeAngles); + //Vec2 StartPoint, EndPoint; + Vector3 Temp; + + //StartPoint = head_; + + float LineLength = cos(EyeAngle.x * std::numbers::pi_v / 180) * 25/*Length*/; + + Temp.x = head_.x + cos(EyeAngle.y * std::numbers::pi_v / 180) * LineLength; + Temp.y = head_.y + sin(EyeAngle.y * std::numbers::pi_v / 180) * LineLength; + Temp.z = head_.z - sin(EyeAngle.x * std::numbers::pi_v / 180) * 25/*Length*/; + + Temp = Temp.world_to_screen(view_matrix); + if (Temp.z > 0) + render::RenderLine(g::hdcBuffer, Ahead.x, Ahead.y, Temp.x, Temp.y, RGB(0, 255, 0)); + } + + Acou = cou.world_to_screen(view_matrix); + if (Acou.z < 0) + continue; + AshoulderR = shoulderR.world_to_screen(view_matrix); + if (AshoulderR.z < 0) + continue; + AshoulderL = shoulderL.world_to_screen(view_matrix); + if (AshoulderL.z < 0) + continue; + AbrasR = brasR.world_to_screen(view_matrix); + if (AbrasR.z < 0) + continue; + AbrasL = brasL.world_to_screen(view_matrix); + if (AbrasL.z < 0) + continue; + AhandL = handL.world_to_screen(view_matrix); + if (AhandL.z < 0) + continue; + AhandR = handR.world_to_screen(view_matrix); + if (AhandR.z < 0) + continue; + Acock = cock.world_to_screen(view_matrix); + if (Acock.z < 0) + continue; + AkneesR = kneesR.world_to_screen(view_matrix); + if (AkneesR.z < 0) + continue; + AkneesL = kneesL.world_to_screen(view_matrix); + if (AkneesL.z < 0) + continue; + AfeetR = feetR.world_to_screen(view_matrix); + if (AfeetR.z < 0) + continue; + AfeetL = feetL.world_to_screen(view_matrix); + if (AfeetL.z < 0) + continue; + + render::RenderLine(g::hdcBuffer, Ahead.x, Ahead.y, Acou.x, Acou.y, BonesColor); + render::RenderLine(g::hdcBuffer, Acou.x, Acou.y, AshoulderR.x, AshoulderR.y, BonesColor); + render::RenderLine(g::hdcBuffer, Acou.x, Acou.y, AshoulderL.x, AshoulderL.y, BonesColor); + render::RenderLine(g::hdcBuffer, AbrasL.x, AbrasL.y, AshoulderL.x, AshoulderL.y, BonesColor); + render::RenderLine(g::hdcBuffer, AbrasR.x, AbrasR.y, AshoulderR.x, AshoulderR.y, BonesColor); + render::RenderLine(g::hdcBuffer, AbrasR.x, AbrasR.y, AhandR.x, AhandR.y, BonesColor); + render::RenderLine(g::hdcBuffer, AbrasL.x, AbrasL.y, AhandL.x, AhandL.y, BonesColor); + render::RenderLine(g::hdcBuffer, Acou.x, Acou.y, Acock.x, Acock.y, BonesColor); + render::RenderLine(g::hdcBuffer, AkneesR.x, AkneesR.y, Acock.x, Acock.y, BonesColor); + render::RenderLine(g::hdcBuffer, AkneesL.x, AkneesL.y, Acock.x, Acock.y, BonesColor); + render::RenderLine(g::hdcBuffer, AkneesL.x, AkneesL.y, AfeetL.x, AfeetL.y, BonesColor); + render::RenderLine(g::hdcBuffer, AkneesR.x, AkneesR.y, AfeetR.x, AfeetR.y, BonesColor); + + // Vector3 previous, current; + // + // + // for (std::vector currentGroup : boneGroups::allGroups) { + // previous = { 0,0,0 }; + // + // for (int currentBone : currentGroup) { + // current = process->read(boneArray + currentBone * 32); + // + // if (previous.IsZero()) { + // previous = current; + // continue; + // } + // + // Vector3 currentScreenPos = current.world_to_screen(view_matrix); + // Vector3 previousScreenPos = previous.world_to_screen(view_matrix); + // + // + // render::RenderLine(g::hdcBuffer, previousScreenPos.x, previousScreenPos.y, currentScreenPos.x, currentScreenPos.y, BonesColor); + // + // previous = current; + // } + // } + } + } +} + +void FunctionT() +{ + if (bTriggerbot) + Triggerbot(); + + static int indirectUpdate = 0; + static uintptr_t localPlayer; + if (!(brecoilControl || AimBot || entity_list || localPlayer)) + return; + + int playerIndex = -1; + uintptr_t list_entry; + static uintptr_t baseViewAnglesAddy; + if (indirectUpdate == 0) + { + indirectUpdate++; + localPlayer = process->read(cs2_module_client.base + client_dll::dwLocalPlayerPawn); + baseViewAnglesAddy = cs2_module_client.base + client_dll::dwViewAngles; + } + else if (indirectUpdate > 20) + indirectUpdate = 0; + else + indirectUpdate++; + + if (bBunnyHop) + Bunnyhop(localPlayer); + + Vector3 cameraPos = process->read(localPlayer + C_CSPlayerPawnBase::m_vecLastClipCameraPos); + + Vector3 baseViewAngles = process->read(cs2_module_client.base + client_dll::dwViewAngles); + + C_UTL_VECTOR aimPunchCache = process->read(localPlayer + C_CSPlayerPawn::m_aimPunchCache); + + int shotsFired = process->read(localPlayer + C_CSPlayerPawnBase::m_iShotsFired); + + float fov = FOV; + + Vector3 AimTarget; + while (true) + { + playerIndex++; + + list_entry = process->read(entity_list + (8 * (playerIndex & 0x7FFF) >> 9) + 16); + if (!list_entry) + break; + + const uintptr_t player = process->read(list_entry + 120 * (playerIndex & 0x1FF)); + if (!player) + continue; + + const int playerTeam = process->read(player + C_BaseEntity::m_iTeamNum); + if ((!AimTeam) && playerTeam == localTeam) + { + continue; + } + + const std::uint32_t playerPawn = process->read(player + CCSPlayerController::m_hPlayerPawn); + + const uintptr_t list_entry2 = process->read(entity_list + 0x8 * ((playerPawn & 0x7FFF) >> 9) + 16); + if (!list_entry2) + continue; + + const uintptr_t pCSPlayerPawn = process->read(list_entry2 + 120 * (playerPawn & 0x1FF)); + if ((!pCSPlayerPawn) || pCSPlayerPawn == localPlayer) + continue; + + if (process->read(player + C_BaseEntity::m_lifeState)) + continue; + + const uintptr_t CGameSceneNode = process->read(pCSPlayerPawn + C_BaseEntity::m_pGameSceneNode); + if (process->read(CGameSceneNode + CGameSceneNode::m_bDormant)) + return; + + const int playerHealth = process->read(pCSPlayerPawn + C_BaseEntity::m_iHealth); + if (playerHealth <= 0 || playerHealth > 100) + continue; + + if (OnlyAttackVisible) + { + const int EntitySpottedState = process->read(pCSPlayerPawn + C_CSPlayerPawnBase::m_entitySpottedState + EntitySpottedState_t::m_bSpottedByMask); + if (!(EntitySpottedState & (1 << localPlayer))) + continue; + } + + const uintptr_t boneArray = process->read(CGameSceneNode + CSkeletonInstance::m_modelState + CGameSceneNode::m_vecOrigin); + + if (AimBot) + { + Vector3 AimTargteBuffer = aimBot(aimPunchCache, shotsFired, cameraPos, fov, AimBotHot, baseViewAngles, boneArray); + + if (!AimTargteBuffer.IsZero()) + { + AimTarget = AimTargteBuffer; + } + } + } + if (brecoilControl && AimTarget.IsZero()) + { + recoilControl(baseViewAngles, aimPunchCache, shotsFired, baseViewAnglesAddy); + } + else if (!AimTarget.IsZero()) + process->write(baseViewAnglesAddy, AimTarget); +} \ No newline at end of file diff --git a/HPCS2/api/ini.h b/HPCS2/api/ini.h new file mode 100644 index 0000000..b5f327b --- /dev/null +++ b/HPCS2/api/ini.h @@ -0,0 +1,789 @@ +/* + * The MIT License (MIT) + * Copyright (c) 2018 Danijel Durakovic + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in + * the Software without restriction, including without limitation the rights to + * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is furnished to do + * so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS + * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR + * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +/////////////////////////////////////////////////////////////////////////////// +// +// /mINI/ v0.9.14 +// An INI file reader and writer for the modern age. +// +/////////////////////////////////////////////////////////////////////////////// +// +// A tiny utility library for manipulating INI files with a straightforward +// API and a minimal footprint. It conforms to the (somewhat) standard INI +// format - sections and keys are case insensitive and all leading and +// trailing whitespace is ignored. Comments are lines that begin with a +// semicolon. Trailing comments are allowed on section lines. +// +// Files are read on demand, upon which data is kept in memory and the file +// is closed. This utility supports lazy writing, which only writes changes +// and updates to a file and preserves custom formatting and comments. A lazy +// write invoked by a write() call will read the output file, find what +// changes have been made and update the file accordingly. If you only need to +// generate files, use generate() instead. Section and key order is preserved +// on read, write and insert. +// +/////////////////////////////////////////////////////////////////////////////// +// +// /* BASIC USAGE EXAMPLE: */ +// +// /* read from file */ +// mINI::INIFile file("myfile.ini"); +// mINI::INIStructure ini; +// file.read(ini); +// +// /* read value; gets a reference to actual value in the structure. +// if key or section don't exist, a new empty value will be created */ +// std::string& value = ini["section"]["key"]; +// +// /* read value safely; gets a copy of value in the structure. +// does not alter the structure */ +// std::string value = ini.get("section").get("key"); +// +// /* set or update values */ +// ini["section"]["key"] = "value"; +// +// /* set multiple values */ +// ini["section2"].set({ +// {"key1", "value1"}, +// {"key2", "value2"} +// }); +// +// /* write updates back to file, preserving comments and formatting */ +// file.write(ini); +// +// /* or generate a file (overwrites the original) */ +// file.generate(ini); +// +/////////////////////////////////////////////////////////////////////////////// +// +// Long live the INI file!!! +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef MINI_INI_H_ +#define MINI_INI_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace mINI +{ + namespace INIStringUtil + { + const char* const whitespaceDelimiters = " \t\n\r\f\v"; + inline void trim(std::string& str) + { + str.erase(str.find_last_not_of(whitespaceDelimiters) + 1); + str.erase(0, str.find_first_not_of(whitespaceDelimiters)); + } +#ifndef MINI_CASE_SENSITIVE + inline void toLower(std::string& str) + { + std::transform(str.begin(), str.end(), str.begin(), [](const char c) { + return static_cast(std::tolower(c)); + }); + } +#endif + inline void replace(std::string& str, std::string const& a, std::string const& b) + { + if (!a.empty()) + { + std::size_t pos = 0; + while ((pos = str.find(a, pos)) != std::string::npos) + { + str.replace(pos, a.size(), b); + pos += b.size(); + } + } + } +#ifdef _WIN32 + const char* const endl = "\r\n"; +#else + const char* const endl = "\n"; +#endif + } + + template + class INIMap + { + private: + using T_DataIndexMap = std::unordered_map; + using T_DataItem = std::pair; + using T_DataContainer = std::vector; + using T_MultiArgs = typename std::vector>; + + T_DataIndexMap dataIndexMap; + T_DataContainer data; + + inline std::size_t setEmpty(std::string& key) + { + std::size_t index = data.size(); + dataIndexMap[key] = index; + data.emplace_back(key, T()); + return index; + } + + public: + using const_iterator = typename T_DataContainer::const_iterator; + + INIMap() { } + + INIMap(INIMap const& other) + { + std::size_t data_size = other.data.size(); + for (std::size_t i = 0; i < data_size; ++i) + { + auto const& key = other.data[i].first; + auto const& obj = other.data[i].second; + data.emplace_back(key, obj); + } + dataIndexMap = T_DataIndexMap(other.dataIndexMap); + } + + T& operator[](std::string key) + { + INIStringUtil::trim(key); +#ifndef MINI_CASE_SENSITIVE + INIStringUtil::toLower(key); +#endif + auto it = dataIndexMap.find(key); + bool hasIt = (it != dataIndexMap.end()); + std::size_t index = (hasIt) ? it->second : setEmpty(key); + return data[index].second; + } + T get(std::string key) const + { + INIStringUtil::trim(key); +#ifndef MINI_CASE_SENSITIVE + INIStringUtil::toLower(key); +#endif + auto it = dataIndexMap.find(key); + if (it == dataIndexMap.end()) + { + return T(); + } + return T(data[it->second].second); + } + bool has(std::string key) const + { + INIStringUtil::trim(key); +#ifndef MINI_CASE_SENSITIVE + INIStringUtil::toLower(key); +#endif + return (dataIndexMap.count(key) == 1); + } + void set(std::string key, T obj) + { + INIStringUtil::trim(key); +#ifndef MINI_CASE_SENSITIVE + INIStringUtil::toLower(key); +#endif + auto it = dataIndexMap.find(key); + if (it != dataIndexMap.end()) + { + data[it->second].second = obj; + } + else + { + dataIndexMap[key] = data.size(); + data.emplace_back(key, obj); + } + } + void set(T_MultiArgs const& multiArgs) + { + for (auto const& it : multiArgs) + { + auto const& key = it.first; + auto const& obj = it.second; + set(key, obj); + } + } + bool remove(std::string key) + { + INIStringUtil::trim(key); +#ifndef MINI_CASE_SENSITIVE + INIStringUtil::toLower(key); +#endif + auto it = dataIndexMap.find(key); + if (it != dataIndexMap.end()) + { + std::size_t index = it->second; + data.erase(data.begin() + index); + dataIndexMap.erase(it); + for (auto& it2 : dataIndexMap) + { + auto& vi = it2.second; + if (vi > index) + { + vi--; + } + } + return true; + } + return false; + } + void clear() + { + data.clear(); + dataIndexMap.clear(); + } + std::size_t size() const + { + return data.size(); + } + const_iterator begin() const { return data.begin(); } + const_iterator end() const { return data.end(); } + }; + + using INIStructure = INIMap>; + + namespace INIParser + { + using T_ParseValues = std::pair; + + enum class PDataType : char + { + PDATA_NONE, + PDATA_COMMENT, + PDATA_SECTION, + PDATA_KEYVALUE, + PDATA_UNKNOWN + }; + + inline PDataType parseLine(std::string line, T_ParseValues& parseData) + { + parseData.first.clear(); + parseData.second.clear(); + INIStringUtil::trim(line); + if (line.empty()) + { + return PDataType::PDATA_NONE; + } + char firstCharacter = line[0]; + if (firstCharacter == ';') + { + return PDataType::PDATA_COMMENT; + } + if (firstCharacter == '[') + { + auto commentAt = line.find_first_of(';'); + if (commentAt != std::string::npos) + { + line = line.substr(0, commentAt); + } + auto closingBracketAt = line.find_last_of(']'); + if (closingBracketAt != std::string::npos) + { + auto section = line.substr(1, closingBracketAt - 1); + INIStringUtil::trim(section); + parseData.first = section; + return PDataType::PDATA_SECTION; + } + } + auto lineNorm = line; + INIStringUtil::replace(lineNorm, "\\=", " "); + auto equalsAt = lineNorm.find_first_of('='); + if (equalsAt != std::string::npos) + { + auto key = line.substr(0, equalsAt); + INIStringUtil::trim(key); + INIStringUtil::replace(key, "\\=", "="); + auto value = line.substr(equalsAt + 1); + INIStringUtil::trim(value); + parseData.first = key; + parseData.second = value; + return PDataType::PDATA_KEYVALUE; + } + return PDataType::PDATA_UNKNOWN; + } + } + + class INIReader + { + public: + using T_LineData = std::vector; + using T_LineDataPtr = std::shared_ptr; + + bool isBOM = false; + + private: + std::ifstream fileReadStream; + T_LineDataPtr lineData; + + T_LineData readFile() + { + fileReadStream.seekg(0, std::ios::end); + const std::size_t fileSize = static_cast(fileReadStream.tellg()); + fileReadStream.seekg(0, std::ios::beg); + if (fileSize >= 3) { + const char header[3] = { + static_cast(fileReadStream.get()), + static_cast(fileReadStream.get()), + static_cast(fileReadStream.get()) + }; + isBOM = ( + header[0] == static_cast(0xEF) && + header[1] == static_cast(0xBB) && + header[2] == static_cast(0xBF) + ); + } + else { + isBOM = false; + } + std::string fileContents; + fileContents.resize(fileSize); + fileReadStream.seekg(isBOM ? 3 : 0, std::ios::beg); + fileReadStream.read(&fileContents[0], fileSize); + fileReadStream.close(); + T_LineData output; + if (fileSize == 0) + { + return output; + } + std::string buffer; + buffer.reserve(50); + for (std::size_t i = 0; i < fileSize; ++i) + { + char& c = fileContents[i]; + if (c == '\n') + { + output.emplace_back(buffer); + buffer.clear(); + continue; + } + if (c != '\0' && c != '\r') + { + buffer += c; + } + } + output.emplace_back(buffer); + return output; + } + + public: + INIReader(std::string const& filename, bool keepLineData = false) + { + fileReadStream.open(filename, std::ios::in | std::ios::binary); + if (keepLineData) + { + lineData = std::make_shared(); + } + } + ~INIReader() { } + + bool operator>>(INIStructure& data) + { + if (!fileReadStream.is_open()) + { + return false; + } + T_LineData fileLines = readFile(); + std::string section; + bool inSection = false; + INIParser::T_ParseValues parseData; + for (auto const& line : fileLines) + { + auto parseResult = INIParser::parseLine(line, parseData); + if (parseResult == INIParser::PDataType::PDATA_SECTION) + { + inSection = true; + data[section = parseData.first]; + } + else if (inSection && parseResult == INIParser::PDataType::PDATA_KEYVALUE) + { + auto const& key = parseData.first; + auto const& value = parseData.second; + data[section][key] = value; + } + if (lineData && parseResult != INIParser::PDataType::PDATA_UNKNOWN) + { + if (parseResult == INIParser::PDataType::PDATA_KEYVALUE && !inSection) + { + continue; + } + lineData->emplace_back(line); + } + } + return true; + } + T_LineDataPtr getLines() + { + return lineData; + } + }; + + class INIGenerator + { + private: + std::ofstream fileWriteStream; + + public: + bool prettyPrint = false; + + INIGenerator(std::string const& filename) + { + fileWriteStream.open(filename, std::ios::out | std::ios::binary); + } + ~INIGenerator() { } + + bool operator<<(INIStructure const& data) + { + if (!fileWriteStream.is_open()) + { + return false; + } + if (!data.size()) + { + return true; + } + auto it = data.begin(); + for (;;) + { + auto const& section = it->first; + auto const& collection = it->second; + fileWriteStream + << "[" + << section + << "]"; + if (collection.size()) + { + fileWriteStream << INIStringUtil::endl; + auto it2 = collection.begin(); + for (;;) + { + auto key = it2->first; + INIStringUtil::replace(key, "=", "\\="); + auto value = it2->second; + INIStringUtil::trim(value); + fileWriteStream + << key + << ((prettyPrint) ? " = " : "=") + << value; + if (++it2 == collection.end()) + { + break; + } + fileWriteStream << INIStringUtil::endl; + } + } + if (++it == data.end()) + { + break; + } + fileWriteStream << INIStringUtil::endl; + if (prettyPrint) + { + fileWriteStream << INIStringUtil::endl; + } + } + return true; + } + }; + + class INIWriter + { + private: + using T_LineData = std::vector; + using T_LineDataPtr = std::shared_ptr; + + std::string filename; + + T_LineData getLazyOutput(T_LineDataPtr const& lineData, INIStructure& data, INIStructure& original) + { + T_LineData output; + INIParser::T_ParseValues parseData; + std::string sectionCurrent; + bool parsingSection = false; + bool continueToNextSection = false; + bool discardNextEmpty = false; + bool writeNewKeys = false; + std::size_t lastKeyLine = 0; + for (auto line = lineData->begin(); line != lineData->end(); ++line) + { + if (!writeNewKeys) + { + auto parseResult = INIParser::parseLine(*line, parseData); + if (parseResult == INIParser::PDataType::PDATA_SECTION) + { + if (parsingSection) + { + writeNewKeys = true; + parsingSection = false; + --line; + continue; + } + sectionCurrent = parseData.first; + if (data.has(sectionCurrent)) + { + parsingSection = true; + continueToNextSection = false; + discardNextEmpty = false; + output.emplace_back(*line); + lastKeyLine = output.size(); + } + else + { + continueToNextSection = true; + discardNextEmpty = true; + continue; + } + } + else if (parseResult == INIParser::PDataType::PDATA_KEYVALUE) + { + if (continueToNextSection) + { + continue; + } + if (data.has(sectionCurrent)) + { + auto& collection = data[sectionCurrent]; + auto const& key = parseData.first; + auto const& value = parseData.second; + if (collection.has(key)) + { + auto outputValue = collection[key]; + if (value == outputValue) + { + output.emplace_back(*line); + } + else + { + INIStringUtil::trim(outputValue); + auto lineNorm = *line; + INIStringUtil::replace(lineNorm, "\\=", " "); + auto equalsAt = lineNorm.find_first_of('='); + auto valueAt = lineNorm.find_first_not_of( + INIStringUtil::whitespaceDelimiters, + equalsAt + 1 + ); + std::string outputLine = line->substr(0, valueAt); + if (prettyPrint && equalsAt + 1 == valueAt) + { + outputLine += " "; + } + outputLine += outputValue; + output.emplace_back(outputLine); + } + lastKeyLine = output.size(); + } + } + } + else + { + if (discardNextEmpty && line->empty()) + { + discardNextEmpty = false; + } + else if (parseResult != INIParser::PDataType::PDATA_UNKNOWN) + { + output.emplace_back(*line); + } + } + } + if (writeNewKeys || std::next(line) == lineData->end()) + { + T_LineData linesToAdd; + if (data.has(sectionCurrent) && original.has(sectionCurrent)) + { + auto const& collection = data[sectionCurrent]; + auto const& collectionOriginal = original[sectionCurrent]; + for (auto const& it : collection) + { + auto key = it.first; + if (collectionOriginal.has(key)) + { + continue; + } + auto value = it.second; + INIStringUtil::replace(key, "=", "\\="); + INIStringUtil::trim(value); + linesToAdd.emplace_back( + key + ((prettyPrint) ? " = " : "=") + value + ); + } + } + if (!linesToAdd.empty()) + { + output.insert( + output.begin() + lastKeyLine, + linesToAdd.begin(), + linesToAdd.end() + ); + } + if (writeNewKeys) + { + writeNewKeys = false; + --line; + } + } + } + for (auto const& it : data) + { + auto const& section = it.first; + if (original.has(section)) + { + continue; + } + if (prettyPrint && output.size() > 0 && !output.back().empty()) + { + output.emplace_back(); + } + output.emplace_back("[" + section + "]"); + auto const& collection = it.second; + for (auto const& it2 : collection) + { + auto key = it2.first; + auto value = it2.second; + INIStringUtil::replace(key, "=", "\\="); + INIStringUtil::trim(value); + output.emplace_back( + key + ((prettyPrint) ? " = " : "=") + value + ); + } + } + return output; + } + + public: + bool prettyPrint = false; + + INIWriter(std::string const& filename) + : filename(filename) + { + } + ~INIWriter() { } + + bool operator<<(INIStructure& data) + { + struct stat buf; + bool fileExists = (stat(filename.c_str(), &buf) == 0); + if (!fileExists) + { + INIGenerator generator(filename); + generator.prettyPrint = prettyPrint; + return generator << data; + } + INIStructure originalData; + T_LineDataPtr lineData; + bool readSuccess = false; + bool fileIsBOM = false; + { + INIReader reader(filename, true); + if ((readSuccess = reader >> originalData)) + { + lineData = reader.getLines(); + fileIsBOM = reader.isBOM; + } + } + if (!readSuccess) + { + return false; + } + T_LineData output = getLazyOutput(lineData, data, originalData); + std::ofstream fileWriteStream(filename, std::ios::out | std::ios::binary); + if (fileWriteStream.is_open()) + { + if (fileIsBOM) { + const char utf8_BOM[3] = { + static_cast(0xEF), + static_cast(0xBB), + static_cast(0xBF) + }; + fileWriteStream.write(utf8_BOM, 3); + } + if (output.size()) + { + auto line = output.begin(); + for (;;) + { + fileWriteStream << *line; + if (++line == output.end()) + { + break; + } + fileWriteStream << INIStringUtil::endl; + } + } + return true; + } + return false; + } + }; + + class INIFile + { + private: + std::string filename; + + public: + INIFile(std::string const& filename) + : filename(filename) + { } + + ~INIFile() { } + + bool read(INIStructure& data) const + { + if (data.size()) + { + data.clear(); + } + if (filename.empty()) + { + return false; + } + INIReader reader(filename); + return reader >> data; + } + bool generate(INIStructure const& data, bool pretty = false) const + { + if (filename.empty()) + { + return false; + } + INIGenerator generator(filename); + generator.prettyPrint = pretty; + return generator << data; + } + bool write(INIStructure& data, bool pretty = false) const + { + if (filename.empty()) + { + return false; + } + INIWriter writer(filename); + writer.prettyPrint = pretty; + return writer << data; + } + }; +} + +#endif // MINI_INI_H_ diff --git a/HPCS2/handle_hijack.hpp b/HPCS2/handle_hijack.hpp new file mode 100644 index 0000000..620fd9a --- /dev/null +++ b/HPCS2/handle_hijack.hpp @@ -0,0 +1,287 @@ + +/* + Credits to: https://github.com/Apxaey/Handle-Hijacking-Anti-Cheat-Bypass for the source and public sharing! + + Its a little bit messy as i tried to make it asap. All comments below this are from the original creator! +*/ + +/* + This is a stand alone bypass made by Apxaey. Feel free to use this in your cheats but credit me for the bypass as i put alot of time into this. + If you have some brain cells you will be able to incorporate this into your cheats and remain undetected by user-mode anticheats. + Obviously standard cheat 'recommendations' still apply: + 1.) Use self-written or not signatured code + 2.) Dont write impossible values + 3.) If your going internal use a manual map injector + + If you follow the guidelines above and use this bypass you will be safe from usermode anticheats like VAC. + Obviously you can build and adapt upon my code to suit your needs. + If I was to make a cheat for myself i would put this bypass into something i call an 'external internal' cheat. + Whereby you make a cheat and inject into a legitimate program like discord and add a check to the this bypass to only hijack a handle from the process you inject into, giving the appearence that nothing is out of the ordinary + However you can implement this bypass into any form of cheat, its your decision. + If you need want some more info i recommend you watch my YT video on this bypass. + Anyways if you want to see more of my stuff feel free to join my discord server discord.gg/********. Here's my YT as well https://www.youtube.com/channel/UCPN6OOLxn1OaBP5jPThIiog. +*/ + +#include +#include +#include +#include + +// macros we use.Some can be found in wintrnl.h +#define SeDebugPriv 20 +#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) +#define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004) +#define NtCurrentProcess ( (HANDLE)(LONG_PTR) -1 ) +#define ProcessHandleType 0x7 +#define SystemHandleInformation 16 + +/* +STRUCTURES NEEDED FOR NTOPENPROCESS: +*/ +typedef struct _UNICODE_STRING { + USHORT Length; + USHORT MaximumLength; + PWCH Buffer; +} UNICODE_STRING, * PUNICODE_STRING; + +typedef struct _OBJECT_ATTRIBUTES { + ULONG Length; + HANDLE RootDirectory; + PUNICODE_STRING ObjectName; + ULONG Attributes; + PVOID SecurityDescriptor; + PVOID SecurityQualityOfService; +} OBJECT_ATTRIBUTES, * POBJECT_ATTRIBUTES; + +typedef struct _CLIENT_ID +{ + PVOID UniqueProcess; + PVOID UniqueThread; +} CLIENT_ID, * PCLIENT_ID; + +/* +STRUCTURES NEEDED FOR HANDLE INFORMATION: +*/ + +typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO +{ + ULONG ProcessId; + BYTE ObjectTypeNumber; + BYTE Flags; + USHORT Handle; + PVOID Object; + ACCESS_MASK GrantedAccess; +} SYSTEM_HANDLE, * PSYSTEM_HANDLE; //i shortened it to SYSTEM_HANDLE for the sake of typing + +typedef struct _SYSTEM_HANDLE_INFORMATION +{ + ULONG HandleCount; + SYSTEM_HANDLE Handles[1]; +} SYSTEM_HANDLE_INFORMATION, * PSYSTEM_HANDLE_INFORMATION; + +/* +FUNCTION PROTOTYPES: +*/ +typedef NTSTATUS(NTAPI* _NtDuplicateObject)( + HANDLE SourceProcessHandle, + HANDLE SourceHandle, + HANDLE TargetProcessHandle, + PHANDLE TargetHandle, + ACCESS_MASK DesiredAccess, + ULONG Attributes, + ULONG Options + ); + +typedef NTSTATUS(NTAPI* _RtlAdjustPrivilege)( + ULONG Privilege, + BOOLEAN Enable, + BOOLEAN CurrentThread, + PBOOLEAN Enabled + ); + +typedef NTSYSAPI NTSTATUS(NTAPI* _NtOpenProcess)( + PHANDLE ProcessHandle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, + PCLIENT_ID ClientId + ); + +typedef NTSTATUS(NTAPI* _NtQuerySystemInformation)( + ULONG SystemInformationClass, //your supposed to supply the whole class but microsoft kept the enum mostly empty so I just passed 16 instead for handle info. Thats why you get a warning in your code btw + PVOID SystemInformation, + ULONG SystemInformationLength, + PULONG ReturnLength + ); + +SYSTEM_HANDLE_INFORMATION* hInfo; //holds the handle information + +//the handles we will need to use later on + +namespace hj { + HANDLE procHandle = NULL; + HANDLE hProcess = NULL; + HANDLE HijackedHandle = NULL; + + // simple function i made that will just initialize our Object_Attributes structure as NtOpenProcess will fail otherwise + OBJECT_ATTRIBUTES InitObjectAttributes(PUNICODE_STRING name, ULONG attributes, HANDLE hRoot, PSECURITY_DESCRIPTOR security) + { + OBJECT_ATTRIBUTES object; + + object.Length = sizeof(OBJECT_ATTRIBUTES); + object.ObjectName = name; + object.Attributes = attributes; + object.RootDirectory = hRoot; + object.SecurityDescriptor = security; + + return object; + } + + bool IsHandleValid(HANDLE handle) // i made this to simply check if a handle is valid rather than repeating the if statments + { + if (handle && handle != INVALID_HANDLE_VALUE) + { + return true; + } + else + { + return false; + } + } + + HANDLE HijackExistingHandle(DWORD dwTargetProcessId) + { + HMODULE Ntdll = GetModuleHandleA("ntdll"); // get the base address of ntdll.dll + + //get the address of RtlAdjustPrivilege in ntdll.dll so we can grant our process the highest permission possible + _RtlAdjustPrivilege RtlAdjustPrivilege = (_RtlAdjustPrivilege)GetProcAddress(Ntdll, "RtlAdjustPrivilege"); + + boolean OldPriv; //store the old privileges + + // Give our program SeDeugPrivileges whcih allows us to get a handle to every process, even the highest privileged SYSTEM level processes. + RtlAdjustPrivilege(SeDebugPriv, TRUE, FALSE, &OldPriv); + + //get the address of NtQuerySystemInformation in ntdll.dll so we can find all the open handles on our system + _NtQuerySystemInformation NtQuerySystemInformation = (_NtQuerySystemInformation)GetProcAddress(Ntdll, "NtQuerySystemInformation"); + + //get the address of NtDuplicateObject in ntdll.dll so we can duplicate an existing handle into our cheat, basically performing the hijacking + _NtDuplicateObject NtDuplicateObject = (_NtDuplicateObject)GetProcAddress(Ntdll, "NtDuplicateObject"); + + //get the address of NtOpenProcess in ntdll.dll so wecan create a Duplicate handle + _NtOpenProcess NtOpenProcess = (_NtOpenProcess)GetProcAddress(Ntdll, "NtOpenProcess"); + + + //initialize the Object Attributes structure, you can just set each member to NULL rather than create a function like i did + OBJECT_ATTRIBUTES Obj_Attribute = InitObjectAttributes(NULL, NULL, NULL, NULL); + + //clientID is a PDWORD or DWORD* of the process id to create a handle to + CLIENT_ID clientID = { 0 }; + + + //the size variable is the amount of bytes allocated to store all the open handles + DWORD size = sizeof(SYSTEM_HANDLE_INFORMATION); + + //we allocate the memory to store all the handles on the heap rather than the stack becuase of the large amount of data + hInfo = (SYSTEM_HANDLE_INFORMATION*) new byte[size]; + + //zero the memory handle info + ZeroMemory(hInfo, size); + + //we use this for checking if the Native functions succeed + NTSTATUS NtRet = NULL; + + do + { + // delete the previously allocated memory on the heap because it wasn't large enough to store all the handles + delete[] hInfo; + + //increase the amount of memory allocated by 50% + size *= 1.5; + try + { + //set and allocate the larger size on the heap + hInfo = (PSYSTEM_HANDLE_INFORMATION) new byte[size]; + } + catch (std::bad_alloc) //catch a bad heap allocation. + { + procHandle ? CloseHandle(procHandle) : 0; + } + Sleep(1); //sleep for the cpu + + //we continue this loop until all the handles have been stored + } while ((NtRet = NtQuerySystemInformation(SystemHandleInformation, hInfo, size, NULL)) == STATUS_INFO_LENGTH_MISMATCH); + + //check if we got all the open handles on our system + if (!NT_SUCCESS(NtRet)) + { + procHandle ? CloseHandle(procHandle) : 0; + } + + + //loop through each handle on our system, and filter out handles that are invalid or cant be hijacked + for (unsigned int i = 0; i < hInfo->HandleCount; ++i) + { + //a variable to store the number of handles OUR cheat has open. + static DWORD NumOfOpenHandles; + + //get the amount of outgoing handles OUR cheat has open + GetProcessHandleCount(GetCurrentProcess(), &NumOfOpenHandles); + + //you can do a higher number if this is triggering false positives. Its just to make sure we dont fuck up and create thousands of handles + if (NumOfOpenHandles > 50) + { + procHandle ? CloseHandle(procHandle) : 0; + } + + //check if the current handle is valid, otherwise increment i and check the next handle + if (!IsHandleValid((HANDLE)hInfo->Handles[i].Handle)) + { + continue; + } + + //check the handle type is 0x7 meaning a process handle so we dont hijack a file handle for example + if (hInfo->Handles[i].ObjectTypeNumber != ProcessHandleType) + { + continue; + } + + + //set clientID to a pointer to the process with the handle to out target + clientID.UniqueProcess = (DWORD*)hInfo->Handles[i].ProcessId; + + //if procHandle is open, close it + procHandle ? CloseHandle(procHandle) : 0; + + //create a a handle with duplicate only permissions to the process with a handle to our target. NOT OUR TARGET. + NtRet = NtOpenProcess(&procHandle, PROCESS_DUP_HANDLE, &Obj_Attribute, &clientID); + if (!IsHandleValid(procHandle) || !NT_SUCCESS(NtRet)) //check is the funcions succeeded and check the handle is valid + { + continue; + } + + + //we duplicate the handle another process has to our target into our cheat with whatever permissions we want. I did all access. + NtRet = NtDuplicateObject(procHandle, (HANDLE)hInfo->Handles[i].Handle, NtCurrentProcess, &HijackedHandle, PROCESS_ALL_ACCESS, 0, 0); + if (!IsHandleValid(HijackedHandle) || !NT_SUCCESS(NtRet))//check is the funcions succeeded and check the handle is valid + { + + continue; + } + + //get the process id of the handle we duplicated and check its to our target + if (GetProcessId(HijackedHandle) != dwTargetProcessId) { + CloseHandle(HijackedHandle); + continue; + } + + + + hProcess = HijackedHandle; + + break; + } + + procHandle ? CloseHandle(procHandle) : 0; + + return hProcess; + } +} \ No newline at end of file diff --git a/HPCS2/memory.cpp b/HPCS2/memory.cpp new file mode 100644 index 0000000..7565142 --- /dev/null +++ b/HPCS2/memory.cpp @@ -0,0 +1,255 @@ +#include "memory.hpp" +#include +#include "handle_hijack.hpp" + +uint32_t pProcess::FindProcessIdByProcessName(const char* ProcessName) +{ + std::wstring wideProcessName; + int wideCharLength = MultiByteToWideChar(CP_UTF8, 0, ProcessName, -1, nullptr, 0); + if (wideCharLength > 0) + { + wideProcessName.resize(wideCharLength); + MultiByteToWideChar(CP_UTF8, 0, ProcessName, -1, &wideProcessName[0], wideCharLength); + } + + HANDLE hPID = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL); + PROCESSENTRY32W process_entry_{ }; + process_entry_.dwSize = sizeof(PROCESSENTRY32W); + + DWORD pid = 0; + if (Process32FirstW(hPID, &process_entry_)) + { + do + { + if (!wcscmp(process_entry_.szExeFile, wideProcessName.c_str())) + { + pid = process_entry_.th32ProcessID; + break; + } + } while (Process32NextW(hPID, &process_entry_)); + } + CloseHandle(hPID); + return pid; +} + +uint32_t pProcess::FindProcessIdByWindowName(const char* WindowName) +{ + DWORD process_id = 0; + HWND windowHandle = FindWindowA(nullptr, WindowName); + if (windowHandle) + GetWindowThreadProcessId(windowHandle, &process_id); + return process_id; +} + +HWND pProcess::GetWindowHandleFromProcessId(DWORD ProcessId) { + HWND hwnd = NULL; + do { + hwnd = FindWindowEx(NULL, hwnd, NULL, NULL); + DWORD pid = 0; + GetWindowThreadProcessId(hwnd, &pid); + if (pid == ProcessId) { + TCHAR windowTitle[MAX_PATH]; + GetWindowText(hwnd, windowTitle, MAX_PATH); + if (IsWindowVisible(hwnd) && windowTitle[0] != '\0') { + return hwnd; + } + } + } while (hwnd != NULL); + return NULL; // No main window found for the given process ID +} + +bool pProcess::AttachProcess(const char* ProcessName) +{ + this->pid_ = this->FindProcessIdByProcessName(ProcessName); + + if (pid_) + { + HMODULE modules[0xFF]; + MODULEINFO module_info; + DWORD _; + + handle_ = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid_); + + EnumProcessModulesEx(this->handle_, modules, sizeof(modules), &_, LIST_MODULES_64BIT); + base_client_.base = (uintptr_t)modules[0]; + + GetModuleInformation(this->handle_, modules[0], &module_info, sizeof(module_info)); + base_client_.size = module_info.SizeOfImage; + + hwnd_ = this->GetWindowHandleFromProcessId(pid_); + + return true; + } + + return false; +} + +bool pProcess::AttachProcessHj(const char* ProcessName) +{ + this->pid_ = this->FindProcessIdByProcessName(ProcessName); + + if (pid_) + { + HMODULE modules[0xFF]; + MODULEINFO module_info; + DWORD _; + + + // Using Apxaey's handle hijack function to safely open a handle + handle_ = hj::HijackExistingHandle(pid_); + + if (!hj::IsHandleValid(handle_)) + { + std::cout << "[cheat] Handle Hijack failed, falling back to OpenProcess method." << std::endl; + return pProcess::AttachProcess(ProcessName); // Handle hijacking failed, so we fall back to the normal OpenProcess method + } + + EnumProcessModulesEx(this->handle_, modules, sizeof(modules), &_, LIST_MODULES_64BIT); + base_client_.base = (uintptr_t)modules[0]; + + GetModuleInformation(this->handle_, modules[0], &module_info, sizeof(module_info)); + base_client_.size = module_info.SizeOfImage; + + hwnd_ = this->GetWindowHandleFromProcessId(pid_); + + return true; + } + + return false; +} + + +bool pProcess::AttachWindow(const char* WindowName) +{ + this->pid_ = this->FindProcessIdByWindowName(WindowName); + + if (pid_) + { + HMODULE modules[0xFF]; + MODULEINFO module_info; + DWORD _; + + handle_ = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid_); + + EnumProcessModulesEx(this->handle_, modules, sizeof(modules), &_, LIST_MODULES_64BIT); + base_client_.base = (uintptr_t)modules[0]; + + GetModuleInformation(this->handle_, modules[0], &module_info, sizeof(module_info)); + base_client_.size = module_info.SizeOfImage; + + hwnd_ = this->GetWindowHandleFromProcessId(pid_); + + return true; + } + return false; +} + +bool pProcess::UpdateHWND() +{ + hwnd_ = this->GetWindowHandleFromProcessId(pid_); + return hwnd_ == nullptr; +} + +ProcessModule pProcess::GetModule(const char* lModule) +{ + std::wstring wideModule; + int wideCharLength = MultiByteToWideChar(CP_UTF8, 0, lModule, -1, nullptr, 0); + if (wideCharLength > 0) + { + wideModule.resize(wideCharLength); + MultiByteToWideChar(CP_UTF8, 0, lModule, -1, &wideModule[0], wideCharLength); + } + + HANDLE handle_module = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid_); + MODULEENTRY32W module_entry_{}; + module_entry_.dwSize = sizeof(MODULEENTRY32W); + + do + { + if (!wcscmp(module_entry_.szModule, wideModule.c_str())) + { + CloseHandle(handle_module); + return { (DWORD_PTR)module_entry_.modBaseAddr, module_entry_.dwSize }; + } + } while (Module32NextW(handle_module, &module_entry_)); + + CloseHandle(handle_module); + return { 0, 0 }; +} + +LPVOID pProcess::Allocate(size_t size_in_bytes) +{ + return VirtualAllocEx(this->handle_, NULL, size_in_bytes, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE); +} + +uintptr_t pProcess::FindSignature(std::vector signature) +{ + std::unique_ptr data; + data = std::make_unique(this->base_client_.size); + + if (!ReadProcessMemory(this->handle_, (void*)(this->base_client_.base), data.get(), this->base_client_.size, NULL)) { + return 0x0; + } + + for (uintptr_t i = 0; i < this->base_client_.size; i++) + { + for (uintptr_t j = 0; j < signature.size(); j++) + { + if (signature.at(j) == 0x00) + continue; + + if (*reinterpret_cast(reinterpret_cast(&data[i + j])) == signature.at(j)) + { + if (j == signature.size() - 1) + return this->base_client_.base + i; + continue; + } + break; + } + } + return 0x0; +} + +uintptr_t pProcess::FindSignature(ProcessModule target_module, std::vector signature) +{ + std::unique_ptr data; + data = std::make_unique(0xFFFFFFF); + + if (!ReadProcessMemory(this->handle_, (void*)(target_module.base), data.get(), 0xFFFFFFF, NULL)) { + return NULL; + } + + for (uintptr_t i = 0; i < 0xFFFFFFF; i++) + { + for (uintptr_t j = 0; j < signature.size(); j++) + { + if (signature.at(j) == 0x00) + continue; + + if (*reinterpret_cast(reinterpret_cast(&data[i + j])) == signature.at(j)) + { + if (j == signature.size() - 1) + return this->base_client_.base + i; + continue; + } + break; + } + } + return 0x0; +} + +uintptr_t pProcess::FindCodeCave(uint32_t length_in_bytes) +{ + std::vector cave_pattern = {}; + + for (uint32_t i = 0; i < length_in_bytes; i++) { + cave_pattern.push_back(0x00); + } + + return FindSignature(cave_pattern); +} + +void pProcess::Close() +{ + CloseHandle(handle_); +} \ No newline at end of file diff --git a/HPCS2/memory.hpp b/HPCS2/memory.hpp new file mode 100644 index 0000000..be13d0e --- /dev/null +++ b/HPCS2/memory.hpp @@ -0,0 +1,124 @@ +#ifndef _PPROCESS_HPP_ +#define _PPROCESS_HPP_ + +#include +#include +#include +#include +#include +#include +#include + +typedef NTSTATUS(WINAPI* pNtReadVirtualMemory)(HANDLE ProcessHandle, PVOID BaseAddress, PVOID Buffer, ULONG NumberOfBytesToRead, PULONG NumberOfBytesRead); +typedef NTSTATUS(WINAPI* pNtWriteVirtualMemory)(HANDLE ProcessHandle, PVOID BaseAddress, PVOID Buffer, ULONG NumberOfBytesToWrite, PULONG NumberOfBytesWritten); + +class pMemory { + +public: + pMemory() { + pfnNtReadVirtualMemory = (pNtReadVirtualMemory)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtReadVirtualMemory"); + pfnNtWriteVirtualMemory = (pNtWriteVirtualMemory)GetProcAddress(GetModuleHandleA("ntdll.dll"), "NtWriteVirtualMemory"); + } + + pNtReadVirtualMemory pfnNtReadVirtualMemory; + pNtWriteVirtualMemory pfnNtWriteVirtualMemory; +}; + +struct ProcessModule +{ + uintptr_t base, size; +}; + +class pProcess +{ +public: + DWORD pid_; // process id + HANDLE handle_; // handle to process + HWND hwnd_; // window handle + ProcessModule base_client_; + +public: + bool AttachProcess(const char* process_name); + bool AttachProcessHj(const char* process_name); + bool AttachWindow(const char* window_name); + bool UpdateHWND(); + void Close(); + +public: + ProcessModule GetModule(const char* module_name); + LPVOID Allocate(size_t size_in_bytes); + uintptr_t FindCodeCave(uint32_t length_in_bytes); + uintptr_t FindSignature(std::vector signature); + uintptr_t FindSignature(ProcessModule target_module, std::vector signature); + + template + uintptr_t ReadOffsetFromSignature(std::vector signature, uint8_t offset) // offset example: "FF 05 ->22628B01<-" offset is 2 + { + uintptr_t pattern_address = this->FindSignature(signature); + if (!pattern_address) + return 0x0; + + T offset_value = this->read(pattern_address + offset); + return pattern_address + offset_value + offset + sizeof(T); + } + + bool read_raw(uintptr_t address, void* buffer, size_t size) + { + SIZE_T bytesRead; + pMemory cMemory; + + if (cMemory.pfnNtReadVirtualMemory(this->handle_, (PVOID)(address), buffer, static_cast(size), (PULONG)&bytesRead)) + { + return bytesRead == size; + } + return false; + } + + template + void write(uintptr_t address, T value) + { + pMemory cMemory; + cMemory.pfnNtWriteVirtualMemory(handle_, (void*)address, &value, sizeof(T), 0); + } + + template + T read(uintptr_t address) + { + T buffer{}; + pMemory cMemory; + + cMemory.pfnNtReadVirtualMemory(handle_, (void*)address, &buffer, sizeof(T), 0); + return buffer; + } + + void write_bytes(uintptr_t addr, std::vector patch) + { + pMemory cMemory; + cMemory.pfnNtWriteVirtualMemory(handle_, (void*)addr, &patch[0], patch.size(), 0); + } + + uintptr_t read_multi_address(uintptr_t ptr, std::vector offsets) + { + uintptr_t buffer = ptr; + for (int i = 0; i < offsets.size(); i++) + buffer = this->read(buffer + offsets[i]); + + return buffer; + } + + template + T read_multi(uintptr_t base, std::vector offsets) { + uintptr_t buffer = base; + for (int i = 0; i < offsets.size() - 1; i++) + { + buffer = this->read(buffer + offsets[i]); + } + return this->read(buffer + offsets.back()); + } + +private: + uint32_t FindProcessIdByProcessName(const char* process_name); + uint32_t FindProcessIdByWindowName(const char* window_name); + HWND GetWindowHandleFromProcessId(DWORD ProcessId); +}; +#endif \ No newline at end of file diff --git a/HPCS2/offset/animationsystem.dll.hpp b/HPCS2/offset/animationsystem.dll.hpp new file mode 100644 index 0000000..e636e09 --- /dev/null +++ b/HPCS2/offset/animationsystem.dll.hpp @@ -0,0 +1,2579 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace AimMatrixOpFixedSettings_t { + constexpr std::ptrdiff_t m_attachment = 0x0; // CAnimAttachment + constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping + constexpr std::ptrdiff_t m_poseCacheHandles = 0x90; // CPoseHandle[10] + constexpr std::ptrdiff_t m_eBlendMode = 0xB8; // AimMatrixBlendMode + constexpr std::ptrdiff_t m_fAngleIncrement = 0xBC; // float + constexpr std::ptrdiff_t m_nSequenceMaxFrame = 0xC0; // int32_t + constexpr std::ptrdiff_t m_nBoneMaskIndex = 0xC4; // int32_t + constexpr std::ptrdiff_t m_bTargetIsPosition = 0xC8; // bool +} + +namespace AnimComponentID { + constexpr std::ptrdiff_t m_id = 0x0; // uint32_t +} + +namespace AnimNodeID { + constexpr std::ptrdiff_t m_id = 0x0; // uint32_t +} + +namespace AnimNodeOutputID { + constexpr std::ptrdiff_t m_id = 0x0; // uint32_t +} + +namespace AnimParamID { + constexpr std::ptrdiff_t m_id = 0x0; // uint32_t +} + +namespace AnimScriptHandle { + constexpr std::ptrdiff_t m_id = 0x0; // uint32_t +} + +namespace AnimStateID { + constexpr std::ptrdiff_t m_id = 0x0; // uint32_t +} + +namespace AnimTagID { + constexpr std::ptrdiff_t m_id = 0x0; // uint32_t +} + +namespace AnimationDecodeDebugDumpElement_t { + constexpr std::ptrdiff_t m_nEntityIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_modelName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_poseParams = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_decodeOps = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_internalOps = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_decodedAnims = 0x58; // CUtlVector +} + +namespace AnimationDecodeDebugDump_t { + constexpr std::ptrdiff_t m_processingType = 0x0; // AnimationProcessingType_t + constexpr std::ptrdiff_t m_elems = 0x8; // CUtlVector +} + +namespace AnimationSnapshotBase_t { + constexpr std::ptrdiff_t m_flRealTime = 0x0; // float + constexpr std::ptrdiff_t m_rootToWorld = 0x10; // matrix3x4a_t + constexpr std::ptrdiff_t m_bBonesInWorldSpace = 0x40; // bool + constexpr std::ptrdiff_t m_boneSetupMask = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_boneTransforms = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_flexControllers = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_SnapshotType = 0x90; // AnimationSnapshotType_t + constexpr std::ptrdiff_t m_bHasDecodeDump = 0x94; // bool + constexpr std::ptrdiff_t m_DecodeDump = 0x98; // AnimationDecodeDebugDumpElement_t +} + +namespace AnimationSnapshot_t { // AnimationSnapshotBase_t + constexpr std::ptrdiff_t m_nEntIndex = 0x110; // int32_t + constexpr std::ptrdiff_t m_modelName = 0x118; // CUtlString +} + +namespace AttachmentHandle_t { + constexpr std::ptrdiff_t m_Value = 0x0; // uint8_t +} + +namespace BlendItem_t { + constexpr std::ptrdiff_t m_tags = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_pChild = 0x18; // CAnimUpdateNodeRef + constexpr std::ptrdiff_t m_hSequence = 0x28; // HSequence + constexpr std::ptrdiff_t m_vPos = 0x2C; // Vector2D + constexpr std::ptrdiff_t m_flDuration = 0x34; // float + constexpr std::ptrdiff_t m_bUseCustomDuration = 0x38; // bool +} + +namespace BoneDemoCaptureSettings_t { + constexpr std::ptrdiff_t m_boneName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_flChainLength = 0x8; // float +} + +namespace CActionComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_actions = 0x30; // CUtlVector> +} + +namespace CAddUpdateNode { // CBinaryUpdateNode + constexpr std::ptrdiff_t m_footMotionTiming = 0x8C; // BinaryNodeChildOption + constexpr std::ptrdiff_t m_bApplyToFootMotion = 0x90; // bool + constexpr std::ptrdiff_t m_bApplyChannelsSeparately = 0x91; // bool + constexpr std::ptrdiff_t m_bUseModelSpace = 0x92; // bool +} + +namespace CAimConstraint { // CBaseConstraint + constexpr std::ptrdiff_t m_qAimOffset = 0x70; // Quaternion + constexpr std::ptrdiff_t m_nUpType = 0x80; // uint32_t +} + +namespace CAimMatrixUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_opFixedSettings = 0x70; // AimMatrixOpFixedSettings_t + constexpr std::ptrdiff_t m_target = 0x148; // AnimVectorSource + constexpr std::ptrdiff_t m_paramIndex = 0x14C; // CAnimParamHandle + constexpr std::ptrdiff_t m_hSequence = 0x150; // HSequence + constexpr std::ptrdiff_t m_bResetChild = 0x154; // bool + constexpr std::ptrdiff_t m_bLockWhenWaning = 0x155; // bool +} + +namespace CAnimActionUpdater { +} + +namespace CAnimActivity { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString + constexpr std::ptrdiff_t m_nActivity = 0x10; // int32_t + constexpr std::ptrdiff_t m_nFlags = 0x14; // int32_t + constexpr std::ptrdiff_t m_nWeight = 0x18; // int32_t +} + +namespace CAnimAttachment { + constexpr std::ptrdiff_t m_influenceRotations = 0x0; // Quaternion[3] + constexpr std::ptrdiff_t m_influenceOffsets = 0x30; // VectorAligned[3] + constexpr std::ptrdiff_t m_influenceIndices = 0x60; // int32_t[3] + constexpr std::ptrdiff_t m_influenceWeights = 0x6C; // float[3] + constexpr std::ptrdiff_t m_numInfluences = 0x78; // uint8_t +} + +namespace CAnimBone { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString + constexpr std::ptrdiff_t m_parent = 0x10; // int32_t + constexpr std::ptrdiff_t m_pos = 0x14; // Vector + constexpr std::ptrdiff_t m_quat = 0x20; // QuaternionStorage + constexpr std::ptrdiff_t m_scale = 0x30; // float + constexpr std::ptrdiff_t m_qAlignment = 0x34; // QuaternionStorage + constexpr std::ptrdiff_t m_flags = 0x44; // int32_t +} + +namespace CAnimBoneDifference { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString + constexpr std::ptrdiff_t m_parent = 0x10; // CBufferString + constexpr std::ptrdiff_t m_posError = 0x20; // Vector + constexpr std::ptrdiff_t m_bHasRotation = 0x2C; // bool + constexpr std::ptrdiff_t m_bHasMovement = 0x2D; // bool +} + +namespace CAnimComponentUpdater { + constexpr std::ptrdiff_t m_name = 0x18; // CUtlString + constexpr std::ptrdiff_t m_id = 0x20; // AnimComponentID + constexpr std::ptrdiff_t m_networkMode = 0x24; // AnimNodeNetworkMode + constexpr std::ptrdiff_t m_bStartEnabled = 0x28; // bool +} + +namespace CAnimCycle { // CCycleBase +} + +namespace CAnimData { + constexpr std::ptrdiff_t m_name = 0x10; // CBufferString + constexpr std::ptrdiff_t m_animArray = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_decoderArray = 0x38; // CUtlVector + constexpr std::ptrdiff_t m_nMaxUniqueFrameIndex = 0x50; // int32_t + constexpr std::ptrdiff_t m_segmentArray = 0x58; // CUtlVector +} + +namespace CAnimDataChannelDesc { + constexpr std::ptrdiff_t m_szChannelClass = 0x0; // CBufferString + constexpr std::ptrdiff_t m_szVariableName = 0x10; // CBufferString + constexpr std::ptrdiff_t m_nFlags = 0x20; // int32_t + constexpr std::ptrdiff_t m_nType = 0x24; // int32_t + constexpr std::ptrdiff_t m_szGrouping = 0x28; // CBufferString + constexpr std::ptrdiff_t m_szDescription = 0x38; // CBufferString + constexpr std::ptrdiff_t m_szElementNameArray = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_nElementIndexArray = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_nElementMaskArray = 0x78; // CUtlVector +} + +namespace CAnimDecoder { + constexpr std::ptrdiff_t m_szName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_nVersion = 0x10; // int32_t + constexpr std::ptrdiff_t m_nType = 0x14; // int32_t +} + +namespace CAnimDemoCaptureSettings { + constexpr std::ptrdiff_t m_rangeBoneChainLength = 0x0; // Vector2D + constexpr std::ptrdiff_t m_rangeMaxSplineErrorRotation = 0x8; // Vector2D + constexpr std::ptrdiff_t m_flMaxSplineErrorTranslation = 0x10; // float + constexpr std::ptrdiff_t m_flMaxSplineErrorScale = 0x14; // float + constexpr std::ptrdiff_t m_flIkRotation_MaxSplineError = 0x18; // float + constexpr std::ptrdiff_t m_flIkTranslation_MaxSplineError = 0x1C; // float + constexpr std::ptrdiff_t m_flMaxQuantizationErrorRotation = 0x20; // float + constexpr std::ptrdiff_t m_flMaxQuantizationErrorTranslation = 0x24; // float + constexpr std::ptrdiff_t m_flMaxQuantizationErrorScale = 0x28; // float + constexpr std::ptrdiff_t m_flIkRotation_MaxQuantizationError = 0x2C; // float + constexpr std::ptrdiff_t m_flIkTranslation_MaxQuantizationError = 0x30; // float + constexpr std::ptrdiff_t m_baseSequence = 0x38; // CUtlString + constexpr std::ptrdiff_t m_nBaseSequenceFrame = 0x40; // int32_t + constexpr std::ptrdiff_t m_boneSelectionMode = 0x44; // EDemoBoneSelectionMode + constexpr std::ptrdiff_t m_bones = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_ikChains = 0x60; // CUtlVector +} + +namespace CAnimDesc { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString + constexpr std::ptrdiff_t m_flags = 0x10; // CAnimDesc_Flag + constexpr std::ptrdiff_t fps = 0x18; // float + constexpr std::ptrdiff_t m_Data = 0x20; // CAnimEncodedFrames + constexpr std::ptrdiff_t m_movementArray = 0xF8; // CUtlVector + constexpr std::ptrdiff_t m_eventArray = 0x110; // CUtlVector + constexpr std::ptrdiff_t m_activityArray = 0x128; // CUtlVector + constexpr std::ptrdiff_t m_hierarchyArray = 0x140; // CUtlVector + constexpr std::ptrdiff_t framestalltime = 0x158; // float + constexpr std::ptrdiff_t m_vecRootMin = 0x15C; // Vector + constexpr std::ptrdiff_t m_vecRootMax = 0x168; // Vector + constexpr std::ptrdiff_t m_vecBoneWorldMin = 0x178; // CUtlVector + constexpr std::ptrdiff_t m_vecBoneWorldMax = 0x190; // CUtlVector + constexpr std::ptrdiff_t m_sequenceParams = 0x1A8; // CAnimSequenceParams +} + +namespace CAnimDesc_Flag { + constexpr std::ptrdiff_t m_bLooping = 0x0; // bool + constexpr std::ptrdiff_t m_bAllZeros = 0x1; // bool + constexpr std::ptrdiff_t m_bHidden = 0x2; // bool + constexpr std::ptrdiff_t m_bDelta = 0x3; // bool + constexpr std::ptrdiff_t m_bLegacyWorldspace = 0x4; // bool + constexpr std::ptrdiff_t m_bModelDoc = 0x5; // bool + constexpr std::ptrdiff_t m_bImplicitSeqIgnoreDelta = 0x6; // bool + constexpr std::ptrdiff_t m_bAnimGraphAdditive = 0x7; // bool +} + +namespace CAnimEncodeDifference { + constexpr std::ptrdiff_t m_boneArray = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_morphArray = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_userArray = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_bHasRotationBitArray = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_bHasMovementBitArray = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_bHasMorphBitArray = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_bHasUserBitArray = 0x90; // CUtlVector +} + +namespace CAnimEncodedFrames { + constexpr std::ptrdiff_t m_fileName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_nFrames = 0x10; // int32_t + constexpr std::ptrdiff_t m_nFramesPerBlock = 0x14; // int32_t + constexpr std::ptrdiff_t m_frameblockArray = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_usageDifferences = 0x30; // CAnimEncodeDifference +} + +namespace CAnimEnum { + constexpr std::ptrdiff_t m_value = 0x0; // uint8_t +} + +namespace CAnimEventDefinition { + constexpr std::ptrdiff_t m_nFrame = 0x8; // int32_t + constexpr std::ptrdiff_t m_flCycle = 0xC; // float + constexpr std::ptrdiff_t m_EventData = 0x10; // KeyValues3 + constexpr std::ptrdiff_t m_sLegacyOptions = 0x20; // CBufferString + constexpr std::ptrdiff_t m_sEventName = 0x30; // CGlobalSymbol +} + +namespace CAnimFoot { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_vBallOffset = 0x8; // Vector + constexpr std::ptrdiff_t m_vHeelOffset = 0x14; // Vector + constexpr std::ptrdiff_t m_ankleBoneIndex = 0x20; // int32_t + constexpr std::ptrdiff_t m_toeBoneIndex = 0x24; // int32_t +} + +namespace CAnimFrameBlockAnim { + constexpr std::ptrdiff_t m_nStartFrame = 0x0; // int32_t + constexpr std::ptrdiff_t m_nEndFrame = 0x4; // int32_t + constexpr std::ptrdiff_t m_segmentIndexArray = 0x8; // CUtlVector +} + +namespace CAnimFrameSegment { + constexpr std::ptrdiff_t m_nUniqueFrameIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_nLocalElementMasks = 0x4; // uint32_t + constexpr std::ptrdiff_t m_nLocalChannel = 0x8; // int32_t + constexpr std::ptrdiff_t m_container = 0x10; // CUtlBinaryBlock +} + +namespace CAnimGraphDebugReplay { + constexpr std::ptrdiff_t m_animGraphFileName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_frameList = 0x48; // CUtlVector> + constexpr std::ptrdiff_t m_startIndex = 0x60; // int32_t + constexpr std::ptrdiff_t m_writeIndex = 0x64; // int32_t + constexpr std::ptrdiff_t m_frameCount = 0x68; // int32_t +} + +namespace CAnimGraphModelBinding { + constexpr std::ptrdiff_t m_modelName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_pSharedData = 0x10; // CSmartPtr +} + +namespace CAnimGraphNetworkSettings { // CAnimGraphSettingsGroup + constexpr std::ptrdiff_t m_bNetworkingEnabled = 0x20; // bool +} + +namespace CAnimGraphSettingsGroup { +} + +namespace CAnimGraphSettingsManager { + constexpr std::ptrdiff_t m_settingsGroups = 0x18; // CUtlVector> +} + +namespace CAnimInputDamping { + constexpr std::ptrdiff_t m_speedFunction = 0x8; // DampingSpeedFunction + constexpr std::ptrdiff_t m_fSpeedScale = 0xC; // float +} + +namespace CAnimKeyData { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString + constexpr std::ptrdiff_t m_boneArray = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_userArray = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_morphArray = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_nChannelElements = 0x58; // int32_t + constexpr std::ptrdiff_t m_dataChannelArray = 0x60; // CUtlVector +} + +namespace CAnimLocalHierarchy { + constexpr std::ptrdiff_t m_sBone = 0x0; // CBufferString + constexpr std::ptrdiff_t m_sNewParent = 0x10; // CBufferString + constexpr std::ptrdiff_t m_nStartFrame = 0x20; // int32_t + constexpr std::ptrdiff_t m_nPeakFrame = 0x24; // int32_t + constexpr std::ptrdiff_t m_nTailFrame = 0x28; // int32_t + constexpr std::ptrdiff_t m_nEndFrame = 0x2C; // int32_t +} + +namespace CAnimMorphDifference { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString +} + +namespace CAnimMotorUpdaterBase { + constexpr std::ptrdiff_t m_name = 0x10; // CUtlString + constexpr std::ptrdiff_t m_bDefault = 0x18; // bool +} + +namespace CAnimMovement { + constexpr std::ptrdiff_t endframe = 0x0; // int32_t + constexpr std::ptrdiff_t motionflags = 0x4; // int32_t + constexpr std::ptrdiff_t v0 = 0x8; // float + constexpr std::ptrdiff_t v1 = 0xC; // float + constexpr std::ptrdiff_t angle = 0x10; // float + constexpr std::ptrdiff_t vector = 0x14; // Vector + constexpr std::ptrdiff_t position = 0x20; // Vector +} + +namespace CAnimNodePath { + constexpr std::ptrdiff_t m_path = 0x0; // AnimNodeID[11] + constexpr std::ptrdiff_t m_nCount = 0x2C; // int32_t +} + +namespace CAnimParamHandle { + constexpr std::ptrdiff_t m_type = 0x0; // AnimParamType_t + constexpr std::ptrdiff_t m_index = 0x1; // uint8_t +} + +namespace CAnimParamHandleMap { + constexpr std::ptrdiff_t m_list = 0x0; // CUtlHashtable +} + +namespace CAnimParameterBase { + constexpr std::ptrdiff_t m_name = 0x18; // CGlobalSymbol + constexpr std::ptrdiff_t m_group = 0x20; // CUtlString + constexpr std::ptrdiff_t m_id = 0x28; // AnimParamID + constexpr std::ptrdiff_t m_componentName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_bNetworkingRequested = 0x4C; // bool + constexpr std::ptrdiff_t m_bIsReferenced = 0x4D; // bool +} + +namespace CAnimParameterManagerUpdater { + constexpr std::ptrdiff_t m_parameters = 0x18; // CUtlVector> + constexpr std::ptrdiff_t m_idToIndexMap = 0x30; // CUtlHashtable + constexpr std::ptrdiff_t m_nameToIndexMap = 0x50; // CUtlHashtable + constexpr std::ptrdiff_t m_indexToHandle = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_autoResetParams = 0x88; // CUtlVector> + constexpr std::ptrdiff_t m_autoResetMap = 0xA0; // CUtlHashtable +} + +namespace CAnimReplayFrame { + constexpr std::ptrdiff_t m_inputDataBlocks = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_instanceData = 0x28; // CUtlBinaryBlock + constexpr std::ptrdiff_t m_startingLocalToWorldTransform = 0x40; // CTransform + constexpr std::ptrdiff_t m_localToWorldTransform = 0x60; // CTransform + constexpr std::ptrdiff_t m_timeStamp = 0x80; // float +} + +namespace CAnimScriptComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_hScript = 0x30; // AnimScriptHandle +} + +namespace CAnimScriptManager { + constexpr std::ptrdiff_t m_scriptInfo = 0x10; // CUtlVector +} + +namespace CAnimSequenceParams { + constexpr std::ptrdiff_t m_flFadeInTime = 0x0; // float + constexpr std::ptrdiff_t m_flFadeOutTime = 0x4; // float +} + +namespace CAnimSkeleton { + constexpr std::ptrdiff_t m_localSpaceTransforms = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_modelSpaceTransforms = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_boneNames = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_children = 0x58; // CUtlVector> + constexpr std::ptrdiff_t m_parents = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_feet = 0x88; // CUtlVector + constexpr std::ptrdiff_t m_morphNames = 0xA0; // CUtlVector + constexpr std::ptrdiff_t m_lodBoneCounts = 0xB8; // CUtlVector +} + +namespace CAnimStateMachineUpdater { + constexpr std::ptrdiff_t m_states = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_transitions = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_startStateIndex = 0x50; // int32_t +} + +namespace CAnimTagBase { + constexpr std::ptrdiff_t m_name = 0x18; // CGlobalSymbol + constexpr std::ptrdiff_t m_group = 0x20; // CGlobalSymbol + constexpr std::ptrdiff_t m_tagID = 0x28; // AnimTagID + constexpr std::ptrdiff_t m_bIsReferenced = 0x2C; // bool +} + +namespace CAnimTagManagerUpdater { + constexpr std::ptrdiff_t m_tags = 0x18; // CUtlVector> +} + +namespace CAnimUpdateNodeBase { + constexpr std::ptrdiff_t m_nodePath = 0x18; // CAnimNodePath + constexpr std::ptrdiff_t m_networkMode = 0x48; // AnimNodeNetworkMode + constexpr std::ptrdiff_t m_name = 0x50; // CUtlString +} + +namespace CAnimUpdateNodeRef { + constexpr std::ptrdiff_t m_nodeIndex = 0x8; // int32_t +} + +namespace CAnimUpdateSharedData { + constexpr std::ptrdiff_t m_nodes = 0x10; // CUtlVector> + constexpr std::ptrdiff_t m_nodeIndexMap = 0x28; // CUtlHashtable + constexpr std::ptrdiff_t m_components = 0x48; // CUtlVector> + constexpr std::ptrdiff_t m_pParamListUpdater = 0x60; // CSmartPtr + constexpr std::ptrdiff_t m_pTagManagerUpdater = 0x68; // CSmartPtr + constexpr std::ptrdiff_t m_scriptManager = 0x70; // CSmartPtr + constexpr std::ptrdiff_t m_settings = 0x78; // CAnimGraphSettingsManager + constexpr std::ptrdiff_t m_pStaticPoseCache = 0xA8; // CSmartPtr + constexpr std::ptrdiff_t m_pSkeleton = 0xB0; // CSmartPtr + constexpr std::ptrdiff_t m_rootNodePath = 0xB8; // CAnimNodePath +} + +namespace CAnimUser { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString + constexpr std::ptrdiff_t m_nType = 0x10; // int32_t +} + +namespace CAnimUserDifference { + constexpr std::ptrdiff_t m_name = 0x0; // CBufferString + constexpr std::ptrdiff_t m_nType = 0x10; // int32_t +} + +namespace CAnimationGraphVisualizerAxis { // CAnimationGraphVisualizerPrimitiveBase + constexpr std::ptrdiff_t m_xWsTransform = 0x40; // CTransform + constexpr std::ptrdiff_t m_flAxisSize = 0x60; // float +} + +namespace CAnimationGraphVisualizerLine { // CAnimationGraphVisualizerPrimitiveBase + constexpr std::ptrdiff_t m_vWsPositionStart = 0x40; // VectorAligned + constexpr std::ptrdiff_t m_vWsPositionEnd = 0x50; // VectorAligned + constexpr std::ptrdiff_t m_Color = 0x60; // Color +} + +namespace CAnimationGraphVisualizerPie { // CAnimationGraphVisualizerPrimitiveBase + constexpr std::ptrdiff_t m_vWsCenter = 0x40; // VectorAligned + constexpr std::ptrdiff_t m_vWsStart = 0x50; // VectorAligned + constexpr std::ptrdiff_t m_vWsEnd = 0x60; // VectorAligned + constexpr std::ptrdiff_t m_Color = 0x70; // Color +} + +namespace CAnimationGraphVisualizerPrimitiveBase { + constexpr std::ptrdiff_t m_Type = 0x8; // CAnimationGraphVisualizerPrimitiveType + constexpr std::ptrdiff_t m_OwningAnimNodePaths = 0xC; // AnimNodeID[11] + constexpr std::ptrdiff_t m_nOwningAnimNodePathCount = 0x38; // int32_t +} + +namespace CAnimationGraphVisualizerSphere { // CAnimationGraphVisualizerPrimitiveBase + constexpr std::ptrdiff_t m_vWsPosition = 0x40; // VectorAligned + constexpr std::ptrdiff_t m_flRadius = 0x50; // float + constexpr std::ptrdiff_t m_Color = 0x54; // Color +} + +namespace CAnimationGraphVisualizerText { // CAnimationGraphVisualizerPrimitiveBase + constexpr std::ptrdiff_t m_vWsPosition = 0x40; // VectorAligned + constexpr std::ptrdiff_t m_Color = 0x50; // Color + constexpr std::ptrdiff_t m_Text = 0x58; // CUtlString +} + +namespace CAnimationGroup { + constexpr std::ptrdiff_t m_nFlags = 0x10; // uint32_t + constexpr std::ptrdiff_t m_name = 0x18; // CBufferString + constexpr std::ptrdiff_t m_localHAnimArray_Handle = 0x60; // CUtlVector> + constexpr std::ptrdiff_t m_includedGroupArray_Handle = 0x78; // CUtlVector> + constexpr std::ptrdiff_t m_directHSeqGroup_Handle = 0x90; // CStrongHandle + constexpr std::ptrdiff_t m_decodeKey = 0x98; // CAnimKeyData + constexpr std::ptrdiff_t m_szScripts = 0x110; // CUtlVector +} + +namespace CAttachment { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_influenceNames = 0x8; // CUtlString[3] + constexpr std::ptrdiff_t m_vInfluenceRotations = 0x20; // Quaternion[3] + constexpr std::ptrdiff_t m_vInfluenceOffsets = 0x50; // Vector[3] + constexpr std::ptrdiff_t m_influenceWeights = 0x74; // float[3] + constexpr std::ptrdiff_t m_bInfluenceRootTransform = 0x80; // bool[3] + constexpr std::ptrdiff_t m_nInfluences = 0x83; // uint8_t + constexpr std::ptrdiff_t m_bIgnoreRotation = 0x84; // bool +} + +namespace CAudioAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_clipName = 0x38; // CUtlString + constexpr std::ptrdiff_t m_attachmentName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_flVolume = 0x48; // float + constexpr std::ptrdiff_t m_bStopWhenTagEnds = 0x4C; // bool + constexpr std::ptrdiff_t m_bStopWhenGraphEnds = 0x4D; // bool + constexpr std::ptrdiff_t m_bPlayOnServer = 0x4E; // bool + constexpr std::ptrdiff_t m_bPlayOnClient = 0x4F; // bool +} + +namespace CBaseConstraint { // CBoneConstraintBase + constexpr std::ptrdiff_t m_name = 0x28; // CUtlString + constexpr std::ptrdiff_t m_vUpVector = 0x30; // Vector + constexpr std::ptrdiff_t m_slaves = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_targets = 0x58; // CUtlVector +} + +namespace CBinaryUpdateNode { // CAnimUpdateNodeBase + constexpr std::ptrdiff_t m_pChild1 = 0x58; // CAnimUpdateNodeRef + constexpr std::ptrdiff_t m_pChild2 = 0x68; // CAnimUpdateNodeRef + constexpr std::ptrdiff_t m_timingBehavior = 0x78; // BinaryNodeTiming + constexpr std::ptrdiff_t m_flTimingBlend = 0x7C; // float + constexpr std::ptrdiff_t m_bResetChild1 = 0x80; // bool + constexpr std::ptrdiff_t m_bResetChild2 = 0x81; // bool +} + +namespace CBindPoseUpdateNode { // CLeafUpdateNode +} + +namespace CBlend2DUpdateNode { // CAnimUpdateNodeBase + constexpr std::ptrdiff_t m_items = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_tags = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_paramSpans = 0x90; // CParamSpanUpdater + constexpr std::ptrdiff_t m_nodeItemIndices = 0xA8; // CUtlVector + constexpr std::ptrdiff_t m_damping = 0xC0; // CAnimInputDamping + constexpr std::ptrdiff_t m_blendSourceX = 0xD0; // AnimValueSource + constexpr std::ptrdiff_t m_paramX = 0xD4; // CAnimParamHandle + constexpr std::ptrdiff_t m_blendSourceY = 0xD8; // AnimValueSource + constexpr std::ptrdiff_t m_paramY = 0xDC; // CAnimParamHandle + constexpr std::ptrdiff_t m_eBlendMode = 0xE0; // Blend2DMode + constexpr std::ptrdiff_t m_playbackSpeed = 0xE4; // float + constexpr std::ptrdiff_t m_bLoop = 0xE8; // bool + constexpr std::ptrdiff_t m_bLockBlendOnReset = 0xE9; // bool + constexpr std::ptrdiff_t m_bLockWhenWaning = 0xEA; // bool + constexpr std::ptrdiff_t m_bAnimEventsAndTagsOnMostWeightedOnly = 0xEB; // bool +} + +namespace CBlendCurve { + constexpr std::ptrdiff_t m_flControlPoint1 = 0x0; // float + constexpr std::ptrdiff_t m_flControlPoint2 = 0x4; // float +} + +namespace CBlendUpdateNode { // CAnimUpdateNodeBase + constexpr std::ptrdiff_t m_children = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_sortedOrder = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_targetValues = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_blendValueSource = 0xAC; // AnimValueSource + constexpr std::ptrdiff_t m_paramIndex = 0xB0; // CAnimParamHandle + constexpr std::ptrdiff_t m_damping = 0xB8; // CAnimInputDamping + constexpr std::ptrdiff_t m_blendKeyType = 0xC8; // BlendKeyType + constexpr std::ptrdiff_t m_bLockBlendOnReset = 0xCC; // bool + constexpr std::ptrdiff_t m_bSyncCycles = 0xCD; // bool + constexpr std::ptrdiff_t m_bLoop = 0xCE; // bool + constexpr std::ptrdiff_t m_bLockWhenWaning = 0xCF; // bool +} + +namespace CBlockSelectionMetricEvaluator { // CMotionMetricEvaluator +} + +namespace CBodyGroupAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_nPriority = 0x38; // int32_t + constexpr std::ptrdiff_t m_bodyGroupSettings = 0x40; // CUtlVector +} + +namespace CBodyGroupSetting { + constexpr std::ptrdiff_t m_BodyGroupName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nBodyGroupOption = 0x8; // int32_t +} + +namespace CBoneConstraintBase { +} + +namespace CBoneConstraintDotToMorph { // CBoneConstraintBase + constexpr std::ptrdiff_t m_sBoneName = 0x28; // CUtlString + constexpr std::ptrdiff_t m_sTargetBoneName = 0x30; // CUtlString + constexpr std::ptrdiff_t m_sMorphChannelName = 0x38; // CUtlString + constexpr std::ptrdiff_t m_flRemap = 0x40; // float[4] +} + +namespace CBoneConstraintPoseSpaceBone { // CBaseConstraint + constexpr std::ptrdiff_t m_inputList = 0x70; // CUtlVector +} + +namespace CBoneConstraintPoseSpaceBone_Input_t { + constexpr std::ptrdiff_t m_inputValue = 0x0; // Vector + constexpr std::ptrdiff_t m_outputTransformList = 0x10; // CUtlVector +} + +namespace CBoneConstraintPoseSpaceMorph { // CBoneConstraintBase + constexpr std::ptrdiff_t m_sBoneName = 0x28; // CUtlString + constexpr std::ptrdiff_t m_sAttachmentName = 0x30; // CUtlString + constexpr std::ptrdiff_t m_outputMorph = 0x38; // CUtlVector + constexpr std::ptrdiff_t m_inputList = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_bClamp = 0x68; // bool +} + +namespace CBoneConstraintPoseSpaceMorph_Input_t { + constexpr std::ptrdiff_t m_inputValue = 0x0; // Vector + constexpr std::ptrdiff_t m_outputWeightList = 0x10; // CUtlVector +} + +namespace CBoneMaskUpdateNode { // CBinaryUpdateNode + constexpr std::ptrdiff_t m_nWeightListIndex = 0x8C; // int32_t + constexpr std::ptrdiff_t m_flRootMotionBlend = 0x90; // float + constexpr std::ptrdiff_t m_blendSpace = 0x94; // BoneMaskBlendSpace + constexpr std::ptrdiff_t m_footMotionTiming = 0x98; // BinaryNodeChildOption + constexpr std::ptrdiff_t m_bUseBlendScale = 0x9C; // bool + constexpr std::ptrdiff_t m_blendValueSource = 0xA0; // AnimValueSource + constexpr std::ptrdiff_t m_hBlendParameter = 0xA4; // CAnimParamHandle +} + +namespace CBonePositionMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_nBoneIndex = 0x50; // int32_t +} + +namespace CBoneVelocityMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_nBoneIndex = 0x50; // int32_t +} + +namespace CBoolAnimParameter { // CConcreteAnimParameter + constexpr std::ptrdiff_t m_bDefaultValue = 0x60; // bool +} + +namespace CCPPScriptComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_scriptsToRun = 0x30; // CUtlVector +} + +namespace CCachedPose { + constexpr std::ptrdiff_t m_transforms = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_morphWeights = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_hSequence = 0x38; // HSequence + constexpr std::ptrdiff_t m_flCycle = 0x3C; // float +} + +namespace CChoiceUpdateNode { // CAnimUpdateNodeBase + constexpr std::ptrdiff_t m_children = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_weights = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_blendTimes = 0x88; // CUtlVector + constexpr std::ptrdiff_t m_choiceMethod = 0xA0; // ChoiceMethod + constexpr std::ptrdiff_t m_choiceChangeMethod = 0xA4; // ChoiceChangeMethod + constexpr std::ptrdiff_t m_blendMethod = 0xA8; // ChoiceBlendMethod + constexpr std::ptrdiff_t m_blendTime = 0xAC; // float + constexpr std::ptrdiff_t m_bCrossFade = 0xB0; // bool + constexpr std::ptrdiff_t m_bResetChosen = 0xB1; // bool + constexpr std::ptrdiff_t m_bDontResetSameSelection = 0xB2; // bool +} + +namespace CChoreoUpdateNode { // CUnaryUpdateNode +} + +namespace CClothSettingsAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_flStiffness = 0x38; // float + constexpr std::ptrdiff_t m_flEaseIn = 0x3C; // float + constexpr std::ptrdiff_t m_flEaseOut = 0x40; // float + constexpr std::ptrdiff_t m_nVertexSet = 0x48; // CUtlString +} + +namespace CCompressorGroup { + constexpr std::ptrdiff_t m_nTotalElementCount = 0x0; // int32_t + constexpr std::ptrdiff_t m_szChannelClass = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_szVariableName = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_nType = 0x38; // CUtlVector + constexpr std::ptrdiff_t m_nFlags = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_szGrouping = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_nCompressorIndex = 0x80; // CUtlVector + constexpr std::ptrdiff_t m_szElementNames = 0x98; // CUtlVector> + constexpr std::ptrdiff_t m_nElementUniqueID = 0xB0; // CUtlVector> + constexpr std::ptrdiff_t m_nElementMask = 0xC8; // CUtlVector + constexpr std::ptrdiff_t m_vectorCompressor = 0xF8; // CUtlVector*> + constexpr std::ptrdiff_t m_quaternionCompressor = 0x110; // CUtlVector*> + constexpr std::ptrdiff_t m_intCompressor = 0x128; // CUtlVector*> + constexpr std::ptrdiff_t m_boolCompressor = 0x140; // CUtlVector*> + constexpr std::ptrdiff_t m_colorCompressor = 0x158; // CUtlVector*> + constexpr std::ptrdiff_t m_vector2DCompressor = 0x170; // CUtlVector*> + constexpr std::ptrdiff_t m_vector4DCompressor = 0x188; // CUtlVector*> +} + +namespace CConcreteAnimParameter { // CAnimParameterBase + constexpr std::ptrdiff_t m_previewButton = 0x50; // AnimParamButton_t + constexpr std::ptrdiff_t m_eNetworkSetting = 0x54; // AnimParamNetworkSetting + constexpr std::ptrdiff_t m_bUseMostRecentValue = 0x58; // bool + constexpr std::ptrdiff_t m_bAutoReset = 0x59; // bool + constexpr std::ptrdiff_t m_bGameWritable = 0x5A; // bool + constexpr std::ptrdiff_t m_bGraphWritable = 0x5B; // bool +} + +namespace CConstraintSlave { + constexpr std::ptrdiff_t m_qBaseOrientation = 0x0; // Quaternion + constexpr std::ptrdiff_t m_vBasePosition = 0x10; // Vector + constexpr std::ptrdiff_t m_nBoneHash = 0x1C; // uint32_t + constexpr std::ptrdiff_t m_flWeight = 0x20; // float + constexpr std::ptrdiff_t m_sName = 0x28; // CUtlString +} + +namespace CConstraintTarget { + constexpr std::ptrdiff_t m_qOffset = 0x20; // Quaternion + constexpr std::ptrdiff_t m_vOffset = 0x30; // Vector + constexpr std::ptrdiff_t m_nBoneHash = 0x3C; // uint32_t + constexpr std::ptrdiff_t m_sName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_flWeight = 0x48; // float + constexpr std::ptrdiff_t m_bIsAttachment = 0x59; // bool +} + +namespace CCurrentRotationVelocityMetricEvaluator { // CMotionMetricEvaluator +} + +namespace CCurrentVelocityMetricEvaluator { // CMotionMetricEvaluator +} + +namespace CCycleBase { + constexpr std::ptrdiff_t m_flCycle = 0x0; // float +} + +namespace CCycleControlClipUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_tags = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_hSequence = 0x7C; // HSequence + constexpr std::ptrdiff_t m_duration = 0x80; // float + constexpr std::ptrdiff_t m_valueSource = 0x84; // AnimValueSource + constexpr std::ptrdiff_t m_paramIndex = 0x88; // CAnimParamHandle +} + +namespace CCycleControlUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_valueSource = 0x68; // AnimValueSource + constexpr std::ptrdiff_t m_paramIndex = 0x6C; // CAnimParamHandle +} + +namespace CDampedPathAnimMotorUpdater { // CPathAnimMotorUpdaterBase + constexpr std::ptrdiff_t m_flAnticipationTime = 0x2C; // float + constexpr std::ptrdiff_t m_flMinSpeedScale = 0x30; // float + constexpr std::ptrdiff_t m_hAnticipationPosParam = 0x34; // CAnimParamHandle + constexpr std::ptrdiff_t m_hAnticipationHeadingParam = 0x36; // CAnimParamHandle + constexpr std::ptrdiff_t m_flSpringConstant = 0x38; // float + constexpr std::ptrdiff_t m_flMinSpringTension = 0x3C; // float + constexpr std::ptrdiff_t m_flMaxSpringTension = 0x40; // float +} + +namespace CDampedValueComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_items = 0x30; // CUtlVector +} + +namespace CDampedValueUpdateItem { + constexpr std::ptrdiff_t m_damping = 0x0; // CAnimInputDamping + constexpr std::ptrdiff_t m_hParamIn = 0x18; // CAnimParamHandle + constexpr std::ptrdiff_t m_hParamOut = 0x1A; // CAnimParamHandle +} + +namespace CDemoSettingsComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_settings = 0x30; // CAnimDemoCaptureSettings +} + +namespace CDirectPlaybackTagData { + constexpr std::ptrdiff_t m_sequenceName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_tags = 0x8; // CUtlVector +} + +namespace CDirectPlaybackUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_bFinishEarly = 0x6C; // bool + constexpr std::ptrdiff_t m_bResetOnFinish = 0x6D; // bool + constexpr std::ptrdiff_t m_allTags = 0x70; // CUtlVector +} + +namespace CDirectionalBlendUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_hSequences = 0x5C; // HSequence[8] + constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping + constexpr std::ptrdiff_t m_blendValueSource = 0x90; // AnimValueSource + constexpr std::ptrdiff_t m_paramIndex = 0x94; // CAnimParamHandle + constexpr std::ptrdiff_t m_playbackSpeed = 0x98; // float + constexpr std::ptrdiff_t m_duration = 0x9C; // float + constexpr std::ptrdiff_t m_bLoop = 0xA0; // bool + constexpr std::ptrdiff_t m_bLockBlendOnReset = 0xA1; // bool +} + +namespace CDistanceRemainingMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_flMaxDistance = 0x50; // float + constexpr std::ptrdiff_t m_flMinDistance = 0x54; // float + constexpr std::ptrdiff_t m_flStartGoalFilterDistance = 0x58; // float + constexpr std::ptrdiff_t m_flMaxGoalOvershootScale = 0x5C; // float + constexpr std::ptrdiff_t m_bFilterFixedMinDistance = 0x60; // bool + constexpr std::ptrdiff_t m_bFilterGoalDistance = 0x61; // bool + constexpr std::ptrdiff_t m_bFilterGoalOvershoot = 0x62; // bool +} + +namespace CDrawCullingData { + constexpr std::ptrdiff_t m_vConeApex = 0x0; // Vector + constexpr std::ptrdiff_t m_ConeAxis = 0xC; // int8_t[3] + constexpr std::ptrdiff_t m_ConeCutoff = 0xF; // int8_t +} + +namespace CEditableMotionGraph { // CMotionGraph +} + +namespace CEmitTagActionUpdater { // CAnimActionUpdater + constexpr std::ptrdiff_t m_nTagIndex = 0x18; // int32_t + constexpr std::ptrdiff_t m_bIsZeroDuration = 0x1C; // bool +} + +namespace CEnumAnimParameter { // CConcreteAnimParameter + constexpr std::ptrdiff_t m_defaultValue = 0x68; // uint8_t + constexpr std::ptrdiff_t m_enumOptions = 0x70; // CUtlVector +} + +namespace CExpressionActionUpdater { // CAnimActionUpdater + constexpr std::ptrdiff_t m_hParam = 0x18; // CAnimParamHandle + constexpr std::ptrdiff_t m_eParamType = 0x1A; // AnimParamType_t + constexpr std::ptrdiff_t m_hScript = 0x1C; // AnimScriptHandle +} + +namespace CFingerBone { + constexpr std::ptrdiff_t m_boneName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_hingeAxis = 0x8; // Vector + constexpr std::ptrdiff_t m_vCapsulePos1 = 0x14; // Vector + constexpr std::ptrdiff_t m_vCapsulePos2 = 0x20; // Vector + constexpr std::ptrdiff_t m_flMinAngle = 0x2C; // float + constexpr std::ptrdiff_t m_flMaxAngle = 0x30; // float + constexpr std::ptrdiff_t m_flRadius = 0x34; // float +} + +namespace CFingerChain { + constexpr std::ptrdiff_t m_targets = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_bones = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_name = 0x30; // CUtlString + constexpr std::ptrdiff_t m_tipParentBoneName = 0x38; // CUtlString + constexpr std::ptrdiff_t m_vTipOffset = 0x40; // Vector + constexpr std::ptrdiff_t m_metacarpalBoneName = 0x50; // CUtlString + constexpr std::ptrdiff_t m_vSplayHingeAxis = 0x58; // Vector + constexpr std::ptrdiff_t m_flSplayMinAngle = 0x64; // float + constexpr std::ptrdiff_t m_flSplayMaxAngle = 0x68; // float + constexpr std::ptrdiff_t m_flFingerScaleRatio = 0x6C; // float +} + +namespace CFingerSource { + constexpr std::ptrdiff_t m_nFingerIndex = 0x0; // AnimVRFinger_t + constexpr std::ptrdiff_t m_flFingerWeight = 0x4; // float +} + +namespace CFlexController { + constexpr std::ptrdiff_t m_szName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_szType = 0x8; // CUtlString + constexpr std::ptrdiff_t min = 0x10; // float + constexpr std::ptrdiff_t max = 0x14; // float +} + +namespace CFlexDesc { + constexpr std::ptrdiff_t m_szFacs = 0x0; // CUtlString +} + +namespace CFlexOp { + constexpr std::ptrdiff_t m_OpCode = 0x0; // FlexOpCode_t + constexpr std::ptrdiff_t m_Data = 0x4; // int32_t +} + +namespace CFlexRule { + constexpr std::ptrdiff_t m_nFlex = 0x0; // int32_t + constexpr std::ptrdiff_t m_FlexOps = 0x8; // CUtlVector +} + +namespace CFloatAnimParameter { // CConcreteAnimParameter + constexpr std::ptrdiff_t m_fDefaultValue = 0x60; // float + constexpr std::ptrdiff_t m_fMinValue = 0x64; // float + constexpr std::ptrdiff_t m_fMaxValue = 0x68; // float + constexpr std::ptrdiff_t m_bInterpolate = 0x6C; // bool +} + +namespace CFollowAttachmentUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_opFixedData = 0x70; // FollowAttachmentSettings_t +} + +namespace CFollowPathUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_flBlendOutTime = 0x6C; // float + constexpr std::ptrdiff_t m_bBlockNonPathMovement = 0x70; // bool + constexpr std::ptrdiff_t m_bStopFeetAtGoal = 0x71; // bool + constexpr std::ptrdiff_t m_bScaleSpeed = 0x72; // bool + constexpr std::ptrdiff_t m_flScale = 0x74; // float + constexpr std::ptrdiff_t m_flMinAngle = 0x78; // float + constexpr std::ptrdiff_t m_flMaxAngle = 0x7C; // float + constexpr std::ptrdiff_t m_flSpeedScaleBlending = 0x80; // float + constexpr std::ptrdiff_t m_turnDamping = 0x88; // CAnimInputDamping + constexpr std::ptrdiff_t m_facingTarget = 0x98; // AnimValueSource + constexpr std::ptrdiff_t m_hParam = 0x9C; // CAnimParamHandle + constexpr std::ptrdiff_t m_flTurnToFaceOffset = 0xA0; // float + constexpr std::ptrdiff_t m_bTurnToFace = 0xA4; // bool +} + +namespace CFootAdjustmentUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_clips = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_hBasePoseCacheHandle = 0x88; // CPoseHandle + constexpr std::ptrdiff_t m_facingTarget = 0x8C; // CAnimParamHandle + constexpr std::ptrdiff_t m_flTurnTimeMin = 0x90; // float + constexpr std::ptrdiff_t m_flTurnTimeMax = 0x94; // float + constexpr std::ptrdiff_t m_flStepHeightMax = 0x98; // float + constexpr std::ptrdiff_t m_flStepHeightMaxAngle = 0x9C; // float + constexpr std::ptrdiff_t m_bResetChild = 0xA0; // bool + constexpr std::ptrdiff_t m_bAnimationDriven = 0xA1; // bool +} + +namespace CFootCycle { // CCycleBase +} + +namespace CFootCycleDefinition { + constexpr std::ptrdiff_t m_vStancePositionMS = 0x0; // Vector + constexpr std::ptrdiff_t m_vMidpointPositionMS = 0xC; // Vector + constexpr std::ptrdiff_t m_flStanceDirectionMS = 0x18; // float + constexpr std::ptrdiff_t m_vToStrideStartPos = 0x1C; // Vector + constexpr std::ptrdiff_t m_stanceCycle = 0x28; // CAnimCycle + constexpr std::ptrdiff_t m_footLiftCycle = 0x2C; // CFootCycle + constexpr std::ptrdiff_t m_footOffCycle = 0x30; // CFootCycle + constexpr std::ptrdiff_t m_footStrikeCycle = 0x34; // CFootCycle + constexpr std::ptrdiff_t m_footLandCycle = 0x38; // CFootCycle +} + +namespace CFootCycleMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_footIndices = 0x50; // CUtlVector +} + +namespace CFootDefinition { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_ankleBoneName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_toeBoneName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_vBallOffset = 0x18; // Vector + constexpr std::ptrdiff_t m_vHeelOffset = 0x24; // Vector + constexpr std::ptrdiff_t m_flFootLength = 0x30; // float + constexpr std::ptrdiff_t m_flBindPoseDirectionMS = 0x34; // float + constexpr std::ptrdiff_t m_flTraceHeight = 0x38; // float + constexpr std::ptrdiff_t m_flTraceRadius = 0x3C; // float +} + +namespace CFootFallAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_foot = 0x38; // FootFallTagFoot_t +} + +namespace CFootLockUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_opFixedSettings = 0x68; // FootLockPoseOpFixedSettings + constexpr std::ptrdiff_t m_footSettings = 0xD0; // CUtlVector + constexpr std::ptrdiff_t m_hipShiftDamping = 0xE8; // CAnimInputDamping + constexpr std::ptrdiff_t m_rootHeightDamping = 0xF8; // CAnimInputDamping + constexpr std::ptrdiff_t m_flStrideCurveScale = 0x108; // float + constexpr std::ptrdiff_t m_flStrideCurveLimitScale = 0x10C; // float + constexpr std::ptrdiff_t m_flStepHeightIncreaseScale = 0x110; // float + constexpr std::ptrdiff_t m_flStepHeightDecreaseScale = 0x114; // float + constexpr std::ptrdiff_t m_flHipShiftScale = 0x118; // float + constexpr std::ptrdiff_t m_flBlendTime = 0x11C; // float + constexpr std::ptrdiff_t m_flMaxRootHeightOffset = 0x120; // float + constexpr std::ptrdiff_t m_flMinRootHeightOffset = 0x124; // float + constexpr std::ptrdiff_t m_flTiltPlanePitchSpringStrength = 0x128; // float + constexpr std::ptrdiff_t m_flTiltPlaneRollSpringStrength = 0x12C; // float + constexpr std::ptrdiff_t m_bApplyFootRotationLimits = 0x130; // bool + constexpr std::ptrdiff_t m_bApplyHipShift = 0x131; // bool + constexpr std::ptrdiff_t m_bModulateStepHeight = 0x132; // bool + constexpr std::ptrdiff_t m_bResetChild = 0x133; // bool + constexpr std::ptrdiff_t m_bEnableVerticalCurvedPaths = 0x134; // bool + constexpr std::ptrdiff_t m_bEnableRootHeightDamping = 0x135; // bool +} + +namespace CFootMotion { + constexpr std::ptrdiff_t m_strides = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_name = 0x18; // CUtlString + constexpr std::ptrdiff_t m_bAdditive = 0x20; // bool +} + +namespace CFootPinningUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_poseOpFixedData = 0x70; // FootPinningPoseOpFixedData_t + constexpr std::ptrdiff_t m_eTimingSource = 0xA0; // FootPinningTimingSource + constexpr std::ptrdiff_t m_params = 0xA8; // CUtlVector + constexpr std::ptrdiff_t m_bResetChild = 0xC0; // bool +} + +namespace CFootPositionMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_footIndices = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_bIgnoreSlope = 0x68; // bool +} + +namespace CFootStepTriggerUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_triggers = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_flTolerance = 0x84; // float +} + +namespace CFootStride { + constexpr std::ptrdiff_t m_definition = 0x0; // CFootCycleDefinition + constexpr std::ptrdiff_t m_trajectories = 0x40; // CFootTrajectories +} + +namespace CFootTrajectories { + constexpr std::ptrdiff_t m_trajectories = 0x0; // CUtlVector +} + +namespace CFootTrajectory { + constexpr std::ptrdiff_t m_vOffset = 0x0; // Vector + constexpr std::ptrdiff_t m_flRotationOffset = 0xC; // float + constexpr std::ptrdiff_t m_flProgression = 0x10; // float +} + +namespace CFootstepLandedAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_FootstepType = 0x38; // FootstepLandedFootSoundType_t + constexpr std::ptrdiff_t m_OverrideSoundName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_DebugAnimSourceString = 0x48; // CUtlString + constexpr std::ptrdiff_t m_BoneName = 0x50; // CUtlString +} + +namespace CFutureFacingMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_flDistance = 0x50; // float + constexpr std::ptrdiff_t m_flTime = 0x54; // float +} + +namespace CFutureVelocityMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_flDistance = 0x50; // float + constexpr std::ptrdiff_t m_flStoppingDistance = 0x54; // float + constexpr std::ptrdiff_t m_flTargetSpeed = 0x58; // float + constexpr std::ptrdiff_t m_eMode = 0x5C; // VelocityMetricMode +} + +namespace CHitBox { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_sSurfaceProperty = 0x8; // CUtlString + constexpr std::ptrdiff_t m_sBoneName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_vMinBounds = 0x18; // Vector + constexpr std::ptrdiff_t m_vMaxBounds = 0x24; // Vector + constexpr std::ptrdiff_t m_flShapeRadius = 0x30; // float + constexpr std::ptrdiff_t m_nBoneNameHash = 0x34; // uint32_t + constexpr std::ptrdiff_t m_nGroupId = 0x38; // int32_t + constexpr std::ptrdiff_t m_nShapeType = 0x3C; // uint8_t + constexpr std::ptrdiff_t m_bTranslationOnly = 0x3D; // bool + constexpr std::ptrdiff_t m_CRC = 0x40; // uint32_t + constexpr std::ptrdiff_t m_cRenderColor = 0x44; // Color + constexpr std::ptrdiff_t m_nHitBoxIndex = 0x48; // uint16_t +} + +namespace CHitBoxSet { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nNameHash = 0x8; // uint32_t + constexpr std::ptrdiff_t m_HitBoxes = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_SourceFilename = 0x28; // CUtlString +} + +namespace CHitBoxSetList { + constexpr std::ptrdiff_t m_HitBoxSets = 0x0; // CUtlVector +} + +namespace CHitReactUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_opFixedSettings = 0x68; // HitReactFixedSettings_t + constexpr std::ptrdiff_t m_triggerParam = 0xB4; // CAnimParamHandle + constexpr std::ptrdiff_t m_hitBoneParam = 0xB6; // CAnimParamHandle + constexpr std::ptrdiff_t m_hitOffsetParam = 0xB8; // CAnimParamHandle + constexpr std::ptrdiff_t m_hitDirectionParam = 0xBA; // CAnimParamHandle + constexpr std::ptrdiff_t m_hitStrengthParam = 0xBC; // CAnimParamHandle + constexpr std::ptrdiff_t m_flMinDelayBetweenHits = 0xC0; // float + constexpr std::ptrdiff_t m_bResetChild = 0xC4; // bool +} + +namespace CInputStreamUpdateNode { // CLeafUpdateNode +} + +namespace CIntAnimParameter { // CConcreteAnimParameter + constexpr std::ptrdiff_t m_defaultValue = 0x60; // int32_t + constexpr std::ptrdiff_t m_minValue = 0x64; // int32_t + constexpr std::ptrdiff_t m_maxValue = 0x68; // int32_t +} + +namespace CJiggleBoneUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_opFixedData = 0x68; // JiggleBoneSettingsList_t +} + +namespace CJumpHelperUpdateNode { // CSequenceUpdateNode + constexpr std::ptrdiff_t m_hTargetParam = 0xA8; // CAnimParamHandle + constexpr std::ptrdiff_t m_flOriginalJumpMovement = 0xAC; // Vector + constexpr std::ptrdiff_t m_flOriginalJumpDuration = 0xB8; // float + constexpr std::ptrdiff_t m_flJumpStartCycle = 0xBC; // float + constexpr std::ptrdiff_t m_flJumpEndCycle = 0xC0; // float + constexpr std::ptrdiff_t m_eCorrectionMethod = 0xC4; // JumpCorrectionMethod + constexpr std::ptrdiff_t m_bTranslationAxis = 0xC8; // bool[3] + constexpr std::ptrdiff_t m_bScaleSpeed = 0xCB; // bool +} + +namespace CLODComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_nServerLOD = 0x30; // int32_t +} + +namespace CLeafUpdateNode { // CAnimUpdateNodeBase +} + +namespace CLeanMatrixUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_frameCorners = 0x5C; // int32_t[3][3] + constexpr std::ptrdiff_t m_poses = 0x80; // CPoseHandle[9] + constexpr std::ptrdiff_t m_damping = 0xA8; // CAnimInputDamping + constexpr std::ptrdiff_t m_blendSource = 0xB8; // AnimVectorSource + constexpr std::ptrdiff_t m_paramIndex = 0xBC; // CAnimParamHandle + constexpr std::ptrdiff_t m_verticalAxis = 0xC0; // Vector + constexpr std::ptrdiff_t m_horizontalAxis = 0xCC; // Vector + constexpr std::ptrdiff_t m_hSequence = 0xD8; // HSequence + constexpr std::ptrdiff_t m_flMaxValue = 0xDC; // float + constexpr std::ptrdiff_t m_nSequenceMaxFrame = 0xE0; // int32_t +} + +namespace CLookAtUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_opFixedSettings = 0x70; // LookAtOpFixedSettings_t + constexpr std::ptrdiff_t m_target = 0x138; // AnimVectorSource + constexpr std::ptrdiff_t m_paramIndex = 0x13C; // CAnimParamHandle + constexpr std::ptrdiff_t m_weightParamIndex = 0x13E; // CAnimParamHandle + constexpr std::ptrdiff_t m_bResetChild = 0x140; // bool + constexpr std::ptrdiff_t m_bLockWhenWaning = 0x141; // bool +} + +namespace CLookComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_hLookHeading = 0x34; // CAnimParamHandle + constexpr std::ptrdiff_t m_hLookHeadingVelocity = 0x36; // CAnimParamHandle + constexpr std::ptrdiff_t m_hLookPitch = 0x38; // CAnimParamHandle + constexpr std::ptrdiff_t m_hLookDistance = 0x3A; // CAnimParamHandle + constexpr std::ptrdiff_t m_hLookDirection = 0x3C; // CAnimParamHandle + constexpr std::ptrdiff_t m_hLookTarget = 0x3E; // CAnimParamHandle + constexpr std::ptrdiff_t m_hLookTargetWorldSpace = 0x40; // CAnimParamHandle + constexpr std::ptrdiff_t m_bNetworkLookTarget = 0x42; // bool +} + +namespace CMaterialAttributeAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_AttributeName = 0x38; // CUtlString + constexpr std::ptrdiff_t m_AttributeType = 0x40; // MatterialAttributeTagType_t + constexpr std::ptrdiff_t m_flValue = 0x44; // float + constexpr std::ptrdiff_t m_Color = 0x48; // Color +} + +namespace CMaterialDrawDescriptor { + constexpr std::ptrdiff_t m_nPrimitiveType = 0x0; // RenderPrimitiveType_t + constexpr std::ptrdiff_t m_nBaseVertex = 0x4; // int32_t + constexpr std::ptrdiff_t m_nVertexCount = 0x8; // int32_t + constexpr std::ptrdiff_t m_nStartIndex = 0xC; // int32_t + constexpr std::ptrdiff_t m_nIndexCount = 0x10; // int32_t + constexpr std::ptrdiff_t m_flUvDensity = 0x14; // float + constexpr std::ptrdiff_t m_vTintColor = 0x18; // Vector + constexpr std::ptrdiff_t m_flAlpha = 0x24; // float + constexpr std::ptrdiff_t m_nFirstMeshlet = 0x2C; // uint32_t + constexpr std::ptrdiff_t m_nNumMeshlets = 0x30; // uint16_t + constexpr std::ptrdiff_t m_indexBuffer = 0xB8; // CRenderBufferBinding + constexpr std::ptrdiff_t m_material = 0xE0; // CStrongHandle +} + +namespace CMeshletDescriptor { + constexpr std::ptrdiff_t m_PackedAABB = 0x0; // PackedAABB_t + constexpr std::ptrdiff_t m_CullingData = 0x8; // CDrawCullingData +} + +namespace CModelConfig { + constexpr std::ptrdiff_t m_ConfigName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_Elements = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_bTopLevel = 0x20; // bool +} + +namespace CModelConfigElement { + constexpr std::ptrdiff_t m_ElementName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_NestedElements = 0x10; // CUtlVector +} + +namespace CModelConfigElement_AttachedModel { // CModelConfigElement + constexpr std::ptrdiff_t m_InstanceName = 0x48; // CUtlString + constexpr std::ptrdiff_t m_EntityClass = 0x50; // CUtlString + constexpr std::ptrdiff_t m_hModel = 0x58; // CStrongHandle + constexpr std::ptrdiff_t m_vOffset = 0x60; // Vector + constexpr std::ptrdiff_t m_aAngOffset = 0x6C; // QAngle + constexpr std::ptrdiff_t m_AttachmentName = 0x78; // CUtlString + constexpr std::ptrdiff_t m_LocalAttachmentOffsetName = 0x80; // CUtlString + constexpr std::ptrdiff_t m_AttachmentType = 0x88; // ModelConfigAttachmentType_t + constexpr std::ptrdiff_t m_bBoneMergeFlex = 0x8C; // bool + constexpr std::ptrdiff_t m_bUserSpecifiedColor = 0x8D; // bool + constexpr std::ptrdiff_t m_bUserSpecifiedMaterialGroup = 0x8E; // bool + constexpr std::ptrdiff_t m_bAcceptParentMaterialDrivenDecals = 0x8F; // bool + constexpr std::ptrdiff_t m_BodygroupOnOtherModels = 0x90; // CUtlString + constexpr std::ptrdiff_t m_MaterialGroupOnOtherModels = 0x98; // CUtlString +} + +namespace CModelConfigElement_Command { // CModelConfigElement + constexpr std::ptrdiff_t m_Command = 0x48; // CUtlString + constexpr std::ptrdiff_t m_Args = 0x50; // KeyValues3 +} + +namespace CModelConfigElement_RandomColor { // CModelConfigElement + constexpr std::ptrdiff_t m_Gradient = 0x48; // CColorGradient +} + +namespace CModelConfigElement_RandomPick { // CModelConfigElement + constexpr std::ptrdiff_t m_Choices = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_ChoiceWeights = 0x60; // CUtlVector +} + +namespace CModelConfigElement_SetBodygroup { // CModelConfigElement + constexpr std::ptrdiff_t m_GroupName = 0x48; // CUtlString + constexpr std::ptrdiff_t m_nChoice = 0x50; // int32_t +} + +namespace CModelConfigElement_SetBodygroupOnAttachedModels { // CModelConfigElement + constexpr std::ptrdiff_t m_GroupName = 0x48; // CUtlString + constexpr std::ptrdiff_t m_nChoice = 0x50; // int32_t +} + +namespace CModelConfigElement_SetMaterialGroup { // CModelConfigElement + constexpr std::ptrdiff_t m_MaterialGroupName = 0x48; // CUtlString +} + +namespace CModelConfigElement_SetMaterialGroupOnAttachedModels { // CModelConfigElement + constexpr std::ptrdiff_t m_MaterialGroupName = 0x48; // CUtlString +} + +namespace CModelConfigElement_SetRenderColor { // CModelConfigElement + constexpr std::ptrdiff_t m_Color = 0x48; // Color +} + +namespace CModelConfigElement_UserPick { // CModelConfigElement + constexpr std::ptrdiff_t m_Choices = 0x48; // CUtlVector +} + +namespace CModelConfigList { + constexpr std::ptrdiff_t m_bHideMaterialGroupInTools = 0x0; // bool + constexpr std::ptrdiff_t m_bHideRenderColorInTools = 0x1; // bool + constexpr std::ptrdiff_t m_Configs = 0x8; // CUtlVector +} + +namespace CMoodVData { + constexpr std::ptrdiff_t m_sModelName = 0x0; // CResourceNameTyped> + constexpr std::ptrdiff_t m_nMoodType = 0xE0; // MoodType_t + constexpr std::ptrdiff_t m_animationLayers = 0xE8; // CUtlVector +} + +namespace CMorphBundleData { + constexpr std::ptrdiff_t m_flULeftSrc = 0x0; // float + constexpr std::ptrdiff_t m_flVTopSrc = 0x4; // float + constexpr std::ptrdiff_t m_offsets = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_ranges = 0x20; // CUtlVector +} + +namespace CMorphConstraint { // CBaseConstraint + constexpr std::ptrdiff_t m_sTargetMorph = 0x70; // CUtlString + constexpr std::ptrdiff_t m_nSlaveChannel = 0x78; // int32_t + constexpr std::ptrdiff_t m_flMin = 0x7C; // float + constexpr std::ptrdiff_t m_flMax = 0x80; // float +} + +namespace CMorphData { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_morphRectDatas = 0x8; // CUtlVector +} + +namespace CMorphRectData { + constexpr std::ptrdiff_t m_nXLeftDst = 0x0; // int16_t + constexpr std::ptrdiff_t m_nYTopDst = 0x2; // int16_t + constexpr std::ptrdiff_t m_flUWidthSrc = 0x4; // float + constexpr std::ptrdiff_t m_flVHeightSrc = 0x8; // float + constexpr std::ptrdiff_t m_bundleDatas = 0x10; // CUtlVector +} + +namespace CMorphSetData { + constexpr std::ptrdiff_t m_nWidth = 0x10; // int32_t + constexpr std::ptrdiff_t m_nHeight = 0x14; // int32_t + constexpr std::ptrdiff_t m_bundleTypes = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_morphDatas = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_pTextureAtlas = 0x48; // CStrongHandle + constexpr std::ptrdiff_t m_FlexDesc = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_FlexControllers = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_FlexRules = 0x80; // CUtlVector +} + +namespace CMotionDataSet { + constexpr std::ptrdiff_t m_groups = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_nDimensionCount = 0x18; // int32_t +} + +namespace CMotionGraph { + constexpr std::ptrdiff_t m_paramSpans = 0x10; // CParamSpanUpdater + constexpr std::ptrdiff_t m_tags = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_pRootNode = 0x40; // CSmartPtr + constexpr std::ptrdiff_t m_nParameterCount = 0x48; // int32_t + constexpr std::ptrdiff_t m_nConfigStartIndex = 0x4C; // int32_t + constexpr std::ptrdiff_t m_nConfigCount = 0x50; // int32_t + constexpr std::ptrdiff_t m_bLoop = 0x54; // bool +} + +namespace CMotionGraphConfig { + constexpr std::ptrdiff_t m_paramValues = 0x0; // float[4] + constexpr std::ptrdiff_t m_flDuration = 0x10; // float + constexpr std::ptrdiff_t m_nMotionIndex = 0x14; // MotionIndex + constexpr std::ptrdiff_t m_nSampleStart = 0x18; // int32_t + constexpr std::ptrdiff_t m_nSampleCount = 0x1C; // int32_t +} + +namespace CMotionGraphGroup { + constexpr std::ptrdiff_t m_searchDB = 0x0; // CMotionSearchDB + constexpr std::ptrdiff_t m_motionGraphs = 0xB8; // CUtlVector> + constexpr std::ptrdiff_t m_motionGraphConfigs = 0xD0; // CUtlVector + constexpr std::ptrdiff_t m_sampleToConfig = 0xE8; // CUtlVector + constexpr std::ptrdiff_t m_hIsActiveScript = 0x100; // AnimScriptHandle +} + +namespace CMotionGraphUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_pMotionGraph = 0x58; // CSmartPtr +} + +namespace CMotionMatchingUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_dataSet = 0x58; // CMotionDataSet + constexpr std::ptrdiff_t m_metrics = 0x78; // CUtlVector> + constexpr std::ptrdiff_t m_weights = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_bSearchEveryTick = 0xE0; // bool + constexpr std::ptrdiff_t m_flSearchInterval = 0xE4; // float + constexpr std::ptrdiff_t m_bSearchWhenClipEnds = 0xE8; // bool + constexpr std::ptrdiff_t m_bSearchWhenGoalChanges = 0xE9; // bool + constexpr std::ptrdiff_t m_blendCurve = 0xEC; // CBlendCurve + constexpr std::ptrdiff_t m_flSampleRate = 0xF4; // float + constexpr std::ptrdiff_t m_flBlendTime = 0xF8; // float + constexpr std::ptrdiff_t m_bLockClipWhenWaning = 0xFC; // bool + constexpr std::ptrdiff_t m_flSelectionThreshold = 0x100; // float + constexpr std::ptrdiff_t m_flReselectionTimeWindow = 0x104; // float + constexpr std::ptrdiff_t m_bEnableRotationCorrection = 0x108; // bool + constexpr std::ptrdiff_t m_bGoalAssist = 0x109; // bool + constexpr std::ptrdiff_t m_flGoalAssistDistance = 0x10C; // float + constexpr std::ptrdiff_t m_flGoalAssistTolerance = 0x110; // float + constexpr std::ptrdiff_t m_distanceScale_Damping = 0x118; // CAnimInputDamping + constexpr std::ptrdiff_t m_flDistanceScale_OuterRadius = 0x128; // float + constexpr std::ptrdiff_t m_flDistanceScale_InnerRadius = 0x12C; // float + constexpr std::ptrdiff_t m_flDistanceScale_MaxScale = 0x130; // float + constexpr std::ptrdiff_t m_flDistanceScale_MinScale = 0x134; // float + constexpr std::ptrdiff_t m_bEnableDistanceScaling = 0x138; // bool +} + +namespace CMotionMetricEvaluator { + constexpr std::ptrdiff_t m_means = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_standardDeviations = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_flWeight = 0x48; // float + constexpr std::ptrdiff_t m_nDimensionStartIndex = 0x4C; // int32_t +} + +namespace CMotionNode { + constexpr std::ptrdiff_t m_name = 0x18; // CUtlString + constexpr std::ptrdiff_t m_id = 0x20; // AnimNodeID +} + +namespace CMotionNodeBlend1D { // CMotionNode + constexpr std::ptrdiff_t m_blendItems = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_nParamIndex = 0x40; // int32_t +} + +namespace CMotionNodeSequence { // CMotionNode + constexpr std::ptrdiff_t m_tags = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_hSequence = 0x40; // HSequence + constexpr std::ptrdiff_t m_flPlaybackSpeed = 0x44; // float +} + +namespace CMotionSearchDB { + constexpr std::ptrdiff_t m_rootNode = 0x0; // CMotionSearchNode + constexpr std::ptrdiff_t m_residualQuantizer = 0x80; // CProductQuantizer + constexpr std::ptrdiff_t m_codeIndices = 0xA0; // CUtlVector +} + +namespace CMotionSearchNode { + constexpr std::ptrdiff_t m_children = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_quantizer = 0x18; // CVectorQuantizer + constexpr std::ptrdiff_t m_sampleCodes = 0x38; // CUtlVector> + constexpr std::ptrdiff_t m_sampleIndices = 0x50; // CUtlVector> + constexpr std::ptrdiff_t m_selectableSamples = 0x68; // CUtlVector +} + +namespace CMovementComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_movementModes = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_motors = 0x48; // CUtlVector> + constexpr std::ptrdiff_t m_facingDamping = 0x60; // CAnimInputDamping + constexpr std::ptrdiff_t m_eDefaultFacingMode = 0x70; // FacingMode + constexpr std::ptrdiff_t m_nDefaultMotorIndex = 0x7C; // int32_t + constexpr std::ptrdiff_t m_bMoveVarsDisabled = 0x80; // bool + constexpr std::ptrdiff_t m_bNetworkPath = 0x81; // bool + constexpr std::ptrdiff_t m_bNetworkFacing = 0x82; // bool + constexpr std::ptrdiff_t m_paramHandles = 0x83; // CAnimParamHandle[30] +} + +namespace CMovementMode { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_flSpeed = 0x8; // float +} + +namespace CMoverUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_damping = 0x70; // CAnimInputDamping + constexpr std::ptrdiff_t m_facingTarget = 0x80; // AnimValueSource + constexpr std::ptrdiff_t m_hMoveVecParam = 0x84; // CAnimParamHandle + constexpr std::ptrdiff_t m_hMoveHeadingParam = 0x86; // CAnimParamHandle + constexpr std::ptrdiff_t m_hTurnToFaceParam = 0x88; // CAnimParamHandle + constexpr std::ptrdiff_t m_flTurnToFaceOffset = 0x8C; // float + constexpr std::ptrdiff_t m_flTurnToFaceLimit = 0x90; // float + constexpr std::ptrdiff_t m_bAdditive = 0x94; // bool + constexpr std::ptrdiff_t m_bApplyMovement = 0x95; // bool + constexpr std::ptrdiff_t m_bOrientMovement = 0x96; // bool + constexpr std::ptrdiff_t m_bApplyRotation = 0x97; // bool + constexpr std::ptrdiff_t m_bLimitOnly = 0x98; // bool +} + +namespace COrientConstraint { // CBaseConstraint +} + +namespace CParamSpanUpdater { + constexpr std::ptrdiff_t m_spans = 0x0; // CUtlVector +} + +namespace CParentConstraint { // CBaseConstraint +} + +namespace CParticleAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_hParticleSystem = 0x38; // CStrongHandle + constexpr std::ptrdiff_t m_particleSystemName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_configName = 0x48; // CUtlString + constexpr std::ptrdiff_t m_bDetachFromOwner = 0x50; // bool + constexpr std::ptrdiff_t m_bStopWhenTagEnds = 0x51; // bool + constexpr std::ptrdiff_t m_bTagEndStopIsInstant = 0x52; // bool + constexpr std::ptrdiff_t m_attachmentName = 0x58; // CUtlString + constexpr std::ptrdiff_t m_attachmentType = 0x60; // ParticleAttachment_t + constexpr std::ptrdiff_t m_attachmentCP1Name = 0x68; // CUtlString + constexpr std::ptrdiff_t m_attachmentCP1Type = 0x70; // ParticleAttachment_t +} + +namespace CPathAnimMotorUpdater { // CPathAnimMotorUpdaterBase +} + +namespace CPathAnimMotorUpdaterBase { // CAnimMotorUpdaterBase + constexpr std::ptrdiff_t m_bLockToPath = 0x20; // bool +} + +namespace CPathHelperUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_flStoppingRadius = 0x68; // float + constexpr std::ptrdiff_t m_flStoppingSpeedScale = 0x6C; // float +} + +namespace CPathMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_pathTimeSamples = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_flDistance = 0x68; // float + constexpr std::ptrdiff_t m_bExtrapolateMovement = 0x6C; // bool + constexpr std::ptrdiff_t m_flMinExtrapolationSpeed = 0x70; // float +} + +namespace CPhysSurfaceProperties { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nameHash = 0x8; // uint32_t + constexpr std::ptrdiff_t m_baseNameHash = 0xC; // uint32_t + constexpr std::ptrdiff_t m_bHidden = 0x18; // bool + constexpr std::ptrdiff_t m_description = 0x20; // CUtlString + constexpr std::ptrdiff_t m_physics = 0x28; // CPhysSurfacePropertiesPhysics + constexpr std::ptrdiff_t m_audioSounds = 0x48; // CPhysSurfacePropertiesSoundNames + constexpr std::ptrdiff_t m_audioParams = 0x88; // CPhysSurfacePropertiesAudio +} + +namespace CPhysSurfacePropertiesAudio { + constexpr std::ptrdiff_t m_reflectivity = 0x0; // float + constexpr std::ptrdiff_t m_hardnessFactor = 0x4; // float + constexpr std::ptrdiff_t m_roughnessFactor = 0x8; // float + constexpr std::ptrdiff_t m_roughThreshold = 0xC; // float + constexpr std::ptrdiff_t m_hardThreshold = 0x10; // float + constexpr std::ptrdiff_t m_hardVelocityThreshold = 0x14; // float + constexpr std::ptrdiff_t m_flStaticImpactVolume = 0x18; // float + constexpr std::ptrdiff_t m_flOcclusionFactor = 0x1C; // float +} + +namespace CPhysSurfacePropertiesPhysics { + constexpr std::ptrdiff_t m_friction = 0x0; // float + constexpr std::ptrdiff_t m_elasticity = 0x4; // float + constexpr std::ptrdiff_t m_density = 0x8; // float + constexpr std::ptrdiff_t m_thickness = 0xC; // float + constexpr std::ptrdiff_t m_softContactFrequency = 0x10; // float + constexpr std::ptrdiff_t m_softContactDampingRatio = 0x14; // float + constexpr std::ptrdiff_t m_wheelDrag = 0x18; // float +} + +namespace CPhysSurfacePropertiesSoundNames { + constexpr std::ptrdiff_t m_impactSoft = 0x0; // CUtlString + constexpr std::ptrdiff_t m_impactHard = 0x8; // CUtlString + constexpr std::ptrdiff_t m_scrapeSmooth = 0x10; // CUtlString + constexpr std::ptrdiff_t m_scrapeRough = 0x18; // CUtlString + constexpr std::ptrdiff_t m_bulletImpact = 0x20; // CUtlString + constexpr std::ptrdiff_t m_rolling = 0x28; // CUtlString + constexpr std::ptrdiff_t m_break = 0x30; // CUtlString + constexpr std::ptrdiff_t m_strain = 0x38; // CUtlString +} + +namespace CPlayerInputAnimMotorUpdater { // CAnimMotorUpdaterBase + constexpr std::ptrdiff_t m_sampleTimes = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_flSpringConstant = 0x3C; // float + constexpr std::ptrdiff_t m_flAnticipationDistance = 0x40; // float + constexpr std::ptrdiff_t m_hAnticipationPosParam = 0x44; // CAnimParamHandle + constexpr std::ptrdiff_t m_hAnticipationHeadingParam = 0x46; // CAnimParamHandle + constexpr std::ptrdiff_t m_bUseAcceleration = 0x48; // bool +} + +namespace CPointConstraint { // CBaseConstraint +} + +namespace CPoseHandle { + constexpr std::ptrdiff_t m_nIndex = 0x0; // uint16_t + constexpr std::ptrdiff_t m_eType = 0x2; // PoseType_t +} + +namespace CProductQuantizer { + constexpr std::ptrdiff_t m_subQuantizers = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_nDimensions = 0x18; // int32_t +} + +namespace CQuaternionAnimParameter { // CConcreteAnimParameter + constexpr std::ptrdiff_t m_defaultValue = 0x60; // Quaternion + constexpr std::ptrdiff_t m_bInterpolate = 0x70; // bool +} + +namespace CRagdollAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_nPoseControl = 0x38; // AnimPoseControl + constexpr std::ptrdiff_t m_flFrequency = 0x3C; // float + constexpr std::ptrdiff_t m_flDampingRatio = 0x40; // float + constexpr std::ptrdiff_t m_flDecayDuration = 0x44; // float + constexpr std::ptrdiff_t m_flDecayBias = 0x48; // float + constexpr std::ptrdiff_t m_bDestroy = 0x4C; // bool +} + +namespace CRagdollComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_ragdollNodePaths = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_boneIndices = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_boneNames = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_weightLists = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_flSpringFrequencyMin = 0x90; // float + constexpr std::ptrdiff_t m_flSpringFrequencyMax = 0x94; // float + constexpr std::ptrdiff_t m_flMaxStretch = 0x98; // float +} + +namespace CRagdollUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_nWeightListIndex = 0x68; // int32_t + constexpr std::ptrdiff_t m_poseControlMethod = 0x6C; // RagdollPoseControl +} + +namespace CRenderBufferBinding { + constexpr std::ptrdiff_t m_hBuffer = 0x0; // uint64_t + constexpr std::ptrdiff_t m_nBindOffsetBytes = 0x10; // uint32_t +} + +namespace CRenderMesh { + constexpr std::ptrdiff_t m_sceneObjects = 0x10; // CUtlVectorFixedGrowable + constexpr std::ptrdiff_t m_constraints = 0xA0; // CUtlVector + constexpr std::ptrdiff_t m_skeleton = 0xB8; // CRenderSkeleton +} + +namespace CRenderSkeleton { + constexpr std::ptrdiff_t m_bones = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_boneParents = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_nBoneWeightCount = 0x48; // int32_t +} + +namespace CRootUpdateNode { // CUnaryUpdateNode +} + +namespace CSceneObjectData { + constexpr std::ptrdiff_t m_vMinBounds = 0x0; // Vector + constexpr std::ptrdiff_t m_vMaxBounds = 0xC; // Vector + constexpr std::ptrdiff_t m_drawCalls = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_drawBounds = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_meshlets = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_vTintColor = 0x60; // Vector4D +} + +namespace CSelectorUpdateNode { // CAnimUpdateNodeBase + constexpr std::ptrdiff_t m_children = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_tags = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_blendCurve = 0x8C; // CBlendCurve + constexpr std::ptrdiff_t m_flBlendTime = 0x94; // CAnimValue + constexpr std::ptrdiff_t m_hParameter = 0x9C; // CAnimParamHandle + constexpr std::ptrdiff_t m_eTagBehavior = 0xA0; // SelectorTagBehavior_t + constexpr std::ptrdiff_t m_bResetOnChange = 0xA4; // bool + constexpr std::ptrdiff_t m_bSyncCyclesOnChange = 0xA5; // bool +} + +namespace CSeqAutoLayer { + constexpr std::ptrdiff_t m_nLocalReference = 0x0; // int16_t + constexpr std::ptrdiff_t m_nLocalPose = 0x2; // int16_t + constexpr std::ptrdiff_t m_flags = 0x4; // CSeqAutoLayerFlag + constexpr std::ptrdiff_t m_start = 0xC; // float + constexpr std::ptrdiff_t m_peak = 0x10; // float + constexpr std::ptrdiff_t m_tail = 0x14; // float + constexpr std::ptrdiff_t m_end = 0x18; // float +} + +namespace CSeqAutoLayerFlag { + constexpr std::ptrdiff_t m_bPost = 0x0; // bool + constexpr std::ptrdiff_t m_bSpline = 0x1; // bool + constexpr std::ptrdiff_t m_bXFade = 0x2; // bool + constexpr std::ptrdiff_t m_bNoBlend = 0x3; // bool + constexpr std::ptrdiff_t m_bLocal = 0x4; // bool + constexpr std::ptrdiff_t m_bPose = 0x5; // bool + constexpr std::ptrdiff_t m_bFetchFrame = 0x6; // bool + constexpr std::ptrdiff_t m_bSubtract = 0x7; // bool +} + +namespace CSeqBoneMaskList { + constexpr std::ptrdiff_t m_sName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_nLocalBoneArray = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_flBoneWeightArray = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_flDefaultMorphCtrlWeight = 0x40; // float + constexpr std::ptrdiff_t m_morphCtrlWeightArray = 0x48; // CUtlVector> +} + +namespace CSeqCmdLayer { + constexpr std::ptrdiff_t m_cmd = 0x0; // int16_t + constexpr std::ptrdiff_t m_nLocalReference = 0x2; // int16_t + constexpr std::ptrdiff_t m_nLocalBonemask = 0x4; // int16_t + constexpr std::ptrdiff_t m_nDstResult = 0x6; // int16_t + constexpr std::ptrdiff_t m_nSrcResult = 0x8; // int16_t + constexpr std::ptrdiff_t m_bSpline = 0xA; // bool + constexpr std::ptrdiff_t m_flVar1 = 0xC; // float + constexpr std::ptrdiff_t m_flVar2 = 0x10; // float + constexpr std::ptrdiff_t m_nLineNumber = 0x14; // int16_t +} + +namespace CSeqCmdSeqDesc { + constexpr std::ptrdiff_t m_sName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_flags = 0x10; // CSeqSeqDescFlag + constexpr std::ptrdiff_t m_transition = 0x1C; // CSeqTransition + constexpr std::ptrdiff_t m_nFrameRangeSequence = 0x24; // int16_t + constexpr std::ptrdiff_t m_nFrameCount = 0x26; // int16_t + constexpr std::ptrdiff_t m_flFPS = 0x28; // float + constexpr std::ptrdiff_t m_nSubCycles = 0x2C; // int16_t + constexpr std::ptrdiff_t m_numLocalResults = 0x2E; // int16_t + constexpr std::ptrdiff_t m_cmdLayerArray = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_eventArray = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_activityArray = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_poseSettingArray = 0x78; // CUtlVector +} + +namespace CSeqIKLock { + constexpr std::ptrdiff_t m_flPosWeight = 0x0; // float + constexpr std::ptrdiff_t m_flAngleWeight = 0x4; // float + constexpr std::ptrdiff_t m_nLocalBone = 0x8; // int16_t + constexpr std::ptrdiff_t m_bBonesOrientedAlongPositiveX = 0xA; // bool +} + +namespace CSeqMultiFetch { + constexpr std::ptrdiff_t m_flags = 0x0; // CSeqMultiFetchFlag + constexpr std::ptrdiff_t m_localReferenceArray = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_nGroupSize = 0x20; // int32_t[2] + constexpr std::ptrdiff_t m_nLocalPose = 0x28; // int32_t[2] + constexpr std::ptrdiff_t m_poseKeyArray0 = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_poseKeyArray1 = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_nLocalCyclePoseParameter = 0x60; // int32_t + constexpr std::ptrdiff_t m_bCalculatePoseParameters = 0x64; // bool +} + +namespace CSeqMultiFetchFlag { + constexpr std::ptrdiff_t m_bRealtime = 0x0; // bool + constexpr std::ptrdiff_t m_bCylepose = 0x1; // bool + constexpr std::ptrdiff_t m_b0D = 0x2; // bool + constexpr std::ptrdiff_t m_b1D = 0x3; // bool + constexpr std::ptrdiff_t m_b2D = 0x4; // bool + constexpr std::ptrdiff_t m_b2D_TRI = 0x5; // bool +} + +namespace CSeqPoseParamDesc { + constexpr std::ptrdiff_t m_sName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_flStart = 0x10; // float + constexpr std::ptrdiff_t m_flEnd = 0x14; // float + constexpr std::ptrdiff_t m_flLoop = 0x18; // float + constexpr std::ptrdiff_t m_bLooping = 0x1C; // bool +} + +namespace CSeqPoseSetting { + constexpr std::ptrdiff_t m_sPoseParameter = 0x0; // CBufferString + constexpr std::ptrdiff_t m_sAttachment = 0x10; // CBufferString + constexpr std::ptrdiff_t m_sReferenceSequence = 0x20; // CBufferString + constexpr std::ptrdiff_t m_flValue = 0x30; // float + constexpr std::ptrdiff_t m_bX = 0x34; // bool + constexpr std::ptrdiff_t m_bY = 0x35; // bool + constexpr std::ptrdiff_t m_bZ = 0x36; // bool + constexpr std::ptrdiff_t m_eType = 0x38; // int32_t +} + +namespace CSeqS1SeqDesc { + constexpr std::ptrdiff_t m_sName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_flags = 0x10; // CSeqSeqDescFlag + constexpr std::ptrdiff_t m_fetch = 0x20; // CSeqMultiFetch + constexpr std::ptrdiff_t m_nLocalWeightlist = 0x88; // int32_t + constexpr std::ptrdiff_t m_autoLayerArray = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_IKLockArray = 0xA8; // CUtlVector + constexpr std::ptrdiff_t m_transition = 0xC0; // CSeqTransition + constexpr std::ptrdiff_t m_SequenceKeys = 0xC8; // KeyValues3 + constexpr std::ptrdiff_t m_LegacyKeyValueText = 0xD8; // CBufferString + constexpr std::ptrdiff_t m_activityArray = 0xE8; // CUtlVector + constexpr std::ptrdiff_t m_footMotion = 0x100; // CUtlVector +} + +namespace CSeqScaleSet { + constexpr std::ptrdiff_t m_sName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_bRootOffset = 0x10; // bool + constexpr std::ptrdiff_t m_vRootOffset = 0x14; // Vector + constexpr std::ptrdiff_t m_nLocalBoneArray = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_flBoneScaleArray = 0x38; // CUtlVector +} + +namespace CSeqSeqDescFlag { + constexpr std::ptrdiff_t m_bLooping = 0x0; // bool + constexpr std::ptrdiff_t m_bSnap = 0x1; // bool + constexpr std::ptrdiff_t m_bAutoplay = 0x2; // bool + constexpr std::ptrdiff_t m_bPost = 0x3; // bool + constexpr std::ptrdiff_t m_bHidden = 0x4; // bool + constexpr std::ptrdiff_t m_bMulti = 0x5; // bool + constexpr std::ptrdiff_t m_bLegacyDelta = 0x6; // bool + constexpr std::ptrdiff_t m_bLegacyWorldspace = 0x7; // bool + constexpr std::ptrdiff_t m_bLegacyCyclepose = 0x8; // bool + constexpr std::ptrdiff_t m_bLegacyRealtime = 0x9; // bool + constexpr std::ptrdiff_t m_bModelDoc = 0xA; // bool +} + +namespace CSeqSynthAnimDesc { + constexpr std::ptrdiff_t m_sName = 0x0; // CBufferString + constexpr std::ptrdiff_t m_flags = 0x10; // CSeqSeqDescFlag + constexpr std::ptrdiff_t m_transition = 0x1C; // CSeqTransition + constexpr std::ptrdiff_t m_nLocalBaseReference = 0x24; // int16_t + constexpr std::ptrdiff_t m_nLocalBoneMask = 0x26; // int16_t + constexpr std::ptrdiff_t m_activityArray = 0x28; // CUtlVector +} + +namespace CSeqTransition { + constexpr std::ptrdiff_t m_flFadeInTime = 0x0; // float + constexpr std::ptrdiff_t m_flFadeOutTime = 0x4; // float +} + +namespace CSequenceFinishedAnimTag { // CAnimTagBase + constexpr std::ptrdiff_t m_sequenceName = 0x38; // CUtlString +} + +namespace CSequenceGroupData { + constexpr std::ptrdiff_t m_sName = 0x10; // CBufferString + constexpr std::ptrdiff_t m_nFlags = 0x20; // uint32_t + constexpr std::ptrdiff_t m_localSequenceNameArray = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_localS1SeqDescArray = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_localMultiSeqDescArray = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_localSynthAnimDescArray = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_localCmdSeqDescArray = 0x88; // CUtlVector + constexpr std::ptrdiff_t m_localBoneMaskArray = 0xA0; // CUtlVector + constexpr std::ptrdiff_t m_localScaleSetArray = 0xB8; // CUtlVector + constexpr std::ptrdiff_t m_localBoneNameArray = 0xD0; // CUtlVector + constexpr std::ptrdiff_t m_localNodeName = 0xE8; // CBufferString + constexpr std::ptrdiff_t m_localPoseParamArray = 0xF8; // CUtlVector + constexpr std::ptrdiff_t m_keyValues = 0x110; // KeyValues3 + constexpr std::ptrdiff_t m_localIKAutoplayLockArray = 0x120; // CUtlVector +} + +namespace CSequenceUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_paramSpans = 0x60; // CParamSpanUpdater + constexpr std::ptrdiff_t m_tags = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_hSequence = 0x94; // HSequence + constexpr std::ptrdiff_t m_playbackSpeed = 0x98; // float + constexpr std::ptrdiff_t m_duration = 0x9C; // float + constexpr std::ptrdiff_t m_bLoop = 0xA0; // bool +} + +namespace CSetFacingUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_facingMode = 0x68; // FacingMode + constexpr std::ptrdiff_t m_bResetChild = 0x6C; // bool +} + +namespace CSetParameterActionUpdater { // CAnimActionUpdater + constexpr std::ptrdiff_t m_hParam = 0x18; // CAnimParamHandle + constexpr std::ptrdiff_t m_value = 0x1A; // CAnimVariant +} + +namespace CSingleFrameUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_actions = 0x58; // CUtlVector> + constexpr std::ptrdiff_t m_hPoseCacheHandle = 0x70; // CPoseHandle + constexpr std::ptrdiff_t m_hSequence = 0x74; // HSequence + constexpr std::ptrdiff_t m_flCycle = 0x78; // float +} + +namespace CSkeletalInputUpdateNode { // CLeafUpdateNode + constexpr std::ptrdiff_t m_fixedOpData = 0x58; // SkeletalInputOpFixedSettings_t +} + +namespace CSlopeComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_flTraceDistance = 0x34; // float + constexpr std::ptrdiff_t m_hSlopeAngle = 0x38; // CAnimParamHandle + constexpr std::ptrdiff_t m_hSlopeAngleFront = 0x3A; // CAnimParamHandle + constexpr std::ptrdiff_t m_hSlopeAngleSide = 0x3C; // CAnimParamHandle + constexpr std::ptrdiff_t m_hSlopeHeading = 0x3E; // CAnimParamHandle + constexpr std::ptrdiff_t m_hSlopeNormal = 0x40; // CAnimParamHandle + constexpr std::ptrdiff_t m_hSlopeNormal_WorldSpace = 0x42; // CAnimParamHandle +} + +namespace CSlowDownOnSlopesUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_flSlowDownStrength = 0x68; // float +} + +namespace CSolveIKChainUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_targetHandles = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_opFixedData = 0x80; // SolveIKChainPoseOpFixedSettings_t +} + +namespace CSolveIKTargetHandle_t { + constexpr std::ptrdiff_t m_positionHandle = 0x0; // CAnimParamHandle + constexpr std::ptrdiff_t m_orientationHandle = 0x2; // CAnimParamHandle +} + +namespace CSpeedScaleUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_paramIndex = 0x68; // CAnimParamHandle +} + +namespace CStanceOverrideUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_footStanceInfo = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_pStanceSourceNode = 0x80; // CAnimUpdateNodeRef + constexpr std::ptrdiff_t m_hParameter = 0x90; // CAnimParamHandle + constexpr std::ptrdiff_t m_eMode = 0x94; // StanceOverrideMode +} + +namespace CStanceScaleUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_hParam = 0x68; // CAnimParamHandle +} + +namespace CStateActionUpdater { + constexpr std::ptrdiff_t m_pAction = 0x0; // CSmartPtr + constexpr std::ptrdiff_t m_eBehavior = 0x8; // StateActionBehavior +} + +namespace CStateMachineComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_stateMachine = 0x30; // CAnimStateMachineUpdater +} + +namespace CStateMachineUpdateNode { // CAnimUpdateNodeBase + constexpr std::ptrdiff_t m_stateMachine = 0x68; // CAnimStateMachineUpdater + constexpr std::ptrdiff_t m_stateData = 0xC0; // CUtlVector + constexpr std::ptrdiff_t m_transitionData = 0xD8; // CUtlVector + constexpr std::ptrdiff_t m_bBlockWaningTags = 0xF4; // bool + constexpr std::ptrdiff_t m_bLockStateWhenWaning = 0xF5; // bool +} + +namespace CStateNodeStateData { + constexpr std::ptrdiff_t m_pChild = 0x0; // CAnimUpdateNodeRef + constexpr std::ptrdiff_t m_bExclusiveRootMotion = 0x0; // bitfield:1 +} + +namespace CStateNodeTransitionData { + constexpr std::ptrdiff_t m_curve = 0x0; // CBlendCurve + constexpr std::ptrdiff_t m_blendDuration = 0x8; // CAnimValue + constexpr std::ptrdiff_t m_resetCycleValue = 0x10; // CAnimValue + constexpr std::ptrdiff_t m_bReset = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_resetCycleOption = 0x0; // bitfield:3 +} + +namespace CStateUpdateData { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_hScript = 0x8; // AnimScriptHandle + constexpr std::ptrdiff_t m_transitionIndices = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_actions = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_stateID = 0x40; // AnimStateID + constexpr std::ptrdiff_t m_bIsStartState = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bIsEndState = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bIsPassthrough = 0x0; // bitfield:1 +} + +namespace CStaticPoseCache { + constexpr std::ptrdiff_t m_poses = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_nBoneCount = 0x28; // int32_t + constexpr std::ptrdiff_t m_nMorphCount = 0x2C; // int32_t +} + +namespace CStaticPoseCacheBuilder { // CStaticPoseCache +} + +namespace CStepsRemainingMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_footIndices = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_flMinStepsRemaining = 0x68; // float +} + +namespace CStopAtGoalUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_flOuterRadius = 0x6C; // float + constexpr std::ptrdiff_t m_flInnerRadius = 0x70; // float + constexpr std::ptrdiff_t m_flMaxScale = 0x74; // float + constexpr std::ptrdiff_t m_flMinScale = 0x78; // float + constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping +} + +namespace CStringAnimTag { // CAnimTagBase +} + +namespace CSubtractUpdateNode { // CBinaryUpdateNode + constexpr std::ptrdiff_t m_footMotionTiming = 0x8C; // BinaryNodeChildOption + constexpr std::ptrdiff_t m_bApplyToFootMotion = 0x90; // bool + constexpr std::ptrdiff_t m_bApplyChannelsSeparately = 0x91; // bool + constexpr std::ptrdiff_t m_bUseModelSpace = 0x92; // bool +} + +namespace CTaskStatusAnimTag { // CAnimTagBase +} + +namespace CTiltTwistConstraint { // CBaseConstraint + constexpr std::ptrdiff_t m_nTargetAxis = 0x70; // int32_t + constexpr std::ptrdiff_t m_nSlaveAxis = 0x74; // int32_t +} + +namespace CTimeRemainingMetricEvaluator { // CMotionMetricEvaluator + constexpr std::ptrdiff_t m_bMatchByTimeRemaining = 0x50; // bool + constexpr std::ptrdiff_t m_flMaxTimeRemaining = 0x54; // float + constexpr std::ptrdiff_t m_bFilterByTimeRemaining = 0x58; // bool + constexpr std::ptrdiff_t m_flMinTimeRemaining = 0x5C; // float +} + +namespace CToggleComponentActionUpdater { // CAnimActionUpdater + constexpr std::ptrdiff_t m_componentID = 0x18; // AnimComponentID + constexpr std::ptrdiff_t m_bSetEnabled = 0x1C; // bool +} + +namespace CTransitionUpdateData { + constexpr std::ptrdiff_t m_srcStateIndex = 0x0; // uint8_t + constexpr std::ptrdiff_t m_destStateIndex = 0x1; // uint8_t + constexpr std::ptrdiff_t m_bDisabled = 0x0; // bitfield:1 +} + +namespace CTurnHelperUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_facingTarget = 0x6C; // AnimValueSource + constexpr std::ptrdiff_t m_turnStartTimeOffset = 0x70; // float + constexpr std::ptrdiff_t m_turnDuration = 0x74; // float + constexpr std::ptrdiff_t m_bMatchChildDuration = 0x78; // bool + constexpr std::ptrdiff_t m_manualTurnOffset = 0x7C; // float + constexpr std::ptrdiff_t m_bUseManualTurnOffset = 0x80; // bool +} + +namespace CTwistConstraint { // CBaseConstraint + constexpr std::ptrdiff_t m_bInverse = 0x70; // bool + constexpr std::ptrdiff_t m_qParentBindRotation = 0x80; // Quaternion + constexpr std::ptrdiff_t m_qChildBindRotation = 0x90; // Quaternion +} + +namespace CTwoBoneIKUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_opFixedData = 0x70; // TwoBoneIKSettings_t +} + +namespace CUnaryUpdateNode { // CAnimUpdateNodeBase + constexpr std::ptrdiff_t m_pChildNode = 0x58; // CAnimUpdateNodeRef +} + +namespace CVPhysXSurfacePropertiesList { + constexpr std::ptrdiff_t m_surfacePropertiesList = 0x0; // CUtlVector +} + +namespace CVRInputComponentUpdater { // CAnimComponentUpdater + constexpr std::ptrdiff_t m_FingerCurl_Thumb = 0x34; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerCurl_Index = 0x36; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerCurl_Middle = 0x38; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerCurl_Ring = 0x3A; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerCurl_Pinky = 0x3C; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerSplay_Thumb_Index = 0x3E; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerSplay_Index_Middle = 0x40; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerSplay_Middle_Ring = 0x42; // CAnimParamHandle + constexpr std::ptrdiff_t m_FingerSplay_Ring_Pinky = 0x44; // CAnimParamHandle +} + +namespace CVectorAnimParameter { // CConcreteAnimParameter + constexpr std::ptrdiff_t m_defaultValue = 0x60; // Vector + constexpr std::ptrdiff_t m_bInterpolate = 0x6C; // bool +} + +namespace CVectorQuantizer { + constexpr std::ptrdiff_t m_centroidVectors = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_nCentroids = 0x18; // int32_t + constexpr std::ptrdiff_t m_nDimensions = 0x1C; // int32_t +} + +namespace CVirtualAnimParameter { // CAnimParameterBase + constexpr std::ptrdiff_t m_expressionString = 0x50; // CUtlString + constexpr std::ptrdiff_t m_eParamType = 0x58; // AnimParamType_t +} + +namespace CVrSkeletalInputSettings { + constexpr std::ptrdiff_t m_wristBones = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_fingers = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_name = 0x30; // CUtlString + constexpr std::ptrdiff_t m_outerKnuckle1 = 0x38; // CUtlString + constexpr std::ptrdiff_t m_outerKnuckle2 = 0x40; // CUtlString + constexpr std::ptrdiff_t m_eHand = 0x48; // AnimVRHand_t +} + +namespace CWayPointHelperUpdateNode { // CUnaryUpdateNode + constexpr std::ptrdiff_t m_flStartCycle = 0x6C; // float + constexpr std::ptrdiff_t m_flEndCycle = 0x70; // float + constexpr std::ptrdiff_t m_bOnlyGoals = 0x74; // bool + constexpr std::ptrdiff_t m_bPreventOvershoot = 0x75; // bool + constexpr std::ptrdiff_t m_bPreventUndershoot = 0x76; // bool +} + +namespace CWristBone { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_vForwardLS = 0x8; // Vector + constexpr std::ptrdiff_t m_vUpLS = 0x14; // Vector + constexpr std::ptrdiff_t m_vOffset = 0x20; // Vector +} + +namespace CZeroPoseUpdateNode { // CLeafUpdateNode +} + +namespace ChainToSolveData_t { + constexpr std::ptrdiff_t m_nChainIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_SolverSettings = 0x4; // IKSolverSettings_t + constexpr std::ptrdiff_t m_TargetSettings = 0x10; // IKTargetSettings_t + constexpr std::ptrdiff_t m_DebugSetting = 0x38; // SolveIKChainAnimNodeDebugSetting + constexpr std::ptrdiff_t m_flDebugNormalizedValue = 0x3C; // float + constexpr std::ptrdiff_t m_vDebugOffset = 0x40; // VectorAligned +} + +namespace ConfigIndex { + constexpr std::ptrdiff_t m_nGroup = 0x0; // uint16_t + constexpr std::ptrdiff_t m_nConfig = 0x2; // uint16_t +} + +namespace FingerBone_t { + constexpr std::ptrdiff_t m_boneIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_hingeAxis = 0x4; // Vector + constexpr std::ptrdiff_t m_vCapsulePos1 = 0x10; // Vector + constexpr std::ptrdiff_t m_vCapsulePos2 = 0x1C; // Vector + constexpr std::ptrdiff_t m_flMinAngle = 0x28; // float + constexpr std::ptrdiff_t m_flMaxAngle = 0x2C; // float + constexpr std::ptrdiff_t m_flRadius = 0x30; // float +} + +namespace FingerChain_t { + constexpr std::ptrdiff_t m_targets = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_bones = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_vTipOffset = 0x30; // Vector + constexpr std::ptrdiff_t m_vSplayHingeAxis = 0x3C; // Vector + constexpr std::ptrdiff_t m_tipParentBoneIndex = 0x48; // int32_t + constexpr std::ptrdiff_t m_metacarpalBoneIndex = 0x4C; // int32_t + constexpr std::ptrdiff_t m_flSplayMinAngle = 0x50; // float + constexpr std::ptrdiff_t m_flSplayMaxAngle = 0x54; // float + constexpr std::ptrdiff_t m_flFingerScaleRatio = 0x58; // float +} + +namespace FingerSource_t { + constexpr std::ptrdiff_t m_nFingerIndex = 0x0; // AnimVRFinger_t + constexpr std::ptrdiff_t m_flFingerWeight = 0x4; // float +} + +namespace FollowAttachmentSettings_t { + constexpr std::ptrdiff_t m_attachment = 0x0; // CAnimAttachment + constexpr std::ptrdiff_t m_boneIndex = 0x80; // int32_t + constexpr std::ptrdiff_t m_bMatchTranslation = 0x84; // bool + constexpr std::ptrdiff_t m_bMatchRotation = 0x85; // bool +} + +namespace FootFixedData_t { + constexpr std::ptrdiff_t m_vToeOffset = 0x0; // VectorAligned + constexpr std::ptrdiff_t m_vHeelOffset = 0x10; // VectorAligned + constexpr std::ptrdiff_t m_nTargetBoneIndex = 0x20; // int32_t + constexpr std::ptrdiff_t m_nAnkleBoneIndex = 0x24; // int32_t + constexpr std::ptrdiff_t m_nIKAnchorBoneIndex = 0x28; // int32_t + constexpr std::ptrdiff_t m_ikChainIndex = 0x2C; // int32_t + constexpr std::ptrdiff_t m_flMaxIKLength = 0x30; // float + constexpr std::ptrdiff_t m_nFootIndex = 0x34; // int32_t + constexpr std::ptrdiff_t m_nTagIndex = 0x38; // int32_t + constexpr std::ptrdiff_t m_flMaxRotationLeft = 0x3C; // float + constexpr std::ptrdiff_t m_flMaxRotationRight = 0x40; // float +} + +namespace FootFixedSettings { + constexpr std::ptrdiff_t m_traceSettings = 0x0; // TraceSettings_t + constexpr std::ptrdiff_t m_vFootBaseBindPosePositionMS = 0x10; // VectorAligned + constexpr std::ptrdiff_t m_flFootBaseLength = 0x20; // float + constexpr std::ptrdiff_t m_flMaxRotationLeft = 0x24; // float + constexpr std::ptrdiff_t m_flMaxRotationRight = 0x28; // float + constexpr std::ptrdiff_t m_footstepLandedTagIndex = 0x2C; // int32_t + constexpr std::ptrdiff_t m_bEnableTracing = 0x30; // bool + constexpr std::ptrdiff_t m_flTraceAngleBlend = 0x34; // float + constexpr std::ptrdiff_t m_nDisableTagIndex = 0x38; // int32_t + constexpr std::ptrdiff_t m_nFootIndex = 0x3C; // int32_t +} + +namespace FootLockPoseOpFixedSettings { + constexpr std::ptrdiff_t m_footInfo = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_hipDampingSettings = 0x18; // CAnimInputDamping + constexpr std::ptrdiff_t m_nHipBoneIndex = 0x28; // int32_t + constexpr std::ptrdiff_t m_ikSolverType = 0x2C; // IKSolverType + constexpr std::ptrdiff_t m_bApplyTilt = 0x30; // bool + constexpr std::ptrdiff_t m_bApplyHipDrop = 0x31; // bool + constexpr std::ptrdiff_t m_bAlwaysUseFallbackHinge = 0x32; // bool + constexpr std::ptrdiff_t m_bApplyFootRotationLimits = 0x33; // bool + constexpr std::ptrdiff_t m_bApplyLegTwistLimits = 0x34; // bool + constexpr std::ptrdiff_t m_flMaxFootHeight = 0x38; // float + constexpr std::ptrdiff_t m_flExtensionScale = 0x3C; // float + constexpr std::ptrdiff_t m_flMaxLegTwist = 0x40; // float + constexpr std::ptrdiff_t m_bEnableLockBreaking = 0x44; // bool + constexpr std::ptrdiff_t m_flLockBreakTolerance = 0x48; // float + constexpr std::ptrdiff_t m_flLockBlendTime = 0x4C; // float + constexpr std::ptrdiff_t m_bEnableStretching = 0x50; // bool + constexpr std::ptrdiff_t m_flMaxStretchAmount = 0x54; // float + constexpr std::ptrdiff_t m_flStretchExtensionScale = 0x58; // float +} + +namespace FootPinningPoseOpFixedData_t { + constexpr std::ptrdiff_t m_footInfo = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_flBlendTime = 0x18; // float + constexpr std::ptrdiff_t m_flLockBreakDistance = 0x1C; // float + constexpr std::ptrdiff_t m_flMaxLegTwist = 0x20; // float + constexpr std::ptrdiff_t m_nHipBoneIndex = 0x24; // int32_t + constexpr std::ptrdiff_t m_bApplyLegTwistLimits = 0x28; // bool + constexpr std::ptrdiff_t m_bApplyFootRotationLimits = 0x29; // bool +} + +namespace FootStepTrigger { + constexpr std::ptrdiff_t m_tags = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_nFootIndex = 0x18; // int32_t + constexpr std::ptrdiff_t m_triggerPhase = 0x1C; // StepPhase +} + +namespace HSequence { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace HitReactFixedSettings_t { + constexpr std::ptrdiff_t m_nWeightListIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_nEffectedBoneCount = 0x4; // int32_t + constexpr std::ptrdiff_t m_flMaxImpactForce = 0x8; // float + constexpr std::ptrdiff_t m_flMinImpactForce = 0xC; // float + constexpr std::ptrdiff_t m_flWhipImpactScale = 0x10; // float + constexpr std::ptrdiff_t m_flCounterRotationScale = 0x14; // float + constexpr std::ptrdiff_t m_flDistanceFadeScale = 0x18; // float + constexpr std::ptrdiff_t m_flPropagationScale = 0x1C; // float + constexpr std::ptrdiff_t m_flWhipDelay = 0x20; // float + constexpr std::ptrdiff_t m_flSpringStrength = 0x24; // float + constexpr std::ptrdiff_t m_flWhipSpringStrength = 0x28; // float + constexpr std::ptrdiff_t m_flMaxAngleRadians = 0x2C; // float + constexpr std::ptrdiff_t m_nHipBoneIndex = 0x30; // int32_t + constexpr std::ptrdiff_t m_flHipBoneTranslationScale = 0x34; // float + constexpr std::ptrdiff_t m_flHipDipSpringStrength = 0x38; // float + constexpr std::ptrdiff_t m_flHipDipImpactScale = 0x3C; // float + constexpr std::ptrdiff_t m_flHipDipDelay = 0x40; // float +} + +namespace IKBoneNameAndIndex_t { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlString +} + +namespace IKDemoCaptureSettings_t { + constexpr std::ptrdiff_t m_parentBoneName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_eMode = 0x8; // IKChannelMode + constexpr std::ptrdiff_t m_ikChainName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_oneBoneStart = 0x18; // CUtlString + constexpr std::ptrdiff_t m_oneBoneEnd = 0x20; // CUtlString +} + +namespace IKSolverSettings_t { + constexpr std::ptrdiff_t m_SolverType = 0x0; // IKSolverType + constexpr std::ptrdiff_t m_nNumIterations = 0x4; // int32_t +} + +namespace IKTargetSettings_t { + constexpr std::ptrdiff_t m_TargetSource = 0x0; // IKTargetSource + constexpr std::ptrdiff_t m_Bone = 0x8; // IKBoneNameAndIndex_t + constexpr std::ptrdiff_t m_AnimgraphParameterNamePosition = 0x18; // AnimParamID + constexpr std::ptrdiff_t m_AnimgraphParameterNameOrientation = 0x1C; // AnimParamID + constexpr std::ptrdiff_t m_TargetCoordSystem = 0x20; // IKTargetCoordinateSystem +} + +namespace JiggleBoneSettingsList_t { + constexpr std::ptrdiff_t m_boneSettings = 0x0; // CUtlVector +} + +namespace JiggleBoneSettings_t { + constexpr std::ptrdiff_t m_nBoneIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_flSpringStrength = 0x4; // float + constexpr std::ptrdiff_t m_flMaxTimeStep = 0x8; // float + constexpr std::ptrdiff_t m_flDamping = 0xC; // float + constexpr std::ptrdiff_t m_vBoundsMaxLS = 0x10; // Vector + constexpr std::ptrdiff_t m_vBoundsMinLS = 0x1C; // Vector + constexpr std::ptrdiff_t m_eSimSpace = 0x28; // JiggleBoneSimSpace +} + +namespace LookAtBone_t { + constexpr std::ptrdiff_t m_index = 0x0; // int32_t + constexpr std::ptrdiff_t m_weight = 0x4; // float +} + +namespace LookAtOpFixedSettings_t { + constexpr std::ptrdiff_t m_attachment = 0x0; // CAnimAttachment + constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping + constexpr std::ptrdiff_t m_bones = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_flYawLimit = 0xA8; // float + constexpr std::ptrdiff_t m_flPitchLimit = 0xAC; // float + constexpr std::ptrdiff_t m_flHysteresisInnerAngle = 0xB0; // float + constexpr std::ptrdiff_t m_flHysteresisOuterAngle = 0xB4; // float + constexpr std::ptrdiff_t m_bRotateYawForward = 0xB8; // bool + constexpr std::ptrdiff_t m_bMaintainUpDirection = 0xB9; // bool + constexpr std::ptrdiff_t m_bTargetIsPosition = 0xBA; // bool + constexpr std::ptrdiff_t m_bUseHysteresis = 0xBB; // bool +} + +namespace MaterialGroup_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_materials = 0x8; // CUtlVector> +} + +namespace ModelBoneFlexDriverControl_t { + constexpr std::ptrdiff_t m_nBoneComponent = 0x0; // ModelBoneFlexComponent_t + constexpr std::ptrdiff_t m_flexController = 0x8; // CUtlString + constexpr std::ptrdiff_t m_flexControllerToken = 0x10; // uint32_t + constexpr std::ptrdiff_t m_flMin = 0x14; // float + constexpr std::ptrdiff_t m_flMax = 0x18; // float +} + +namespace ModelBoneFlexDriver_t { + constexpr std::ptrdiff_t m_boneName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_boneNameToken = 0x8; // uint32_t + constexpr std::ptrdiff_t m_controls = 0x10; // CUtlVector +} + +namespace ModelSkeletonData_t { + constexpr std::ptrdiff_t m_boneName = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_nParent = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_boneSphere = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_nFlag = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_bonePosParent = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_boneRotParent = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_boneScaleParent = 0x90; // CUtlVector +} + +namespace MoodAnimationLayer_t { + constexpr std::ptrdiff_t m_sName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_bActiveListening = 0x8; // bool + constexpr std::ptrdiff_t m_bActiveTalking = 0x9; // bool + constexpr std::ptrdiff_t m_layerAnimations = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_flIntensity = 0x28; // CRangeFloat + constexpr std::ptrdiff_t m_flDurationScale = 0x30; // CRangeFloat + constexpr std::ptrdiff_t m_bScaleWithInts = 0x38; // bool + constexpr std::ptrdiff_t m_flNextStart = 0x3C; // CRangeFloat + constexpr std::ptrdiff_t m_flStartOffset = 0x44; // CRangeFloat + constexpr std::ptrdiff_t m_flEndOffset = 0x4C; // CRangeFloat + constexpr std::ptrdiff_t m_flFadeIn = 0x54; // float + constexpr std::ptrdiff_t m_flFadeOut = 0x58; // float +} + +namespace MoodAnimation_t { + constexpr std::ptrdiff_t m_sName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_flWeight = 0x8; // float +} + +namespace MotionBlendItem { + constexpr std::ptrdiff_t m_pChild = 0x0; // CSmartPtr + constexpr std::ptrdiff_t m_flKeyValue = 0x8; // float +} + +namespace MotionDBIndex { + constexpr std::ptrdiff_t m_nIndex = 0x0; // uint32_t +} + +namespace MotionIndex { + constexpr std::ptrdiff_t m_nGroup = 0x0; // uint16_t + constexpr std::ptrdiff_t m_nMotion = 0x2; // uint16_t +} + +namespace ParamSpanSample_t { + constexpr std::ptrdiff_t m_value = 0x0; // CAnimVariant + constexpr std::ptrdiff_t m_flCycle = 0x14; // float +} + +namespace ParamSpan_t { + constexpr std::ptrdiff_t m_samples = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_hParam = 0x18; // CAnimParamHandle + constexpr std::ptrdiff_t m_eParamType = 0x1A; // AnimParamType_t + constexpr std::ptrdiff_t m_flStartCycle = 0x1C; // float + constexpr std::ptrdiff_t m_flEndCycle = 0x20; // float +} + +namespace PermModelDataAnimatedMaterialAttribute_t { + constexpr std::ptrdiff_t m_AttributeName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nNumChannels = 0x8; // int32_t +} + +namespace PermModelData_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_modelInfo = 0x8; // PermModelInfo_t + constexpr std::ptrdiff_t m_ExtParts = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_refMeshes = 0x78; // CUtlVector> + constexpr std::ptrdiff_t m_refMeshGroupMasks = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_refPhysGroupMasks = 0xA8; // CUtlVector + constexpr std::ptrdiff_t m_refLODGroupMasks = 0xC0; // CUtlVector + constexpr std::ptrdiff_t m_lodGroupSwitchDistances = 0xD8; // CUtlVector + constexpr std::ptrdiff_t m_refPhysicsData = 0xF0; // CUtlVector> + constexpr std::ptrdiff_t m_refPhysicsHitboxData = 0x108; // CUtlVector> + constexpr std::ptrdiff_t m_refAnimGroups = 0x120; // CUtlVector> + constexpr std::ptrdiff_t m_refSequenceGroups = 0x138; // CUtlVector> + constexpr std::ptrdiff_t m_meshGroups = 0x150; // CUtlVector + constexpr std::ptrdiff_t m_materialGroups = 0x168; // CUtlVector + constexpr std::ptrdiff_t m_nDefaultMeshGroupMask = 0x180; // uint64_t + constexpr std::ptrdiff_t m_modelSkeleton = 0x188; // ModelSkeletonData_t + constexpr std::ptrdiff_t m_remappingTable = 0x230; // CUtlVector + constexpr std::ptrdiff_t m_remappingTableStarts = 0x248; // CUtlVector + constexpr std::ptrdiff_t m_boneFlexDrivers = 0x260; // CUtlVector + constexpr std::ptrdiff_t m_pModelConfigList = 0x278; // CModelConfigList* + constexpr std::ptrdiff_t m_BodyGroupsHiddenInTools = 0x280; // CUtlVector + constexpr std::ptrdiff_t m_refAnimIncludeModels = 0x298; // CUtlVector> + constexpr std::ptrdiff_t m_AnimatedMaterialAttributes = 0x2B0; // CUtlVector +} + +namespace PermModelExtPart_t { + constexpr std::ptrdiff_t m_Transform = 0x0; // CTransform + constexpr std::ptrdiff_t m_Name = 0x20; // CUtlString + constexpr std::ptrdiff_t m_nParent = 0x28; // int32_t + constexpr std::ptrdiff_t m_refModel = 0x30; // CStrongHandle +} + +namespace PermModelInfo_t { + constexpr std::ptrdiff_t m_nFlags = 0x0; // uint32_t + constexpr std::ptrdiff_t m_vHullMin = 0x4; // Vector + constexpr std::ptrdiff_t m_vHullMax = 0x10; // Vector + constexpr std::ptrdiff_t m_vViewMin = 0x1C; // Vector + constexpr std::ptrdiff_t m_vViewMax = 0x28; // Vector + constexpr std::ptrdiff_t m_flMass = 0x34; // float + constexpr std::ptrdiff_t m_vEyePosition = 0x38; // Vector + constexpr std::ptrdiff_t m_flMaxEyeDeflection = 0x44; // float + constexpr std::ptrdiff_t m_sSurfaceProperty = 0x48; // CUtlString + constexpr std::ptrdiff_t m_keyValueText = 0x50; // CUtlString +} + +namespace PhysSoftbodyDesc_t { + constexpr std::ptrdiff_t m_ParticleBoneHash = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_Particles = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_Springs = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_Capsules = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_InitPose = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_ParticleBoneName = 0x78; // CUtlVector +} + +namespace RenderSkeletonBone_t { + constexpr std::ptrdiff_t m_boneName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_parentName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_invBindPose = 0x10; // matrix3x4_t + constexpr std::ptrdiff_t m_bbox = 0x40; // SkeletonBoneBounds_t + constexpr std::ptrdiff_t m_flSphereRadius = 0x58; // float +} + +namespace SampleCode { + constexpr std::ptrdiff_t m_subCode = 0x0; // uint8_t[8] +} + +namespace ScriptInfo_t { + constexpr std::ptrdiff_t m_code = 0x0; // CUtlString + constexpr std::ptrdiff_t m_paramsModified = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_proxyReadParams = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_proxyWriteParams = 0x38; // CUtlVector + constexpr std::ptrdiff_t m_eScriptType = 0x50; // AnimScriptType +} + +namespace SkeletalInputOpFixedSettings_t { + constexpr std::ptrdiff_t m_wristBones = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_fingers = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_outerKnuckle1 = 0x30; // int32_t + constexpr std::ptrdiff_t m_outerKnuckle2 = 0x34; // int32_t + constexpr std::ptrdiff_t m_eHand = 0x38; // AnimVRHand_t + constexpr std::ptrdiff_t m_eMotionRange = 0x3C; // AnimVRHandMotionRange_t + constexpr std::ptrdiff_t m_eTransformSource = 0x40; // AnimVrBoneTransformSource_t + constexpr std::ptrdiff_t m_bEnableIK = 0x44; // bool + constexpr std::ptrdiff_t m_bEnableCollision = 0x45; // bool +} + +namespace SkeletonBoneBounds_t { + constexpr std::ptrdiff_t m_vecCenter = 0x0; // Vector + constexpr std::ptrdiff_t m_vecSize = 0xC; // Vector +} + +namespace SolveIKChainPoseOpFixedSettings_t { + constexpr std::ptrdiff_t m_ChainsToSolveData = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_bMatchTargetOrientation = 0x18; // bool +} + +namespace StanceInfo_t { + constexpr std::ptrdiff_t m_vPosition = 0x0; // Vector + constexpr std::ptrdiff_t m_flDirection = 0xC; // float +} + +namespace TagSpan_t { + constexpr std::ptrdiff_t m_tagIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_startCycle = 0x4; // float + constexpr std::ptrdiff_t m_endCycle = 0x8; // float +} + +namespace TraceSettings_t { + constexpr std::ptrdiff_t m_flTraceHeight = 0x0; // float + constexpr std::ptrdiff_t m_flTraceRadius = 0x4; // float +} + +namespace TwoBoneIKSettings_t { + constexpr std::ptrdiff_t m_endEffectorType = 0x0; // IkEndEffectorType + constexpr std::ptrdiff_t m_endEffectorAttachment = 0x10; // CAnimAttachment + constexpr std::ptrdiff_t m_targetType = 0x90; // IkTargetType + constexpr std::ptrdiff_t m_targetAttachment = 0xA0; // CAnimAttachment + constexpr std::ptrdiff_t m_targetBoneIndex = 0x120; // int32_t + constexpr std::ptrdiff_t m_hPositionParam = 0x124; // CAnimParamHandle + constexpr std::ptrdiff_t m_hRotationParam = 0x126; // CAnimParamHandle + constexpr std::ptrdiff_t m_bAlwaysUseFallbackHinge = 0x128; // bool + constexpr std::ptrdiff_t m_vLsFallbackHingeAxis = 0x130; // VectorAligned + constexpr std::ptrdiff_t m_nFixedBoneIndex = 0x140; // int32_t + constexpr std::ptrdiff_t m_nMiddleBoneIndex = 0x144; // int32_t + constexpr std::ptrdiff_t m_nEndBoneIndex = 0x148; // int32_t + constexpr std::ptrdiff_t m_bMatchTargetOrientation = 0x14C; // bool + constexpr std::ptrdiff_t m_bConstrainTwist = 0x14D; // bool + constexpr std::ptrdiff_t m_flMaxTwist = 0x150; // float +} + +namespace VPhysXAggregateData_t { + constexpr std::ptrdiff_t m_nFlags = 0x0; // uint16_t + constexpr std::ptrdiff_t m_nRefCounter = 0x2; // uint16_t + constexpr std::ptrdiff_t m_bonesHash = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_boneNames = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_indexNames = 0x38; // CUtlVector + constexpr std::ptrdiff_t m_indexHash = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_bindPose = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_parts = 0x80; // CUtlVector + constexpr std::ptrdiff_t m_constraints2 = 0x98; // CUtlVector + constexpr std::ptrdiff_t m_joints = 0xB0; // CUtlVector + constexpr std::ptrdiff_t m_pFeModel = 0xC8; // PhysFeModelDesc_t* + constexpr std::ptrdiff_t m_boneParents = 0xD0; // CUtlVector + constexpr std::ptrdiff_t m_surfacePropertyHashes = 0xE8; // CUtlVector + constexpr std::ptrdiff_t m_collisionAttributes = 0x100; // CUtlVector + constexpr std::ptrdiff_t m_debugPartNames = 0x118; // CUtlVector + constexpr std::ptrdiff_t m_embeddedKeyvalues = 0x130; // CUtlString +} + +namespace VPhysXBodyPart_t { + constexpr std::ptrdiff_t m_nFlags = 0x0; // uint32_t + constexpr std::ptrdiff_t m_flMass = 0x4; // float + constexpr std::ptrdiff_t m_rnShape = 0x8; // VPhysics2ShapeDef_t + constexpr std::ptrdiff_t m_nCollisionAttributeIndex = 0x80; // uint16_t + constexpr std::ptrdiff_t m_nReserved = 0x82; // uint16_t + constexpr std::ptrdiff_t m_flInertiaScale = 0x84; // float + constexpr std::ptrdiff_t m_flLinearDamping = 0x88; // float + constexpr std::ptrdiff_t m_flAngularDamping = 0x8C; // float + constexpr std::ptrdiff_t m_bOverrideMassCenter = 0x90; // bool + constexpr std::ptrdiff_t m_vMassCenterOverride = 0x94; // Vector +} + +namespace VPhysXCollisionAttributes_t { + constexpr std::ptrdiff_t m_CollisionGroup = 0x0; // uint32_t + constexpr std::ptrdiff_t m_InteractAs = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_InteractWith = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_InteractExclude = 0x38; // CUtlVector + constexpr std::ptrdiff_t m_CollisionGroupString = 0x50; // CUtlString + constexpr std::ptrdiff_t m_InteractAsStrings = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_InteractWithStrings = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_InteractExcludeStrings = 0x88; // CUtlVector +} + +namespace VPhysXConstraint2_t { + constexpr std::ptrdiff_t m_nFlags = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nParent = 0x4; // uint16_t + constexpr std::ptrdiff_t m_nChild = 0x6; // uint16_t + constexpr std::ptrdiff_t m_params = 0x8; // VPhysXConstraintParams_t +} + +namespace VPhysXConstraintParams_t { + constexpr std::ptrdiff_t m_nType = 0x0; // int8_t + constexpr std::ptrdiff_t m_nTranslateMotion = 0x1; // int8_t + constexpr std::ptrdiff_t m_nRotateMotion = 0x2; // int8_t + constexpr std::ptrdiff_t m_nFlags = 0x3; // int8_t + constexpr std::ptrdiff_t m_anchor = 0x4; // Vector[2] + constexpr std::ptrdiff_t m_axes = 0x1C; // QuaternionStorage[2] + constexpr std::ptrdiff_t m_maxForce = 0x3C; // float + constexpr std::ptrdiff_t m_maxTorque = 0x40; // float + constexpr std::ptrdiff_t m_linearLimitValue = 0x44; // float + constexpr std::ptrdiff_t m_linearLimitRestitution = 0x48; // float + constexpr std::ptrdiff_t m_linearLimitSpring = 0x4C; // float + constexpr std::ptrdiff_t m_linearLimitDamping = 0x50; // float + constexpr std::ptrdiff_t m_twistLowLimitValue = 0x54; // float + constexpr std::ptrdiff_t m_twistLowLimitRestitution = 0x58; // float + constexpr std::ptrdiff_t m_twistLowLimitSpring = 0x5C; // float + constexpr std::ptrdiff_t m_twistLowLimitDamping = 0x60; // float + constexpr std::ptrdiff_t m_twistHighLimitValue = 0x64; // float + constexpr std::ptrdiff_t m_twistHighLimitRestitution = 0x68; // float + constexpr std::ptrdiff_t m_twistHighLimitSpring = 0x6C; // float + constexpr std::ptrdiff_t m_twistHighLimitDamping = 0x70; // float + constexpr std::ptrdiff_t m_swing1LimitValue = 0x74; // float + constexpr std::ptrdiff_t m_swing1LimitRestitution = 0x78; // float + constexpr std::ptrdiff_t m_swing1LimitSpring = 0x7C; // float + constexpr std::ptrdiff_t m_swing1LimitDamping = 0x80; // float + constexpr std::ptrdiff_t m_swing2LimitValue = 0x84; // float + constexpr std::ptrdiff_t m_swing2LimitRestitution = 0x88; // float + constexpr std::ptrdiff_t m_swing2LimitSpring = 0x8C; // float + constexpr std::ptrdiff_t m_swing2LimitDamping = 0x90; // float + constexpr std::ptrdiff_t m_goalPosition = 0x94; // Vector + constexpr std::ptrdiff_t m_goalOrientation = 0xA0; // QuaternionStorage + constexpr std::ptrdiff_t m_goalAngularVelocity = 0xB0; // Vector + constexpr std::ptrdiff_t m_driveSpringX = 0xBC; // float + constexpr std::ptrdiff_t m_driveSpringY = 0xC0; // float + constexpr std::ptrdiff_t m_driveSpringZ = 0xC4; // float + constexpr std::ptrdiff_t m_driveDampingX = 0xC8; // float + constexpr std::ptrdiff_t m_driveDampingY = 0xCC; // float + constexpr std::ptrdiff_t m_driveDampingZ = 0xD0; // float + constexpr std::ptrdiff_t m_driveSpringTwist = 0xD4; // float + constexpr std::ptrdiff_t m_driveSpringSwing = 0xD8; // float + constexpr std::ptrdiff_t m_driveSpringSlerp = 0xDC; // float + constexpr std::ptrdiff_t m_driveDampingTwist = 0xE0; // float + constexpr std::ptrdiff_t m_driveDampingSwing = 0xE4; // float + constexpr std::ptrdiff_t m_driveDampingSlerp = 0xE8; // float + constexpr std::ptrdiff_t m_solverIterationCount = 0xEC; // int32_t + constexpr std::ptrdiff_t m_projectionLinearTolerance = 0xF0; // float + constexpr std::ptrdiff_t m_projectionAngularTolerance = 0xF4; // float +} + +namespace VPhysXJoint_t { + constexpr std::ptrdiff_t m_nType = 0x0; // uint16_t + constexpr std::ptrdiff_t m_nBody1 = 0x2; // uint16_t + constexpr std::ptrdiff_t m_nBody2 = 0x4; // uint16_t + constexpr std::ptrdiff_t m_nFlags = 0x6; // uint16_t + constexpr std::ptrdiff_t m_Frame1 = 0x10; // CTransform + constexpr std::ptrdiff_t m_Frame2 = 0x30; // CTransform + constexpr std::ptrdiff_t m_bEnableCollision = 0x50; // bool + constexpr std::ptrdiff_t m_bEnableLinearLimit = 0x51; // bool + constexpr std::ptrdiff_t m_LinearLimit = 0x54; // VPhysXRange_t + constexpr std::ptrdiff_t m_bEnableLinearMotor = 0x5C; // bool + constexpr std::ptrdiff_t m_vLinearTargetVelocity = 0x60; // Vector + constexpr std::ptrdiff_t m_flMaxForce = 0x6C; // float + constexpr std::ptrdiff_t m_bEnableSwingLimit = 0x70; // bool + constexpr std::ptrdiff_t m_SwingLimit = 0x74; // VPhysXRange_t + constexpr std::ptrdiff_t m_bEnableTwistLimit = 0x7C; // bool + constexpr std::ptrdiff_t m_TwistLimit = 0x80; // VPhysXRange_t + constexpr std::ptrdiff_t m_bEnableAngularMotor = 0x88; // bool + constexpr std::ptrdiff_t m_vAngularTargetVelocity = 0x8C; // Vector + constexpr std::ptrdiff_t m_flMaxTorque = 0x98; // float + constexpr std::ptrdiff_t m_flLinearFrequency = 0x9C; // float + constexpr std::ptrdiff_t m_flLinearDampingRatio = 0xA0; // float + constexpr std::ptrdiff_t m_flAngularFrequency = 0xA4; // float + constexpr std::ptrdiff_t m_flAngularDampingRatio = 0xA8; // float + constexpr std::ptrdiff_t m_flFriction = 0xAC; // float +} + +namespace VPhysXRange_t { + constexpr std::ptrdiff_t m_flMin = 0x0; // float + constexpr std::ptrdiff_t m_flMax = 0x4; // float +} + +namespace VPhysics2ShapeDef_t { + constexpr std::ptrdiff_t m_spheres = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_capsules = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_hulls = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_meshes = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_CollisionAttributeIndices = 0x60; // CUtlVector +} + +namespace WeightList { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_weights = 0x8; // CUtlVector +} + +namespace WristBone_t { + constexpr std::ptrdiff_t m_xOffsetTransformMS = 0x0; // CTransform + constexpr std::ptrdiff_t m_boneIndex = 0x20; // int32_t +} \ No newline at end of file diff --git a/HPCS2/offset/client.dll.hpp b/HPCS2/offset/client.dll.hpp new file mode 100644 index 0000000..ea0f58c --- /dev/null +++ b/HPCS2/offset/client.dll.hpp @@ -0,0 +1,4159 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:22 +0000 + */ + +#pragma once + +#include + +namespace ActiveModelConfig_t { + constexpr std::ptrdiff_t m_Handle = 0x28; // ModelConfigHandle_t + constexpr std::ptrdiff_t m_Name = 0x30; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_AssociatedEntities = 0x38; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_AssociatedEntityNames = 0x50; // C_NetworkUtlVectorBase +} + +namespace CAnimGraphNetworkedVariables { + constexpr std::ptrdiff_t m_PredNetBoolVariables = 0x8; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetByteVariables = 0x20; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetUInt16Variables = 0x38; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetIntVariables = 0x50; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetUInt32Variables = 0x68; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetUInt64Variables = 0x80; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetFloatVariables = 0x98; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetVectorVariables = 0xB0; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetQuaternionVariables = 0xC8; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetBoolVariables = 0xE0; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetByteVariables = 0xF8; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetUInt16Variables = 0x110; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetIntVariables = 0x128; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetUInt32Variables = 0x140; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetUInt64Variables = 0x158; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetFloatVariables = 0x170; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetVectorVariables = 0x188; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetQuaternionVariables = 0x1A0; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_nBoolVariablesCount = 0x1B8; // int32_t + constexpr std::ptrdiff_t m_nOwnerOnlyBoolVariablesCount = 0x1BC; // int32_t + constexpr std::ptrdiff_t m_nRandomSeedOffset = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flLastTeleportTime = 0x1C4; // float +} + +namespace CAttributeList { + constexpr std::ptrdiff_t m_Attributes = 0x8; // C_UtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_pManager = 0x58; // CAttributeManager* +} + +namespace CAttributeManager { + constexpr std::ptrdiff_t m_Providers = 0x8; // CUtlVector> + constexpr std::ptrdiff_t m_iReapplyProvisionParity = 0x20; // int32_t + constexpr std::ptrdiff_t m_hOuter = 0x24; // CHandle + constexpr std::ptrdiff_t m_bPreventLoopback = 0x28; // bool + constexpr std::ptrdiff_t m_ProviderType = 0x2C; // attributeprovidertypes_t + constexpr std::ptrdiff_t m_CachedResults = 0x30; // CUtlVector +} + +namespace CAttributeManager_cached_attribute_float_t { + constexpr std::ptrdiff_t flIn = 0x0; // float + constexpr std::ptrdiff_t iAttribHook = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t flOut = 0x10; // float +} + +namespace CBaseAnimGraph { // C_BaseModelEntity + constexpr std::ptrdiff_t m_bInitiallyPopulateInterpHistory = 0xCC0; // bool + constexpr std::ptrdiff_t m_bShouldAnimateDuringGameplayPause = 0xCC1; // bool + constexpr std::ptrdiff_t m_bSuppressAnimEventSounds = 0xCC3; // bool + constexpr std::ptrdiff_t m_bAnimGraphUpdateEnabled = 0xCD0; // bool + constexpr std::ptrdiff_t m_flMaxSlopeDistance = 0xCD4; // float + constexpr std::ptrdiff_t m_vLastSlopeCheckPos = 0xCD8; // Vector + constexpr std::ptrdiff_t m_vecForce = 0xCE8; // Vector + constexpr std::ptrdiff_t m_nForceBone = 0xCF4; // int32_t + constexpr std::ptrdiff_t m_pClientsideRagdoll = 0xCF8; // CBaseAnimGraph* + constexpr std::ptrdiff_t m_bBuiltRagdoll = 0xD00; // bool + constexpr std::ptrdiff_t m_pRagdollPose = 0xD18; // PhysicsRagdollPose_t* + constexpr std::ptrdiff_t m_bClientRagdoll = 0xD20; // bool + constexpr std::ptrdiff_t m_bHasAnimatedMaterialAttributes = 0xD30; // bool +} + +namespace CBaseAnimGraphController { // CSkeletonAnimationController + constexpr std::ptrdiff_t m_baseLayer = 0x18; // CNetworkedSequenceOperation + constexpr std::ptrdiff_t m_animGraphNetworkedVars = 0x40; // CAnimGraphNetworkedVariables + constexpr std::ptrdiff_t m_bSequenceFinished = 0x1320; // bool + constexpr std::ptrdiff_t m_flLastEventCycle = 0x1324; // float + constexpr std::ptrdiff_t m_flLastEventAnimTime = 0x1328; // float + constexpr std::ptrdiff_t m_flPlaybackRate = 0x132C; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_flPrevAnimTime = 0x1334; // float + constexpr std::ptrdiff_t m_bClientSideAnimation = 0x1338; // bool + constexpr std::ptrdiff_t m_bNetworkedAnimationInputsChanged = 0x1339; // bool + constexpr std::ptrdiff_t m_nPrevNewSequenceParity = 0x133A; // uint8_t + constexpr std::ptrdiff_t m_nPrevResetEventsParity = 0x133B; // uint8_t + constexpr std::ptrdiff_t m_nNewSequenceParity = 0x133C; // int32_t + constexpr std::ptrdiff_t m_nResetEventsParity = 0x1340; // int32_t + constexpr std::ptrdiff_t m_nAnimLoopMode = 0x1344; // AnimLoopMode_t + constexpr std::ptrdiff_t m_hAnimationUpdate = 0x13E4; // AnimationUpdateListHandle_t + constexpr std::ptrdiff_t m_hLastAnimEventSequence = 0x13E8; // HSequence +} + +namespace CBasePlayerController { // C_BaseEntity + constexpr std::ptrdiff_t m_nFinalPredictedTick = 0x548; // int32_t + constexpr std::ptrdiff_t m_CommandContext = 0x550; // C_CommandContext + constexpr std::ptrdiff_t m_nInButtonsWhichAreToggles = 0x5D0; // uint64_t + constexpr std::ptrdiff_t m_nTickBase = 0x5D8; // uint32_t + constexpr std::ptrdiff_t m_hPawn = 0x5DC; // CHandle + constexpr std::ptrdiff_t m_hPredictedPawn = 0x5E0; // CHandle + constexpr std::ptrdiff_t m_nSplitScreenSlot = 0x5E4; // CSplitScreenSlot + constexpr std::ptrdiff_t m_hSplitOwner = 0x5E8; // CHandle + constexpr std::ptrdiff_t m_hSplitScreenPlayers = 0x5F0; // CUtlVector> + constexpr std::ptrdiff_t m_bIsHLTV = 0x608; // bool + constexpr std::ptrdiff_t m_iConnected = 0x60C; // PlayerConnectedState + constexpr std::ptrdiff_t m_iszPlayerName = 0x610; // char[128] + constexpr std::ptrdiff_t m_steamID = 0x698; // uint64_t + constexpr std::ptrdiff_t m_bIsLocalPlayerController = 0x6A0; // bool + constexpr std::ptrdiff_t m_iDesiredFOV = 0x6A4; // uint32_t +} + +namespace CBasePlayerVData { // CEntitySubclassVDataBase + constexpr std::ptrdiff_t m_sModelName = 0x28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_flHeadDamageMultiplier = 0x108; // CSkillFloat + constexpr std::ptrdiff_t m_flChestDamageMultiplier = 0x118; // CSkillFloat + constexpr std::ptrdiff_t m_flStomachDamageMultiplier = 0x128; // CSkillFloat + constexpr std::ptrdiff_t m_flArmDamageMultiplier = 0x138; // CSkillFloat + constexpr std::ptrdiff_t m_flLegDamageMultiplier = 0x148; // CSkillFloat + constexpr std::ptrdiff_t m_flHoldBreathTime = 0x158; // float + constexpr std::ptrdiff_t m_flDrowningDamageInterval = 0x15C; // float + constexpr std::ptrdiff_t m_nDrowningDamageInitial = 0x160; // int32_t + constexpr std::ptrdiff_t m_nDrowningDamageMax = 0x164; // int32_t + constexpr std::ptrdiff_t m_nWaterSpeed = 0x168; // int32_t + constexpr std::ptrdiff_t m_flUseRange = 0x16C; // float + constexpr std::ptrdiff_t m_flUseAngleTolerance = 0x170; // float + constexpr std::ptrdiff_t m_flCrouchTime = 0x174; // float +} + +namespace CBasePlayerWeaponVData { // CEntitySubclassVDataBase + constexpr std::ptrdiff_t m_szWorldModel = 0x28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_bBuiltRightHanded = 0x108; // bool + constexpr std::ptrdiff_t m_bAllowFlipping = 0x109; // bool + constexpr std::ptrdiff_t m_bIsFullAuto = 0x10A; // bool + constexpr std::ptrdiff_t m_nNumBullets = 0x10C; // int32_t + constexpr std::ptrdiff_t m_sMuzzleAttachment = 0x110; // CUtlString + constexpr std::ptrdiff_t m_szMuzzleFlashParticle = 0x118; // CResourceNameTyped> + constexpr std::ptrdiff_t m_iFlags = 0x1F8; // ItemFlagTypes_t + constexpr std::ptrdiff_t m_nPrimaryAmmoType = 0x1F9; // AmmoIndex_t + constexpr std::ptrdiff_t m_nSecondaryAmmoType = 0x1FA; // AmmoIndex_t + constexpr std::ptrdiff_t m_iMaxClip1 = 0x1FC; // int32_t + constexpr std::ptrdiff_t m_iMaxClip2 = 0x200; // int32_t + constexpr std::ptrdiff_t m_iDefaultClip1 = 0x204; // int32_t + constexpr std::ptrdiff_t m_iDefaultClip2 = 0x208; // int32_t + constexpr std::ptrdiff_t m_iWeight = 0x20C; // int32_t + constexpr std::ptrdiff_t m_bAutoSwitchTo = 0x210; // bool + constexpr std::ptrdiff_t m_bAutoSwitchFrom = 0x211; // bool + constexpr std::ptrdiff_t m_iRumbleEffect = 0x214; // RumbleEffect_t + constexpr std::ptrdiff_t m_aShootSounds = 0x218; // CUtlMap + constexpr std::ptrdiff_t m_iSlot = 0x238; // int32_t + constexpr std::ptrdiff_t m_iPosition = 0x23C; // int32_t +} + +namespace CBaseProp { // CBaseAnimGraph + constexpr std::ptrdiff_t m_bModelOverrodeBlockLOS = 0xE80; // bool + constexpr std::ptrdiff_t m_iShapeType = 0xE84; // int32_t + constexpr std::ptrdiff_t m_bConformToCollisionBounds = 0xE88; // bool + constexpr std::ptrdiff_t m_mPreferredCatchTransform = 0xE8C; // matrix3x4_t +} + +namespace CBodyComponent { // CEntityComponent + constexpr std::ptrdiff_t m_pSceneNode = 0x8; // CGameSceneNode* + constexpr std::ptrdiff_t __m_pChainEntity = 0x20; // CNetworkVarChainer +} + +namespace CBodyComponentBaseAnimGraph { // CBodyComponentSkeletonInstance + constexpr std::ptrdiff_t m_animationController = 0x480; // CBaseAnimGraphController + constexpr std::ptrdiff_t __m_pChainEntity = 0x18C0; // CNetworkVarChainer +} + +namespace CBodyComponentBaseModelEntity { // CBodyComponentSkeletonInstance + constexpr std::ptrdiff_t __m_pChainEntity = 0x480; // CNetworkVarChainer +} + +namespace CBodyComponentPoint { // CBodyComponent + constexpr std::ptrdiff_t m_sceneNode = 0x50; // CGameSceneNode + constexpr std::ptrdiff_t __m_pChainEntity = 0x1A0; // CNetworkVarChainer +} + +namespace CBodyComponentSkeletonInstance { // CBodyComponent + constexpr std::ptrdiff_t m_skeletonInstance = 0x50; // CSkeletonInstance + constexpr std::ptrdiff_t __m_pChainEntity = 0x450; // CNetworkVarChainer +} + +namespace CBombTarget { // C_BaseTrigger + constexpr std::ptrdiff_t m_bBombPlantedHere = 0xCC8; // bool +} + +namespace CBreachCharge { // C_CSWeaponBase +} + +namespace CBreachChargeProjectile { // C_BaseGrenade +} + +namespace CBumpMine { // C_CSWeaponBase +} + +namespace CBumpMineProjectile { // C_BaseGrenade +} + +namespace CBuoyancyHelper { + constexpr std::ptrdiff_t m_flFluidDensity = 0x18; // float +} + +namespace CCSGO_WingmanIntroCharacterPosition { // C_CSGO_TeamIntroCharacterPosition +} + +namespace CCSGO_WingmanIntroCounterTerroristPosition { // CCSGO_WingmanIntroCharacterPosition +} + +namespace CCSGO_WingmanIntroTerroristPosition { // CCSGO_WingmanIntroCharacterPosition +} + +namespace CCSGameModeRules { + constexpr std::ptrdiff_t __m_pChainEntity = 0x8; // CNetworkVarChainer +} + +namespace CCSGameModeRules_Deathmatch { // CCSGameModeRules + constexpr std::ptrdiff_t m_bFirstThink = 0x30; // bool + constexpr std::ptrdiff_t m_bFirstThinkAfterConnected = 0x31; // bool + constexpr std::ptrdiff_t m_flDMBonusStartTime = 0x34; // GameTime_t + constexpr std::ptrdiff_t m_flDMBonusTimeLength = 0x38; // float + constexpr std::ptrdiff_t m_nDMBonusWeaponLoadoutSlot = 0x3C; // int16_t +} + +namespace CCSGameModeRules_Noop { // CCSGameModeRules +} + +namespace CCSGameModeRules_Scripted { // CCSGameModeRules +} + +namespace CCSGameModeScript { // CBasePulseGraphInstance +} + +namespace CCSObserver_CameraServices { // CCSPlayerBase_CameraServices +} + +namespace CCSObserver_MovementServices { // CPlayer_MovementServices +} + +namespace CCSObserver_ObserverServices { // CPlayer_ObserverServices + constexpr std::ptrdiff_t m_hLastObserverTarget = 0x58; // CEntityHandle + constexpr std::ptrdiff_t m_vecObserverInterpolateOffset = 0x5C; // Vector + constexpr std::ptrdiff_t m_vecObserverInterpStartPos = 0x68; // Vector + constexpr std::ptrdiff_t m_flObsInterp_PathLength = 0x74; // float + constexpr std::ptrdiff_t m_qObsInterp_OrientationStart = 0x80; // Quaternion + constexpr std::ptrdiff_t m_qObsInterp_OrientationTravelDir = 0x90; // Quaternion + constexpr std::ptrdiff_t m_obsInterpState = 0xA0; // ObserverInterpState_t + constexpr std::ptrdiff_t m_bObserverInterpolationNeedsDeferredSetup = 0xA4; // bool +} + +namespace CCSObserver_UseServices { // CPlayer_UseServices +} + +namespace CCSObserver_ViewModelServices { // CPlayer_ViewModelServices +} + +namespace CCSPlayerBase_CameraServices { // CPlayer_CameraServices + constexpr std::ptrdiff_t m_iFOV = 0x210; // uint32_t + constexpr std::ptrdiff_t m_iFOVStart = 0x214; // uint32_t + constexpr std::ptrdiff_t m_flFOVTime = 0x218; // GameTime_t + constexpr std::ptrdiff_t m_flFOVRate = 0x21C; // float + constexpr std::ptrdiff_t m_hZoomOwner = 0x220; // CHandle + constexpr std::ptrdiff_t m_flLastShotFOV = 0x224; // float +} + +namespace CCSPlayerController { // CBasePlayerController + constexpr std::ptrdiff_t m_pInGameMoneyServices = 0x6D0; // CCSPlayerController_InGameMoneyServices* + constexpr std::ptrdiff_t m_pInventoryServices = 0x6D8; // CCSPlayerController_InventoryServices* + constexpr std::ptrdiff_t m_pActionTrackingServices = 0x6E0; // CCSPlayerController_ActionTrackingServices* + constexpr std::ptrdiff_t m_pDamageServices = 0x6E8; // CCSPlayerController_DamageServices* + constexpr std::ptrdiff_t m_iPing = 0x6F0; // uint32_t + constexpr std::ptrdiff_t m_bHasCommunicationAbuseMute = 0x6F4; // bool + constexpr std::ptrdiff_t m_szCrosshairCodes = 0x6F8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iPendingTeamNum = 0x700; // uint8_t + constexpr std::ptrdiff_t m_flForceTeamTime = 0x704; // GameTime_t + constexpr std::ptrdiff_t m_iCompTeammateColor = 0x708; // int32_t + constexpr std::ptrdiff_t m_bEverPlayedOnTeam = 0x70C; // bool + constexpr std::ptrdiff_t m_flPreviousForceJoinTeamTime = 0x710; // GameTime_t + constexpr std::ptrdiff_t m_szClan = 0x718; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sSanitizedPlayerName = 0x720; // CUtlString + constexpr std::ptrdiff_t m_iCoachingTeam = 0x728; // int32_t + constexpr std::ptrdiff_t m_nPlayerDominated = 0x730; // uint64_t + constexpr std::ptrdiff_t m_nPlayerDominatingMe = 0x738; // uint64_t + constexpr std::ptrdiff_t m_iCompetitiveRanking = 0x740; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveWins = 0x744; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveRankType = 0x748; // int8_t + constexpr std::ptrdiff_t m_iCompetitiveRankingPredicted_Win = 0x74C; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveRankingPredicted_Loss = 0x750; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveRankingPredicted_Tie = 0x754; // int32_t + constexpr std::ptrdiff_t m_nEndMatchNextMapVote = 0x758; // int32_t + constexpr std::ptrdiff_t m_unActiveQuestId = 0x75C; // uint16_t + constexpr std::ptrdiff_t m_nQuestProgressReason = 0x760; // QuestProgress::Reason + constexpr std::ptrdiff_t m_unPlayerTvControlFlags = 0x764; // uint32_t + constexpr std::ptrdiff_t m_iDraftIndex = 0x790; // int32_t + constexpr std::ptrdiff_t m_msQueuedModeDisconnectionTimestamp = 0x794; // uint32_t + constexpr std::ptrdiff_t m_uiAbandonRecordedReason = 0x798; // uint32_t + constexpr std::ptrdiff_t m_bEverFullyConnected = 0x79C; // bool + constexpr std::ptrdiff_t m_bAbandonAllowsSurrender = 0x79D; // bool + constexpr std::ptrdiff_t m_bAbandonOffersInstantSurrender = 0x79E; // bool + constexpr std::ptrdiff_t m_bDisconnection1MinWarningPrinted = 0x79F; // bool + constexpr std::ptrdiff_t m_bScoreReported = 0x7A0; // bool + constexpr std::ptrdiff_t m_nDisconnectionTick = 0x7A4; // int32_t + constexpr std::ptrdiff_t m_bControllingBot = 0x7B0; // bool + constexpr std::ptrdiff_t m_bHasControlledBotThisRound = 0x7B1; // bool + constexpr std::ptrdiff_t m_bHasBeenControlledByPlayerThisRound = 0x7B2; // bool + constexpr std::ptrdiff_t m_nBotsControlledThisRound = 0x7B4; // int32_t + constexpr std::ptrdiff_t m_bCanControlObservedBot = 0x7B8; // bool + constexpr std::ptrdiff_t m_hPlayerPawn = 0x7BC; // CHandle + constexpr std::ptrdiff_t m_hObserverPawn = 0x7C0; // CHandle + constexpr std::ptrdiff_t m_bPawnIsAlive = 0x7C4; // bool + constexpr std::ptrdiff_t m_iPawnHealth = 0x7C8; // uint32_t + constexpr std::ptrdiff_t m_iPawnArmor = 0x7CC; // int32_t + constexpr std::ptrdiff_t m_bPawnHasDefuser = 0x7D0; // bool + constexpr std::ptrdiff_t m_bPawnHasHelmet = 0x7D1; // bool + constexpr std::ptrdiff_t m_nPawnCharacterDefIndex = 0x7D2; // uint16_t + constexpr std::ptrdiff_t m_iPawnLifetimeStart = 0x7D4; // int32_t + constexpr std::ptrdiff_t m_iPawnLifetimeEnd = 0x7D8; // int32_t + constexpr std::ptrdiff_t m_iPawnBotDifficulty = 0x7DC; // int32_t + constexpr std::ptrdiff_t m_hOriginalControllerOfCurrentPawn = 0x7E0; // CHandle + constexpr std::ptrdiff_t m_iScore = 0x7E4; // int32_t + constexpr std::ptrdiff_t m_vecKills = 0x7E8; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_iMVPs = 0x800; // int32_t + constexpr std::ptrdiff_t m_bIsPlayerNameDirty = 0x804; // bool +} + +namespace CCSPlayerController_ActionTrackingServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_perRoundStats = 0x40; // C_UtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_matchStats = 0x90; // CSMatchStats_t + constexpr std::ptrdiff_t m_iNumRoundKills = 0x108; // int32_t + constexpr std::ptrdiff_t m_iNumRoundKillsHeadshots = 0x10C; // int32_t + constexpr std::ptrdiff_t m_unTotalRoundDamageDealt = 0x110; // uint32_t +} + +namespace CCSPlayerController_DamageServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_nSendUpdate = 0x40; // int32_t + constexpr std::ptrdiff_t m_DamageList = 0x48; // C_UtlVectorEmbeddedNetworkVar +} + +namespace CCSPlayerController_InGameMoneyServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_iAccount = 0x40; // int32_t + constexpr std::ptrdiff_t m_iStartAccount = 0x44; // int32_t + constexpr std::ptrdiff_t m_iTotalCashSpent = 0x48; // int32_t + constexpr std::ptrdiff_t m_iCashSpentThisRound = 0x4C; // int32_t + constexpr std::ptrdiff_t m_nPreviousAccount = 0x50; // int32_t +} + +namespace CCSPlayerController_InventoryServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_unMusicID = 0x40; // uint16_t + constexpr std::ptrdiff_t m_rank = 0x44; // MedalRank_t[6] + constexpr std::ptrdiff_t m_nPersonaDataPublicLevel = 0x5C; // int32_t + constexpr std::ptrdiff_t m_nPersonaDataPublicCommendsLeader = 0x60; // int32_t + constexpr std::ptrdiff_t m_nPersonaDataPublicCommendsTeacher = 0x64; // int32_t + constexpr std::ptrdiff_t m_nPersonaDataPublicCommendsFriendly = 0x68; // int32_t + constexpr std::ptrdiff_t m_vecServerAuthoritativeWeaponSlots = 0x70; // C_UtlVectorEmbeddedNetworkVar +} + +namespace CCSPlayer_ActionTrackingServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_hLastWeaponBeforeC4AutoSwitch = 0x40; // CHandle + constexpr std::ptrdiff_t m_bIsRescuing = 0x44; // bool + constexpr std::ptrdiff_t m_weaponPurchasesThisMatch = 0x48; // WeaponPurchaseTracker_t + constexpr std::ptrdiff_t m_weaponPurchasesThisRound = 0xA0; // WeaponPurchaseTracker_t +} + +namespace CCSPlayer_BulletServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_totalHitsOnServer = 0x40; // int32_t +} + +namespace CCSPlayer_BuyServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_vecSellbackPurchaseEntries = 0x40; // C_UtlVectorEmbeddedNetworkVar +} + +namespace CCSPlayer_CameraServices { // CCSPlayerBase_CameraServices + constexpr std::ptrdiff_t m_flDeathCamTilt = 0x228; // float +} + +namespace CCSPlayer_GlowServices { // CPlayerPawnComponent +} + +namespace CCSPlayer_HostageServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_hCarriedHostage = 0x40; // CHandle + constexpr std::ptrdiff_t m_hCarriedHostageProp = 0x44; // CHandle +} + +namespace CCSPlayer_ItemServices { // CPlayer_ItemServices + constexpr std::ptrdiff_t m_bHasDefuser = 0x40; // bool + constexpr std::ptrdiff_t m_bHasHelmet = 0x41; // bool + constexpr std::ptrdiff_t m_bHasHeavyArmor = 0x42; // bool +} + +namespace CCSPlayer_MovementServices { // CPlayer_MovementServices_Humanoid + constexpr std::ptrdiff_t m_flMaxFallVelocity = 0x210; // float + constexpr std::ptrdiff_t m_vecLadderNormal = 0x214; // Vector + constexpr std::ptrdiff_t m_nLadderSurfacePropIndex = 0x220; // int32_t + constexpr std::ptrdiff_t m_flDuckAmount = 0x224; // float + constexpr std::ptrdiff_t m_flDuckSpeed = 0x228; // float + constexpr std::ptrdiff_t m_bDuckOverride = 0x22C; // bool + constexpr std::ptrdiff_t m_bDesiresDuck = 0x22D; // bool + constexpr std::ptrdiff_t m_flDuckOffset = 0x230; // float + constexpr std::ptrdiff_t m_nDuckTimeMsecs = 0x234; // uint32_t + constexpr std::ptrdiff_t m_nDuckJumpTimeMsecs = 0x238; // uint32_t + constexpr std::ptrdiff_t m_nJumpTimeMsecs = 0x23C; // uint32_t + constexpr std::ptrdiff_t m_flLastDuckTime = 0x240; // float + constexpr std::ptrdiff_t m_vecLastPositionAtFullCrouchSpeed = 0x250; // Vector2D + constexpr std::ptrdiff_t m_duckUntilOnGround = 0x258; // bool + constexpr std::ptrdiff_t m_bHasWalkMovedSinceLastJump = 0x259; // bool + constexpr std::ptrdiff_t m_bInStuckTest = 0x25A; // bool + constexpr std::ptrdiff_t m_flStuckCheckTime = 0x268; // float[64][2] + constexpr std::ptrdiff_t m_nTraceCount = 0x468; // int32_t + constexpr std::ptrdiff_t m_StuckLast = 0x46C; // int32_t + constexpr std::ptrdiff_t m_bSpeedCropped = 0x470; // bool + constexpr std::ptrdiff_t m_nOldWaterLevel = 0x474; // int32_t + constexpr std::ptrdiff_t m_flWaterEntryTime = 0x478; // float + constexpr std::ptrdiff_t m_vecForward = 0x47C; // Vector + constexpr std::ptrdiff_t m_vecLeft = 0x488; // Vector + constexpr std::ptrdiff_t m_vecUp = 0x494; // Vector + constexpr std::ptrdiff_t m_vecPreviouslyPredictedOrigin = 0x4A0; // Vector + constexpr std::ptrdiff_t m_bOldJumpPressed = 0x4AC; // bool + constexpr std::ptrdiff_t m_flJumpPressedTime = 0x4B0; // float + constexpr std::ptrdiff_t m_flJumpUntil = 0x4B4; // float + constexpr std::ptrdiff_t m_flJumpVel = 0x4B8; // float + constexpr std::ptrdiff_t m_fStashGrenadeParameterWhen = 0x4BC; // GameTime_t + constexpr std::ptrdiff_t m_nButtonDownMaskPrev = 0x4C0; // uint64_t + constexpr std::ptrdiff_t m_flOffsetTickCompleteTime = 0x4C8; // float + constexpr std::ptrdiff_t m_flOffsetTickStashedSpeed = 0x4CC; // float + constexpr std::ptrdiff_t m_flStamina = 0x4D0; // float + constexpr std::ptrdiff_t m_bUpdatePredictedOriginAfterDataUpdate = 0x4D4; // bool +} + +namespace CCSPlayer_PingServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_hPlayerPing = 0x40; // CHandle +} + +namespace CCSPlayer_UseServices { // CPlayer_UseServices +} + +namespace CCSPlayer_ViewModelServices { // CPlayer_ViewModelServices + constexpr std::ptrdiff_t m_hViewModel = 0x40; // CHandle[3] +} + +namespace CCSPlayer_WaterServices { // CPlayer_WaterServices + constexpr std::ptrdiff_t m_flWaterJumpTime = 0x40; // float + constexpr std::ptrdiff_t m_vecWaterJumpVel = 0x44; // Vector + constexpr std::ptrdiff_t m_flSwimSoundTime = 0x50; // float +} + +namespace CCSPlayer_WeaponServices { // CPlayer_WeaponServices + constexpr std::ptrdiff_t m_flNextAttack = 0xA8; // GameTime_t + constexpr std::ptrdiff_t m_bIsLookingAtWeapon = 0xAC; // bool + constexpr std::ptrdiff_t m_bIsHoldingLookAtWeapon = 0xAD; // bool +} + +namespace CCSWeaponBaseVData { // CBasePlayerWeaponVData + constexpr std::ptrdiff_t m_WeaponType = 0x240; // CSWeaponType + constexpr std::ptrdiff_t m_WeaponCategory = 0x244; // CSWeaponCategory + constexpr std::ptrdiff_t m_szViewModel = 0x248; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szPlayerModel = 0x328; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szWorldDroppedModel = 0x408; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szAimsightLensMaskModel = 0x4E8; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMagazineModel = 0x5C8; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szHeatEffect = 0x6A8; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szEjectBrassEffect = 0x788; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMuzzleFlashParticleAlt = 0x868; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMuzzleFlashThirdPersonParticle = 0x948; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMuzzleFlashThirdPersonParticleAlt = 0xA28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szTracerParticle = 0xB08; // CResourceNameTyped> + constexpr std::ptrdiff_t m_GearSlot = 0xBE8; // gear_slot_t + constexpr std::ptrdiff_t m_GearSlotPosition = 0xBEC; // int32_t + constexpr std::ptrdiff_t m_DefaultLoadoutSlot = 0xBF0; // loadout_slot_t + constexpr std::ptrdiff_t m_sWrongTeamMsg = 0xBF8; // CUtlString + constexpr std::ptrdiff_t m_nPrice = 0xC00; // int32_t + constexpr std::ptrdiff_t m_nKillAward = 0xC04; // int32_t + constexpr std::ptrdiff_t m_nPrimaryReserveAmmoMax = 0xC08; // int32_t + constexpr std::ptrdiff_t m_nSecondaryReserveAmmoMax = 0xC0C; // int32_t + constexpr std::ptrdiff_t m_bMeleeWeapon = 0xC10; // bool + constexpr std::ptrdiff_t m_bHasBurstMode = 0xC11; // bool + constexpr std::ptrdiff_t m_bIsRevolver = 0xC12; // bool + constexpr std::ptrdiff_t m_bCannotShootUnderwater = 0xC13; // bool + constexpr std::ptrdiff_t m_szName = 0xC18; // CUtlString + constexpr std::ptrdiff_t m_szAnimExtension = 0xC20; // CUtlString + constexpr std::ptrdiff_t m_eSilencerType = 0xC28; // CSWeaponSilencerType + constexpr std::ptrdiff_t m_nCrosshairMinDistance = 0xC2C; // int32_t + constexpr std::ptrdiff_t m_nCrosshairDeltaDistance = 0xC30; // int32_t + constexpr std::ptrdiff_t m_flCycleTime = 0xC34; // CFiringModeFloat + constexpr std::ptrdiff_t m_flMaxSpeed = 0xC3C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flSpread = 0xC44; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyCrouch = 0xC4C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyStand = 0xC54; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyJump = 0xC5C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyLand = 0xC64; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyLadder = 0xC6C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyFire = 0xC74; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyMove = 0xC7C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilAngle = 0xC84; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilAngleVariance = 0xC8C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilMagnitude = 0xC94; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilMagnitudeVariance = 0xC9C; // CFiringModeFloat + constexpr std::ptrdiff_t m_nTracerFrequency = 0xCA4; // CFiringModeInt + constexpr std::ptrdiff_t m_flInaccuracyJumpInitial = 0xCAC; // float + constexpr std::ptrdiff_t m_flInaccuracyJumpApex = 0xCB0; // float + constexpr std::ptrdiff_t m_flInaccuracyReload = 0xCB4; // float + constexpr std::ptrdiff_t m_nRecoilSeed = 0xCB8; // int32_t + constexpr std::ptrdiff_t m_nSpreadSeed = 0xCBC; // int32_t + constexpr std::ptrdiff_t m_flTimeToIdleAfterFire = 0xCC0; // float + constexpr std::ptrdiff_t m_flIdleInterval = 0xCC4; // float + constexpr std::ptrdiff_t m_flAttackMovespeedFactor = 0xCC8; // float + constexpr std::ptrdiff_t m_flHeatPerShot = 0xCCC; // float + constexpr std::ptrdiff_t m_flInaccuracyPitchShift = 0xCD0; // float + constexpr std::ptrdiff_t m_flInaccuracyAltSoundThreshold = 0xCD4; // float + constexpr std::ptrdiff_t m_flBotAudibleRange = 0xCD8; // float + constexpr std::ptrdiff_t m_szUseRadioSubtitle = 0xCE0; // CUtlString + constexpr std::ptrdiff_t m_bUnzoomsAfterShot = 0xCE8; // bool + constexpr std::ptrdiff_t m_bHideViewModelWhenZoomed = 0xCE9; // bool + constexpr std::ptrdiff_t m_nZoomLevels = 0xCEC; // int32_t + constexpr std::ptrdiff_t m_nZoomFOV1 = 0xCF0; // int32_t + constexpr std::ptrdiff_t m_nZoomFOV2 = 0xCF4; // int32_t + constexpr std::ptrdiff_t m_flZoomTime0 = 0xCF8; // float + constexpr std::ptrdiff_t m_flZoomTime1 = 0xCFC; // float + constexpr std::ptrdiff_t m_flZoomTime2 = 0xD00; // float + constexpr std::ptrdiff_t m_flIronSightPullUpSpeed = 0xD04; // float + constexpr std::ptrdiff_t m_flIronSightPutDownSpeed = 0xD08; // float + constexpr std::ptrdiff_t m_flIronSightFOV = 0xD0C; // float + constexpr std::ptrdiff_t m_flIronSightPivotForward = 0xD10; // float + constexpr std::ptrdiff_t m_flIronSightLooseness = 0xD14; // float + constexpr std::ptrdiff_t m_angPivotAngle = 0xD18; // QAngle + constexpr std::ptrdiff_t m_vecIronSightEyePos = 0xD24; // Vector + constexpr std::ptrdiff_t m_nDamage = 0xD30; // int32_t + constexpr std::ptrdiff_t m_flHeadshotMultiplier = 0xD34; // float + constexpr std::ptrdiff_t m_flArmorRatio = 0xD38; // float + constexpr std::ptrdiff_t m_flPenetration = 0xD3C; // float + constexpr std::ptrdiff_t m_flRange = 0xD40; // float + constexpr std::ptrdiff_t m_flRangeModifier = 0xD44; // float + constexpr std::ptrdiff_t m_flFlinchVelocityModifierLarge = 0xD48; // float + constexpr std::ptrdiff_t m_flFlinchVelocityModifierSmall = 0xD4C; // float + constexpr std::ptrdiff_t m_flRecoveryTimeCrouch = 0xD50; // float + constexpr std::ptrdiff_t m_flRecoveryTimeStand = 0xD54; // float + constexpr std::ptrdiff_t m_flRecoveryTimeCrouchFinal = 0xD58; // float + constexpr std::ptrdiff_t m_flRecoveryTimeStandFinal = 0xD5C; // float + constexpr std::ptrdiff_t m_nRecoveryTransitionStartBullet = 0xD60; // int32_t + constexpr std::ptrdiff_t m_nRecoveryTransitionEndBullet = 0xD64; // int32_t + constexpr std::ptrdiff_t m_flThrowVelocity = 0xD68; // float + constexpr std::ptrdiff_t m_vSmokeColor = 0xD6C; // Vector + constexpr std::ptrdiff_t m_szAnimClass = 0xD78; // CUtlString +} + +namespace CClientAlphaProperty { // IClientAlphaProperty + constexpr std::ptrdiff_t m_nRenderFX = 0x10; // uint8_t + constexpr std::ptrdiff_t m_nRenderMode = 0x11; // uint8_t + constexpr std::ptrdiff_t m_bAlphaOverride = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bShadowAlphaOverride = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_nReserved = 0x0; // bitfield:6 + constexpr std::ptrdiff_t m_nAlpha = 0x13; // uint8_t + constexpr std::ptrdiff_t m_nDesyncOffset = 0x14; // uint16_t + constexpr std::ptrdiff_t m_nReserved2 = 0x16; // uint16_t + constexpr std::ptrdiff_t m_nDistFadeStart = 0x18; // uint16_t + constexpr std::ptrdiff_t m_nDistFadeEnd = 0x1A; // uint16_t + constexpr std::ptrdiff_t m_flFadeScale = 0x1C; // float + constexpr std::ptrdiff_t m_flRenderFxStartTime = 0x20; // GameTime_t + constexpr std::ptrdiff_t m_flRenderFxDuration = 0x24; // float +} + +namespace CCollisionProperty { + constexpr std::ptrdiff_t m_collisionAttribute = 0x10; // VPhysicsCollisionAttribute_t + constexpr std::ptrdiff_t m_vecMins = 0x40; // Vector + constexpr std::ptrdiff_t m_vecMaxs = 0x4C; // Vector + constexpr std::ptrdiff_t m_usSolidFlags = 0x5A; // uint8_t + constexpr std::ptrdiff_t m_nSolidType = 0x5B; // SolidType_t + constexpr std::ptrdiff_t m_triggerBloat = 0x5C; // uint8_t + constexpr std::ptrdiff_t m_nSurroundType = 0x5D; // SurroundingBoundsType_t + constexpr std::ptrdiff_t m_CollisionGroup = 0x5E; // uint8_t + constexpr std::ptrdiff_t m_nEnablePhysics = 0x5F; // uint8_t + constexpr std::ptrdiff_t m_flBoundingRadius = 0x60; // float + constexpr std::ptrdiff_t m_vecSpecifiedSurroundingMins = 0x64; // Vector + constexpr std::ptrdiff_t m_vecSpecifiedSurroundingMaxs = 0x70; // Vector + constexpr std::ptrdiff_t m_vecSurroundingMaxs = 0x7C; // Vector + constexpr std::ptrdiff_t m_vecSurroundingMins = 0x88; // Vector + constexpr std::ptrdiff_t m_vCapsuleCenter1 = 0x94; // Vector + constexpr std::ptrdiff_t m_vCapsuleCenter2 = 0xA0; // Vector + constexpr std::ptrdiff_t m_flCapsuleRadius = 0xAC; // float +} + +namespace CComicBook { + constexpr std::ptrdiff_t m_CoverImage = 0x8; // CPanoramaImageName + constexpr std::ptrdiff_t m_XmlFile = 0x18; // CUtlString +} + +namespace CCompositeMaterialEditorDoc { + constexpr std::ptrdiff_t m_nVersion = 0x8; // int32_t + constexpr std::ptrdiff_t m_Points = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_KVthumbnail = 0x28; // KeyValues3 +} + +namespace CDamageRecord { + constexpr std::ptrdiff_t m_PlayerDamager = 0x28; // CHandle + constexpr std::ptrdiff_t m_PlayerRecipient = 0x2C; // CHandle + constexpr std::ptrdiff_t m_hPlayerControllerDamager = 0x30; // CHandle + constexpr std::ptrdiff_t m_hPlayerControllerRecipient = 0x34; // CHandle + constexpr std::ptrdiff_t m_szPlayerDamagerName = 0x38; // CUtlString + constexpr std::ptrdiff_t m_szPlayerRecipientName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_DamagerXuid = 0x48; // uint64_t + constexpr std::ptrdiff_t m_RecipientXuid = 0x50; // uint64_t + constexpr std::ptrdiff_t m_iDamage = 0x58; // int32_t + constexpr std::ptrdiff_t m_iActualHealthRemoved = 0x5C; // int32_t + constexpr std::ptrdiff_t m_iNumHits = 0x60; // int32_t + constexpr std::ptrdiff_t m_iLastBulletUpdate = 0x64; // int32_t + constexpr std::ptrdiff_t m_bIsOtherEnemy = 0x68; // bool + constexpr std::ptrdiff_t m_killType = 0x69; // EKillTypes_t +} + +namespace CDecalInfo { + constexpr std::ptrdiff_t m_flAnimationScale = 0x0; // float + constexpr std::ptrdiff_t m_flAnimationLifeSpan = 0x4; // float + constexpr std::ptrdiff_t m_flPlaceTime = 0x8; // float + constexpr std::ptrdiff_t m_flFadeStartTime = 0xC; // float + constexpr std::ptrdiff_t m_flFadeDuration = 0x10; // float + constexpr std::ptrdiff_t m_nVBSlot = 0x14; // int32_t + constexpr std::ptrdiff_t m_nBoneIndex = 0x18; // int32_t + constexpr std::ptrdiff_t m_pNext = 0x28; // CDecalInfo* + constexpr std::ptrdiff_t m_pPrev = 0x30; // CDecalInfo* + constexpr std::ptrdiff_t m_nDecalMaterialIndex = 0x90; // int32_t +} + +namespace CEconItemAttribute { + constexpr std::ptrdiff_t m_iAttributeDefinitionIndex = 0x30; // uint16_t + constexpr std::ptrdiff_t m_flValue = 0x34; // float + constexpr std::ptrdiff_t m_flInitialValue = 0x38; // float + constexpr std::ptrdiff_t m_nRefundableCurrency = 0x3C; // int32_t + constexpr std::ptrdiff_t m_bSetBonus = 0x40; // bool +} + +namespace CEffectData { + constexpr std::ptrdiff_t m_vOrigin = 0x8; // Vector + constexpr std::ptrdiff_t m_vStart = 0x14; // Vector + constexpr std::ptrdiff_t m_vNormal = 0x20; // Vector + constexpr std::ptrdiff_t m_vAngles = 0x2C; // QAngle + constexpr std::ptrdiff_t m_hEntity = 0x38; // CEntityHandle + constexpr std::ptrdiff_t m_hOtherEntity = 0x3C; // CEntityHandle + constexpr std::ptrdiff_t m_flScale = 0x40; // float + constexpr std::ptrdiff_t m_flMagnitude = 0x44; // float + constexpr std::ptrdiff_t m_flRadius = 0x48; // float + constexpr std::ptrdiff_t m_nSurfaceProp = 0x4C; // CUtlStringToken + constexpr std::ptrdiff_t m_nEffectIndex = 0x50; // CWeakHandle + constexpr std::ptrdiff_t m_nDamageType = 0x58; // uint32_t + constexpr std::ptrdiff_t m_nPenetrate = 0x5C; // uint8_t + constexpr std::ptrdiff_t m_nMaterial = 0x5E; // uint16_t + constexpr std::ptrdiff_t m_nHitBox = 0x60; // uint16_t + constexpr std::ptrdiff_t m_nColor = 0x62; // uint8_t + constexpr std::ptrdiff_t m_fFlags = 0x63; // uint8_t + constexpr std::ptrdiff_t m_nAttachmentIndex = 0x64; // AttachmentHandle_t + constexpr std::ptrdiff_t m_nAttachmentName = 0x68; // CUtlStringToken + constexpr std::ptrdiff_t m_iEffectName = 0x6C; // uint16_t + constexpr std::ptrdiff_t m_nExplosionType = 0x6E; // uint8_t +} + +namespace CEntityComponent { +} + +namespace CEntityIdentity { + constexpr std::ptrdiff_t m_nameStringableIndex = 0x14; // int32_t + constexpr std::ptrdiff_t m_name = 0x18; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_designerName = 0x20; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flags = 0x30; // uint32_t + constexpr std::ptrdiff_t m_worldGroupId = 0x38; // WorldGroupId_t + constexpr std::ptrdiff_t m_fDataObjectTypes = 0x3C; // uint32_t + constexpr std::ptrdiff_t m_PathIndex = 0x40; // ChangeAccessorFieldPathIndex_t + constexpr std::ptrdiff_t m_pPrev = 0x58; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNext = 0x60; // CEntityIdentity* + constexpr std::ptrdiff_t m_pPrevByClass = 0x68; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNextByClass = 0x70; // CEntityIdentity* +} + +namespace CEntityInstance { + constexpr std::ptrdiff_t m_iszPrivateVScripts = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pEntity = 0x10; // CEntityIdentity* + constexpr std::ptrdiff_t m_CScriptComponent = 0x28; // CScriptComponent* +} + +namespace CFireOverlay { // CGlowOverlay + constexpr std::ptrdiff_t m_pOwner = 0xD0; // C_FireSmoke* + constexpr std::ptrdiff_t m_vBaseColors = 0xD8; // Vector[4] + constexpr std::ptrdiff_t m_flScale = 0x108; // float + constexpr std::ptrdiff_t m_nGUID = 0x10C; // int32_t +} + +namespace CFlashlightEffect { + constexpr std::ptrdiff_t m_bIsOn = 0x10; // bool + constexpr std::ptrdiff_t m_bMuzzleFlashEnabled = 0x20; // bool + constexpr std::ptrdiff_t m_flMuzzleFlashBrightness = 0x24; // float + constexpr std::ptrdiff_t m_quatMuzzleFlashOrientation = 0x30; // Quaternion + constexpr std::ptrdiff_t m_vecMuzzleFlashOrigin = 0x40; // Vector + constexpr std::ptrdiff_t m_flFov = 0x4C; // float + constexpr std::ptrdiff_t m_flFarZ = 0x50; // float + constexpr std::ptrdiff_t m_flLinearAtten = 0x54; // float + constexpr std::ptrdiff_t m_bCastsShadows = 0x58; // bool + constexpr std::ptrdiff_t m_flCurrentPullBackDist = 0x5C; // float + constexpr std::ptrdiff_t m_FlashlightTexture = 0x60; // CStrongHandle + constexpr std::ptrdiff_t m_MuzzleFlashTexture = 0x68; // CStrongHandle + constexpr std::ptrdiff_t m_textureName = 0x70; // char[64] +} + +namespace CFuncWater { // C_BaseModelEntity + constexpr std::ptrdiff_t m_BuoyancyHelper = 0xCC0; // CBuoyancyHelper +} + +namespace CGameSceneNode { + constexpr std::ptrdiff_t m_nodeToWorld = 0x10; // CTransform + constexpr std::ptrdiff_t m_pOwner = 0x30; // CEntityInstance* + constexpr std::ptrdiff_t m_pParent = 0x38; // CGameSceneNode* + constexpr std::ptrdiff_t m_pChild = 0x40; // CGameSceneNode* + constexpr std::ptrdiff_t m_pNextSibling = 0x48; // CGameSceneNode* + constexpr std::ptrdiff_t m_hParent = 0x70; // CGameSceneNodeHandle + constexpr std::ptrdiff_t m_vecOrigin = 0x80; // CNetworkOriginCellCoordQuantizedVector + constexpr std::ptrdiff_t m_angRotation = 0xB8; // QAngle + constexpr std::ptrdiff_t m_flScale = 0xC4; // float + constexpr std::ptrdiff_t m_vecAbsOrigin = 0xC8; // Vector + constexpr std::ptrdiff_t m_angAbsRotation = 0xD4; // QAngle + constexpr std::ptrdiff_t m_flAbsScale = 0xE0; // float + constexpr std::ptrdiff_t m_nParentAttachmentOrBone = 0xE4; // int16_t + constexpr std::ptrdiff_t m_bDebugAbsOriginChanges = 0xE6; // bool + constexpr std::ptrdiff_t m_bDormant = 0xE7; // bool + constexpr std::ptrdiff_t m_bForceParentToBeNetworked = 0xE8; // bool + constexpr std::ptrdiff_t m_bDirtyHierarchy = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bDirtyBoneMergeInfo = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNetworkedPositionChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNetworkedAnglesChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNetworkedScaleChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bWillBeCallingPostDataUpdate = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNotifyBoneTransformsChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bBoneMergeFlex = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_nLatchAbsOrigin = 0x0; // bitfield:2 + constexpr std::ptrdiff_t m_bDirtyBoneMergeBoneToRoot = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_nHierarchicalDepth = 0xEB; // uint8_t + constexpr std::ptrdiff_t m_nHierarchyType = 0xEC; // uint8_t + constexpr std::ptrdiff_t m_nDoNotSetAnimTimeInInvalidatePhysicsCount = 0xED; // uint8_t + constexpr std::ptrdiff_t m_name = 0xF0; // CUtlStringToken + constexpr std::ptrdiff_t m_hierarchyAttachName = 0x130; // CUtlStringToken + constexpr std::ptrdiff_t m_flZOffset = 0x134; // float + constexpr std::ptrdiff_t m_vRenderOrigin = 0x138; // Vector +} + +namespace CGameSceneNodeHandle { + constexpr std::ptrdiff_t m_hOwner = 0x8; // CEntityHandle + constexpr std::ptrdiff_t m_name = 0xC; // CUtlStringToken +} + +namespace CGlobalLightBase { + constexpr std::ptrdiff_t m_bSpotLight = 0x10; // bool + constexpr std::ptrdiff_t m_SpotLightOrigin = 0x14; // Vector + constexpr std::ptrdiff_t m_SpotLightAngles = 0x20; // QAngle + constexpr std::ptrdiff_t m_ShadowDirection = 0x2C; // Vector + constexpr std::ptrdiff_t m_AmbientDirection = 0x38; // Vector + constexpr std::ptrdiff_t m_SpecularDirection = 0x44; // Vector + constexpr std::ptrdiff_t m_InspectorSpecularDirection = 0x50; // Vector + constexpr std::ptrdiff_t m_flSpecularPower = 0x5C; // float + constexpr std::ptrdiff_t m_flSpecularIndependence = 0x60; // float + constexpr std::ptrdiff_t m_SpecularColor = 0x64; // Color + constexpr std::ptrdiff_t m_bStartDisabled = 0x68; // bool + constexpr std::ptrdiff_t m_bEnabled = 0x69; // bool + constexpr std::ptrdiff_t m_LightColor = 0x6A; // Color + constexpr std::ptrdiff_t m_AmbientColor1 = 0x6E; // Color + constexpr std::ptrdiff_t m_AmbientColor2 = 0x72; // Color + constexpr std::ptrdiff_t m_AmbientColor3 = 0x76; // Color + constexpr std::ptrdiff_t m_flSunDistance = 0x7C; // float + constexpr std::ptrdiff_t m_flFOV = 0x80; // float + constexpr std::ptrdiff_t m_flNearZ = 0x84; // float + constexpr std::ptrdiff_t m_flFarZ = 0x88; // float + constexpr std::ptrdiff_t m_bEnableShadows = 0x8C; // bool + constexpr std::ptrdiff_t m_bOldEnableShadows = 0x8D; // bool + constexpr std::ptrdiff_t m_bBackgroundClearNotRequired = 0x8E; // bool + constexpr std::ptrdiff_t m_flCloudScale = 0x90; // float + constexpr std::ptrdiff_t m_flCloud1Speed = 0x94; // float + constexpr std::ptrdiff_t m_flCloud1Direction = 0x98; // float + constexpr std::ptrdiff_t m_flCloud2Speed = 0x9C; // float + constexpr std::ptrdiff_t m_flCloud2Direction = 0xA0; // float + constexpr std::ptrdiff_t m_flAmbientScale1 = 0xB0; // float + constexpr std::ptrdiff_t m_flAmbientScale2 = 0xB4; // float + constexpr std::ptrdiff_t m_flGroundScale = 0xB8; // float + constexpr std::ptrdiff_t m_flLightScale = 0xBC; // float + constexpr std::ptrdiff_t m_flFoWDarkness = 0xC0; // float + constexpr std::ptrdiff_t m_bEnableSeparateSkyboxFog = 0xC4; // bool + constexpr std::ptrdiff_t m_vFowColor = 0xC8; // Vector + constexpr std::ptrdiff_t m_ViewOrigin = 0xD4; // Vector + constexpr std::ptrdiff_t m_ViewAngles = 0xE0; // QAngle + constexpr std::ptrdiff_t m_flViewFoV = 0xEC; // float + constexpr std::ptrdiff_t m_WorldPoints = 0xF0; // Vector[8] + constexpr std::ptrdiff_t m_vFogOffsetLayer0 = 0x4A8; // Vector2D + constexpr std::ptrdiff_t m_vFogOffsetLayer1 = 0x4B0; // Vector2D + constexpr std::ptrdiff_t m_hEnvWind = 0x4B8; // CHandle + constexpr std::ptrdiff_t m_hEnvSky = 0x4BC; // CHandle +} + +namespace CGlowOverlay { + constexpr std::ptrdiff_t m_vPos = 0x8; // Vector + constexpr std::ptrdiff_t m_bDirectional = 0x14; // bool + constexpr std::ptrdiff_t m_vDirection = 0x18; // Vector + constexpr std::ptrdiff_t m_bInSky = 0x24; // bool + constexpr std::ptrdiff_t m_skyObstructionScale = 0x28; // float + constexpr std::ptrdiff_t m_Sprites = 0x30; // CGlowSprite[4] + constexpr std::ptrdiff_t m_nSprites = 0xB0; // int32_t + constexpr std::ptrdiff_t m_flProxyRadius = 0xB4; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0xB8; // float + constexpr std::ptrdiff_t m_flGlowObstructionScale = 0xBC; // float + constexpr std::ptrdiff_t m_bCacheGlowObstruction = 0xC0; // bool + constexpr std::ptrdiff_t m_bCacheSkyObstruction = 0xC1; // bool + constexpr std::ptrdiff_t m_bActivated = 0xC2; // int16_t + constexpr std::ptrdiff_t m_ListIndex = 0xC4; // uint16_t + constexpr std::ptrdiff_t m_queryHandle = 0xC8; // int32_t +} + +namespace CGlowProperty { + constexpr std::ptrdiff_t m_fGlowColor = 0x8; // Vector + constexpr std::ptrdiff_t m_iGlowType = 0x30; // int32_t + constexpr std::ptrdiff_t m_iGlowTeam = 0x34; // int32_t + constexpr std::ptrdiff_t m_nGlowRange = 0x38; // int32_t + constexpr std::ptrdiff_t m_nGlowRangeMin = 0x3C; // int32_t + constexpr std::ptrdiff_t m_glowColorOverride = 0x40; // Color + constexpr std::ptrdiff_t m_bFlashing = 0x44; // bool + constexpr std::ptrdiff_t m_flGlowTime = 0x48; // float + constexpr std::ptrdiff_t m_flGlowStartTime = 0x4C; // float + constexpr std::ptrdiff_t m_bEligibleForScreenHighlight = 0x50; // bool + constexpr std::ptrdiff_t m_bGlowing = 0x51; // bool +} + +namespace CGlowSprite { + constexpr std::ptrdiff_t m_vColor = 0x0; // Vector + constexpr std::ptrdiff_t m_flHorzSize = 0xC; // float + constexpr std::ptrdiff_t m_flVertSize = 0x10; // float + constexpr std::ptrdiff_t m_hMaterial = 0x18; // CStrongHandle +} + +namespace CGrenadeTracer { // C_BaseModelEntity + constexpr std::ptrdiff_t m_flTracerDuration = 0xCE0; // float + constexpr std::ptrdiff_t m_nType = 0xCE4; // GrenadeType_t +} + +namespace CHitboxComponent { // CEntityComponent + constexpr std::ptrdiff_t m_bvDisabledHitGroups = 0x24; // uint32_t[1] +} + +namespace CHostageRescueZone { // CHostageRescueZoneShim +} + +namespace CHostageRescueZoneShim { // C_BaseTrigger +} + +namespace CInfoDynamicShadowHint { // C_PointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x540; // bool + constexpr std::ptrdiff_t m_flRange = 0x544; // float + constexpr std::ptrdiff_t m_nImportance = 0x548; // int32_t + constexpr std::ptrdiff_t m_nLightChoice = 0x54C; // int32_t + constexpr std::ptrdiff_t m_hLight = 0x550; // CHandle +} + +namespace CInfoDynamicShadowHintBox { // CInfoDynamicShadowHint + constexpr std::ptrdiff_t m_vBoxMins = 0x558; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x564; // Vector +} + +namespace CInfoOffscreenPanoramaTexture { // C_PointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x540; // bool + constexpr std::ptrdiff_t m_nResolutionX = 0x544; // int32_t + constexpr std::ptrdiff_t m_nResolutionY = 0x548; // int32_t + constexpr std::ptrdiff_t m_szLayoutFileName = 0x550; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_RenderAttrName = 0x558; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_TargetEntities = 0x560; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_nTargetChangeCount = 0x578; // int32_t + constexpr std::ptrdiff_t m_vecCSSClasses = 0x580; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_bCheckCSSClasses = 0x6F8; // bool +} + +namespace CInfoParticleTarget { // C_PointEntity +} + +namespace CInfoTarget { // C_PointEntity +} + +namespace CInfoWorldLayer { // C_BaseEntity + constexpr std::ptrdiff_t m_pOutputOnEntitiesSpawned = 0x540; // CEntityIOOutput + constexpr std::ptrdiff_t m_worldName = 0x568; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_layerName = 0x570; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bWorldLayerVisible = 0x578; // bool + constexpr std::ptrdiff_t m_bEntitiesSpawned = 0x579; // bool + constexpr std::ptrdiff_t m_bCreateAsChildSpawnGroup = 0x57A; // bool + constexpr std::ptrdiff_t m_hLayerSpawnGroup = 0x57C; // uint32_t + constexpr std::ptrdiff_t m_bWorldLayerActuallyVisible = 0x580; // bool +} + +namespace CInterpolatedValue { + constexpr std::ptrdiff_t m_flStartTime = 0x0; // float + constexpr std::ptrdiff_t m_flEndTime = 0x4; // float + constexpr std::ptrdiff_t m_flStartValue = 0x8; // float + constexpr std::ptrdiff_t m_flEndValue = 0xC; // float + constexpr std::ptrdiff_t m_nInterpType = 0x10; // int32_t +} + +namespace CLightComponent { // CEntityComponent + constexpr std::ptrdiff_t __m_pChainEntity = 0x48; // CNetworkVarChainer + constexpr std::ptrdiff_t m_Color = 0x85; // Color + constexpr std::ptrdiff_t m_SecondaryColor = 0x89; // Color + constexpr std::ptrdiff_t m_flBrightness = 0x90; // float + constexpr std::ptrdiff_t m_flBrightnessScale = 0x94; // float + constexpr std::ptrdiff_t m_flBrightnessMult = 0x98; // float + constexpr std::ptrdiff_t m_flRange = 0x9C; // float + constexpr std::ptrdiff_t m_flFalloff = 0xA0; // float + constexpr std::ptrdiff_t m_flAttenuation0 = 0xA4; // float + constexpr std::ptrdiff_t m_flAttenuation1 = 0xA8; // float + constexpr std::ptrdiff_t m_flAttenuation2 = 0xAC; // float + constexpr std::ptrdiff_t m_flTheta = 0xB0; // float + constexpr std::ptrdiff_t m_flPhi = 0xB4; // float + constexpr std::ptrdiff_t m_hLightCookie = 0xB8; // CStrongHandle + constexpr std::ptrdiff_t m_nCascades = 0xC0; // int32_t + constexpr std::ptrdiff_t m_nCastShadows = 0xC4; // int32_t + constexpr std::ptrdiff_t m_nShadowWidth = 0xC8; // int32_t + constexpr std::ptrdiff_t m_nShadowHeight = 0xCC; // int32_t + constexpr std::ptrdiff_t m_bRenderDiffuse = 0xD0; // bool + constexpr std::ptrdiff_t m_nRenderSpecular = 0xD4; // int32_t + constexpr std::ptrdiff_t m_bRenderTransmissive = 0xD8; // bool + constexpr std::ptrdiff_t m_flOrthoLightWidth = 0xDC; // float + constexpr std::ptrdiff_t m_flOrthoLightHeight = 0xE0; // float + constexpr std::ptrdiff_t m_nStyle = 0xE4; // int32_t + constexpr std::ptrdiff_t m_Pattern = 0xE8; // CUtlString + constexpr std::ptrdiff_t m_nCascadeRenderStaticObjects = 0xF0; // int32_t + constexpr std::ptrdiff_t m_flShadowCascadeCrossFade = 0xF4; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistanceFade = 0xF8; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance0 = 0xFC; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance1 = 0x100; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance2 = 0x104; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance3 = 0x108; // float + constexpr std::ptrdiff_t m_nShadowCascadeResolution0 = 0x10C; // int32_t + constexpr std::ptrdiff_t m_nShadowCascadeResolution1 = 0x110; // int32_t + constexpr std::ptrdiff_t m_nShadowCascadeResolution2 = 0x114; // int32_t + constexpr std::ptrdiff_t m_nShadowCascadeResolution3 = 0x118; // int32_t + constexpr std::ptrdiff_t m_bUsesBakedShadowing = 0x11C; // bool + constexpr std::ptrdiff_t m_nShadowPriority = 0x120; // int32_t + constexpr std::ptrdiff_t m_nBakedShadowIndex = 0x124; // int32_t + constexpr std::ptrdiff_t m_bRenderToCubemaps = 0x128; // bool + constexpr std::ptrdiff_t m_nDirectLight = 0x12C; // int32_t + constexpr std::ptrdiff_t m_nIndirectLight = 0x130; // int32_t + constexpr std::ptrdiff_t m_flFadeMinDist = 0x134; // float + constexpr std::ptrdiff_t m_flFadeMaxDist = 0x138; // float + constexpr std::ptrdiff_t m_flShadowFadeMinDist = 0x13C; // float + constexpr std::ptrdiff_t m_flShadowFadeMaxDist = 0x140; // float + constexpr std::ptrdiff_t m_bEnabled = 0x144; // bool + constexpr std::ptrdiff_t m_bFlicker = 0x145; // bool + constexpr std::ptrdiff_t m_bPrecomputedFieldsValid = 0x146; // bool + constexpr std::ptrdiff_t m_vPrecomputedBoundsMins = 0x148; // Vector + constexpr std::ptrdiff_t m_vPrecomputedBoundsMaxs = 0x154; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBOrigin = 0x160; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBAngles = 0x16C; // QAngle + constexpr std::ptrdiff_t m_vPrecomputedOBBExtent = 0x178; // Vector + constexpr std::ptrdiff_t m_flPrecomputedMaxRange = 0x184; // float + constexpr std::ptrdiff_t m_nFogLightingMode = 0x188; // int32_t + constexpr std::ptrdiff_t m_flFogContributionStength = 0x18C; // float + constexpr std::ptrdiff_t m_flNearClipPlane = 0x190; // float + constexpr std::ptrdiff_t m_SkyColor = 0x194; // Color + constexpr std::ptrdiff_t m_flSkyIntensity = 0x198; // float + constexpr std::ptrdiff_t m_SkyAmbientBounce = 0x19C; // Color + constexpr std::ptrdiff_t m_bUseSecondaryColor = 0x1A0; // bool + constexpr std::ptrdiff_t m_bMixedShadows = 0x1A1; // bool + constexpr std::ptrdiff_t m_flLightStyleStartTime = 0x1A4; // GameTime_t + constexpr std::ptrdiff_t m_flCapsuleLength = 0x1A8; // float + constexpr std::ptrdiff_t m_flMinRoughness = 0x1AC; // float +} + +namespace CLogicRelay { // CLogicalEntity + constexpr std::ptrdiff_t m_OnTrigger = 0x540; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnSpawn = 0x568; // CEntityIOOutput + constexpr std::ptrdiff_t m_bDisabled = 0x590; // bool + constexpr std::ptrdiff_t m_bWaitForRefire = 0x591; // bool + constexpr std::ptrdiff_t m_bTriggerOnce = 0x592; // bool + constexpr std::ptrdiff_t m_bFastRetrigger = 0x593; // bool + constexpr std::ptrdiff_t m_bPassthoughCaller = 0x594; // bool +} + +namespace CLogicalEntity { // C_BaseEntity +} + +namespace CModelState { + constexpr std::ptrdiff_t m_hModel = 0xA0; // CStrongHandle + constexpr std::ptrdiff_t m_ModelName = 0xA8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bClientClothCreationSuppressed = 0xE8; // bool + constexpr std::ptrdiff_t m_MeshGroupMask = 0x180; // uint64_t + constexpr std::ptrdiff_t m_nIdealMotionType = 0x222; // int8_t + constexpr std::ptrdiff_t m_nForceLOD = 0x223; // int8_t + constexpr std::ptrdiff_t m_nClothUpdateFlags = 0x224; // int8_t +} + +namespace CNetworkedSequenceOperation { + constexpr std::ptrdiff_t m_hSequence = 0x8; // HSequence + constexpr std::ptrdiff_t m_flPrevCycle = 0xC; // float + constexpr std::ptrdiff_t m_flCycle = 0x10; // float + constexpr std::ptrdiff_t m_flWeight = 0x14; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_bSequenceChangeNetworked = 0x1C; // bool + constexpr std::ptrdiff_t m_bDiscontinuity = 0x1D; // bool + constexpr std::ptrdiff_t m_flPrevCycleFromDiscontinuity = 0x20; // float + constexpr std::ptrdiff_t m_flPrevCycleForAnimEventDetection = 0x24; // float +} + +namespace CPlayerSprayDecalRenderHelper { +} + +namespace CPlayer_AutoaimServices { // CPlayerPawnComponent +} + +namespace CPlayer_CameraServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_vecCsViewPunchAngle = 0x40; // QAngle + constexpr std::ptrdiff_t m_nCsViewPunchAngleTick = 0x4C; // GameTick_t + constexpr std::ptrdiff_t m_flCsViewPunchAngleTickRatio = 0x50; // float + constexpr std::ptrdiff_t m_PlayerFog = 0x58; // C_fogplayerparams_t + constexpr std::ptrdiff_t m_hColorCorrectionCtrl = 0x98; // CHandle + constexpr std::ptrdiff_t m_hViewEntity = 0x9C; // CHandle + constexpr std::ptrdiff_t m_hTonemapController = 0xA0; // CHandle + constexpr std::ptrdiff_t m_audio = 0xA8; // audioparams_t + constexpr std::ptrdiff_t m_PostProcessingVolumes = 0x120; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_flOldPlayerZ = 0x138; // float + constexpr std::ptrdiff_t m_flOldPlayerViewOffsetZ = 0x13C; // float + constexpr std::ptrdiff_t m_CurrentFog = 0x140; // fogparams_t + constexpr std::ptrdiff_t m_hOldFogController = 0x1A8; // CHandle + constexpr std::ptrdiff_t m_bOverrideFogColor = 0x1AC; // bool[5] + constexpr std::ptrdiff_t m_OverrideFogColor = 0x1B1; // Color[5] + constexpr std::ptrdiff_t m_bOverrideFogStartEnd = 0x1C5; // bool[5] + constexpr std::ptrdiff_t m_fOverrideFogStart = 0x1CC; // float[5] + constexpr std::ptrdiff_t m_fOverrideFogEnd = 0x1E0; // float[5] + constexpr std::ptrdiff_t m_hActivePostProcessingVolume = 0x1F4; // CHandle + constexpr std::ptrdiff_t m_angDemoViewAngles = 0x1F8; // QAngle +} + +namespace CPlayer_FlashlightServices { // CPlayerPawnComponent +} + +namespace CPlayer_ItemServices { // CPlayerPawnComponent +} + +namespace CPlayer_MovementServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_nImpulse = 0x40; // int32_t + constexpr std::ptrdiff_t m_nButtons = 0x48; // CInButtonState + constexpr std::ptrdiff_t m_nQueuedButtonDownMask = 0x68; // uint64_t + constexpr std::ptrdiff_t m_nQueuedButtonChangeMask = 0x70; // uint64_t + constexpr std::ptrdiff_t m_nButtonDoublePressed = 0x78; // uint64_t + constexpr std::ptrdiff_t m_pButtonPressedCmdNumber = 0x80; // uint32_t[64] + constexpr std::ptrdiff_t m_nLastCommandNumberProcessed = 0x180; // uint32_t + constexpr std::ptrdiff_t m_nToggleButtonDownMask = 0x188; // uint64_t + constexpr std::ptrdiff_t m_flMaxspeed = 0x190; // float + constexpr std::ptrdiff_t m_arrForceSubtickMoveWhen = 0x194; // float[4] + constexpr std::ptrdiff_t m_flForwardMove = 0x1A4; // float + constexpr std::ptrdiff_t m_flLeftMove = 0x1A8; // float + constexpr std::ptrdiff_t m_flUpMove = 0x1AC; // float + constexpr std::ptrdiff_t m_vecLastMovementImpulses = 0x1B0; // Vector + constexpr std::ptrdiff_t m_vecOldViewAngles = 0x1BC; // QAngle +} + +namespace CPlayer_MovementServices_Humanoid { // CPlayer_MovementServices + constexpr std::ptrdiff_t m_flStepSoundTime = 0x1D0; // float + constexpr std::ptrdiff_t m_flFallVelocity = 0x1D4; // float + constexpr std::ptrdiff_t m_bInCrouch = 0x1D8; // bool + constexpr std::ptrdiff_t m_nCrouchState = 0x1DC; // uint32_t + constexpr std::ptrdiff_t m_flCrouchTransitionStartTime = 0x1E0; // GameTime_t + constexpr std::ptrdiff_t m_bDucked = 0x1E4; // bool + constexpr std::ptrdiff_t m_bDucking = 0x1E5; // bool + constexpr std::ptrdiff_t m_bInDuckJump = 0x1E6; // bool + constexpr std::ptrdiff_t m_groundNormal = 0x1E8; // Vector + constexpr std::ptrdiff_t m_flSurfaceFriction = 0x1F4; // float + constexpr std::ptrdiff_t m_surfaceProps = 0x1F8; // CUtlStringToken + constexpr std::ptrdiff_t m_nStepside = 0x208; // int32_t +} + +namespace CPlayer_ObserverServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_iObserverMode = 0x40; // uint8_t + constexpr std::ptrdiff_t m_hObserverTarget = 0x44; // CHandle + constexpr std::ptrdiff_t m_iObserverLastMode = 0x48; // ObserverMode_t + constexpr std::ptrdiff_t m_bForcedObserverMode = 0x4C; // bool + constexpr std::ptrdiff_t m_flObserverChaseDistance = 0x50; // float + constexpr std::ptrdiff_t m_flObserverChaseDistanceCalcTime = 0x54; // GameTime_t +} + +namespace CPlayer_UseServices { // CPlayerPawnComponent +} + +namespace CPlayer_ViewModelServices { // CPlayerPawnComponent +} + +namespace CPlayer_WaterServices { // CPlayerPawnComponent +} + +namespace CPlayer_WeaponServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_bAllowSwitchToNoWeapon = 0x40; // bool + constexpr std::ptrdiff_t m_hMyWeapons = 0x48; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_hActiveWeapon = 0x60; // CHandle + constexpr std::ptrdiff_t m_hLastWeapon = 0x64; // CHandle + constexpr std::ptrdiff_t m_iAmmo = 0x68; // uint16_t[32] +} + +namespace CPointOffScreenIndicatorUi { // C_PointClientUIWorldPanel + constexpr std::ptrdiff_t m_bBeenEnabled = 0xF20; // bool + constexpr std::ptrdiff_t m_bHide = 0xF21; // bool + constexpr std::ptrdiff_t m_flSeenTargetTime = 0xF24; // float + constexpr std::ptrdiff_t m_pTargetPanel = 0xF28; // C_PointClientUIWorldPanel* +} + +namespace CPointTemplate { // CLogicalEntity + constexpr std::ptrdiff_t m_iszWorldName = 0x540; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSource2EntityLumpName = 0x548; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszEntityFilterName = 0x550; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flTimeoutInterval = 0x558; // float + constexpr std::ptrdiff_t m_bAsynchronouslySpawnEntities = 0x55C; // bool + constexpr std::ptrdiff_t m_pOutputOnSpawned = 0x560; // CEntityIOOutput + constexpr std::ptrdiff_t m_clientOnlyEntityBehavior = 0x588; // PointTemplateClientOnlyEntityBehavior_t + constexpr std::ptrdiff_t m_ownerSpawnGroupType = 0x58C; // PointTemplateOwnerSpawnGroupType_t + constexpr std::ptrdiff_t m_createdSpawnGroupHandles = 0x590; // CUtlVector + constexpr std::ptrdiff_t m_SpawnedEntityHandles = 0x5A8; // CUtlVector + constexpr std::ptrdiff_t m_ScriptSpawnCallback = 0x5C0; // HSCRIPT + constexpr std::ptrdiff_t m_ScriptCallbackScope = 0x5C8; // HSCRIPT +} + +namespace CPrecipitationVData { // CEntitySubclassVDataBase + constexpr std::ptrdiff_t m_szParticlePrecipitationEffect = 0x28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_flInnerDistance = 0x108; // float + constexpr std::ptrdiff_t m_nAttachType = 0x10C; // ParticleAttachment_t + constexpr std::ptrdiff_t m_bBatchSameVolumeType = 0x110; // bool + constexpr std::ptrdiff_t m_nRTEnvCP = 0x114; // int32_t + constexpr std::ptrdiff_t m_nRTEnvCPComponent = 0x118; // int32_t + constexpr std::ptrdiff_t m_szModifier = 0x120; // CUtlString +} + +namespace CProjectedTextureBase { + constexpr std::ptrdiff_t m_hTargetEntity = 0xC; // CHandle + constexpr std::ptrdiff_t m_bState = 0x10; // bool + constexpr std::ptrdiff_t m_bAlwaysUpdate = 0x11; // bool + constexpr std::ptrdiff_t m_flLightFOV = 0x14; // float + constexpr std::ptrdiff_t m_bEnableShadows = 0x18; // bool + constexpr std::ptrdiff_t m_bSimpleProjection = 0x19; // bool + constexpr std::ptrdiff_t m_bLightOnlyTarget = 0x1A; // bool + constexpr std::ptrdiff_t m_bLightWorld = 0x1B; // bool + constexpr std::ptrdiff_t m_bCameraSpace = 0x1C; // bool + constexpr std::ptrdiff_t m_flBrightnessScale = 0x20; // float + constexpr std::ptrdiff_t m_LightColor = 0x24; // Color + constexpr std::ptrdiff_t m_flIntensity = 0x28; // float + constexpr std::ptrdiff_t m_flLinearAttenuation = 0x2C; // float + constexpr std::ptrdiff_t m_flQuadraticAttenuation = 0x30; // float + constexpr std::ptrdiff_t m_bVolumetric = 0x34; // bool + constexpr std::ptrdiff_t m_flVolumetricIntensity = 0x38; // float + constexpr std::ptrdiff_t m_flNoiseStrength = 0x3C; // float + constexpr std::ptrdiff_t m_flFlashlightTime = 0x40; // float + constexpr std::ptrdiff_t m_nNumPlanes = 0x44; // uint32_t + constexpr std::ptrdiff_t m_flPlaneOffset = 0x48; // float + constexpr std::ptrdiff_t m_flColorTransitionTime = 0x4C; // float + constexpr std::ptrdiff_t m_flAmbient = 0x50; // float + constexpr std::ptrdiff_t m_SpotlightTextureName = 0x54; // char[512] + constexpr std::ptrdiff_t m_nSpotlightTextureFrame = 0x254; // int32_t + constexpr std::ptrdiff_t m_nShadowQuality = 0x258; // uint32_t + constexpr std::ptrdiff_t m_flNearZ = 0x25C; // float + constexpr std::ptrdiff_t m_flFarZ = 0x260; // float + constexpr std::ptrdiff_t m_flProjectionSize = 0x264; // float + constexpr std::ptrdiff_t m_flRotation = 0x268; // float + constexpr std::ptrdiff_t m_bFlipHorizontal = 0x26C; // bool +} + +namespace CRenderComponent { // CEntityComponent + constexpr std::ptrdiff_t __m_pChainEntity = 0x10; // CNetworkVarChainer + constexpr std::ptrdiff_t m_bIsRenderingWithViewModels = 0x50; // bool + constexpr std::ptrdiff_t m_nSplitscreenFlags = 0x54; // uint32_t + constexpr std::ptrdiff_t m_bEnableRendering = 0x60; // bool + constexpr std::ptrdiff_t m_bInterpolationReadyToDraw = 0xB0; // bool +} + +namespace CSMatchStats_t { // CSPerRoundStats_t + constexpr std::ptrdiff_t m_iEnemy5Ks = 0x68; // int32_t + constexpr std::ptrdiff_t m_iEnemy4Ks = 0x6C; // int32_t + constexpr std::ptrdiff_t m_iEnemy3Ks = 0x70; // int32_t +} + +namespace CSPerRoundStats_t { + constexpr std::ptrdiff_t m_iKills = 0x30; // int32_t + constexpr std::ptrdiff_t m_iDeaths = 0x34; // int32_t + constexpr std::ptrdiff_t m_iAssists = 0x38; // int32_t + constexpr std::ptrdiff_t m_iDamage = 0x3C; // int32_t + constexpr std::ptrdiff_t m_iEquipmentValue = 0x40; // int32_t + constexpr std::ptrdiff_t m_iMoneySaved = 0x44; // int32_t + constexpr std::ptrdiff_t m_iKillReward = 0x48; // int32_t + constexpr std::ptrdiff_t m_iLiveTime = 0x4C; // int32_t + constexpr std::ptrdiff_t m_iHeadShotKills = 0x50; // int32_t + constexpr std::ptrdiff_t m_iObjective = 0x54; // int32_t + constexpr std::ptrdiff_t m_iCashEarned = 0x58; // int32_t + constexpr std::ptrdiff_t m_iUtilityDamage = 0x5C; // int32_t + constexpr std::ptrdiff_t m_iEnemiesFlashed = 0x60; // int32_t +} + +namespace CScriptComponent { // CEntityComponent + constexpr std::ptrdiff_t m_scriptClassName = 0x30; // CUtlSymbolLarge +} + +namespace CServerOnlyModelEntity { // C_BaseModelEntity +} + +namespace CSkeletonInstance { // CGameSceneNode + constexpr std::ptrdiff_t m_modelState = 0x160; // CModelState + constexpr std::ptrdiff_t m_bIsAnimationEnabled = 0x390; // bool + constexpr std::ptrdiff_t m_bUseParentRenderBounds = 0x391; // bool + constexpr std::ptrdiff_t m_bDisableSolidCollisionsForHierarchy = 0x392; // bool + constexpr std::ptrdiff_t m_bDirtyMotionType = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bIsGeneratingLatchedParentSpaceState = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_materialGroup = 0x394; // CUtlStringToken + constexpr std::ptrdiff_t m_nHitboxSet = 0x398; // uint8_t +} + +namespace CSkyboxReference { // C_BaseEntity + constexpr std::ptrdiff_t m_worldGroupId = 0x540; // WorldGroupId_t + constexpr std::ptrdiff_t m_hSkyCamera = 0x544; // CHandle +} + +namespace CTablet { // C_CSWeaponBase +} + +namespace CTimeline { // IntervalTimer + constexpr std::ptrdiff_t m_flValues = 0x10; // float[64] + constexpr std::ptrdiff_t m_nValueCounts = 0x110; // int32_t[64] + constexpr std::ptrdiff_t m_nBucketCount = 0x210; // int32_t + constexpr std::ptrdiff_t m_flInterval = 0x214; // float + constexpr std::ptrdiff_t m_flFinalValue = 0x218; // float + constexpr std::ptrdiff_t m_nCompressionType = 0x21C; // TimelineCompression_t + constexpr std::ptrdiff_t m_bStopped = 0x220; // bool +} + +namespace CTripWireFire { // C_BaseCSGrenade +} + +namespace CTripWireFireProjectile { // C_BaseGrenade +} + +namespace CWaterSplasher { // C_BaseModelEntity +} + +namespace CWeaponZoneRepulsor { // C_CSWeaponBaseGun +} + +namespace C_AK47 { // C_CSWeaponBaseGun +} + +namespace C_AttributeContainer { // CAttributeManager + constexpr std::ptrdiff_t m_Item = 0x50; // C_EconItemView + constexpr std::ptrdiff_t m_iExternalItemProviderRegisteredToken = 0x498; // int32_t + constexpr std::ptrdiff_t m_ullRegisteredAsItemID = 0x4A0; // uint64_t +} + +namespace C_BarnLight { // C_BaseModelEntity + constexpr std::ptrdiff_t m_bEnabled = 0xCC0; // bool + constexpr std::ptrdiff_t m_nColorMode = 0xCC4; // int32_t + constexpr std::ptrdiff_t m_Color = 0xCC8; // Color + constexpr std::ptrdiff_t m_flColorTemperature = 0xCCC; // float + constexpr std::ptrdiff_t m_flBrightness = 0xCD0; // float + constexpr std::ptrdiff_t m_flBrightnessScale = 0xCD4; // float + constexpr std::ptrdiff_t m_nDirectLight = 0xCD8; // int32_t + constexpr std::ptrdiff_t m_nBakedShadowIndex = 0xCDC; // int32_t + constexpr std::ptrdiff_t m_nLuminaireShape = 0xCE0; // int32_t + constexpr std::ptrdiff_t m_flLuminaireSize = 0xCE4; // float + constexpr std::ptrdiff_t m_flLuminaireAnisotropy = 0xCE8; // float + constexpr std::ptrdiff_t m_LightStyleString = 0xCF0; // CUtlString + constexpr std::ptrdiff_t m_flLightStyleStartTime = 0xCF8; // GameTime_t + constexpr std::ptrdiff_t m_QueuedLightStyleStrings = 0xD00; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_LightStyleEvents = 0xD18; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_LightStyleTargets = 0xD30; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_StyleEvent = 0xD48; // CEntityIOOutput[4] + constexpr std::ptrdiff_t m_hLightCookie = 0xDE8; // CStrongHandle + constexpr std::ptrdiff_t m_flShape = 0xDF0; // float + constexpr std::ptrdiff_t m_flSoftX = 0xDF4; // float + constexpr std::ptrdiff_t m_flSoftY = 0xDF8; // float + constexpr std::ptrdiff_t m_flSkirt = 0xDFC; // float + constexpr std::ptrdiff_t m_flSkirtNear = 0xE00; // float + constexpr std::ptrdiff_t m_vSizeParams = 0xE04; // Vector + constexpr std::ptrdiff_t m_flRange = 0xE10; // float + constexpr std::ptrdiff_t m_vShear = 0xE14; // Vector + constexpr std::ptrdiff_t m_nBakeSpecularToCubemaps = 0xE20; // int32_t + constexpr std::ptrdiff_t m_vBakeSpecularToCubemapsSize = 0xE24; // Vector + constexpr std::ptrdiff_t m_nCastShadows = 0xE30; // int32_t + constexpr std::ptrdiff_t m_nShadowMapSize = 0xE34; // int32_t + constexpr std::ptrdiff_t m_nShadowPriority = 0xE38; // int32_t + constexpr std::ptrdiff_t m_bContactShadow = 0xE3C; // bool + constexpr std::ptrdiff_t m_nBounceLight = 0xE40; // int32_t + constexpr std::ptrdiff_t m_flBounceScale = 0xE44; // float + constexpr std::ptrdiff_t m_flMinRoughness = 0xE48; // float + constexpr std::ptrdiff_t m_vAlternateColor = 0xE4C; // Vector + constexpr std::ptrdiff_t m_fAlternateColorBrightness = 0xE58; // float + constexpr std::ptrdiff_t m_nFog = 0xE5C; // int32_t + constexpr std::ptrdiff_t m_flFogStrength = 0xE60; // float + constexpr std::ptrdiff_t m_nFogShadows = 0xE64; // int32_t + constexpr std::ptrdiff_t m_flFogScale = 0xE68; // float + constexpr std::ptrdiff_t m_flFadeSizeStart = 0xE6C; // float + constexpr std::ptrdiff_t m_flFadeSizeEnd = 0xE70; // float + constexpr std::ptrdiff_t m_flShadowFadeSizeStart = 0xE74; // float + constexpr std::ptrdiff_t m_flShadowFadeSizeEnd = 0xE78; // float + constexpr std::ptrdiff_t m_bPrecomputedFieldsValid = 0xE7C; // bool + constexpr std::ptrdiff_t m_vPrecomputedBoundsMins = 0xE80; // Vector + constexpr std::ptrdiff_t m_vPrecomputedBoundsMaxs = 0xE8C; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBOrigin = 0xE98; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBAngles = 0xEA4; // QAngle + constexpr std::ptrdiff_t m_vPrecomputedOBBExtent = 0xEB0; // Vector +} + +namespace C_BaseButton { // C_BaseToggle + constexpr std::ptrdiff_t m_glowEntity = 0xCC0; // CHandle + constexpr std::ptrdiff_t m_usable = 0xCC4; // bool + constexpr std::ptrdiff_t m_szDisplayText = 0xCC8; // CUtlSymbolLarge +} + +namespace C_BaseCSGrenade { // C_CSWeaponBase + constexpr std::ptrdiff_t m_bClientPredictDelete = 0x1990; // bool + constexpr std::ptrdiff_t m_bRedraw = 0x1991; // bool + constexpr std::ptrdiff_t m_bIsHeldByPlayer = 0x1992; // bool + constexpr std::ptrdiff_t m_bPinPulled = 0x1993; // bool + constexpr std::ptrdiff_t m_bJumpThrow = 0x1994; // bool + constexpr std::ptrdiff_t m_eThrowStatus = 0x1998; // EGrenadeThrowState + constexpr std::ptrdiff_t m_fThrowTime = 0x199C; // GameTime_t + constexpr std::ptrdiff_t m_flThrowStrength = 0x19A0; // float + constexpr std::ptrdiff_t m_flThrowStrengthApproach = 0x19A4; // float + constexpr std::ptrdiff_t m_fDropTime = 0x19A8; // GameTime_t +} + +namespace C_BaseCSGrenadeProjectile { // C_BaseGrenade + constexpr std::ptrdiff_t m_vInitialVelocity = 0x1068; // Vector + constexpr std::ptrdiff_t m_nBounces = 0x1074; // int32_t + constexpr std::ptrdiff_t m_nExplodeEffectIndex = 0x1078; // CStrongHandle + constexpr std::ptrdiff_t m_nExplodeEffectTickBegin = 0x1080; // int32_t + constexpr std::ptrdiff_t m_vecExplodeEffectOrigin = 0x1084; // Vector + constexpr std::ptrdiff_t m_flSpawnTime = 0x1090; // GameTime_t + constexpr std::ptrdiff_t vecLastTrailLinePos = 0x1094; // Vector + constexpr std::ptrdiff_t flNextTrailLineTime = 0x10A0; // GameTime_t + constexpr std::ptrdiff_t m_bExplodeEffectBegan = 0x10A4; // bool + constexpr std::ptrdiff_t m_bCanCreateGrenadeTrail = 0x10A5; // bool + constexpr std::ptrdiff_t m_nSnapshotTrajectoryEffectIndex = 0x10A8; // ParticleIndex_t + constexpr std::ptrdiff_t m_hSnapshotTrajectoryParticleSnapshot = 0x10B0; // CStrongHandle + constexpr std::ptrdiff_t m_arrTrajectoryTrailPoints = 0x10B8; // CUtlVector + constexpr std::ptrdiff_t m_arrTrajectoryTrailPointCreationTimes = 0x10D0; // CUtlVector + constexpr std::ptrdiff_t m_flTrajectoryTrailEffectCreationTime = 0x10E8; // float +} + +namespace C_BaseClientUIEntity { // C_BaseModelEntity + constexpr std::ptrdiff_t m_bEnabled = 0xCC8; // bool + constexpr std::ptrdiff_t m_DialogXMLName = 0xCD0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_PanelClassName = 0xCD8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_PanelID = 0xCE0; // CUtlSymbolLarge +} + +namespace C_BaseCombatCharacter { // C_BaseFlex + constexpr std::ptrdiff_t m_hMyWearables = 0x1018; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_bloodColor = 0x1030; // int32_t + constexpr std::ptrdiff_t m_leftFootAttachment = 0x1034; // AttachmentHandle_t + constexpr std::ptrdiff_t m_rightFootAttachment = 0x1035; // AttachmentHandle_t + constexpr std::ptrdiff_t m_nWaterWakeMode = 0x1038; // C_BaseCombatCharacter::WaterWakeMode_t + constexpr std::ptrdiff_t m_flWaterWorldZ = 0x103C; // float + constexpr std::ptrdiff_t m_flWaterNextTraceTime = 0x1040; // float + constexpr std::ptrdiff_t m_flFieldOfView = 0x1044; // float +} + +namespace C_BaseDoor { // C_BaseToggle + constexpr std::ptrdiff_t m_bIsUsable = 0xCC0; // bool +} + +namespace C_BaseEntity { // CEntityInstance + constexpr std::ptrdiff_t m_CBodyComponent = 0x30; // CBodyComponent* + constexpr std::ptrdiff_t m_NetworkTransmitComponent = 0x38; // CNetworkTransmitComponent + constexpr std::ptrdiff_t m_nLastThinkTick = 0x308; // GameTick_t + constexpr std::ptrdiff_t m_pGameSceneNode = 0x310; // CGameSceneNode* + constexpr std::ptrdiff_t m_pRenderComponent = 0x318; // CRenderComponent* + constexpr std::ptrdiff_t m_pCollision = 0x320; // CCollisionProperty* + constexpr std::ptrdiff_t m_iMaxHealth = 0x328; // int32_t + constexpr std::ptrdiff_t m_iHealth = 0x32C; // int32_t + constexpr std::ptrdiff_t m_lifeState = 0x330; // uint8_t + constexpr std::ptrdiff_t m_bTakesDamage = 0x331; // bool + constexpr std::ptrdiff_t m_nTakeDamageFlags = 0x334; // TakeDamageFlags_t + constexpr std::ptrdiff_t m_ubInterpolationFrame = 0x338; // uint8_t + constexpr std::ptrdiff_t m_hSceneObjectController = 0x33C; // CHandle + constexpr std::ptrdiff_t m_nNoInterpolationTick = 0x340; // int32_t + constexpr std::ptrdiff_t m_nVisibilityNoInterpolationTick = 0x344; // int32_t + constexpr std::ptrdiff_t m_flProxyRandomValue = 0x348; // float + constexpr std::ptrdiff_t m_iEFlags = 0x34C; // int32_t + constexpr std::ptrdiff_t m_nWaterType = 0x350; // uint8_t + constexpr std::ptrdiff_t m_bInterpolateEvenWithNoModel = 0x351; // bool + constexpr std::ptrdiff_t m_bPredictionEligible = 0x352; // bool + constexpr std::ptrdiff_t m_bApplyLayerMatchIDToModel = 0x353; // bool + constexpr std::ptrdiff_t m_tokLayerMatchID = 0x354; // CUtlStringToken + constexpr std::ptrdiff_t m_nSubclassID = 0x358; // CUtlStringToken + constexpr std::ptrdiff_t m_nSimulationTick = 0x368; // int32_t + constexpr std::ptrdiff_t m_iCurrentThinkContext = 0x36C; // int32_t + constexpr std::ptrdiff_t m_aThinkFunctions = 0x370; // CUtlVector + constexpr std::ptrdiff_t m_flAnimTime = 0x388; // float + constexpr std::ptrdiff_t m_flSimulationTime = 0x38C; // float + constexpr std::ptrdiff_t m_nSceneObjectOverrideFlags = 0x390; // uint8_t + constexpr std::ptrdiff_t m_bHasSuccessfullyInterpolated = 0x391; // bool + constexpr std::ptrdiff_t m_bHasAddedVarsToInterpolation = 0x392; // bool + constexpr std::ptrdiff_t m_bRenderEvenWhenNotSuccessfullyInterpolated = 0x393; // bool + constexpr std::ptrdiff_t m_nInterpolationLatchDirtyFlags = 0x394; // int32_t[2] + constexpr std::ptrdiff_t m_ListEntry = 0x39C; // uint16_t[11] + constexpr std::ptrdiff_t m_flCreateTime = 0x3B4; // GameTime_t + constexpr std::ptrdiff_t m_flSpeed = 0x3B8; // float + constexpr std::ptrdiff_t m_EntClientFlags = 0x3BC; // uint16_t + constexpr std::ptrdiff_t m_bClientSideRagdoll = 0x3BE; // bool + constexpr std::ptrdiff_t m_iTeamNum = 0x3BF; // uint8_t + constexpr std::ptrdiff_t m_spawnflags = 0x3C0; // uint32_t + constexpr std::ptrdiff_t m_nNextThinkTick = 0x3C4; // GameTick_t + constexpr std::ptrdiff_t m_fFlags = 0x3C8; // uint32_t + constexpr std::ptrdiff_t m_vecAbsVelocity = 0x3CC; // Vector + constexpr std::ptrdiff_t m_vecVelocity = 0x3D8; // CNetworkVelocityVector + constexpr std::ptrdiff_t m_vecBaseVelocity = 0x408; // Vector + constexpr std::ptrdiff_t m_hEffectEntity = 0x414; // CHandle + constexpr std::ptrdiff_t m_hOwnerEntity = 0x418; // CHandle + constexpr std::ptrdiff_t m_MoveCollide = 0x41C; // MoveCollide_t + constexpr std::ptrdiff_t m_MoveType = 0x41D; // MoveType_t + constexpr std::ptrdiff_t m_flWaterLevel = 0x420; // float + constexpr std::ptrdiff_t m_fEffects = 0x424; // uint32_t + constexpr std::ptrdiff_t m_hGroundEntity = 0x428; // CHandle + constexpr std::ptrdiff_t m_flFriction = 0x42C; // float + constexpr std::ptrdiff_t m_flElasticity = 0x430; // float + constexpr std::ptrdiff_t m_flGravityScale = 0x434; // float + constexpr std::ptrdiff_t m_flTimeScale = 0x438; // float + constexpr std::ptrdiff_t m_bSimulatedEveryTick = 0x43C; // bool + constexpr std::ptrdiff_t m_bAnimatedEveryTick = 0x43D; // bool + constexpr std::ptrdiff_t m_flNavIgnoreUntilTime = 0x440; // GameTime_t + constexpr std::ptrdiff_t m_hThink = 0x444; // uint16_t + constexpr std::ptrdiff_t m_fBBoxVisFlags = 0x450; // uint8_t + constexpr std::ptrdiff_t m_bPredictable = 0x451; // bool + constexpr std::ptrdiff_t m_bRenderWithViewModels = 0x452; // bool + constexpr std::ptrdiff_t m_nSplitUserPlayerPredictionSlot = 0x454; // CSplitScreenSlot + constexpr std::ptrdiff_t m_nFirstPredictableCommand = 0x458; // int32_t + constexpr std::ptrdiff_t m_nLastPredictableCommand = 0x45C; // int32_t + constexpr std::ptrdiff_t m_hOldMoveParent = 0x460; // CHandle + constexpr std::ptrdiff_t m_Particles = 0x468; // CParticleProperty + constexpr std::ptrdiff_t m_vecPredictedScriptFloats = 0x490; // CUtlVector + constexpr std::ptrdiff_t m_vecPredictedScriptFloatIDs = 0x4A8; // CUtlVector + constexpr std::ptrdiff_t m_nNextScriptVarRecordID = 0x4D8; // int32_t + constexpr std::ptrdiff_t m_vecAngVelocity = 0x4E8; // QAngle + constexpr std::ptrdiff_t m_DataChangeEventRef = 0x4F4; // int32_t + constexpr std::ptrdiff_t m_dependencies = 0x4F8; // CUtlVector + constexpr std::ptrdiff_t m_nCreationTick = 0x510; // int32_t + constexpr std::ptrdiff_t m_bAnimTimeChanged = 0x529; // bool + constexpr std::ptrdiff_t m_bSimulationTimeChanged = 0x52A; // bool + constexpr std::ptrdiff_t m_sUniqueHammerID = 0x538; // CUtlString +} + +namespace C_BaseFire { // C_BaseEntity + constexpr std::ptrdiff_t m_flScale = 0x540; // float + constexpr std::ptrdiff_t m_flStartScale = 0x544; // float + constexpr std::ptrdiff_t m_flScaleTime = 0x548; // float + constexpr std::ptrdiff_t m_nFlags = 0x54C; // uint32_t +} + +namespace C_BaseFlex { // CBaseAnimGraph + constexpr std::ptrdiff_t m_flexWeight = 0xE90; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_vLookTargetPosition = 0xEA8; // Vector + constexpr std::ptrdiff_t m_blinktoggle = 0xEC0; // bool + constexpr std::ptrdiff_t m_nLastFlexUpdateFrameCount = 0xF20; // int32_t + constexpr std::ptrdiff_t m_CachedViewTarget = 0xF24; // Vector + constexpr std::ptrdiff_t m_nNextSceneEventId = 0xF30; // uint32_t + constexpr std::ptrdiff_t m_iBlink = 0xF34; // int32_t + constexpr std::ptrdiff_t m_blinktime = 0xF38; // float + constexpr std::ptrdiff_t m_prevblinktoggle = 0xF3C; // bool + constexpr std::ptrdiff_t m_iJawOpen = 0xF40; // int32_t + constexpr std::ptrdiff_t m_flJawOpenAmount = 0xF44; // float + constexpr std::ptrdiff_t m_flBlinkAmount = 0xF48; // float + constexpr std::ptrdiff_t m_iMouthAttachment = 0xF4C; // AttachmentHandle_t + constexpr std::ptrdiff_t m_iEyeAttachment = 0xF4D; // AttachmentHandle_t + constexpr std::ptrdiff_t m_bResetFlexWeightsOnModelChange = 0xF4E; // bool + constexpr std::ptrdiff_t m_nEyeOcclusionRendererBone = 0xF68; // int32_t + constexpr std::ptrdiff_t m_mEyeOcclusionRendererCameraToBoneTransform = 0xF6C; // matrix3x4_t + constexpr std::ptrdiff_t m_vEyeOcclusionRendererHalfExtent = 0xF9C; // Vector + constexpr std::ptrdiff_t m_PhonemeClasses = 0xFB8; // C_BaseFlex::Emphasized_Phoneme[3] +} + +namespace C_BaseFlex_Emphasized_Phoneme { + constexpr std::ptrdiff_t m_sClassName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_flAmount = 0x18; // float + constexpr std::ptrdiff_t m_bRequired = 0x1C; // bool + constexpr std::ptrdiff_t m_bBasechecked = 0x1D; // bool + constexpr std::ptrdiff_t m_bValid = 0x1E; // bool +} + +namespace C_BaseGrenade { // C_BaseFlex + constexpr std::ptrdiff_t m_bHasWarnedAI = 0x1018; // bool + constexpr std::ptrdiff_t m_bIsSmokeGrenade = 0x1019; // bool + constexpr std::ptrdiff_t m_bIsLive = 0x101A; // bool + constexpr std::ptrdiff_t m_DmgRadius = 0x101C; // float + constexpr std::ptrdiff_t m_flDetonateTime = 0x1020; // GameTime_t + constexpr std::ptrdiff_t m_flWarnAITime = 0x1024; // float + constexpr std::ptrdiff_t m_flDamage = 0x1028; // float + constexpr std::ptrdiff_t m_iszBounceSound = 0x1030; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_ExplosionSound = 0x1038; // CUtlString + constexpr std::ptrdiff_t m_hThrower = 0x1044; // CHandle + constexpr std::ptrdiff_t m_flNextAttack = 0x105C; // GameTime_t + constexpr std::ptrdiff_t m_hOriginalThrower = 0x1060; // CHandle +} + +namespace C_BaseModelEntity { // C_BaseEntity + constexpr std::ptrdiff_t m_CRenderComponent = 0xA10; // CRenderComponent* + constexpr std::ptrdiff_t m_CHitboxComponent = 0xA18; // CHitboxComponent + constexpr std::ptrdiff_t m_bInitModelEffects = 0xA60; // bool + constexpr std::ptrdiff_t m_bIsStaticProp = 0xA61; // bool + constexpr std::ptrdiff_t m_nLastAddDecal = 0xA64; // int32_t + constexpr std::ptrdiff_t m_nDecalsAdded = 0xA68; // int32_t + constexpr std::ptrdiff_t m_iOldHealth = 0xA6C; // int32_t + constexpr std::ptrdiff_t m_nRenderMode = 0xA70; // RenderMode_t + constexpr std::ptrdiff_t m_nRenderFX = 0xA71; // RenderFx_t + constexpr std::ptrdiff_t m_bAllowFadeInView = 0xA72; // bool + constexpr std::ptrdiff_t m_clrRender = 0xA73; // Color + constexpr std::ptrdiff_t m_vecRenderAttributes = 0xA78; // C_UtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_bRenderToCubemaps = 0xAE0; // bool + constexpr std::ptrdiff_t m_Collision = 0xAE8; // CCollisionProperty + constexpr std::ptrdiff_t m_Glow = 0xB98; // CGlowProperty + constexpr std::ptrdiff_t m_flGlowBackfaceMult = 0xBF0; // float + constexpr std::ptrdiff_t m_fadeMinDist = 0xBF4; // float + constexpr std::ptrdiff_t m_fadeMaxDist = 0xBF8; // float + constexpr std::ptrdiff_t m_flFadeScale = 0xBFC; // float + constexpr std::ptrdiff_t m_flShadowStrength = 0xC00; // float + constexpr std::ptrdiff_t m_nObjectCulling = 0xC04; // uint8_t + constexpr std::ptrdiff_t m_nAddDecal = 0xC08; // int32_t + constexpr std::ptrdiff_t m_vDecalPosition = 0xC0C; // Vector + constexpr std::ptrdiff_t m_vDecalForwardAxis = 0xC18; // Vector + constexpr std::ptrdiff_t m_flDecalHealBloodRate = 0xC24; // float + constexpr std::ptrdiff_t m_flDecalHealHeightRate = 0xC28; // float + constexpr std::ptrdiff_t m_ConfigEntitiesToPropagateMaterialDecalsTo = 0xC30; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_vecViewOffset = 0xC48; // CNetworkViewOffsetVector + constexpr std::ptrdiff_t m_pClientAlphaProperty = 0xC78; // CClientAlphaProperty* + constexpr std::ptrdiff_t m_ClientOverrideTint = 0xC80; // Color + constexpr std::ptrdiff_t m_bUseClientOverrideTint = 0xC84; // bool +} + +namespace C_BasePlayerPawn { // C_BaseCombatCharacter + constexpr std::ptrdiff_t m_pWeaponServices = 0x10A8; // CPlayer_WeaponServices* + constexpr std::ptrdiff_t m_pItemServices = 0x10B0; // CPlayer_ItemServices* + constexpr std::ptrdiff_t m_pAutoaimServices = 0x10B8; // CPlayer_AutoaimServices* + constexpr std::ptrdiff_t m_pObserverServices = 0x10C0; // CPlayer_ObserverServices* + constexpr std::ptrdiff_t m_pWaterServices = 0x10C8; // CPlayer_WaterServices* + constexpr std::ptrdiff_t m_pUseServices = 0x10D0; // CPlayer_UseServices* + constexpr std::ptrdiff_t m_pFlashlightServices = 0x10D8; // CPlayer_FlashlightServices* + constexpr std::ptrdiff_t m_pCameraServices = 0x10E0; // CPlayer_CameraServices* + constexpr std::ptrdiff_t m_pMovementServices = 0x10E8; // CPlayer_MovementServices* + constexpr std::ptrdiff_t m_ServerViewAngleChanges = 0x10F8; // C_UtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_nHighestConsumedServerViewAngleChangeIndex = 0x1148; // uint32_t + constexpr std::ptrdiff_t v_angle = 0x114C; // QAngle + constexpr std::ptrdiff_t v_anglePrevious = 0x1158; // QAngle + constexpr std::ptrdiff_t m_iHideHUD = 0x1164; // uint32_t + constexpr std::ptrdiff_t m_skybox3d = 0x1168; // sky3dparams_t + constexpr std::ptrdiff_t m_flDeathTime = 0x11F8; // GameTime_t + constexpr std::ptrdiff_t m_vecPredictionError = 0x11FC; // Vector + constexpr std::ptrdiff_t m_flPredictionErrorTime = 0x1208; // GameTime_t + constexpr std::ptrdiff_t m_vecLastCameraSetupLocalOrigin = 0x120C; // Vector + constexpr std::ptrdiff_t m_flLastCameraSetupTime = 0x1218; // GameTime_t + constexpr std::ptrdiff_t m_flFOVSensitivityAdjust = 0x121C; // float + constexpr std::ptrdiff_t m_flMouseSensitivity = 0x1220; // float + constexpr std::ptrdiff_t m_vOldOrigin = 0x1224; // Vector + constexpr std::ptrdiff_t m_flOldSimulationTime = 0x1230; // float + constexpr std::ptrdiff_t m_nLastExecutedCommandNumber = 0x1234; // int32_t + constexpr std::ptrdiff_t m_nLastExecutedCommandTick = 0x1238; // int32_t + constexpr std::ptrdiff_t m_hController = 0x123C; // CHandle + constexpr std::ptrdiff_t m_bIsSwappingToPredictableController = 0x1240; // bool +} + +namespace C_BasePlayerWeapon { // C_EconEntity + constexpr std::ptrdiff_t m_nNextPrimaryAttackTick = 0x1560; // GameTick_t + constexpr std::ptrdiff_t m_flNextPrimaryAttackTickRatio = 0x1564; // float + constexpr std::ptrdiff_t m_nNextSecondaryAttackTick = 0x1568; // GameTick_t + constexpr std::ptrdiff_t m_flNextSecondaryAttackTickRatio = 0x156C; // float + constexpr std::ptrdiff_t m_iClip1 = 0x1570; // int32_t + constexpr std::ptrdiff_t m_iClip2 = 0x1574; // int32_t + constexpr std::ptrdiff_t m_pReserveAmmo = 0x1578; // int32_t[2] +} + +namespace C_BasePropDoor { // C_DynamicProp + constexpr std::ptrdiff_t m_eDoorState = 0x10F8; // DoorState_t + constexpr std::ptrdiff_t m_modelChanged = 0x10FC; // bool + constexpr std::ptrdiff_t m_bLocked = 0x10FD; // bool + constexpr std::ptrdiff_t m_closedPosition = 0x1100; // Vector + constexpr std::ptrdiff_t m_closedAngles = 0x110C; // QAngle + constexpr std::ptrdiff_t m_hMaster = 0x1118; // CHandle + constexpr std::ptrdiff_t m_vWhereToSetLightingOrigin = 0x111C; // Vector +} + +namespace C_BaseToggle { // C_BaseModelEntity +} + +namespace C_BaseTrigger { // C_BaseToggle + constexpr std::ptrdiff_t m_bDisabled = 0xCC0; // bool + constexpr std::ptrdiff_t m_bClientSidePredicted = 0xCC1; // bool +} + +namespace C_BaseViewModel { // CBaseAnimGraph + constexpr std::ptrdiff_t m_vecLastFacing = 0xE88; // Vector + constexpr std::ptrdiff_t m_nViewModelIndex = 0xE94; // uint32_t + constexpr std::ptrdiff_t m_nAnimationParity = 0xE98; // uint32_t + constexpr std::ptrdiff_t m_flAnimationStartTime = 0xE9C; // float + constexpr std::ptrdiff_t m_hWeapon = 0xEA0; // CHandle + constexpr std::ptrdiff_t m_sVMName = 0xEA8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sAnimationPrefix = 0xEB0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hWeaponModel = 0xEB8; // CHandle + constexpr std::ptrdiff_t m_iCameraAttachment = 0xEBC; // AttachmentHandle_t + constexpr std::ptrdiff_t m_vecLastCameraAngles = 0xEC0; // QAngle + constexpr std::ptrdiff_t m_previousElapsedDuration = 0xECC; // float + constexpr std::ptrdiff_t m_previousCycle = 0xED0; // float + constexpr std::ptrdiff_t m_nOldAnimationParity = 0xED4; // int32_t + constexpr std::ptrdiff_t m_hOldLayerSequence = 0xED8; // HSequence + constexpr std::ptrdiff_t m_oldLayer = 0xEDC; // int32_t + constexpr std::ptrdiff_t m_oldLayerStartTime = 0xEE0; // float + constexpr std::ptrdiff_t m_hControlPanel = 0xEE4; // CHandle +} + +namespace C_Beam { // C_BaseModelEntity + constexpr std::ptrdiff_t m_flFrameRate = 0xCC0; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0xCC4; // float + constexpr std::ptrdiff_t m_flFireTime = 0xCC8; // GameTime_t + constexpr std::ptrdiff_t m_flDamage = 0xCCC; // float + constexpr std::ptrdiff_t m_nNumBeamEnts = 0xCD0; // uint8_t + constexpr std::ptrdiff_t m_queryHandleHalo = 0xCD4; // int32_t + constexpr std::ptrdiff_t m_hBaseMaterial = 0xCF8; // CStrongHandle + constexpr std::ptrdiff_t m_nHaloIndex = 0xD00; // CStrongHandle + constexpr std::ptrdiff_t m_nBeamType = 0xD08; // BeamType_t + constexpr std::ptrdiff_t m_nBeamFlags = 0xD0C; // uint32_t + constexpr std::ptrdiff_t m_hAttachEntity = 0xD10; // CHandle[10] + constexpr std::ptrdiff_t m_nAttachIndex = 0xD38; // AttachmentHandle_t[10] + constexpr std::ptrdiff_t m_fWidth = 0xD44; // float + constexpr std::ptrdiff_t m_fEndWidth = 0xD48; // float + constexpr std::ptrdiff_t m_fFadeLength = 0xD4C; // float + constexpr std::ptrdiff_t m_fHaloScale = 0xD50; // float + constexpr std::ptrdiff_t m_fAmplitude = 0xD54; // float + constexpr std::ptrdiff_t m_fStartFrame = 0xD58; // float + constexpr std::ptrdiff_t m_fSpeed = 0xD5C; // float + constexpr std::ptrdiff_t m_flFrame = 0xD60; // float + constexpr std::ptrdiff_t m_nClipStyle = 0xD64; // BeamClipStyle_t + constexpr std::ptrdiff_t m_bTurnedOff = 0xD68; // bool + constexpr std::ptrdiff_t m_vecEndPos = 0xD6C; // Vector + constexpr std::ptrdiff_t m_hEndEntity = 0xD78; // CHandle +} + +namespace C_Breakable { // C_BaseModelEntity +} + +namespace C_BreakableProp { // CBaseProp + constexpr std::ptrdiff_t m_OnBreak = 0xEC8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnHealthChanged = 0xEF0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnTakeDamage = 0xF18; // CEntityIOOutput + constexpr std::ptrdiff_t m_impactEnergyScale = 0xF40; // float + constexpr std::ptrdiff_t m_iMinHealthDmg = 0xF44; // int32_t + constexpr std::ptrdiff_t m_flPressureDelay = 0xF48; // float + constexpr std::ptrdiff_t m_hBreaker = 0xF4C; // CHandle + constexpr std::ptrdiff_t m_PerformanceMode = 0xF50; // PerformanceMode_t + constexpr std::ptrdiff_t m_flDmgModBullet = 0xF54; // float + constexpr std::ptrdiff_t m_flDmgModClub = 0xF58; // float + constexpr std::ptrdiff_t m_flDmgModExplosive = 0xF5C; // float + constexpr std::ptrdiff_t m_flDmgModFire = 0xF60; // float + constexpr std::ptrdiff_t m_iszPhysicsDamageTableName = 0xF68; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszBasePropData = 0xF70; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iInteractions = 0xF78; // int32_t + constexpr std::ptrdiff_t m_flPreventDamageBeforeTime = 0xF7C; // GameTime_t + constexpr std::ptrdiff_t m_bHasBreakPiecesOrCommands = 0xF80; // bool + constexpr std::ptrdiff_t m_explodeDamage = 0xF84; // float + constexpr std::ptrdiff_t m_explodeRadius = 0xF88; // float + constexpr std::ptrdiff_t m_explosionDelay = 0xF90; // float + constexpr std::ptrdiff_t m_explosionBuildupSound = 0xF98; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_explosionCustomEffect = 0xFA0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_explosionCustomSound = 0xFA8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_explosionModifier = 0xFB0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hPhysicsAttacker = 0xFB8; // CHandle + constexpr std::ptrdiff_t m_flLastPhysicsInfluenceTime = 0xFBC; // GameTime_t + constexpr std::ptrdiff_t m_flDefaultFadeScale = 0xFC0; // float + constexpr std::ptrdiff_t m_hLastAttacker = 0xFC4; // CHandle + constexpr std::ptrdiff_t m_hFlareEnt = 0xFC8; // CHandle + constexpr std::ptrdiff_t m_noGhostCollision = 0xFCC; // bool +} + +namespace C_BulletHitModel { // CBaseAnimGraph + constexpr std::ptrdiff_t m_matLocal = 0xE80; // matrix3x4_t + constexpr std::ptrdiff_t m_iBoneIndex = 0xEB0; // int32_t + constexpr std::ptrdiff_t m_hPlayerParent = 0xEB4; // CHandle + constexpr std::ptrdiff_t m_bIsHit = 0xEB8; // bool + constexpr std::ptrdiff_t m_flTimeCreated = 0xEBC; // float + constexpr std::ptrdiff_t m_vecStartPos = 0xEC0; // Vector +} + +namespace C_C4 { // C_CSWeaponBase + constexpr std::ptrdiff_t m_szScreenText = 0x1990; // char[32] + constexpr std::ptrdiff_t m_bombdroppedlightParticleIndex = 0x19B0; // ParticleIndex_t + constexpr std::ptrdiff_t m_bStartedArming = 0x19B4; // bool + constexpr std::ptrdiff_t m_fArmedTime = 0x19B8; // GameTime_t + constexpr std::ptrdiff_t m_bBombPlacedAnimation = 0x19BC; // bool + constexpr std::ptrdiff_t m_bIsPlantingViaUse = 0x19BD; // bool + constexpr std::ptrdiff_t m_entitySpottedState = 0x19C0; // EntitySpottedState_t + constexpr std::ptrdiff_t m_nSpotRules = 0x19D8; // int32_t + constexpr std::ptrdiff_t m_bPlayedArmingBeeps = 0x19DC; // bool[7] + constexpr std::ptrdiff_t m_bBombPlanted = 0x19E3; // bool + constexpr std::ptrdiff_t m_bDroppedFromDeath = 0x19E4; // bool +} + +namespace C_CSGOViewModel { // C_PredictedViewModel + constexpr std::ptrdiff_t m_bShouldIgnoreOffsetAndAccuracy = 0xF10; // bool + constexpr std::ptrdiff_t m_nWeaponParity = 0xF14; // uint32_t + constexpr std::ptrdiff_t m_nOldWeaponParity = 0xF18; // uint32_t + constexpr std::ptrdiff_t m_nLastKnownAssociatedWeaponEntIndex = 0xF1C; // CEntityIndex + constexpr std::ptrdiff_t m_bNeedToQueueHighResComposite = 0xF20; // bool + constexpr std::ptrdiff_t m_vLoweredWeaponOffset = 0xF64; // QAngle +} + +namespace C_CSGO_CounterTerroristTeamIntroCamera { // C_CSGO_TeamPreviewCamera +} + +namespace C_CSGO_CounterTerroristWingmanIntroCamera { // C_CSGO_TeamPreviewCamera +} + +namespace C_CSGO_EndOfMatchCamera { // C_CSGO_TeamPreviewCamera +} + +namespace C_CSGO_EndOfMatchCharacterPosition { // C_CSGO_TeamPreviewCharacterPosition +} + +namespace C_CSGO_EndOfMatchLineupEnd { // C_CSGO_EndOfMatchLineupEndpoint +} + +namespace C_CSGO_EndOfMatchLineupEndpoint { // C_BaseEntity +} + +namespace C_CSGO_EndOfMatchLineupStart { // C_CSGO_EndOfMatchLineupEndpoint +} + +namespace C_CSGO_MapPreviewCameraPath { // C_BaseEntity + constexpr std::ptrdiff_t m_flZFar = 0x540; // float + constexpr std::ptrdiff_t m_flZNear = 0x544; // float + constexpr std::ptrdiff_t m_bLoop = 0x548; // bool + constexpr std::ptrdiff_t m_bVerticalFOV = 0x549; // bool + constexpr std::ptrdiff_t m_bConstantSpeed = 0x54A; // bool + constexpr std::ptrdiff_t m_flDuration = 0x54C; // float + constexpr std::ptrdiff_t m_flPathLength = 0x590; // float + constexpr std::ptrdiff_t m_flPathDuration = 0x594; // float +} + +namespace C_CSGO_MapPreviewCameraPathNode { // C_BaseEntity + constexpr std::ptrdiff_t m_szParentPathUniqueID = 0x540; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nPathIndex = 0x548; // int32_t + constexpr std::ptrdiff_t m_vInTangentLocal = 0x54C; // Vector + constexpr std::ptrdiff_t m_vOutTangentLocal = 0x558; // Vector + constexpr std::ptrdiff_t m_flFOV = 0x564; // float + constexpr std::ptrdiff_t m_flSpeed = 0x568; // float + constexpr std::ptrdiff_t m_flEaseIn = 0x56C; // float + constexpr std::ptrdiff_t m_flEaseOut = 0x570; // float + constexpr std::ptrdiff_t m_vInTangentWorld = 0x574; // Vector + constexpr std::ptrdiff_t m_vOutTangentWorld = 0x580; // Vector +} + +namespace C_CSGO_PreviewModel { // C_BaseFlex + constexpr std::ptrdiff_t m_animgraph = 0x1018; // CUtlString + constexpr std::ptrdiff_t m_animgraphCharacterModeString = 0x1020; // CUtlString + constexpr std::ptrdiff_t m_defaultAnim = 0x1028; // CUtlString + constexpr std::ptrdiff_t m_nDefaultAnimLoopMode = 0x1030; // AnimLoopMode_t + constexpr std::ptrdiff_t m_flInitialModelScale = 0x1034; // float +} + +namespace C_CSGO_PreviewModelAlias_csgo_item_previewmodel { // C_CSGO_PreviewModel +} + +namespace C_CSGO_PreviewPlayer { // C_CSPlayerPawn + constexpr std::ptrdiff_t m_animgraph = 0x22E0; // CUtlString + constexpr std::ptrdiff_t m_animgraphCharacterModeString = 0x22E8; // CUtlString + constexpr std::ptrdiff_t m_flInitialModelScale = 0x22F0; // float +} + +namespace C_CSGO_PreviewPlayerAlias_csgo_player_previewmodel { // C_CSGO_PreviewPlayer +} + +namespace C_CSGO_TeamIntroCharacterPosition { // C_CSGO_TeamPreviewCharacterPosition +} + +namespace C_CSGO_TeamIntroCounterTerroristPosition { // C_CSGO_TeamIntroCharacterPosition +} + +namespace C_CSGO_TeamIntroTerroristPosition { // C_CSGO_TeamIntroCharacterPosition +} + +namespace C_CSGO_TeamPreviewCamera { // C_CSGO_MapPreviewCameraPath + constexpr std::ptrdiff_t m_nVariant = 0x5A0; // int32_t + constexpr std::ptrdiff_t m_bDofEnabled = 0x5A4; // bool + constexpr std::ptrdiff_t m_flDofNearBlurry = 0x5A8; // float + constexpr std::ptrdiff_t m_flDofNearCrisp = 0x5AC; // float + constexpr std::ptrdiff_t m_flDofFarCrisp = 0x5B0; // float + constexpr std::ptrdiff_t m_flDofFarBlurry = 0x5B4; // float + constexpr std::ptrdiff_t m_flDofTiltToGround = 0x5B8; // float +} + +namespace C_CSGO_TeamPreviewCharacterPosition { // C_BaseEntity + constexpr std::ptrdiff_t m_nVariant = 0x540; // int32_t + constexpr std::ptrdiff_t m_nRandom = 0x544; // int32_t + constexpr std::ptrdiff_t m_nOrdinal = 0x548; // int32_t + constexpr std::ptrdiff_t m_sWeaponName = 0x550; // CUtlString + constexpr std::ptrdiff_t m_xuid = 0x558; // uint64_t + constexpr std::ptrdiff_t m_agentItem = 0x560; // C_EconItemView + constexpr std::ptrdiff_t m_glovesItem = 0x9A8; // C_EconItemView + constexpr std::ptrdiff_t m_weaponItem = 0xDF0; // C_EconItemView +} + +namespace C_CSGO_TeamPreviewModel { // C_CSGO_PreviewPlayer +} + +namespace C_CSGO_TeamSelectCamera { // C_CSGO_TeamPreviewCamera +} + +namespace C_CSGO_TeamSelectCharacterPosition { // C_CSGO_TeamPreviewCharacterPosition +} + +namespace C_CSGO_TeamSelectCounterTerroristPosition { // C_CSGO_TeamSelectCharacterPosition +} + +namespace C_CSGO_TeamSelectTerroristPosition { // C_CSGO_TeamSelectCharacterPosition +} + +namespace C_CSGO_TerroristTeamIntroCamera { // C_CSGO_TeamPreviewCamera +} + +namespace C_CSGO_TerroristWingmanIntroCamera { // C_CSGO_TeamPreviewCamera +} + +namespace C_CSGameRules { // C_TeamplayRules + constexpr std::ptrdiff_t __m_pChainEntity = 0x8; // CNetworkVarChainer + constexpr std::ptrdiff_t m_bFreezePeriod = 0x30; // bool + constexpr std::ptrdiff_t m_bWarmupPeriod = 0x31; // bool + constexpr std::ptrdiff_t m_fWarmupPeriodEnd = 0x34; // GameTime_t + constexpr std::ptrdiff_t m_fWarmupPeriodStart = 0x38; // GameTime_t + constexpr std::ptrdiff_t m_nTotalPausedTicks = 0x3C; // int32_t + constexpr std::ptrdiff_t m_nPauseStartTick = 0x40; // int32_t + constexpr std::ptrdiff_t m_bServerPaused = 0x44; // bool + constexpr std::ptrdiff_t m_bGamePaused = 0x45; // bool + constexpr std::ptrdiff_t m_bTerroristTimeOutActive = 0x46; // bool + constexpr std::ptrdiff_t m_bCTTimeOutActive = 0x47; // bool + constexpr std::ptrdiff_t m_flTerroristTimeOutRemaining = 0x48; // float + constexpr std::ptrdiff_t m_flCTTimeOutRemaining = 0x4C; // float + constexpr std::ptrdiff_t m_nTerroristTimeOuts = 0x50; // int32_t + constexpr std::ptrdiff_t m_nCTTimeOuts = 0x54; // int32_t + constexpr std::ptrdiff_t m_bTechnicalTimeOut = 0x58; // bool + constexpr std::ptrdiff_t m_bMatchWaitingForResume = 0x59; // bool + constexpr std::ptrdiff_t m_iRoundTime = 0x5C; // int32_t + constexpr std::ptrdiff_t m_fMatchStartTime = 0x60; // float + constexpr std::ptrdiff_t m_fRoundStartTime = 0x64; // GameTime_t + constexpr std::ptrdiff_t m_flRestartRoundTime = 0x68; // GameTime_t + constexpr std::ptrdiff_t m_bGameRestart = 0x6C; // bool + constexpr std::ptrdiff_t m_flGameStartTime = 0x70; // float + constexpr std::ptrdiff_t m_timeUntilNextPhaseStarts = 0x74; // float + constexpr std::ptrdiff_t m_gamePhase = 0x78; // int32_t + constexpr std::ptrdiff_t m_totalRoundsPlayed = 0x7C; // int32_t + constexpr std::ptrdiff_t m_nRoundsPlayedThisPhase = 0x80; // int32_t + constexpr std::ptrdiff_t m_nOvertimePlaying = 0x84; // int32_t + constexpr std::ptrdiff_t m_iHostagesRemaining = 0x88; // int32_t + constexpr std::ptrdiff_t m_bAnyHostageReached = 0x8C; // bool + constexpr std::ptrdiff_t m_bMapHasBombTarget = 0x8D; // bool + constexpr std::ptrdiff_t m_bMapHasRescueZone = 0x8E; // bool + constexpr std::ptrdiff_t m_bMapHasBuyZone = 0x8F; // bool + constexpr std::ptrdiff_t m_bIsQueuedMatchmaking = 0x90; // bool + constexpr std::ptrdiff_t m_nQueuedMatchmakingMode = 0x94; // int32_t + constexpr std::ptrdiff_t m_bIsValveDS = 0x98; // bool + constexpr std::ptrdiff_t m_bLogoMap = 0x99; // bool + constexpr std::ptrdiff_t m_bPlayAllStepSoundsOnServer = 0x9A; // bool + constexpr std::ptrdiff_t m_iSpectatorSlotCount = 0x9C; // int32_t + constexpr std::ptrdiff_t m_MatchDevice = 0xA0; // int32_t + constexpr std::ptrdiff_t m_bHasMatchStarted = 0xA4; // bool + constexpr std::ptrdiff_t m_nNextMapInMapgroup = 0xA8; // int32_t + constexpr std::ptrdiff_t m_szTournamentEventName = 0xAC; // char[512] + constexpr std::ptrdiff_t m_szTournamentEventStage = 0x2AC; // char[512] + constexpr std::ptrdiff_t m_szMatchStatTxt = 0x4AC; // char[512] + constexpr std::ptrdiff_t m_szTournamentPredictionsTxt = 0x6AC; // char[512] + constexpr std::ptrdiff_t m_nTournamentPredictionsPct = 0x8AC; // int32_t + constexpr std::ptrdiff_t m_flCMMItemDropRevealStartTime = 0x8B0; // GameTime_t + constexpr std::ptrdiff_t m_flCMMItemDropRevealEndTime = 0x8B4; // GameTime_t + constexpr std::ptrdiff_t m_bIsDroppingItems = 0x8B8; // bool + constexpr std::ptrdiff_t m_bIsQuestEligible = 0x8B9; // bool + constexpr std::ptrdiff_t m_bIsHltvActive = 0x8BA; // bool + constexpr std::ptrdiff_t m_nGuardianModeWaveNumber = 0x8BC; // int32_t + constexpr std::ptrdiff_t m_nGuardianModeSpecialKillsRemaining = 0x8C0; // int32_t + constexpr std::ptrdiff_t m_nGuardianModeSpecialWeaponNeeded = 0x8C4; // int32_t + constexpr std::ptrdiff_t m_nGuardianGrenadesToGiveBots = 0x8C8; // int32_t + constexpr std::ptrdiff_t m_nNumHeaviesToSpawn = 0x8CC; // int32_t + constexpr std::ptrdiff_t m_numGlobalGiftsGiven = 0x8D0; // uint32_t + constexpr std::ptrdiff_t m_numGlobalGifters = 0x8D4; // uint32_t + constexpr std::ptrdiff_t m_numGlobalGiftsPeriodSeconds = 0x8D8; // uint32_t + constexpr std::ptrdiff_t m_arrFeaturedGiftersAccounts = 0x8DC; // uint32_t[4] + constexpr std::ptrdiff_t m_arrFeaturedGiftersGifts = 0x8EC; // uint32_t[4] + constexpr std::ptrdiff_t m_arrProhibitedItemIndices = 0x8FC; // uint16_t[100] + constexpr std::ptrdiff_t m_arrTournamentActiveCasterAccounts = 0x9C4; // uint32_t[4] + constexpr std::ptrdiff_t m_numBestOfMaps = 0x9D4; // int32_t + constexpr std::ptrdiff_t m_nHalloweenMaskListSeed = 0x9D8; // int32_t + constexpr std::ptrdiff_t m_bBombDropped = 0x9DC; // bool + constexpr std::ptrdiff_t m_bBombPlanted = 0x9DD; // bool + constexpr std::ptrdiff_t m_iRoundWinStatus = 0x9E0; // int32_t + constexpr std::ptrdiff_t m_eRoundWinReason = 0x9E4; // int32_t + constexpr std::ptrdiff_t m_bTCantBuy = 0x9E8; // bool + constexpr std::ptrdiff_t m_bCTCantBuy = 0x9E9; // bool + constexpr std::ptrdiff_t m_flGuardianBuyUntilTime = 0x9EC; // GameTime_t + constexpr std::ptrdiff_t m_iMatchStats_RoundResults = 0x9F0; // int32_t[30] + constexpr std::ptrdiff_t m_iMatchStats_PlayersAlive_CT = 0xA68; // int32_t[30] + constexpr std::ptrdiff_t m_iMatchStats_PlayersAlive_T = 0xAE0; // int32_t[30] + constexpr std::ptrdiff_t m_TeamRespawnWaveTimes = 0xB58; // float[32] + constexpr std::ptrdiff_t m_flNextRespawnWave = 0xBD8; // GameTime_t[32] + constexpr std::ptrdiff_t m_nServerQuestID = 0xC58; // int32_t + constexpr std::ptrdiff_t m_vMinimapMins = 0xC5C; // Vector + constexpr std::ptrdiff_t m_vMinimapMaxs = 0xC68; // Vector + constexpr std::ptrdiff_t m_MinimapVerticalSectionHeights = 0xC74; // float[8] + constexpr std::ptrdiff_t m_bDontIncrementCoopWave = 0xC94; // bool + constexpr std::ptrdiff_t m_bSpawnedTerrorHuntHeavy = 0xC95; // bool + constexpr std::ptrdiff_t m_nEndMatchMapGroupVoteTypes = 0xC98; // int32_t[10] + constexpr std::ptrdiff_t m_nEndMatchMapGroupVoteOptions = 0xCC0; // int32_t[10] + constexpr std::ptrdiff_t m_nEndMatchMapVoteWinner = 0xCE8; // int32_t + constexpr std::ptrdiff_t m_iNumConsecutiveCTLoses = 0xCEC; // int32_t + constexpr std::ptrdiff_t m_iNumConsecutiveTerroristLoses = 0xCF0; // int32_t + constexpr std::ptrdiff_t m_bMarkClientStopRecordAtRoundEnd = 0xD10; // bool + constexpr std::ptrdiff_t m_bMatchAbortedDueToPlayerBan = 0xD68; // bool + constexpr std::ptrdiff_t m_bHasTriggeredRoundStartMusic = 0xD69; // bool + constexpr std::ptrdiff_t m_bHasTriggeredCoopSpawnReset = 0xD6A; // bool + constexpr std::ptrdiff_t m_bSwitchingTeamsAtRoundReset = 0xD6B; // bool + constexpr std::ptrdiff_t m_pGameModeRules = 0xD88; // CCSGameModeRules* + constexpr std::ptrdiff_t m_RetakeRules = 0xD90; // C_RetakeGameRules + constexpr std::ptrdiff_t m_nMatchEndCount = 0xEA8; // uint8_t + constexpr std::ptrdiff_t m_nTTeamIntroVariant = 0xEAC; // int32_t + constexpr std::ptrdiff_t m_nCTTeamIntroVariant = 0xEB0; // int32_t + constexpr std::ptrdiff_t m_bTeamIntroPeriod = 0xEB4; // bool + constexpr std::ptrdiff_t m_flLastPerfSampleTime = 0x4EC0; // double +} + +namespace C_CSGameRulesProxy { // C_GameRulesProxy + constexpr std::ptrdiff_t m_pGameRules = 0x540; // C_CSGameRules* +} + +namespace C_CSMinimapBoundary { // C_BaseEntity +} + +namespace C_CSObserverPawn { // C_CSPlayerPawnBase + constexpr std::ptrdiff_t m_hDetectParentChange = 0x16B0; // CEntityHandle +} + +namespace C_CSPlayerPawn { // C_CSPlayerPawnBase + constexpr std::ptrdiff_t m_pBulletServices = 0x16B0; // CCSPlayer_BulletServices* + constexpr std::ptrdiff_t m_pHostageServices = 0x16B8; // CCSPlayer_HostageServices* + constexpr std::ptrdiff_t m_pBuyServices = 0x16C0; // CCSPlayer_BuyServices* + constexpr std::ptrdiff_t m_pGlowServices = 0x16C8; // CCSPlayer_GlowServices* + constexpr std::ptrdiff_t m_pActionTrackingServices = 0x16D0; // CCSPlayer_ActionTrackingServices* + constexpr std::ptrdiff_t m_flHealthShotBoostExpirationTime = 0x16D8; // GameTime_t + constexpr std::ptrdiff_t m_flLastFiredWeaponTime = 0x16DC; // GameTime_t + constexpr std::ptrdiff_t m_bHasFemaleVoice = 0x16E0; // bool + constexpr std::ptrdiff_t m_flLandseconds = 0x16E4; // float + constexpr std::ptrdiff_t m_flOldFallVelocity = 0x16E8; // float + constexpr std::ptrdiff_t m_szLastPlaceName = 0x16EC; // char[18] + constexpr std::ptrdiff_t m_bPrevDefuser = 0x16FE; // bool + constexpr std::ptrdiff_t m_bPrevHelmet = 0x16FF; // bool + constexpr std::ptrdiff_t m_nPrevArmorVal = 0x1700; // int32_t + constexpr std::ptrdiff_t m_nPrevGrenadeAmmoCount = 0x1704; // int32_t + constexpr std::ptrdiff_t m_unPreviousWeaponHash = 0x1708; // uint32_t + constexpr std::ptrdiff_t m_unWeaponHash = 0x170C; // uint32_t + constexpr std::ptrdiff_t m_bInBuyZone = 0x1710; // bool + constexpr std::ptrdiff_t m_bPreviouslyInBuyZone = 0x1711; // bool + constexpr std::ptrdiff_t m_aimPunchAngle = 0x1714; // QAngle + constexpr std::ptrdiff_t m_aimPunchAngleVel = 0x1720; // QAngle + constexpr std::ptrdiff_t m_aimPunchTickBase = 0x172C; // int32_t + constexpr std::ptrdiff_t m_aimPunchTickFraction = 0x1730; // float + constexpr std::ptrdiff_t m_aimPunchCache = 0x1738; // CUtlVector + constexpr std::ptrdiff_t m_bInLanding = 0x1758; // bool + constexpr std::ptrdiff_t m_flLandingTime = 0x175C; // float + constexpr std::ptrdiff_t m_bInHostageRescueZone = 0x1760; // bool + constexpr std::ptrdiff_t m_bInBombZone = 0x1761; // bool + constexpr std::ptrdiff_t m_bIsBuyMenuOpen = 0x1762; // bool + constexpr std::ptrdiff_t m_flTimeOfLastInjury = 0x1764; // GameTime_t + constexpr std::ptrdiff_t m_flNextSprayDecalTime = 0x1768; // GameTime_t + constexpr std::ptrdiff_t m_iRetakesOffering = 0x1880; // int32_t + constexpr std::ptrdiff_t m_iRetakesOfferingCard = 0x1884; // int32_t + constexpr std::ptrdiff_t m_bRetakesHasDefuseKit = 0x1888; // bool + constexpr std::ptrdiff_t m_bRetakesMVPLastRound = 0x1889; // bool + constexpr std::ptrdiff_t m_iRetakesMVPBoostItem = 0x188C; // int32_t + constexpr std::ptrdiff_t m_RetakesMVPBoostExtraUtility = 0x1890; // loadout_slot_t + constexpr std::ptrdiff_t m_bNeedToReApplyGloves = 0x18B0; // bool + constexpr std::ptrdiff_t m_EconGloves = 0x18B8; // C_EconItemView + constexpr std::ptrdiff_t m_bMustSyncRagdollState = 0x1D00; // bool + constexpr std::ptrdiff_t m_nRagdollDamageBone = 0x1D04; // int32_t + constexpr std::ptrdiff_t m_vRagdollDamageForce = 0x1D08; // Vector + constexpr std::ptrdiff_t m_vRagdollDamagePosition = 0x1D14; // Vector + constexpr std::ptrdiff_t m_szRagdollDamageWeaponName = 0x1D20; // char[64] + constexpr std::ptrdiff_t m_bRagdollDamageHeadshot = 0x1D60; // bool + constexpr std::ptrdiff_t m_vRagdollServerOrigin = 0x1D64; // Vector + constexpr std::ptrdiff_t m_bLastHeadBoneTransformIsValid = 0x22A8; // bool + constexpr std::ptrdiff_t m_lastLandTime = 0x22AC; // GameTime_t + constexpr std::ptrdiff_t m_bOnGroundLastTick = 0x22B0; // bool + constexpr std::ptrdiff_t m_qDeathEyeAngles = 0x22CC; // QAngle + constexpr std::ptrdiff_t m_bSkipOneHeadConstraintUpdate = 0x22D8; // bool +} + +namespace C_CSPlayerPawnBase { // C_BasePlayerPawn + constexpr std::ptrdiff_t m_pPingServices = 0x1268; // CCSPlayer_PingServices* + constexpr std::ptrdiff_t m_pViewModelServices = 0x1270; // CPlayer_ViewModelServices* + constexpr std::ptrdiff_t m_fRenderingClipPlane = 0x1278; // float[4] + constexpr std::ptrdiff_t m_nLastClipPlaneSetupFrame = 0x1288; // int32_t + constexpr std::ptrdiff_t m_vecLastClipCameraPos = 0x128C; // Vector + constexpr std::ptrdiff_t m_vecLastClipCameraForward = 0x1298; // Vector + constexpr std::ptrdiff_t m_bClipHitStaticWorld = 0x12A4; // bool + constexpr std::ptrdiff_t m_bCachedPlaneIsValid = 0x12A5; // bool + constexpr std::ptrdiff_t m_pClippingWeapon = 0x12A8; // C_CSWeaponBase* + constexpr std::ptrdiff_t m_previousPlayerState = 0x12B0; // CSPlayerState + constexpr std::ptrdiff_t m_flLastCollisionCeiling = 0x12B4; // float + constexpr std::ptrdiff_t m_flLastCollisionCeilingChangeTime = 0x12B8; // float + constexpr std::ptrdiff_t m_grenadeParameterStashTime = 0x12D8; // GameTime_t + constexpr std::ptrdiff_t m_bGrenadeParametersStashed = 0x12DC; // bool + constexpr std::ptrdiff_t m_angStashedShootAngles = 0x12E0; // QAngle + constexpr std::ptrdiff_t m_vecStashedGrenadeThrowPosition = 0x12EC; // Vector + constexpr std::ptrdiff_t m_vecStashedVelocity = 0x12F8; // Vector + constexpr std::ptrdiff_t m_angShootAngleHistory = 0x1304; // QAngle[2] + constexpr std::ptrdiff_t m_vecThrowPositionHistory = 0x131C; // Vector[2] + constexpr std::ptrdiff_t m_vecVelocityHistory = 0x1334; // Vector[2] + constexpr std::ptrdiff_t m_thirdPersonHeading = 0x1350; // QAngle + constexpr std::ptrdiff_t m_flSlopeDropOffset = 0x1368; // float + constexpr std::ptrdiff_t m_flSlopeDropHeight = 0x1378; // float + constexpr std::ptrdiff_t m_vHeadConstraintOffset = 0x1388; // Vector + constexpr std::ptrdiff_t m_bIsScoped = 0x13A0; // bool + constexpr std::ptrdiff_t m_bIsWalking = 0x13A1; // bool + constexpr std::ptrdiff_t m_bResumeZoom = 0x13A2; // bool + constexpr std::ptrdiff_t m_iPlayerState = 0x13A4; // CSPlayerState + constexpr std::ptrdiff_t m_bIsDefusing = 0x13A8; // bool + constexpr std::ptrdiff_t m_bIsGrabbingHostage = 0x13A9; // bool + constexpr std::ptrdiff_t m_iBlockingUseActionInProgress = 0x13AC; // CSPlayerBlockingUseAction_t + constexpr std::ptrdiff_t m_bIsRescuing = 0x13B0; // bool + constexpr std::ptrdiff_t m_fImmuneToGunGameDamageTime = 0x13B4; // GameTime_t + constexpr std::ptrdiff_t m_fImmuneToGunGameDamageTimeLast = 0x13B8; // GameTime_t + constexpr std::ptrdiff_t m_bGunGameImmunity = 0x13BC; // bool + constexpr std::ptrdiff_t m_bHasMovedSinceSpawn = 0x13BD; // bool + constexpr std::ptrdiff_t m_fMolotovUseTime = 0x13C0; // float + constexpr std::ptrdiff_t m_fMolotovDamageTime = 0x13C4; // float + constexpr std::ptrdiff_t m_nWhichBombZone = 0x13C8; // int32_t + constexpr std::ptrdiff_t m_bInNoDefuseArea = 0x13CC; // bool + constexpr std::ptrdiff_t m_iThrowGrenadeCounter = 0x13D0; // int32_t + constexpr std::ptrdiff_t m_bWaitForNoAttack = 0x13D4; // bool + constexpr std::ptrdiff_t m_flGuardianTooFarDistFrac = 0x13D8; // float + constexpr std::ptrdiff_t m_flDetectedByEnemySensorTime = 0x13DC; // GameTime_t + constexpr std::ptrdiff_t m_flNextGuardianTooFarWarning = 0x13E0; // float + constexpr std::ptrdiff_t m_bSuppressGuardianTooFarWarningAudio = 0x13E4; // bool + constexpr std::ptrdiff_t m_bKilledByTaser = 0x13E5; // bool + constexpr std::ptrdiff_t m_iMoveState = 0x13E8; // int32_t + constexpr std::ptrdiff_t m_bCanMoveDuringFreezePeriod = 0x13EC; // bool + constexpr std::ptrdiff_t m_flLowerBodyYawTarget = 0x13F0; // float + constexpr std::ptrdiff_t m_bStrafing = 0x13F4; // bool + constexpr std::ptrdiff_t m_flLastSpawnTimeIndex = 0x13F8; // GameTime_t + constexpr std::ptrdiff_t m_flEmitSoundTime = 0x13FC; // GameTime_t + constexpr std::ptrdiff_t m_iAddonBits = 0x1400; // int32_t + constexpr std::ptrdiff_t m_iPrimaryAddon = 0x1404; // int32_t + constexpr std::ptrdiff_t m_iSecondaryAddon = 0x1408; // int32_t + constexpr std::ptrdiff_t m_iProgressBarDuration = 0x140C; // int32_t + constexpr std::ptrdiff_t m_flProgressBarStartTime = 0x1410; // float + constexpr std::ptrdiff_t m_iDirection = 0x1414; // int32_t + constexpr std::ptrdiff_t m_iShotsFired = 0x1418; // int32_t + constexpr std::ptrdiff_t m_bNightVisionOn = 0x141C; // bool + constexpr std::ptrdiff_t m_bHasNightVision = 0x141D; // bool + constexpr std::ptrdiff_t m_flVelocityModifier = 0x1420; // float + constexpr std::ptrdiff_t m_flHitHeading = 0x1424; // float + constexpr std::ptrdiff_t m_nHitBodyPart = 0x1428; // int32_t + constexpr std::ptrdiff_t m_iStartAccount = 0x142C; // int32_t + constexpr std::ptrdiff_t m_vecIntroStartEyePosition = 0x1430; // Vector + constexpr std::ptrdiff_t m_vecIntroStartPlayerForward = 0x143C; // Vector + constexpr std::ptrdiff_t m_flClientDeathTime = 0x1448; // GameTime_t + constexpr std::ptrdiff_t m_flNightVisionAlpha = 0x144C; // float + constexpr std::ptrdiff_t m_bScreenTearFrameCaptured = 0x1450; // bool + constexpr std::ptrdiff_t m_flFlashBangTime = 0x1454; // float + constexpr std::ptrdiff_t m_flFlashScreenshotAlpha = 0x1458; // float + constexpr std::ptrdiff_t m_flFlashOverlayAlpha = 0x145C; // float + constexpr std::ptrdiff_t m_bFlashBuildUp = 0x1460; // bool + constexpr std::ptrdiff_t m_bFlashDspHasBeenCleared = 0x1461; // bool + constexpr std::ptrdiff_t m_bFlashScreenshotHasBeenGrabbed = 0x1462; // bool + constexpr std::ptrdiff_t m_flFlashMaxAlpha = 0x1464; // float + constexpr std::ptrdiff_t m_flFlashDuration = 0x1468; // float + constexpr std::ptrdiff_t m_lastStandingPos = 0x146C; // Vector + constexpr std::ptrdiff_t m_vecLastMuzzleFlashPos = 0x1478; // Vector + constexpr std::ptrdiff_t m_angLastMuzzleFlashAngle = 0x1484; // QAngle + constexpr std::ptrdiff_t m_hMuzzleFlashShape = 0x1490; // CHandle + constexpr std::ptrdiff_t m_iHealthBarRenderMaskIndex = 0x1494; // int32_t + constexpr std::ptrdiff_t m_flHealthFadeValue = 0x1498; // float + constexpr std::ptrdiff_t m_flHealthFadeAlpha = 0x149C; // float + constexpr std::ptrdiff_t m_nMyCollisionGroup = 0x14A0; // int32_t + constexpr std::ptrdiff_t m_ignoreLadderJumpTime = 0x14A4; // float + constexpr std::ptrdiff_t m_ladderSurpressionTimer = 0x14A8; // CountdownTimer + constexpr std::ptrdiff_t m_lastLadderNormal = 0x14C0; // Vector + constexpr std::ptrdiff_t m_lastLadderPos = 0x14CC; // Vector + constexpr std::ptrdiff_t m_flDeathCCWeight = 0x14E0; // float + constexpr std::ptrdiff_t m_bOldIsScoped = 0x14E4; // bool + constexpr std::ptrdiff_t m_flPrevRoundEndTime = 0x14E8; // float + constexpr std::ptrdiff_t m_flPrevMatchEndTime = 0x14EC; // float + constexpr std::ptrdiff_t m_unCurrentEquipmentValue = 0x14F0; // uint16_t + constexpr std::ptrdiff_t m_unRoundStartEquipmentValue = 0x14F2; // uint16_t + constexpr std::ptrdiff_t m_unFreezetimeEndEquipmentValue = 0x14F4; // uint16_t + constexpr std::ptrdiff_t m_vecThirdPersonViewPositionOverride = 0x14F8; // Vector + constexpr std::ptrdiff_t m_nHeavyAssaultSuitCooldownRemaining = 0x1504; // int32_t + constexpr std::ptrdiff_t m_ArmorValue = 0x1508; // int32_t + constexpr std::ptrdiff_t m_angEyeAngles = 0x1510; // QAngle + constexpr std::ptrdiff_t m_fNextThinkPushAway = 0x1528; // float + constexpr std::ptrdiff_t m_bShouldAutobuyDMWeapons = 0x152C; // bool + constexpr std::ptrdiff_t m_bShouldAutobuyNow = 0x152D; // bool + constexpr std::ptrdiff_t m_bHud_MiniScoreHidden = 0x152E; // bool + constexpr std::ptrdiff_t m_bHud_RadarHidden = 0x152F; // bool + constexpr std::ptrdiff_t m_nLastKillerIndex = 0x1530; // CEntityIndex + constexpr std::ptrdiff_t m_nLastConcurrentKilled = 0x1534; // int32_t + constexpr std::ptrdiff_t m_nDeathCamMusic = 0x1538; // int32_t + constexpr std::ptrdiff_t m_iIDEntIndex = 0x153C; // CEntityIndex + constexpr std::ptrdiff_t m_delayTargetIDTimer = 0x1540; // CountdownTimer + constexpr std::ptrdiff_t m_iTargetedWeaponEntIndex = 0x1558; // CEntityIndex + constexpr std::ptrdiff_t m_iOldIDEntIndex = 0x155C; // CEntityIndex + constexpr std::ptrdiff_t m_holdTargetIDTimer = 0x1560; // CountdownTimer + constexpr std::ptrdiff_t m_flCurrentMusicStartTime = 0x157C; // float + constexpr std::ptrdiff_t m_flMusicRoundStartTime = 0x1580; // float + constexpr std::ptrdiff_t m_bDeferStartMusicOnWarmup = 0x1584; // bool + constexpr std::ptrdiff_t m_cycleLatch = 0x1588; // int32_t + constexpr std::ptrdiff_t m_serverIntendedCycle = 0x158C; // float + constexpr std::ptrdiff_t m_vecPlayerPatchEconIndices = 0x1590; // uint32_t[5] + constexpr std::ptrdiff_t m_bHideTargetID = 0x15AC; // bool + constexpr std::ptrdiff_t m_nextTaserShakeTime = 0x15B0; // float + constexpr std::ptrdiff_t m_firstTaserShakeTime = 0x15B4; // float + constexpr std::ptrdiff_t m_flLastSmokeOverlayAlpha = 0x15B8; // float + constexpr std::ptrdiff_t m_vLastSmokeOverlayColor = 0x15BC; // Vector + constexpr std::ptrdiff_t m_nPlayerSmokedFx = 0x15C8; // ParticleIndex_t + constexpr std::ptrdiff_t m_flNextMagDropTime = 0x15CC; // float + constexpr std::ptrdiff_t m_nLastMagDropAttachmentIndex = 0x15D0; // int32_t + constexpr std::ptrdiff_t m_vecBulletHitModels = 0x15D8; // CUtlVector + constexpr std::ptrdiff_t m_vecPickupModelSlerpers = 0x15F0; // CUtlVector + constexpr std::ptrdiff_t m_vecLastAliveLocalVelocity = 0x1608; // Vector + constexpr std::ptrdiff_t m_entitySpottedState = 0x1630; // EntitySpottedState_t + constexpr std::ptrdiff_t m_nSurvivalTeamNumber = 0x1648; // int32_t + constexpr std::ptrdiff_t m_bGuardianShouldSprayCustomXMark = 0x164C; // bool + constexpr std::ptrdiff_t m_bHasDeathInfo = 0x164D; // bool + constexpr std::ptrdiff_t m_flDeathInfoTime = 0x1650; // float + constexpr std::ptrdiff_t m_vecDeathInfoOrigin = 0x1654; // Vector + constexpr std::ptrdiff_t m_bKilledByHeadshot = 0x1660; // bool + constexpr std::ptrdiff_t m_hOriginalController = 0x1664; // CHandle +} + +namespace C_CSPlayerResource { // C_BaseEntity + constexpr std::ptrdiff_t m_bHostageAlive = 0x540; // bool[12] + constexpr std::ptrdiff_t m_isHostageFollowingSomeone = 0x54C; // bool[12] + constexpr std::ptrdiff_t m_iHostageEntityIDs = 0x558; // CEntityIndex[12] + constexpr std::ptrdiff_t m_bombsiteCenterA = 0x588; // Vector + constexpr std::ptrdiff_t m_bombsiteCenterB = 0x594; // Vector + constexpr std::ptrdiff_t m_hostageRescueX = 0x5A0; // int32_t[4] + constexpr std::ptrdiff_t m_hostageRescueY = 0x5B0; // int32_t[4] + constexpr std::ptrdiff_t m_hostageRescueZ = 0x5C0; // int32_t[4] + constexpr std::ptrdiff_t m_bEndMatchNextMapAllVoted = 0x5D0; // bool + constexpr std::ptrdiff_t m_foundGoalPositions = 0x5D1; // bool +} + +namespace C_CSTeam { // C_Team + constexpr std::ptrdiff_t m_szTeamMatchStat = 0x5F8; // char[512] + constexpr std::ptrdiff_t m_numMapVictories = 0x7F8; // int32_t + constexpr std::ptrdiff_t m_bSurrendered = 0x7FC; // bool + constexpr std::ptrdiff_t m_scoreFirstHalf = 0x800; // int32_t + constexpr std::ptrdiff_t m_scoreSecondHalf = 0x804; // int32_t + constexpr std::ptrdiff_t m_scoreOvertime = 0x808; // int32_t + constexpr std::ptrdiff_t m_szClanTeamname = 0x80C; // char[129] + constexpr std::ptrdiff_t m_iClanID = 0x890; // uint32_t + constexpr std::ptrdiff_t m_szTeamFlagImage = 0x894; // char[8] + constexpr std::ptrdiff_t m_szTeamLogoImage = 0x89C; // char[8] +} + +namespace C_CSWeaponBase { // C_BasePlayerWeapon + constexpr std::ptrdiff_t m_flFireSequenceStartTime = 0x15D0; // float + constexpr std::ptrdiff_t m_nFireSequenceStartTimeChange = 0x15D4; // int32_t + constexpr std::ptrdiff_t m_nFireSequenceStartTimeAck = 0x15D8; // int32_t + constexpr std::ptrdiff_t m_bPlayerFireEventIsPrimary = 0x15DC; // bool + constexpr std::ptrdiff_t m_seqIdle = 0x15E0; // HSequence + constexpr std::ptrdiff_t m_seqFirePrimary = 0x15E4; // HSequence + constexpr std::ptrdiff_t m_seqFireSecondary = 0x15E8; // HSequence + constexpr std::ptrdiff_t m_thirdPersonFireSequences = 0x15F0; // CUtlVector + constexpr std::ptrdiff_t m_hCurrentThirdPersonSequence = 0x1608; // HSequence + constexpr std::ptrdiff_t m_nSilencerBoneIndex = 0x160C; // int32_t + constexpr std::ptrdiff_t m_thirdPersonSequences = 0x1610; // HSequence[6] + constexpr std::ptrdiff_t m_ClientPreviousWeaponState = 0x1640; // CSWeaponState_t + constexpr std::ptrdiff_t m_iState = 0x1644; // CSWeaponState_t + constexpr std::ptrdiff_t m_flCrosshairDistance = 0x1648; // float + constexpr std::ptrdiff_t m_iAmmoLastCheck = 0x164C; // int32_t + constexpr std::ptrdiff_t m_iAlpha = 0x1650; // int32_t + constexpr std::ptrdiff_t m_iScopeTextureID = 0x1654; // int32_t + constexpr std::ptrdiff_t m_iCrosshairTextureID = 0x1658; // int32_t + constexpr std::ptrdiff_t m_flGunAccuracyPosition = 0x165C; // float + constexpr std::ptrdiff_t m_nViewModelIndex = 0x1660; // uint32_t + constexpr std::ptrdiff_t m_bReloadsWithClips = 0x1664; // bool + constexpr std::ptrdiff_t m_flTimeWeaponIdle = 0x1668; // GameTime_t + constexpr std::ptrdiff_t m_bFireOnEmpty = 0x166C; // bool + constexpr std::ptrdiff_t m_OnPlayerPickup = 0x1670; // CEntityIOOutput + constexpr std::ptrdiff_t m_weaponMode = 0x1698; // CSWeaponMode + constexpr std::ptrdiff_t m_flTurningInaccuracyDelta = 0x169C; // float + constexpr std::ptrdiff_t m_vecTurningInaccuracyEyeDirLast = 0x16A0; // Vector + constexpr std::ptrdiff_t m_flTurningInaccuracy = 0x16AC; // float + constexpr std::ptrdiff_t m_fAccuracyPenalty = 0x16B0; // float + constexpr std::ptrdiff_t m_flLastAccuracyUpdateTime = 0x16B4; // GameTime_t + constexpr std::ptrdiff_t m_fAccuracySmoothedForZoom = 0x16B8; // float + constexpr std::ptrdiff_t m_fScopeZoomEndTime = 0x16BC; // GameTime_t + constexpr std::ptrdiff_t m_iRecoilIndex = 0x16C0; // int32_t + constexpr std::ptrdiff_t m_flRecoilIndex = 0x16C4; // float + constexpr std::ptrdiff_t m_bBurstMode = 0x16C8; // bool + constexpr std::ptrdiff_t m_flPostponeFireReadyTime = 0x16CC; // GameTime_t + constexpr std::ptrdiff_t m_bInReload = 0x16D0; // bool + constexpr std::ptrdiff_t m_bReloadVisuallyComplete = 0x16D1; // bool + constexpr std::ptrdiff_t m_flDroppedAtTime = 0x16D4; // GameTime_t + constexpr std::ptrdiff_t m_bIsHauledBack = 0x16D8; // bool + constexpr std::ptrdiff_t m_bSilencerOn = 0x16D9; // bool + constexpr std::ptrdiff_t m_flTimeSilencerSwitchComplete = 0x16DC; // GameTime_t + constexpr std::ptrdiff_t m_iOriginalTeamNumber = 0x16E0; // int32_t + constexpr std::ptrdiff_t m_flNextAttackRenderTimeOffset = 0x16E4; // float + constexpr std::ptrdiff_t m_bVisualsDataSet = 0x1768; // bool + constexpr std::ptrdiff_t m_bOldFirstPersonSpectatedState = 0x1769; // bool + constexpr std::ptrdiff_t m_hOurPing = 0x176C; // CHandle + constexpr std::ptrdiff_t m_nOurPingIndex = 0x1770; // CEntityIndex + constexpr std::ptrdiff_t m_vecOurPingPos = 0x1774; // Vector + constexpr std::ptrdiff_t m_bGlowForPing = 0x1780; // bool + constexpr std::ptrdiff_t m_bUIWeapon = 0x1781; // bool + constexpr std::ptrdiff_t m_hPrevOwner = 0x1790; // CHandle + constexpr std::ptrdiff_t m_nDropTick = 0x1794; // GameTick_t + constexpr std::ptrdiff_t m_donated = 0x17B4; // bool + constexpr std::ptrdiff_t m_fLastShotTime = 0x17B8; // GameTime_t + constexpr std::ptrdiff_t m_bWasOwnedByCT = 0x17BC; // bool + constexpr std::ptrdiff_t m_bWasOwnedByTerrorist = 0x17BD; // bool + constexpr std::ptrdiff_t m_gunHeat = 0x17C0; // float + constexpr std::ptrdiff_t m_smokeAttachments = 0x17C4; // uint32_t + constexpr std::ptrdiff_t m_lastSmokeTime = 0x17C8; // GameTime_t + constexpr std::ptrdiff_t m_flNextClientFireBulletTime = 0x17CC; // float + constexpr std::ptrdiff_t m_flNextClientFireBulletTime_Repredict = 0x17D0; // float + constexpr std::ptrdiff_t m_IronSightController = 0x1890; // C_IronSightController + constexpr std::ptrdiff_t m_iIronSightMode = 0x1940; // int32_t + constexpr std::ptrdiff_t m_flLastLOSTraceFailureTime = 0x1950; // GameTime_t + constexpr std::ptrdiff_t m_iNumEmptyAttacks = 0x1954; // int32_t +} + +namespace C_CSWeaponBaseGun { // C_CSWeaponBase + constexpr std::ptrdiff_t m_zoomLevel = 0x1990; // int32_t + constexpr std::ptrdiff_t m_iBurstShotsRemaining = 0x1994; // int32_t + constexpr std::ptrdiff_t m_iSilencerBodygroup = 0x1998; // int32_t + constexpr std::ptrdiff_t m_silencedModelIndex = 0x19A8; // int32_t + constexpr std::ptrdiff_t m_inPrecache = 0x19AC; // bool + constexpr std::ptrdiff_t m_bNeedsBoltAction = 0x19AD; // bool +} + +namespace C_Chicken { // C_DynamicProp + constexpr std::ptrdiff_t m_hHolidayHatAddon = 0x10F0; // CHandle + constexpr std::ptrdiff_t m_jumpedThisFrame = 0x10F4; // bool + constexpr std::ptrdiff_t m_leader = 0x10F8; // CHandle + constexpr std::ptrdiff_t m_AttributeManager = 0x1100; // C_AttributeContainer + constexpr std::ptrdiff_t m_OriginalOwnerXuidLow = 0x15A8; // uint32_t + constexpr std::ptrdiff_t m_OriginalOwnerXuidHigh = 0x15AC; // uint32_t + constexpr std::ptrdiff_t m_bAttributesInitialized = 0x15B0; // bool + constexpr std::ptrdiff_t m_hWaterWakeParticles = 0x15B4; // ParticleIndex_t +} + +namespace C_ClientRagdoll { // CBaseAnimGraph + constexpr std::ptrdiff_t m_bFadeOut = 0xE80; // bool + constexpr std::ptrdiff_t m_bImportant = 0xE81; // bool + constexpr std::ptrdiff_t m_flEffectTime = 0xE84; // GameTime_t + constexpr std::ptrdiff_t m_gibDespawnTime = 0xE88; // GameTime_t + constexpr std::ptrdiff_t m_iCurrentFriction = 0xE8C; // int32_t + constexpr std::ptrdiff_t m_iMinFriction = 0xE90; // int32_t + constexpr std::ptrdiff_t m_iMaxFriction = 0xE94; // int32_t + constexpr std::ptrdiff_t m_iFrictionAnimState = 0xE98; // int32_t + constexpr std::ptrdiff_t m_bReleaseRagdoll = 0xE9C; // bool + constexpr std::ptrdiff_t m_iEyeAttachment = 0xE9D; // AttachmentHandle_t + constexpr std::ptrdiff_t m_bFadingOut = 0xE9E; // bool + constexpr std::ptrdiff_t m_flScaleEnd = 0xEA0; // float[10] + constexpr std::ptrdiff_t m_flScaleTimeStart = 0xEC8; // GameTime_t[10] + constexpr std::ptrdiff_t m_flScaleTimeEnd = 0xEF0; // GameTime_t[10] +} + +namespace C_ColorCorrection { // C_BaseEntity + constexpr std::ptrdiff_t m_vecOrigin = 0x540; // Vector + constexpr std::ptrdiff_t m_MinFalloff = 0x54C; // float + constexpr std::ptrdiff_t m_MaxFalloff = 0x550; // float + constexpr std::ptrdiff_t m_flFadeInDuration = 0x554; // float + constexpr std::ptrdiff_t m_flFadeOutDuration = 0x558; // float + constexpr std::ptrdiff_t m_flMaxWeight = 0x55C; // float + constexpr std::ptrdiff_t m_flCurWeight = 0x560; // float + constexpr std::ptrdiff_t m_netlookupFilename = 0x564; // char[512] + constexpr std::ptrdiff_t m_bEnabled = 0x764; // bool + constexpr std::ptrdiff_t m_bMaster = 0x765; // bool + constexpr std::ptrdiff_t m_bClientSide = 0x766; // bool + constexpr std::ptrdiff_t m_bExclusive = 0x767; // bool + constexpr std::ptrdiff_t m_bEnabledOnClient = 0x768; // bool[1] + constexpr std::ptrdiff_t m_flCurWeightOnClient = 0x76C; // float[1] + constexpr std::ptrdiff_t m_bFadingIn = 0x770; // bool[1] + constexpr std::ptrdiff_t m_flFadeStartWeight = 0x774; // float[1] + constexpr std::ptrdiff_t m_flFadeStartTime = 0x778; // float[1] + constexpr std::ptrdiff_t m_flFadeDuration = 0x77C; // float[1] +} + +namespace C_ColorCorrectionVolume { // C_BaseTrigger + constexpr std::ptrdiff_t m_LastEnterWeight = 0xCC8; // float + constexpr std::ptrdiff_t m_LastEnterTime = 0xCCC; // float + constexpr std::ptrdiff_t m_LastExitWeight = 0xCD0; // float + constexpr std::ptrdiff_t m_LastExitTime = 0xCD4; // float + constexpr std::ptrdiff_t m_bEnabled = 0xCD8; // bool + constexpr std::ptrdiff_t m_MaxWeight = 0xCDC; // float + constexpr std::ptrdiff_t m_FadeDuration = 0xCE0; // float + constexpr std::ptrdiff_t m_Weight = 0xCE4; // float + constexpr std::ptrdiff_t m_lookupFilename = 0xCE8; // char[512] +} + +namespace C_CommandContext { + constexpr std::ptrdiff_t needsprocessing = 0x0; // bool + constexpr std::ptrdiff_t command_number = 0x78; // int32_t +} + +namespace C_CsmFovOverride { // C_BaseEntity + constexpr std::ptrdiff_t m_cameraName = 0x540; // CUtlString + constexpr std::ptrdiff_t m_flCsmFovOverrideValue = 0x548; // float +} + +namespace C_DEagle { // C_CSWeaponBaseGun +} + +namespace C_DecoyGrenade { // C_BaseCSGrenade +} + +namespace C_DecoyProjectile { // C_BaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_nDecoyShotTick = 0x10F0; // int32_t + constexpr std::ptrdiff_t m_nClientLastKnownDecoyShotTick = 0x10F4; // int32_t + constexpr std::ptrdiff_t m_flTimeParticleEffectSpawn = 0x1118; // GameTime_t +} + +namespace C_DynamicLight { // C_BaseModelEntity + constexpr std::ptrdiff_t m_Flags = 0xCC0; // uint8_t + constexpr std::ptrdiff_t m_LightStyle = 0xCC1; // uint8_t + constexpr std::ptrdiff_t m_Radius = 0xCC4; // float + constexpr std::ptrdiff_t m_Exponent = 0xCC8; // int32_t + constexpr std::ptrdiff_t m_InnerAngle = 0xCCC; // float + constexpr std::ptrdiff_t m_OuterAngle = 0xCD0; // float + constexpr std::ptrdiff_t m_SpotRadius = 0xCD4; // float +} + +namespace C_DynamicProp { // C_BreakableProp + constexpr std::ptrdiff_t m_bUseHitboxesForRenderBox = 0xFD0; // bool + constexpr std::ptrdiff_t m_bUseAnimGraph = 0xFD1; // bool + constexpr std::ptrdiff_t m_pOutputAnimBegun = 0xFD8; // CEntityIOOutput + constexpr std::ptrdiff_t m_pOutputAnimOver = 0x1000; // CEntityIOOutput + constexpr std::ptrdiff_t m_pOutputAnimLoopCycleOver = 0x1028; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAnimReachedStart = 0x1050; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAnimReachedEnd = 0x1078; // CEntityIOOutput + constexpr std::ptrdiff_t m_iszDefaultAnim = 0x10A0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nDefaultAnimLoopMode = 0x10A8; // AnimLoopMode_t + constexpr std::ptrdiff_t m_bAnimateOnServer = 0x10AC; // bool + constexpr std::ptrdiff_t m_bRandomizeCycle = 0x10AD; // bool + constexpr std::ptrdiff_t m_bStartDisabled = 0x10AE; // bool + constexpr std::ptrdiff_t m_bScriptedMovement = 0x10AF; // bool + constexpr std::ptrdiff_t m_bFiredStartEndOutput = 0x10B0; // bool + constexpr std::ptrdiff_t m_bForceNpcExclude = 0x10B1; // bool + constexpr std::ptrdiff_t m_bCreateNonSolid = 0x10B2; // bool + constexpr std::ptrdiff_t m_bIsOverrideProp = 0x10B3; // bool + constexpr std::ptrdiff_t m_iInitialGlowState = 0x10B4; // int32_t + constexpr std::ptrdiff_t m_nGlowRange = 0x10B8; // int32_t + constexpr std::ptrdiff_t m_nGlowRangeMin = 0x10BC; // int32_t + constexpr std::ptrdiff_t m_glowColor = 0x10C0; // Color + constexpr std::ptrdiff_t m_nGlowTeam = 0x10C4; // int32_t + constexpr std::ptrdiff_t m_iCachedFrameCount = 0x10C8; // int32_t + constexpr std::ptrdiff_t m_vecCachedRenderMins = 0x10CC; // Vector + constexpr std::ptrdiff_t m_vecCachedRenderMaxs = 0x10D8; // Vector +} + +namespace C_DynamicPropAlias_cable_dynamic { // C_DynamicProp +} + +namespace C_DynamicPropAlias_dynamic_prop { // C_DynamicProp +} + +namespace C_DynamicPropAlias_prop_dynamic_override { // C_DynamicProp +} + +namespace C_EconEntity { // C_BaseFlex + constexpr std::ptrdiff_t m_flFlexDelayTime = 0x1028; // float + constexpr std::ptrdiff_t m_flFlexDelayedWeight = 0x1030; // float* + constexpr std::ptrdiff_t m_bAttributesInitialized = 0x1038; // bool + constexpr std::ptrdiff_t m_AttributeManager = 0x1040; // C_AttributeContainer + constexpr std::ptrdiff_t m_OriginalOwnerXuidLow = 0x14E8; // uint32_t + constexpr std::ptrdiff_t m_OriginalOwnerXuidHigh = 0x14EC; // uint32_t + constexpr std::ptrdiff_t m_nFallbackPaintKit = 0x14F0; // int32_t + constexpr std::ptrdiff_t m_nFallbackSeed = 0x14F4; // int32_t + constexpr std::ptrdiff_t m_flFallbackWear = 0x14F8; // float + constexpr std::ptrdiff_t m_nFallbackStatTrak = 0x14FC; // int32_t + constexpr std::ptrdiff_t m_bClientside = 0x1500; // bool + constexpr std::ptrdiff_t m_bParticleSystemsCreated = 0x1501; // bool + constexpr std::ptrdiff_t m_vecAttachedParticles = 0x1508; // CUtlVector + constexpr std::ptrdiff_t m_hViewmodelAttachment = 0x1520; // CHandle + constexpr std::ptrdiff_t m_iOldTeam = 0x1524; // int32_t + constexpr std::ptrdiff_t m_bAttachmentDirty = 0x1528; // bool + constexpr std::ptrdiff_t m_nUnloadedModelIndex = 0x152C; // int32_t + constexpr std::ptrdiff_t m_iNumOwnerValidationRetries = 0x1530; // int32_t + constexpr std::ptrdiff_t m_hOldProvidee = 0x1540; // CHandle + constexpr std::ptrdiff_t m_vecAttachedModels = 0x1548; // CUtlVector +} + +namespace C_EconEntity_AttachedModelData_t { + constexpr std::ptrdiff_t m_iModelDisplayFlags = 0x0; // int32_t +} + +namespace C_EconItemView { // IEconItemInterface + constexpr std::ptrdiff_t m_bInventoryImageRgbaRequested = 0x60; // bool + constexpr std::ptrdiff_t m_bInventoryImageTriedCache = 0x61; // bool + constexpr std::ptrdiff_t m_nInventoryImageRgbaWidth = 0x80; // int32_t + constexpr std::ptrdiff_t m_nInventoryImageRgbaHeight = 0x84; // int32_t + constexpr std::ptrdiff_t m_szCurrentLoadCachedFileName = 0x88; // char[260] + constexpr std::ptrdiff_t m_bRestoreCustomMaterialAfterPrecache = 0x1B8; // bool + constexpr std::ptrdiff_t m_iItemDefinitionIndex = 0x1BA; // uint16_t + constexpr std::ptrdiff_t m_iEntityQuality = 0x1BC; // int32_t + constexpr std::ptrdiff_t m_iEntityLevel = 0x1C0; // uint32_t + constexpr std::ptrdiff_t m_iItemID = 0x1C8; // uint64_t + constexpr std::ptrdiff_t m_iItemIDHigh = 0x1D0; // uint32_t + constexpr std::ptrdiff_t m_iItemIDLow = 0x1D4; // uint32_t + constexpr std::ptrdiff_t m_iAccountID = 0x1D8; // uint32_t + constexpr std::ptrdiff_t m_iInventoryPosition = 0x1DC; // uint32_t + constexpr std::ptrdiff_t m_bInitialized = 0x1E8; // bool + constexpr std::ptrdiff_t m_bIsStoreItem = 0x1E9; // bool + constexpr std::ptrdiff_t m_bIsTradeItem = 0x1EA; // bool + constexpr std::ptrdiff_t m_iEntityQuantity = 0x1EC; // int32_t + constexpr std::ptrdiff_t m_iRarityOverride = 0x1F0; // int32_t + constexpr std::ptrdiff_t m_iQualityOverride = 0x1F4; // int32_t + constexpr std::ptrdiff_t m_unClientFlags = 0x1F8; // uint8_t + constexpr std::ptrdiff_t m_unOverrideStyle = 0x1F9; // uint8_t + constexpr std::ptrdiff_t m_AttributeList = 0x210; // CAttributeList + constexpr std::ptrdiff_t m_NetworkedDynamicAttributes = 0x270; // CAttributeList + constexpr std::ptrdiff_t m_szCustomName = 0x2D0; // char[161] + constexpr std::ptrdiff_t m_szCustomNameOverride = 0x371; // char[161] + constexpr std::ptrdiff_t m_bInitializedTags = 0x440; // bool +} + +namespace C_EconWearable { // C_EconEntity + constexpr std::ptrdiff_t m_nForceSkin = 0x1560; // int32_t + constexpr std::ptrdiff_t m_bAlwaysAllow = 0x1564; // bool +} + +namespace C_EntityDissolve { // C_BaseModelEntity + constexpr std::ptrdiff_t m_flStartTime = 0xCC8; // GameTime_t + constexpr std::ptrdiff_t m_flFadeInStart = 0xCCC; // float + constexpr std::ptrdiff_t m_flFadeInLength = 0xCD0; // float + constexpr std::ptrdiff_t m_flFadeOutModelStart = 0xCD4; // float + constexpr std::ptrdiff_t m_flFadeOutModelLength = 0xCD8; // float + constexpr std::ptrdiff_t m_flFadeOutStart = 0xCDC; // float + constexpr std::ptrdiff_t m_flFadeOutLength = 0xCE0; // float + constexpr std::ptrdiff_t m_flNextSparkTime = 0xCE4; // GameTime_t + constexpr std::ptrdiff_t m_nDissolveType = 0xCE8; // EntityDisolveType_t + constexpr std::ptrdiff_t m_vDissolverOrigin = 0xCEC; // Vector + constexpr std::ptrdiff_t m_nMagnitude = 0xCF8; // uint32_t + constexpr std::ptrdiff_t m_bCoreExplode = 0xCFC; // bool + constexpr std::ptrdiff_t m_bLinkedToServerEnt = 0xCFD; // bool +} + +namespace C_EntityFlame { // C_BaseEntity + constexpr std::ptrdiff_t m_hEntAttached = 0x540; // CHandle + constexpr std::ptrdiff_t m_hOldAttached = 0x568; // CHandle + constexpr std::ptrdiff_t m_bCheapEffect = 0x56C; // bool +} + +namespace C_EnvCombinedLightProbeVolume { // C_BaseEntity + constexpr std::ptrdiff_t m_Color = 0x1598; // Color + constexpr std::ptrdiff_t m_flBrightness = 0x159C; // float + constexpr std::ptrdiff_t m_hCubemapTexture = 0x15A0; // CStrongHandle + constexpr std::ptrdiff_t m_bCustomCubemapTexture = 0x15A8; // bool + constexpr std::ptrdiff_t m_hLightProbeTexture = 0x15B0; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightIndicesTexture = 0x15B8; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightScalarsTexture = 0x15C0; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightShadowsTexture = 0x15C8; // CStrongHandle + constexpr std::ptrdiff_t m_vBoxMins = 0x15D0; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x15DC; // Vector + constexpr std::ptrdiff_t m_bMoveable = 0x15E8; // bool + constexpr std::ptrdiff_t m_nHandshake = 0x15EC; // int32_t + constexpr std::ptrdiff_t m_nEnvCubeMapArrayIndex = 0x15F0; // int32_t + constexpr std::ptrdiff_t m_nPriority = 0x15F4; // int32_t + constexpr std::ptrdiff_t m_bStartDisabled = 0x15F8; // bool + constexpr std::ptrdiff_t m_flEdgeFadeDist = 0x15FC; // float + constexpr std::ptrdiff_t m_vEdgeFadeDists = 0x1600; // Vector + constexpr std::ptrdiff_t m_nLightProbeSizeX = 0x160C; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeY = 0x1610; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeZ = 0x1614; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasX = 0x1618; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasY = 0x161C; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasZ = 0x1620; // int32_t + constexpr std::ptrdiff_t m_bEnabled = 0x1639; // bool +} + +namespace C_EnvCubemap { // C_BaseEntity + constexpr std::ptrdiff_t m_hCubemapTexture = 0x5C0; // CStrongHandle + constexpr std::ptrdiff_t m_bCustomCubemapTexture = 0x5C8; // bool + constexpr std::ptrdiff_t m_flInfluenceRadius = 0x5CC; // float + constexpr std::ptrdiff_t m_vBoxProjectMins = 0x5D0; // Vector + constexpr std::ptrdiff_t m_vBoxProjectMaxs = 0x5DC; // Vector + constexpr std::ptrdiff_t m_bMoveable = 0x5E8; // bool + constexpr std::ptrdiff_t m_nHandshake = 0x5EC; // int32_t + constexpr std::ptrdiff_t m_nEnvCubeMapArrayIndex = 0x5F0; // int32_t + constexpr std::ptrdiff_t m_nPriority = 0x5F4; // int32_t + constexpr std::ptrdiff_t m_flEdgeFadeDist = 0x5F8; // float + constexpr std::ptrdiff_t m_vEdgeFadeDists = 0x5FC; // Vector + constexpr std::ptrdiff_t m_flDiffuseScale = 0x608; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x60C; // bool + constexpr std::ptrdiff_t m_bDefaultEnvMap = 0x60D; // bool + constexpr std::ptrdiff_t m_bDefaultSpecEnvMap = 0x60E; // bool + constexpr std::ptrdiff_t m_bIndoorCubeMap = 0x60F; // bool + constexpr std::ptrdiff_t m_bCopyDiffuseFromDefaultCubemap = 0x610; // bool + constexpr std::ptrdiff_t m_bEnabled = 0x620; // bool +} + +namespace C_EnvCubemapBox { // C_EnvCubemap +} + +namespace C_EnvCubemapFog { // C_BaseEntity + constexpr std::ptrdiff_t m_flEndDistance = 0x540; // float + constexpr std::ptrdiff_t m_flStartDistance = 0x544; // float + constexpr std::ptrdiff_t m_flFogFalloffExponent = 0x548; // float + constexpr std::ptrdiff_t m_bHeightFogEnabled = 0x54C; // bool + constexpr std::ptrdiff_t m_flFogHeightWidth = 0x550; // float + constexpr std::ptrdiff_t m_flFogHeightEnd = 0x554; // float + constexpr std::ptrdiff_t m_flFogHeightStart = 0x558; // float + constexpr std::ptrdiff_t m_flFogHeightExponent = 0x55C; // float + constexpr std::ptrdiff_t m_flLODBias = 0x560; // float + constexpr std::ptrdiff_t m_bActive = 0x564; // bool + constexpr std::ptrdiff_t m_bStartDisabled = 0x565; // bool + constexpr std::ptrdiff_t m_flFogMaxOpacity = 0x568; // float + constexpr std::ptrdiff_t m_nCubemapSourceType = 0x56C; // int32_t + constexpr std::ptrdiff_t m_hSkyMaterial = 0x570; // CStrongHandle + constexpr std::ptrdiff_t m_iszSkyEntity = 0x578; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFogCubemapTexture = 0x580; // CStrongHandle + constexpr std::ptrdiff_t m_bHasHeightFogEnd = 0x588; // bool + constexpr std::ptrdiff_t m_bFirstTime = 0x589; // bool +} + +namespace C_EnvDecal { // C_BaseModelEntity + constexpr std::ptrdiff_t m_hDecalMaterial = 0xCC0; // CStrongHandle + constexpr std::ptrdiff_t m_flWidth = 0xCC8; // float + constexpr std::ptrdiff_t m_flHeight = 0xCCC; // float + constexpr std::ptrdiff_t m_flDepth = 0xCD0; // float + constexpr std::ptrdiff_t m_nRenderOrder = 0xCD4; // uint32_t + constexpr std::ptrdiff_t m_bProjectOnWorld = 0xCD8; // bool + constexpr std::ptrdiff_t m_bProjectOnCharacters = 0xCD9; // bool + constexpr std::ptrdiff_t m_bProjectOnWater = 0xCDA; // bool + constexpr std::ptrdiff_t m_flDepthSortBias = 0xCDC; // float +} + +namespace C_EnvDetailController { // C_BaseEntity + constexpr std::ptrdiff_t m_flFadeStartDist = 0x540; // float + constexpr std::ptrdiff_t m_flFadeEndDist = 0x544; // float +} + +namespace C_EnvLightProbeVolume { // C_BaseEntity + constexpr std::ptrdiff_t m_hLightProbeTexture = 0x1518; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightIndicesTexture = 0x1520; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightScalarsTexture = 0x1528; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightShadowsTexture = 0x1530; // CStrongHandle + constexpr std::ptrdiff_t m_vBoxMins = 0x1538; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x1544; // Vector + constexpr std::ptrdiff_t m_bMoveable = 0x1550; // bool + constexpr std::ptrdiff_t m_nHandshake = 0x1554; // int32_t + constexpr std::ptrdiff_t m_nPriority = 0x1558; // int32_t + constexpr std::ptrdiff_t m_bStartDisabled = 0x155C; // bool + constexpr std::ptrdiff_t m_nLightProbeSizeX = 0x1560; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeY = 0x1564; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeZ = 0x1568; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasX = 0x156C; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasY = 0x1570; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasZ = 0x1574; // int32_t + constexpr std::ptrdiff_t m_bEnabled = 0x1581; // bool +} + +namespace C_EnvParticleGlow { // C_ParticleSystem + constexpr std::ptrdiff_t m_flAlphaScale = 0x1270; // float + constexpr std::ptrdiff_t m_flRadiusScale = 0x1274; // float + constexpr std::ptrdiff_t m_flSelfIllumScale = 0x1278; // float + constexpr std::ptrdiff_t m_ColorTint = 0x127C; // Color + constexpr std::ptrdiff_t m_hTextureOverride = 0x1280; // CStrongHandle +} + +namespace C_EnvProjectedTexture { // C_ModelPointEntity +} + +namespace C_EnvScreenOverlay { // C_PointEntity + constexpr std::ptrdiff_t m_iszOverlayNames = 0x540; // CUtlSymbolLarge[10] + constexpr std::ptrdiff_t m_flOverlayTimes = 0x590; // float[10] + constexpr std::ptrdiff_t m_flStartTime = 0x5B8; // GameTime_t + constexpr std::ptrdiff_t m_iDesiredOverlay = 0x5BC; // int32_t + constexpr std::ptrdiff_t m_bIsActive = 0x5C0; // bool + constexpr std::ptrdiff_t m_bWasActive = 0x5C1; // bool + constexpr std::ptrdiff_t m_iCachedDesiredOverlay = 0x5C4; // int32_t + constexpr std::ptrdiff_t m_iCurrentOverlay = 0x5C8; // int32_t + constexpr std::ptrdiff_t m_flCurrentOverlayTime = 0x5CC; // GameTime_t +} + +namespace C_EnvSky { // C_BaseModelEntity + constexpr std::ptrdiff_t m_hSkyMaterial = 0xCC0; // CStrongHandle + constexpr std::ptrdiff_t m_hSkyMaterialLightingOnly = 0xCC8; // CStrongHandle + constexpr std::ptrdiff_t m_bStartDisabled = 0xCD0; // bool + constexpr std::ptrdiff_t m_vTintColor = 0xCD1; // Color + constexpr std::ptrdiff_t m_vTintColorLightingOnly = 0xCD5; // Color + constexpr std::ptrdiff_t m_flBrightnessScale = 0xCDC; // float + constexpr std::ptrdiff_t m_nFogType = 0xCE0; // int32_t + constexpr std::ptrdiff_t m_flFogMinStart = 0xCE4; // float + constexpr std::ptrdiff_t m_flFogMinEnd = 0xCE8; // float + constexpr std::ptrdiff_t m_flFogMaxStart = 0xCEC; // float + constexpr std::ptrdiff_t m_flFogMaxEnd = 0xCF0; // float + constexpr std::ptrdiff_t m_bEnabled = 0xCF4; // bool +} + +namespace C_EnvVolumetricFogController { // C_BaseEntity + constexpr std::ptrdiff_t m_flScattering = 0x540; // float + constexpr std::ptrdiff_t m_flAnisotropy = 0x544; // float + constexpr std::ptrdiff_t m_flFadeSpeed = 0x548; // float + constexpr std::ptrdiff_t m_flDrawDistance = 0x54C; // float + constexpr std::ptrdiff_t m_flFadeInStart = 0x550; // float + constexpr std::ptrdiff_t m_flFadeInEnd = 0x554; // float + constexpr std::ptrdiff_t m_flIndirectStrength = 0x558; // float + constexpr std::ptrdiff_t m_nIndirectTextureDimX = 0x55C; // int32_t + constexpr std::ptrdiff_t m_nIndirectTextureDimY = 0x560; // int32_t + constexpr std::ptrdiff_t m_nIndirectTextureDimZ = 0x564; // int32_t + constexpr std::ptrdiff_t m_vBoxMins = 0x568; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x574; // Vector + constexpr std::ptrdiff_t m_bActive = 0x580; // bool + constexpr std::ptrdiff_t m_flStartAnisoTime = 0x584; // GameTime_t + constexpr std::ptrdiff_t m_flStartScatterTime = 0x588; // GameTime_t + constexpr std::ptrdiff_t m_flStartDrawDistanceTime = 0x58C; // GameTime_t + constexpr std::ptrdiff_t m_flStartAnisotropy = 0x590; // float + constexpr std::ptrdiff_t m_flStartScattering = 0x594; // float + constexpr std::ptrdiff_t m_flStartDrawDistance = 0x598; // float + constexpr std::ptrdiff_t m_flDefaultAnisotropy = 0x59C; // float + constexpr std::ptrdiff_t m_flDefaultScattering = 0x5A0; // float + constexpr std::ptrdiff_t m_flDefaultDrawDistance = 0x5A4; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x5A8; // bool + constexpr std::ptrdiff_t m_bEnableIndirect = 0x5A9; // bool + constexpr std::ptrdiff_t m_bIsMaster = 0x5AA; // bool + constexpr std::ptrdiff_t m_hFogIndirectTexture = 0x5B0; // CStrongHandle + constexpr std::ptrdiff_t m_nForceRefreshCount = 0x5B8; // int32_t + constexpr std::ptrdiff_t m_bFirstTime = 0x5BC; // bool +} + +namespace C_EnvVolumetricFogVolume { // C_BaseEntity + constexpr std::ptrdiff_t m_bActive = 0x540; // bool + constexpr std::ptrdiff_t m_vBoxMins = 0x544; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x550; // Vector + constexpr std::ptrdiff_t m_bStartDisabled = 0x55C; // bool + constexpr std::ptrdiff_t m_flStrength = 0x560; // float + constexpr std::ptrdiff_t m_nFalloffShape = 0x564; // int32_t + constexpr std::ptrdiff_t m_flFalloffExponent = 0x568; // float +} + +namespace C_EnvWind { // C_BaseEntity + constexpr std::ptrdiff_t m_EnvWindShared = 0x540; // C_EnvWindShared +} + +namespace C_EnvWindClientside { // C_BaseEntity + constexpr std::ptrdiff_t m_EnvWindShared = 0x540; // C_EnvWindShared +} + +namespace C_EnvWindShared { + constexpr std::ptrdiff_t m_flStartTime = 0x8; // GameTime_t + constexpr std::ptrdiff_t m_iWindSeed = 0xC; // uint32_t + constexpr std::ptrdiff_t m_iMinWind = 0x10; // uint16_t + constexpr std::ptrdiff_t m_iMaxWind = 0x12; // uint16_t + constexpr std::ptrdiff_t m_windRadius = 0x14; // int32_t + constexpr std::ptrdiff_t m_iMinGust = 0x18; // uint16_t + constexpr std::ptrdiff_t m_iMaxGust = 0x1A; // uint16_t + constexpr std::ptrdiff_t m_flMinGustDelay = 0x1C; // float + constexpr std::ptrdiff_t m_flMaxGustDelay = 0x20; // float + constexpr std::ptrdiff_t m_flGustDuration = 0x24; // float + constexpr std::ptrdiff_t m_iGustDirChange = 0x28; // uint16_t + constexpr std::ptrdiff_t m_location = 0x2C; // Vector + constexpr std::ptrdiff_t m_iszGustSound = 0x38; // int32_t + constexpr std::ptrdiff_t m_iWindDir = 0x3C; // int32_t + constexpr std::ptrdiff_t m_flWindSpeed = 0x40; // float + constexpr std::ptrdiff_t m_currentWindVector = 0x44; // Vector + constexpr std::ptrdiff_t m_CurrentSwayVector = 0x50; // Vector + constexpr std::ptrdiff_t m_PrevSwayVector = 0x5C; // Vector + constexpr std::ptrdiff_t m_iInitialWindDir = 0x68; // uint16_t + constexpr std::ptrdiff_t m_flInitialWindSpeed = 0x6C; // float + constexpr std::ptrdiff_t m_flVariationTime = 0x70; // GameTime_t + constexpr std::ptrdiff_t m_flSwayTime = 0x74; // GameTime_t + constexpr std::ptrdiff_t m_flSimTime = 0x78; // GameTime_t + constexpr std::ptrdiff_t m_flSwitchTime = 0x7C; // GameTime_t + constexpr std::ptrdiff_t m_flAveWindSpeed = 0x80; // float + constexpr std::ptrdiff_t m_bGusting = 0x84; // bool + constexpr std::ptrdiff_t m_flWindAngleVariation = 0x88; // float + constexpr std::ptrdiff_t m_flWindSpeedVariation = 0x8C; // float + constexpr std::ptrdiff_t m_iEntIndex = 0x90; // CEntityIndex +} + +namespace C_EnvWindShared_WindAveEvent_t { + constexpr std::ptrdiff_t m_flStartWindSpeed = 0x0; // float + constexpr std::ptrdiff_t m_flAveWindSpeed = 0x4; // float +} + +namespace C_EnvWindShared_WindVariationEvent_t { + constexpr std::ptrdiff_t m_flWindAngleVariation = 0x0; // float + constexpr std::ptrdiff_t m_flWindSpeedVariation = 0x4; // float +} + +namespace C_FireCrackerBlast { // C_Inferno +} + +namespace C_FireFromAboveSprite { // C_Sprite +} + +namespace C_FireSmoke { // C_BaseFire + constexpr std::ptrdiff_t m_nFlameModelIndex = 0x550; // int32_t + constexpr std::ptrdiff_t m_nFlameFromAboveModelIndex = 0x554; // int32_t + constexpr std::ptrdiff_t m_flScaleRegister = 0x558; // float + constexpr std::ptrdiff_t m_flScaleStart = 0x55C; // float + constexpr std::ptrdiff_t m_flScaleEnd = 0x560; // float + constexpr std::ptrdiff_t m_flScaleTimeStart = 0x564; // GameTime_t + constexpr std::ptrdiff_t m_flScaleTimeEnd = 0x568; // GameTime_t + constexpr std::ptrdiff_t m_flChildFlameSpread = 0x56C; // float + constexpr std::ptrdiff_t m_flClipPerc = 0x580; // float + constexpr std::ptrdiff_t m_bClipTested = 0x584; // bool + constexpr std::ptrdiff_t m_bFadingOut = 0x585; // bool + constexpr std::ptrdiff_t m_tParticleSpawn = 0x588; // TimedEvent + constexpr std::ptrdiff_t m_pFireOverlay = 0x590; // CFireOverlay* +} + +namespace C_FireSprite { // C_Sprite + constexpr std::ptrdiff_t m_vecMoveDir = 0xDF0; // Vector + constexpr std::ptrdiff_t m_bFadeFromAbove = 0xDFC; // bool +} + +namespace C_Fish { // CBaseAnimGraph + constexpr std::ptrdiff_t m_pos = 0xE80; // Vector + constexpr std::ptrdiff_t m_vel = 0xE8C; // Vector + constexpr std::ptrdiff_t m_angles = 0xE98; // QAngle + constexpr std::ptrdiff_t m_localLifeState = 0xEA4; // int32_t + constexpr std::ptrdiff_t m_deathDepth = 0xEA8; // float + constexpr std::ptrdiff_t m_deathAngle = 0xEAC; // float + constexpr std::ptrdiff_t m_buoyancy = 0xEB0; // float + constexpr std::ptrdiff_t m_wiggleTimer = 0xEB8; // CountdownTimer + constexpr std::ptrdiff_t m_wigglePhase = 0xED0; // float + constexpr std::ptrdiff_t m_wiggleRate = 0xED4; // float + constexpr std::ptrdiff_t m_actualPos = 0xED8; // Vector + constexpr std::ptrdiff_t m_actualAngles = 0xEE4; // QAngle + constexpr std::ptrdiff_t m_poolOrigin = 0xEF0; // Vector + constexpr std::ptrdiff_t m_waterLevel = 0xEFC; // float + constexpr std::ptrdiff_t m_gotUpdate = 0xF00; // bool + constexpr std::ptrdiff_t m_x = 0xF04; // float + constexpr std::ptrdiff_t m_y = 0xF08; // float + constexpr std::ptrdiff_t m_z = 0xF0C; // float + constexpr std::ptrdiff_t m_angle = 0xF10; // float + constexpr std::ptrdiff_t m_errorHistory = 0xF14; // float[20] + constexpr std::ptrdiff_t m_errorHistoryIndex = 0xF64; // int32_t + constexpr std::ptrdiff_t m_errorHistoryCount = 0xF68; // int32_t + constexpr std::ptrdiff_t m_averageError = 0xF6C; // float +} + +namespace C_Fists { // C_CSWeaponBase + constexpr std::ptrdiff_t m_bPlayingUninterruptableAct = 0x1990; // bool + constexpr std::ptrdiff_t m_nUninterruptableActivity = 0x1994; // PlayerAnimEvent_t +} + +namespace C_Flashbang { // C_BaseCSGrenade +} + +namespace C_FlashbangProjectile { // C_BaseCSGrenadeProjectile +} + +namespace C_FogController { // C_BaseEntity + constexpr std::ptrdiff_t m_fog = 0x540; // fogparams_t + constexpr std::ptrdiff_t m_bUseAngles = 0x5A8; // bool + constexpr std::ptrdiff_t m_iChangedVariables = 0x5AC; // int32_t +} + +namespace C_FootstepControl { // C_BaseTrigger + constexpr std::ptrdiff_t m_source = 0xCC8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_destination = 0xCD0; // CUtlSymbolLarge +} + +namespace C_FuncBrush { // C_BaseModelEntity +} + +namespace C_FuncConveyor { // C_BaseModelEntity + constexpr std::ptrdiff_t m_vecMoveDirEntitySpace = 0xCC8; // Vector + constexpr std::ptrdiff_t m_flTargetSpeed = 0xCD4; // float + constexpr std::ptrdiff_t m_nTransitionStartTick = 0xCD8; // GameTick_t + constexpr std::ptrdiff_t m_nTransitionDurationTicks = 0xCDC; // int32_t + constexpr std::ptrdiff_t m_flTransitionStartSpeed = 0xCE0; // float + constexpr std::ptrdiff_t m_hConveyorModels = 0xCE8; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_flCurrentConveyorOffset = 0xD00; // float + constexpr std::ptrdiff_t m_flCurrentConveyorSpeed = 0xD04; // float +} + +namespace C_FuncElectrifiedVolume { // C_FuncBrush + constexpr std::ptrdiff_t m_nAmbientEffect = 0xCC0; // ParticleIndex_t + constexpr std::ptrdiff_t m_EffectName = 0xCC8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bState = 0xCD0; // bool +} + +namespace C_FuncLadder { // C_BaseModelEntity + constexpr std::ptrdiff_t m_vecLadderDir = 0xCC0; // Vector + constexpr std::ptrdiff_t m_Dismounts = 0xCD0; // CUtlVector> + constexpr std::ptrdiff_t m_vecLocalTop = 0xCE8; // Vector + constexpr std::ptrdiff_t m_vecPlayerMountPositionTop = 0xCF4; // Vector + constexpr std::ptrdiff_t m_vecPlayerMountPositionBottom = 0xD00; // Vector + constexpr std::ptrdiff_t m_flAutoRideSpeed = 0xD0C; // float + constexpr std::ptrdiff_t m_bDisabled = 0xD10; // bool + constexpr std::ptrdiff_t m_bFakeLadder = 0xD11; // bool + constexpr std::ptrdiff_t m_bHasSlack = 0xD12; // bool +} + +namespace C_FuncMonitor { // C_FuncBrush + constexpr std::ptrdiff_t m_targetCamera = 0xCC0; // CUtlString + constexpr std::ptrdiff_t m_nResolutionEnum = 0xCC8; // int32_t + constexpr std::ptrdiff_t m_bRenderShadows = 0xCCC; // bool + constexpr std::ptrdiff_t m_bUseUniqueColorTarget = 0xCCD; // bool + constexpr std::ptrdiff_t m_brushModelName = 0xCD0; // CUtlString + constexpr std::ptrdiff_t m_hTargetCamera = 0xCD8; // CHandle + constexpr std::ptrdiff_t m_bEnabled = 0xCDC; // bool + constexpr std::ptrdiff_t m_bDraw3DSkybox = 0xCDD; // bool +} + +namespace C_FuncMoveLinear { // C_BaseToggle +} + +namespace C_FuncRotating { // C_BaseModelEntity +} + +namespace C_FuncTrackTrain { // C_BaseModelEntity + constexpr std::ptrdiff_t m_nLongAxis = 0xCC0; // int32_t + constexpr std::ptrdiff_t m_flRadius = 0xCC4; // float + constexpr std::ptrdiff_t m_flLineLength = 0xCC8; // float +} + +namespace C_GameRules { +} + +namespace C_GameRulesProxy { // C_BaseEntity +} + +namespace C_GlobalLight { // C_BaseEntity + constexpr std::ptrdiff_t m_WindClothForceHandle = 0xA00; // uint16_t +} + +namespace C_GradientFog { // C_BaseEntity + constexpr std::ptrdiff_t m_hGradientFogTexture = 0x540; // CStrongHandle + constexpr std::ptrdiff_t m_flFogStartDistance = 0x548; // float + constexpr std::ptrdiff_t m_flFogEndDistance = 0x54C; // float + constexpr std::ptrdiff_t m_bHeightFogEnabled = 0x550; // bool + constexpr std::ptrdiff_t m_flFogStartHeight = 0x554; // float + constexpr std::ptrdiff_t m_flFogEndHeight = 0x558; // float + constexpr std::ptrdiff_t m_flFarZ = 0x55C; // float + constexpr std::ptrdiff_t m_flFogMaxOpacity = 0x560; // float + constexpr std::ptrdiff_t m_flFogFalloffExponent = 0x564; // float + constexpr std::ptrdiff_t m_flFogVerticalExponent = 0x568; // float + constexpr std::ptrdiff_t m_fogColor = 0x56C; // Color + constexpr std::ptrdiff_t m_flFogStrength = 0x570; // float + constexpr std::ptrdiff_t m_flFadeTime = 0x574; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x578; // bool + constexpr std::ptrdiff_t m_bIsEnabled = 0x579; // bool + constexpr std::ptrdiff_t m_bGradientFogNeedsTextures = 0x57A; // bool +} + +namespace C_HEGrenade { // C_BaseCSGrenade +} + +namespace C_HEGrenadeProjectile { // C_BaseCSGrenadeProjectile +} + +namespace C_HandleTest { // C_BaseEntity + constexpr std::ptrdiff_t m_Handle = 0x540; // CHandle + constexpr std::ptrdiff_t m_bSendHandle = 0x544; // bool +} + +namespace C_Hostage { // C_BaseCombatCharacter + constexpr std::ptrdiff_t m_entitySpottedState = 0x10A8; // EntitySpottedState_t + constexpr std::ptrdiff_t m_leader = 0x10C0; // CHandle + constexpr std::ptrdiff_t m_reuseTimer = 0x10C8; // CountdownTimer + constexpr std::ptrdiff_t m_vel = 0x10E0; // Vector + constexpr std::ptrdiff_t m_isRescued = 0x10EC; // bool + constexpr std::ptrdiff_t m_jumpedThisFrame = 0x10ED; // bool + constexpr std::ptrdiff_t m_nHostageState = 0x10F0; // int32_t + constexpr std::ptrdiff_t m_bHandsHaveBeenCut = 0x10F4; // bool + constexpr std::ptrdiff_t m_hHostageGrabber = 0x10F8; // CHandle + constexpr std::ptrdiff_t m_fLastGrabTime = 0x10FC; // GameTime_t + constexpr std::ptrdiff_t m_vecGrabbedPos = 0x1100; // Vector + constexpr std::ptrdiff_t m_flRescueStartTime = 0x110C; // GameTime_t + constexpr std::ptrdiff_t m_flGrabSuccessTime = 0x1110; // GameTime_t + constexpr std::ptrdiff_t m_flDropStartTime = 0x1114; // GameTime_t + constexpr std::ptrdiff_t m_flDeadOrRescuedTime = 0x1118; // GameTime_t + constexpr std::ptrdiff_t m_blinkTimer = 0x1120; // CountdownTimer + constexpr std::ptrdiff_t m_lookAt = 0x1138; // Vector + constexpr std::ptrdiff_t m_lookAroundTimer = 0x1148; // CountdownTimer + constexpr std::ptrdiff_t m_isInit = 0x1160; // bool + constexpr std::ptrdiff_t m_eyeAttachment = 0x1161; // AttachmentHandle_t + constexpr std::ptrdiff_t m_chestAttachment = 0x1162; // AttachmentHandle_t + constexpr std::ptrdiff_t m_pPredictionOwner = 0x1168; // CBasePlayerController* + constexpr std::ptrdiff_t m_fNewestAlphaThinkTime = 0x1170; // GameTime_t +} + +namespace C_HostageCarriableProp { // CBaseAnimGraph +} + +namespace C_IncendiaryGrenade { // C_MolotovGrenade +} + +namespace C_Inferno { // C_BaseModelEntity + constexpr std::ptrdiff_t m_nfxFireDamageEffect = 0xD00; // ParticleIndex_t + constexpr std::ptrdiff_t m_firePositions = 0xD04; // Vector[64] + constexpr std::ptrdiff_t m_fireParentPositions = 0x1004; // Vector[64] + constexpr std::ptrdiff_t m_bFireIsBurning = 0x1304; // bool[64] + constexpr std::ptrdiff_t m_BurnNormal = 0x1344; // Vector[64] + constexpr std::ptrdiff_t m_fireCount = 0x1644; // int32_t + constexpr std::ptrdiff_t m_nInfernoType = 0x1648; // int32_t + constexpr std::ptrdiff_t m_nFireLifetime = 0x164C; // float + constexpr std::ptrdiff_t m_bInPostEffectTime = 0x1650; // bool + constexpr std::ptrdiff_t m_lastFireCount = 0x1654; // int32_t + constexpr std::ptrdiff_t m_nFireEffectTickBegin = 0x1658; // int32_t + constexpr std::ptrdiff_t m_drawableCount = 0x8260; // int32_t + constexpr std::ptrdiff_t m_blosCheck = 0x8264; // bool + constexpr std::ptrdiff_t m_nlosperiod = 0x8268; // int32_t + constexpr std::ptrdiff_t m_maxFireHalfWidth = 0x826C; // float + constexpr std::ptrdiff_t m_maxFireHeight = 0x8270; // float + constexpr std::ptrdiff_t m_minBounds = 0x8274; // Vector + constexpr std::ptrdiff_t m_maxBounds = 0x8280; // Vector + constexpr std::ptrdiff_t m_flLastGrassBurnThink = 0x828C; // float +} + +namespace C_InfoInstructorHintHostageRescueZone { // C_PointEntity +} + +namespace C_InfoLadderDismount { // C_BaseEntity +} + +namespace C_InfoVisibilityBox { // C_BaseEntity + constexpr std::ptrdiff_t m_nMode = 0x544; // int32_t + constexpr std::ptrdiff_t m_vBoxSize = 0x548; // Vector + constexpr std::ptrdiff_t m_bEnabled = 0x554; // bool +} + +namespace C_IronSightController { + constexpr std::ptrdiff_t m_bIronSightAvailable = 0x10; // bool + constexpr std::ptrdiff_t m_flIronSightAmount = 0x14; // float + constexpr std::ptrdiff_t m_flIronSightAmountGained = 0x18; // float + constexpr std::ptrdiff_t m_flIronSightAmountBiased = 0x1C; // float + constexpr std::ptrdiff_t m_flIronSightAmount_Interpolated = 0x20; // float + constexpr std::ptrdiff_t m_flIronSightAmountGained_Interpolated = 0x24; // float + constexpr std::ptrdiff_t m_flIronSightAmountBiased_Interpolated = 0x28; // float + constexpr std::ptrdiff_t m_flInterpolationLastUpdated = 0x2C; // float + constexpr std::ptrdiff_t m_angDeltaAverage = 0x30; // QAngle[8] + constexpr std::ptrdiff_t m_angViewLast = 0x90; // QAngle + constexpr std::ptrdiff_t m_vecDotCoords = 0x9C; // Vector2D + constexpr std::ptrdiff_t m_flDotBlur = 0xA4; // float + constexpr std::ptrdiff_t m_flSpeedRatio = 0xA8; // float +} + +namespace C_Item { // C_EconEntity + constexpr std::ptrdiff_t m_bShouldGlow = 0x1560; // bool + constexpr std::ptrdiff_t m_pReticleHintTextName = 0x1561; // char[256] +} + +namespace C_ItemDogtags { // C_Item + constexpr std::ptrdiff_t m_OwningPlayer = 0x1668; // CHandle + constexpr std::ptrdiff_t m_KillingPlayer = 0x166C; // CHandle +} + +namespace C_Item_Healthshot { // C_WeaponBaseItem +} + +namespace C_Knife { // C_CSWeaponBase +} + +namespace C_LightDirectionalEntity { // C_LightEntity +} + +namespace C_LightEntity { // C_BaseModelEntity + constexpr std::ptrdiff_t m_CLightComponent = 0xCC0; // CLightComponent* +} + +namespace C_LightEnvironmentEntity { // C_LightDirectionalEntity +} + +namespace C_LightGlow { // C_BaseModelEntity + constexpr std::ptrdiff_t m_nHorizontalSize = 0xCC0; // uint32_t + constexpr std::ptrdiff_t m_nVerticalSize = 0xCC4; // uint32_t + constexpr std::ptrdiff_t m_nMinDist = 0xCC8; // uint32_t + constexpr std::ptrdiff_t m_nMaxDist = 0xCCC; // uint32_t + constexpr std::ptrdiff_t m_nOuterMaxDist = 0xCD0; // uint32_t + constexpr std::ptrdiff_t m_flGlowProxySize = 0xCD4; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0xCD8; // float + constexpr std::ptrdiff_t m_Glow = 0xCE0; // C_LightGlowOverlay +} + +namespace C_LightGlowOverlay { // CGlowOverlay + constexpr std::ptrdiff_t m_vecOrigin = 0xD0; // Vector + constexpr std::ptrdiff_t m_vecDirection = 0xDC; // Vector + constexpr std::ptrdiff_t m_nMinDist = 0xE8; // int32_t + constexpr std::ptrdiff_t m_nMaxDist = 0xEC; // int32_t + constexpr std::ptrdiff_t m_nOuterMaxDist = 0xF0; // int32_t + constexpr std::ptrdiff_t m_bOneSided = 0xF4; // bool + constexpr std::ptrdiff_t m_bModulateByDot = 0xF5; // bool +} + +namespace C_LightOrthoEntity { // C_LightEntity +} + +namespace C_LightSpotEntity { // C_LightEntity +} + +namespace C_LocalTempEntity { // CBaseAnimGraph + constexpr std::ptrdiff_t flags = 0xE98; // int32_t + constexpr std::ptrdiff_t die = 0xE9C; // GameTime_t + constexpr std::ptrdiff_t m_flFrameMax = 0xEA0; // float + constexpr std::ptrdiff_t x = 0xEA4; // float + constexpr std::ptrdiff_t y = 0xEA8; // float + constexpr std::ptrdiff_t fadeSpeed = 0xEAC; // float + constexpr std::ptrdiff_t bounceFactor = 0xEB0; // float + constexpr std::ptrdiff_t hitSound = 0xEB4; // int32_t + constexpr std::ptrdiff_t priority = 0xEB8; // int32_t + constexpr std::ptrdiff_t tentOffset = 0xEBC; // Vector + constexpr std::ptrdiff_t m_vecTempEntAngVelocity = 0xEC8; // QAngle + constexpr std::ptrdiff_t tempent_renderamt = 0xED4; // int32_t + constexpr std::ptrdiff_t m_vecNormal = 0xED8; // Vector + constexpr std::ptrdiff_t m_flSpriteScale = 0xEE4; // float + constexpr std::ptrdiff_t m_nFlickerFrame = 0xEE8; // int32_t + constexpr std::ptrdiff_t m_flFrameRate = 0xEEC; // float + constexpr std::ptrdiff_t m_flFrame = 0xEF0; // float + constexpr std::ptrdiff_t m_pszImpactEffect = 0xEF8; // char* + constexpr std::ptrdiff_t m_pszParticleEffect = 0xF00; // char* + constexpr std::ptrdiff_t m_bParticleCollision = 0xF08; // bool + constexpr std::ptrdiff_t m_iLastCollisionFrame = 0xF0C; // int32_t + constexpr std::ptrdiff_t m_vLastCollisionOrigin = 0xF10; // Vector + constexpr std::ptrdiff_t m_vecTempEntVelocity = 0xF1C; // Vector + constexpr std::ptrdiff_t m_vecPrevAbsOrigin = 0xF28; // Vector + constexpr std::ptrdiff_t m_vecTempEntAcceleration = 0xF34; // Vector +} + +namespace C_MapPreviewParticleSystem { // C_ParticleSystem +} + +namespace C_MapVetoPickController { // C_BaseEntity + constexpr std::ptrdiff_t m_nDraftType = 0x550; // int32_t + constexpr std::ptrdiff_t m_nTeamWinningCoinToss = 0x554; // int32_t + constexpr std::ptrdiff_t m_nTeamWithFirstChoice = 0x558; // int32_t[64] + constexpr std::ptrdiff_t m_nVoteMapIdsList = 0x658; // int32_t[7] + constexpr std::ptrdiff_t m_nAccountIDs = 0x674; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId0 = 0x774; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId1 = 0x874; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId2 = 0x974; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId3 = 0xA74; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId4 = 0xB74; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId5 = 0xC74; // int32_t[64] + constexpr std::ptrdiff_t m_nStartingSide0 = 0xD74; // int32_t[64] + constexpr std::ptrdiff_t m_nCurrentPhase = 0xE74; // int32_t + constexpr std::ptrdiff_t m_nPhaseStartTick = 0xE78; // int32_t + constexpr std::ptrdiff_t m_nPhaseDurationTicks = 0xE7C; // int32_t + constexpr std::ptrdiff_t m_nPostDataUpdateTick = 0xE80; // int32_t + constexpr std::ptrdiff_t m_bDisabledHud = 0xE84; // bool +} + +namespace C_Melee { // C_CSWeaponBase + constexpr std::ptrdiff_t m_flThrowAt = 0x1990; // GameTime_t +} + +namespace C_ModelPointEntity { // C_BaseModelEntity +} + +namespace C_MolotovGrenade { // C_BaseCSGrenade +} + +namespace C_MolotovProjectile { // C_BaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_bIsIncGrenade = 0x10F0; // bool +} + +namespace C_Multimeter { // CBaseAnimGraph + constexpr std::ptrdiff_t m_hTargetC4 = 0xE88; // CHandle +} + +namespace C_MultiplayRules { // C_GameRules +} + +namespace C_NetTestBaseCombatCharacter { // C_BaseCombatCharacter +} + +namespace C_OmniLight { // C_BarnLight + constexpr std::ptrdiff_t m_flInnerAngle = 0xF08; // float + constexpr std::ptrdiff_t m_flOuterAngle = 0xF0C; // float + constexpr std::ptrdiff_t m_bShowLight = 0xF10; // bool +} + +namespace C_ParticleSystem { // C_BaseModelEntity + constexpr std::ptrdiff_t m_szSnapshotFileName = 0xCC0; // char[512] + constexpr std::ptrdiff_t m_bActive = 0xEC0; // bool + constexpr std::ptrdiff_t m_bFrozen = 0xEC1; // bool + constexpr std::ptrdiff_t m_flFreezeTransitionDuration = 0xEC4; // float + constexpr std::ptrdiff_t m_nStopType = 0xEC8; // int32_t + constexpr std::ptrdiff_t m_bAnimateDuringGameplayPause = 0xECC; // bool + constexpr std::ptrdiff_t m_iEffectIndex = 0xED0; // CStrongHandle + constexpr std::ptrdiff_t m_flStartTime = 0xED8; // GameTime_t + constexpr std::ptrdiff_t m_flPreSimTime = 0xEDC; // float + constexpr std::ptrdiff_t m_vServerControlPoints = 0xEE0; // Vector[4] + constexpr std::ptrdiff_t m_iServerControlPointAssignments = 0xF10; // uint8_t[4] + constexpr std::ptrdiff_t m_hControlPointEnts = 0xF14; // CHandle[64] + constexpr std::ptrdiff_t m_bNoSave = 0x1014; // bool + constexpr std::ptrdiff_t m_bNoFreeze = 0x1015; // bool + constexpr std::ptrdiff_t m_bNoRamp = 0x1016; // bool + constexpr std::ptrdiff_t m_bStartActive = 0x1017; // bool + constexpr std::ptrdiff_t m_iszEffectName = 0x1018; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszControlPointNames = 0x1020; // CUtlSymbolLarge[64] + constexpr std::ptrdiff_t m_nDataCP = 0x1220; // int32_t + constexpr std::ptrdiff_t m_vecDataCPValue = 0x1224; // Vector + constexpr std::ptrdiff_t m_nTintCP = 0x1230; // int32_t + constexpr std::ptrdiff_t m_clrTint = 0x1234; // Color + constexpr std::ptrdiff_t m_bOldActive = 0x1258; // bool + constexpr std::ptrdiff_t m_bOldFrozen = 0x1259; // bool +} + +namespace C_PathParticleRope { // C_BaseEntity + constexpr std::ptrdiff_t m_bStartActive = 0x540; // bool + constexpr std::ptrdiff_t m_flMaxSimulationTime = 0x544; // float + constexpr std::ptrdiff_t m_iszEffectName = 0x548; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_PathNodes_Name = 0x550; // CUtlVector + constexpr std::ptrdiff_t m_flParticleSpacing = 0x568; // float + constexpr std::ptrdiff_t m_flSlack = 0x56C; // float + constexpr std::ptrdiff_t m_flRadius = 0x570; // float + constexpr std::ptrdiff_t m_ColorTint = 0x574; // Color + constexpr std::ptrdiff_t m_nEffectState = 0x578; // int32_t + constexpr std::ptrdiff_t m_iEffectIndex = 0x580; // CStrongHandle + constexpr std::ptrdiff_t m_PathNodes_Position = 0x588; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_TangentIn = 0x5A0; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_TangentOut = 0x5B8; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_Color = 0x5D0; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_PinEnabled = 0x5E8; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_RadiusScale = 0x600; // C_NetworkUtlVectorBase +} + +namespace C_PathParticleRopeAlias_path_particle_rope_clientside { // C_PathParticleRope +} + +namespace C_PhysBox { // C_Breakable +} + +namespace C_PhysMagnet { // CBaseAnimGraph + constexpr std::ptrdiff_t m_aAttachedObjectsFromServer = 0xE80; // CUtlVector + constexpr std::ptrdiff_t m_aAttachedObjects = 0xE98; // CUtlVector> +} + +namespace C_PhysPropClientside { // C_BreakableProp + constexpr std::ptrdiff_t m_flTouchDelta = 0xFD0; // GameTime_t + constexpr std::ptrdiff_t m_fDeathTime = 0xFD4; // GameTime_t + constexpr std::ptrdiff_t m_impactEnergyScale = 0xFD8; // float + constexpr std::ptrdiff_t m_inertiaScale = 0xFDC; // float + constexpr std::ptrdiff_t m_flDmgModBullet = 0xFE0; // float + constexpr std::ptrdiff_t m_flDmgModClub = 0xFE4; // float + constexpr std::ptrdiff_t m_flDmgModExplosive = 0xFE8; // float + constexpr std::ptrdiff_t m_flDmgModFire = 0xFEC; // float + constexpr std::ptrdiff_t m_iszPhysicsDamageTableName = 0xFF0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszBasePropData = 0xFF8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iInteractions = 0x1000; // int32_t + constexpr std::ptrdiff_t m_bHasBreakPiecesOrCommands = 0x1004; // bool + constexpr std::ptrdiff_t m_vecDamagePosition = 0x1008; // Vector + constexpr std::ptrdiff_t m_vecDamageDirection = 0x1014; // Vector + constexpr std::ptrdiff_t m_nDamageType = 0x1020; // int32_t +} + +namespace C_PhysicsProp { // C_BreakableProp + constexpr std::ptrdiff_t m_bAwake = 0xFD0; // bool +} + +namespace C_PhysicsPropMultiplayer { // C_PhysicsProp +} + +namespace C_PickUpModelSlerper { // CBaseAnimGraph + constexpr std::ptrdiff_t m_hPlayerParent = 0xE80; // CHandle + constexpr std::ptrdiff_t m_hItem = 0xE84; // CHandle + constexpr std::ptrdiff_t m_flTimePickedUp = 0xE88; // float + constexpr std::ptrdiff_t m_angOriginal = 0xE8C; // QAngle + constexpr std::ptrdiff_t m_vecPosOriginal = 0xE98; // Vector + constexpr std::ptrdiff_t m_angRandom = 0xEA8; // QAngle +} + +namespace C_PlantedC4 { // CBaseAnimGraph + constexpr std::ptrdiff_t m_bBombTicking = 0xE80; // bool + constexpr std::ptrdiff_t m_nBombSite = 0xE84; // int32_t + constexpr std::ptrdiff_t m_nSourceSoundscapeHash = 0xE88; // int32_t + constexpr std::ptrdiff_t m_entitySpottedState = 0xE90; // EntitySpottedState_t + constexpr std::ptrdiff_t m_flNextGlow = 0xEA8; // GameTime_t + constexpr std::ptrdiff_t m_flNextBeep = 0xEAC; // GameTime_t + constexpr std::ptrdiff_t m_flC4Blow = 0xEB0; // GameTime_t + constexpr std::ptrdiff_t m_bCannotBeDefused = 0xEB4; // bool + constexpr std::ptrdiff_t m_bHasExploded = 0xEB5; // bool + constexpr std::ptrdiff_t m_flTimerLength = 0xEB8; // float + constexpr std::ptrdiff_t m_bBeingDefused = 0xEBC; // bool + constexpr std::ptrdiff_t m_bTriggerWarning = 0xEC0; // float + constexpr std::ptrdiff_t m_bExplodeWarning = 0xEC4; // float + constexpr std::ptrdiff_t m_bC4Activated = 0xEC8; // bool + constexpr std::ptrdiff_t m_bTenSecWarning = 0xEC9; // bool + constexpr std::ptrdiff_t m_flDefuseLength = 0xECC; // float + constexpr std::ptrdiff_t m_flDefuseCountDown = 0xED0; // GameTime_t + constexpr std::ptrdiff_t m_bBombDefused = 0xED4; // bool + constexpr std::ptrdiff_t m_hBombDefuser = 0xED8; // CHandle + constexpr std::ptrdiff_t m_hControlPanel = 0xEDC; // CHandle + constexpr std::ptrdiff_t m_hDefuserMultimeter = 0xEE0; // CHandle + constexpr std::ptrdiff_t m_flNextRadarFlashTime = 0xEE4; // GameTime_t + constexpr std::ptrdiff_t m_bRadarFlash = 0xEE8; // bool + constexpr std::ptrdiff_t m_pBombDefuser = 0xEEC; // CHandle + constexpr std::ptrdiff_t m_fLastDefuseTime = 0xEF0; // GameTime_t + constexpr std::ptrdiff_t m_pPredictionOwner = 0xEF8; // CBasePlayerController* +} + +namespace C_PlayerPing { // C_BaseEntity + constexpr std::ptrdiff_t m_hPlayer = 0x570; // CHandle + constexpr std::ptrdiff_t m_hPingedEntity = 0x574; // CHandle + constexpr std::ptrdiff_t m_iType = 0x578; // int32_t + constexpr std::ptrdiff_t m_bUrgent = 0x57C; // bool + constexpr std::ptrdiff_t m_szPlaceName = 0x57D; // char[18] +} + +namespace C_PlayerSprayDecal { // C_ModelPointEntity + constexpr std::ptrdiff_t m_nUniqueID = 0xCC0; // int32_t + constexpr std::ptrdiff_t m_unAccountID = 0xCC4; // uint32_t + constexpr std::ptrdiff_t m_unTraceID = 0xCC8; // uint32_t + constexpr std::ptrdiff_t m_rtGcTime = 0xCCC; // uint32_t + constexpr std::ptrdiff_t m_vecEndPos = 0xCD0; // Vector + constexpr std::ptrdiff_t m_vecStart = 0xCDC; // Vector + constexpr std::ptrdiff_t m_vecLeft = 0xCE8; // Vector + constexpr std::ptrdiff_t m_vecNormal = 0xCF4; // Vector + constexpr std::ptrdiff_t m_nPlayer = 0xD00; // int32_t + constexpr std::ptrdiff_t m_nEntity = 0xD04; // int32_t + constexpr std::ptrdiff_t m_nHitbox = 0xD08; // int32_t + constexpr std::ptrdiff_t m_flCreationTime = 0xD0C; // float + constexpr std::ptrdiff_t m_nTintID = 0xD10; // int32_t + constexpr std::ptrdiff_t m_nVersion = 0xD14; // uint8_t + constexpr std::ptrdiff_t m_ubSignature = 0xD15; // uint8_t[128] + constexpr std::ptrdiff_t m_SprayRenderHelper = 0xDA0; // CPlayerSprayDecalRenderHelper +} + +namespace C_PlayerVisibility { // C_BaseEntity + constexpr std::ptrdiff_t m_flVisibilityStrength = 0x540; // float + constexpr std::ptrdiff_t m_flFogDistanceMultiplier = 0x544; // float + constexpr std::ptrdiff_t m_flFogMaxDensityMultiplier = 0x548; // float + constexpr std::ptrdiff_t m_flFadeTime = 0x54C; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x550; // bool + constexpr std::ptrdiff_t m_bIsEnabled = 0x551; // bool +} + +namespace C_PointCamera { // C_BaseEntity + constexpr std::ptrdiff_t m_FOV = 0x540; // float + constexpr std::ptrdiff_t m_Resolution = 0x544; // float + constexpr std::ptrdiff_t m_bFogEnable = 0x548; // bool + constexpr std::ptrdiff_t m_FogColor = 0x549; // Color + constexpr std::ptrdiff_t m_flFogStart = 0x550; // float + constexpr std::ptrdiff_t m_flFogEnd = 0x554; // float + constexpr std::ptrdiff_t m_flFogMaxDensity = 0x558; // float + constexpr std::ptrdiff_t m_bActive = 0x55C; // bool + constexpr std::ptrdiff_t m_bUseScreenAspectRatio = 0x55D; // bool + constexpr std::ptrdiff_t m_flAspectRatio = 0x560; // float + constexpr std::ptrdiff_t m_bNoSky = 0x564; // bool + constexpr std::ptrdiff_t m_fBrightness = 0x568; // float + constexpr std::ptrdiff_t m_flZFar = 0x56C; // float + constexpr std::ptrdiff_t m_flZNear = 0x570; // float + constexpr std::ptrdiff_t m_bCanHLTVUse = 0x574; // bool + constexpr std::ptrdiff_t m_bDofEnabled = 0x575; // bool + constexpr std::ptrdiff_t m_flDofNearBlurry = 0x578; // float + constexpr std::ptrdiff_t m_flDofNearCrisp = 0x57C; // float + constexpr std::ptrdiff_t m_flDofFarCrisp = 0x580; // float + constexpr std::ptrdiff_t m_flDofFarBlurry = 0x584; // float + constexpr std::ptrdiff_t m_flDofTiltToGround = 0x588; // float + constexpr std::ptrdiff_t m_TargetFOV = 0x58C; // float + constexpr std::ptrdiff_t m_DegreesPerSecond = 0x590; // float + constexpr std::ptrdiff_t m_bIsOn = 0x594; // bool + constexpr std::ptrdiff_t m_pNext = 0x598; // C_PointCamera* +} + +namespace C_PointCameraVFOV { // C_PointCamera + constexpr std::ptrdiff_t m_flVerticalFOV = 0x5A0; // float +} + +namespace C_PointClientUIDialog { // C_BaseClientUIEntity + constexpr std::ptrdiff_t m_hActivator = 0xCF0; // CHandle + constexpr std::ptrdiff_t m_bStartEnabled = 0xCF4; // bool +} + +namespace C_PointClientUIHUD { // C_BaseClientUIEntity + constexpr std::ptrdiff_t m_bCheckCSSClasses = 0xCF8; // bool + constexpr std::ptrdiff_t m_bIgnoreInput = 0xE80; // bool + constexpr std::ptrdiff_t m_flWidth = 0xE84; // float + constexpr std::ptrdiff_t m_flHeight = 0xE88; // float + constexpr std::ptrdiff_t m_flDPI = 0xE8C; // float + constexpr std::ptrdiff_t m_flInteractDistance = 0xE90; // float + constexpr std::ptrdiff_t m_flDepthOffset = 0xE94; // float + constexpr std::ptrdiff_t m_unOwnerContext = 0xE98; // uint32_t + constexpr std::ptrdiff_t m_unHorizontalAlign = 0xE9C; // uint32_t + constexpr std::ptrdiff_t m_unVerticalAlign = 0xEA0; // uint32_t + constexpr std::ptrdiff_t m_unOrientation = 0xEA4; // uint32_t + constexpr std::ptrdiff_t m_bAllowInteractionFromAllSceneWorlds = 0xEA8; // bool + constexpr std::ptrdiff_t m_vecCSSClasses = 0xEB0; // C_NetworkUtlVectorBase +} + +namespace C_PointClientUIWorldPanel { // C_BaseClientUIEntity + constexpr std::ptrdiff_t m_bForceRecreateNextUpdate = 0xCF8; // bool + constexpr std::ptrdiff_t m_bMoveViewToPlayerNextThink = 0xCF9; // bool + constexpr std::ptrdiff_t m_bCheckCSSClasses = 0xCFA; // bool + constexpr std::ptrdiff_t m_anchorDeltaTransform = 0xD00; // CTransform + constexpr std::ptrdiff_t m_pOffScreenIndicator = 0xEA0; // CPointOffScreenIndicatorUi* + constexpr std::ptrdiff_t m_bIgnoreInput = 0xEC8; // bool + constexpr std::ptrdiff_t m_bLit = 0xEC9; // bool + constexpr std::ptrdiff_t m_bFollowPlayerAcrossTeleport = 0xECA; // bool + constexpr std::ptrdiff_t m_flWidth = 0xECC; // float + constexpr std::ptrdiff_t m_flHeight = 0xED0; // float + constexpr std::ptrdiff_t m_flDPI = 0xED4; // float + constexpr std::ptrdiff_t m_flInteractDistance = 0xED8; // float + constexpr std::ptrdiff_t m_flDepthOffset = 0xEDC; // float + constexpr std::ptrdiff_t m_unOwnerContext = 0xEE0; // uint32_t + constexpr std::ptrdiff_t m_unHorizontalAlign = 0xEE4; // uint32_t + constexpr std::ptrdiff_t m_unVerticalAlign = 0xEE8; // uint32_t + constexpr std::ptrdiff_t m_unOrientation = 0xEEC; // uint32_t + constexpr std::ptrdiff_t m_bAllowInteractionFromAllSceneWorlds = 0xEF0; // bool + constexpr std::ptrdiff_t m_vecCSSClasses = 0xEF8; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_bOpaque = 0xF10; // bool + constexpr std::ptrdiff_t m_bNoDepth = 0xF11; // bool + constexpr std::ptrdiff_t m_bRenderBackface = 0xF12; // bool + constexpr std::ptrdiff_t m_bUseOffScreenIndicator = 0xF13; // bool + constexpr std::ptrdiff_t m_bExcludeFromSaveGames = 0xF14; // bool + constexpr std::ptrdiff_t m_bGrabbable = 0xF15; // bool + constexpr std::ptrdiff_t m_bOnlyRenderToTexture = 0xF16; // bool + constexpr std::ptrdiff_t m_bDisableMipGen = 0xF17; // bool + constexpr std::ptrdiff_t m_nExplicitImageLayout = 0xF18; // int32_t +} + +namespace C_PointClientUIWorldTextPanel { // C_PointClientUIWorldPanel + constexpr std::ptrdiff_t m_messageText = 0xF20; // char[512] +} + +namespace C_PointCommentaryNode { // CBaseAnimGraph + constexpr std::ptrdiff_t m_bActive = 0xE88; // bool + constexpr std::ptrdiff_t m_bWasActive = 0xE89; // bool + constexpr std::ptrdiff_t m_flEndTime = 0xE8C; // GameTime_t + constexpr std::ptrdiff_t m_flStartTime = 0xE90; // GameTime_t + constexpr std::ptrdiff_t m_flStartTimeInCommentary = 0xE94; // float + constexpr std::ptrdiff_t m_iszCommentaryFile = 0xE98; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTitle = 0xEA0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSpeakers = 0xEA8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iNodeNumber = 0xEB0; // int32_t + constexpr std::ptrdiff_t m_iNodeNumberMax = 0xEB4; // int32_t + constexpr std::ptrdiff_t m_bListenedTo = 0xEB8; // bool + constexpr std::ptrdiff_t m_hViewPosition = 0xEC8; // CHandle + constexpr std::ptrdiff_t m_bRestartAfterRestore = 0xECC; // bool +} + +namespace C_PointEntity { // C_BaseEntity +} + +namespace C_PointValueRemapper { // C_BaseEntity + constexpr std::ptrdiff_t m_bDisabled = 0x540; // bool + constexpr std::ptrdiff_t m_bDisabledOld = 0x541; // bool + constexpr std::ptrdiff_t m_bUpdateOnClient = 0x542; // bool + constexpr std::ptrdiff_t m_nInputType = 0x544; // ValueRemapperInputType_t + constexpr std::ptrdiff_t m_hRemapLineStart = 0x548; // CHandle + constexpr std::ptrdiff_t m_hRemapLineEnd = 0x54C; // CHandle + constexpr std::ptrdiff_t m_flMaximumChangePerSecond = 0x550; // float + constexpr std::ptrdiff_t m_flDisengageDistance = 0x554; // float + constexpr std::ptrdiff_t m_flEngageDistance = 0x558; // float + constexpr std::ptrdiff_t m_bRequiresUseKey = 0x55C; // bool + constexpr std::ptrdiff_t m_nOutputType = 0x560; // ValueRemapperOutputType_t + constexpr std::ptrdiff_t m_hOutputEntities = 0x568; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_nHapticsType = 0x580; // ValueRemapperHapticsType_t + constexpr std::ptrdiff_t m_nMomentumType = 0x584; // ValueRemapperMomentumType_t + constexpr std::ptrdiff_t m_flMomentumModifier = 0x588; // float + constexpr std::ptrdiff_t m_flSnapValue = 0x58C; // float + constexpr std::ptrdiff_t m_flCurrentMomentum = 0x590; // float + constexpr std::ptrdiff_t m_nRatchetType = 0x594; // ValueRemapperRatchetType_t + constexpr std::ptrdiff_t m_flRatchetOffset = 0x598; // float + constexpr std::ptrdiff_t m_flInputOffset = 0x59C; // float + constexpr std::ptrdiff_t m_bEngaged = 0x5A0; // bool + constexpr std::ptrdiff_t m_bFirstUpdate = 0x5A1; // bool + constexpr std::ptrdiff_t m_flPreviousValue = 0x5A4; // float + constexpr std::ptrdiff_t m_flPreviousUpdateTickTime = 0x5A8; // GameTime_t + constexpr std::ptrdiff_t m_vecPreviousTestPoint = 0x5AC; // Vector +} + +namespace C_PointWorldText { // C_ModelPointEntity + constexpr std::ptrdiff_t m_bForceRecreateNextUpdate = 0xCC8; // bool + constexpr std::ptrdiff_t m_messageText = 0xCD8; // char[512] + constexpr std::ptrdiff_t m_FontName = 0xED8; // char[64] + constexpr std::ptrdiff_t m_bEnabled = 0xF18; // bool + constexpr std::ptrdiff_t m_bFullbright = 0xF19; // bool + constexpr std::ptrdiff_t m_flWorldUnitsPerPx = 0xF1C; // float + constexpr std::ptrdiff_t m_flFontSize = 0xF20; // float + constexpr std::ptrdiff_t m_flDepthOffset = 0xF24; // float + constexpr std::ptrdiff_t m_Color = 0xF28; // Color + constexpr std::ptrdiff_t m_nJustifyHorizontal = 0xF2C; // PointWorldTextJustifyHorizontal_t + constexpr std::ptrdiff_t m_nJustifyVertical = 0xF30; // PointWorldTextJustifyVertical_t + constexpr std::ptrdiff_t m_nReorientMode = 0xF34; // PointWorldTextReorientMode_t +} + +namespace C_PostProcessingVolume { // C_BaseTrigger + constexpr std::ptrdiff_t m_hPostSettings = 0xCD8; // CStrongHandle + constexpr std::ptrdiff_t m_flFadeDuration = 0xCE0; // float + constexpr std::ptrdiff_t m_flMinLogExposure = 0xCE4; // float + constexpr std::ptrdiff_t m_flMaxLogExposure = 0xCE8; // float + constexpr std::ptrdiff_t m_flMinExposure = 0xCEC; // float + constexpr std::ptrdiff_t m_flMaxExposure = 0xCF0; // float + constexpr std::ptrdiff_t m_flExposureCompensation = 0xCF4; // float + constexpr std::ptrdiff_t m_flExposureFadeSpeedUp = 0xCF8; // float + constexpr std::ptrdiff_t m_flExposureFadeSpeedDown = 0xCFC; // float + constexpr std::ptrdiff_t m_flTonemapEVSmoothingRange = 0xD00; // float + constexpr std::ptrdiff_t m_bMaster = 0xD04; // bool + constexpr std::ptrdiff_t m_bExposureControl = 0xD05; // bool + constexpr std::ptrdiff_t m_flRate = 0xD08; // float + constexpr std::ptrdiff_t m_flTonemapPercentTarget = 0xD0C; // float + constexpr std::ptrdiff_t m_flTonemapPercentBrightPixels = 0xD10; // float + constexpr std::ptrdiff_t m_flTonemapMinAvgLum = 0xD14; // float +} + +namespace C_Precipitation { // C_BaseTrigger + constexpr std::ptrdiff_t m_flDensity = 0xCC8; // float + constexpr std::ptrdiff_t m_flParticleInnerDist = 0xCD8; // float + constexpr std::ptrdiff_t m_pParticleDef = 0xCE0; // char* + constexpr std::ptrdiff_t m_tParticlePrecipTraceTimer = 0xD08; // TimedEvent[1] + constexpr std::ptrdiff_t m_bActiveParticlePrecipEmitter = 0xD10; // bool[1] + constexpr std::ptrdiff_t m_bParticlePrecipInitialized = 0xD11; // bool + constexpr std::ptrdiff_t m_bHasSimulatedSinceLastSceneObjectUpdate = 0xD12; // bool + constexpr std::ptrdiff_t m_nAvailableSheetSequencesMaxIndex = 0xD14; // int32_t +} + +namespace C_PrecipitationBlocker { // C_BaseModelEntity +} + +namespace C_PredictedViewModel { // C_BaseViewModel + constexpr std::ptrdiff_t m_LagAnglesHistory = 0xEE8; // QAngle + constexpr std::ptrdiff_t m_vPredictedOffset = 0xF00; // Vector +} + +namespace C_RagdollManager { // C_BaseEntity + constexpr std::ptrdiff_t m_iCurrentMaxRagdollCount = 0x540; // int8_t +} + +namespace C_RagdollProp { // CBaseAnimGraph + constexpr std::ptrdiff_t m_ragPos = 0xE88; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_ragAngles = 0xEA0; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_flBlendWeight = 0xEB8; // float + constexpr std::ptrdiff_t m_hRagdollSource = 0xEBC; // CHandle + constexpr std::ptrdiff_t m_iEyeAttachment = 0xEC0; // AttachmentHandle_t + constexpr std::ptrdiff_t m_flBlendWeightCurrent = 0xEC4; // float + constexpr std::ptrdiff_t m_parentPhysicsBoneIndices = 0xEC8; // CUtlVector + constexpr std::ptrdiff_t m_worldSpaceBoneComputationOrder = 0xEE0; // CUtlVector +} + +namespace C_RagdollPropAttached { // C_RagdollProp + constexpr std::ptrdiff_t m_boneIndexAttached = 0xEF8; // uint32_t + constexpr std::ptrdiff_t m_ragdollAttachedObjectIndex = 0xEFC; // uint32_t + constexpr std::ptrdiff_t m_attachmentPointBoneSpace = 0xF00; // Vector + constexpr std::ptrdiff_t m_attachmentPointRagdollSpace = 0xF0C; // Vector + constexpr std::ptrdiff_t m_vecOffset = 0xF18; // Vector + constexpr std::ptrdiff_t m_parentTime = 0xF24; // float + constexpr std::ptrdiff_t m_bHasParent = 0xF28; // bool +} + +namespace C_RectLight { // C_BarnLight + constexpr std::ptrdiff_t m_bShowLight = 0xF08; // bool +} + +namespace C_RetakeGameRules { + constexpr std::ptrdiff_t m_nMatchSeed = 0xF8; // int32_t + constexpr std::ptrdiff_t m_bBlockersPresent = 0xFC; // bool + constexpr std::ptrdiff_t m_bRoundInProgress = 0xFD; // bool + constexpr std::ptrdiff_t m_iFirstSecondHalfRound = 0x100; // int32_t + constexpr std::ptrdiff_t m_iBombSite = 0x104; // int32_t +} + +namespace C_RopeKeyframe { // C_BaseModelEntity + constexpr std::ptrdiff_t m_LinksTouchingSomething = 0xCC8; // CBitVec<10> + constexpr std::ptrdiff_t m_nLinksTouchingSomething = 0xCCC; // int32_t + constexpr std::ptrdiff_t m_bApplyWind = 0xCD0; // bool + constexpr std::ptrdiff_t m_fPrevLockedPoints = 0xCD4; // int32_t + constexpr std::ptrdiff_t m_iForcePointMoveCounter = 0xCD8; // int32_t + constexpr std::ptrdiff_t m_bPrevEndPointPos = 0xCDC; // bool[2] + constexpr std::ptrdiff_t m_vPrevEndPointPos = 0xCE0; // Vector[2] + constexpr std::ptrdiff_t m_flCurScroll = 0xCF8; // float + constexpr std::ptrdiff_t m_flScrollSpeed = 0xCFC; // float + constexpr std::ptrdiff_t m_RopeFlags = 0xD00; // uint16_t + constexpr std::ptrdiff_t m_iRopeMaterialModelIndex = 0xD08; // CStrongHandle + constexpr std::ptrdiff_t m_LightValues = 0xF80; // Vector[10] + constexpr std::ptrdiff_t m_nSegments = 0xFF8; // uint8_t + constexpr std::ptrdiff_t m_hStartPoint = 0xFFC; // CHandle + constexpr std::ptrdiff_t m_hEndPoint = 0x1000; // CHandle + constexpr std::ptrdiff_t m_iStartAttachment = 0x1004; // AttachmentHandle_t + constexpr std::ptrdiff_t m_iEndAttachment = 0x1005; // AttachmentHandle_t + constexpr std::ptrdiff_t m_Subdiv = 0x1006; // uint8_t + constexpr std::ptrdiff_t m_RopeLength = 0x1008; // int16_t + constexpr std::ptrdiff_t m_Slack = 0x100A; // int16_t + constexpr std::ptrdiff_t m_TextureScale = 0x100C; // float + constexpr std::ptrdiff_t m_fLockedPoints = 0x1010; // uint8_t + constexpr std::ptrdiff_t m_nChangeCount = 0x1011; // uint8_t + constexpr std::ptrdiff_t m_Width = 0x1014; // float + constexpr std::ptrdiff_t m_PhysicsDelegate = 0x1018; // C_RopeKeyframe::CPhysicsDelegate + constexpr std::ptrdiff_t m_hMaterial = 0x1028; // CStrongHandle + constexpr std::ptrdiff_t m_TextureHeight = 0x1030; // int32_t + constexpr std::ptrdiff_t m_vecImpulse = 0x1034; // Vector + constexpr std::ptrdiff_t m_vecPreviousImpulse = 0x1040; // Vector + constexpr std::ptrdiff_t m_flCurrentGustTimer = 0x104C; // float + constexpr std::ptrdiff_t m_flCurrentGustLifetime = 0x1050; // float + constexpr std::ptrdiff_t m_flTimeToNextGust = 0x1054; // float + constexpr std::ptrdiff_t m_vWindDir = 0x1058; // Vector + constexpr std::ptrdiff_t m_vColorMod = 0x1064; // Vector + constexpr std::ptrdiff_t m_vCachedEndPointAttachmentPos = 0x1070; // Vector[2] + constexpr std::ptrdiff_t m_vCachedEndPointAttachmentAngle = 0x1088; // QAngle[2] + constexpr std::ptrdiff_t m_bConstrainBetweenEndpoints = 0x10A0; // bool + constexpr std::ptrdiff_t m_bEndPointAttachmentPositionsDirty = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bEndPointAttachmentAnglesDirty = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNewDataThisFrame = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bPhysicsInitted = 0x0; // bitfield:1 +} + +namespace C_RopeKeyframe_CPhysicsDelegate { + constexpr std::ptrdiff_t m_pKeyframe = 0x8; // C_RopeKeyframe* +} + +namespace C_SceneEntity { // C_PointEntity + constexpr std::ptrdiff_t m_bIsPlayingBack = 0x548; // bool + constexpr std::ptrdiff_t m_bPaused = 0x549; // bool + constexpr std::ptrdiff_t m_bMultiplayer = 0x54A; // bool + constexpr std::ptrdiff_t m_bAutogenerated = 0x54B; // bool + constexpr std::ptrdiff_t m_flForceClientTime = 0x54C; // float + constexpr std::ptrdiff_t m_nSceneStringIndex = 0x550; // uint16_t + constexpr std::ptrdiff_t m_bClientOnly = 0x552; // bool + constexpr std::ptrdiff_t m_hOwner = 0x554; // CHandle + constexpr std::ptrdiff_t m_hActorList = 0x558; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_bWasPlaying = 0x570; // bool + constexpr std::ptrdiff_t m_QueuedEvents = 0x580; // CUtlVector + constexpr std::ptrdiff_t m_flCurrentTime = 0x598; // float +} + +namespace C_SceneEntity_QueuedEvents_t { + constexpr std::ptrdiff_t starttime = 0x0; // float +} + +namespace C_SensorGrenade { // C_BaseCSGrenade +} + +namespace C_SensorGrenadeProjectile { // C_BaseCSGrenadeProjectile +} + +namespace C_ShatterGlassShardPhysics { // C_PhysicsProp + constexpr std::ptrdiff_t m_ShardDesc = 0xFE0; // shard_model_desc_t +} + +namespace C_SingleplayRules { // C_GameRules +} + +namespace C_SkyCamera { // C_BaseEntity + constexpr std::ptrdiff_t m_skyboxData = 0x540; // sky3dparams_t + constexpr std::ptrdiff_t m_skyboxSlotToken = 0x5D0; // CUtlStringToken + constexpr std::ptrdiff_t m_bUseAngles = 0x5D4; // bool + constexpr std::ptrdiff_t m_pNext = 0x5D8; // C_SkyCamera* +} + +namespace C_SmokeGrenade { // C_BaseCSGrenade +} + +namespace C_SmokeGrenadeProjectile { // C_BaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_nSmokeEffectTickBegin = 0x10F8; // int32_t + constexpr std::ptrdiff_t m_bDidSmokeEffect = 0x10FC; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0x1100; // int32_t + constexpr std::ptrdiff_t m_vSmokeColor = 0x1104; // Vector + constexpr std::ptrdiff_t m_vSmokeDetonationPos = 0x1110; // Vector + constexpr std::ptrdiff_t m_VoxelFrameData = 0x1120; // CUtlVector + constexpr std::ptrdiff_t m_bSmokeVolumeDataReceived = 0x1138; // bool + constexpr std::ptrdiff_t m_bSmokeEffectSpawned = 0x1139; // bool +} + +namespace C_SoundAreaEntityBase { // C_BaseEntity + constexpr std::ptrdiff_t m_bDisabled = 0x540; // bool + constexpr std::ptrdiff_t m_bWasEnabled = 0x548; // bool + constexpr std::ptrdiff_t m_iszSoundAreaType = 0x550; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_vPos = 0x558; // Vector +} + +namespace C_SoundAreaEntityOrientedBox { // C_SoundAreaEntityBase + constexpr std::ptrdiff_t m_vMin = 0x568; // Vector + constexpr std::ptrdiff_t m_vMax = 0x574; // Vector +} + +namespace C_SoundAreaEntitySphere { // C_SoundAreaEntityBase + constexpr std::ptrdiff_t m_flRadius = 0x568; // float +} + +namespace C_SoundOpvarSetAABBEntity { // C_SoundOpvarSetPointEntity +} + +namespace C_SoundOpvarSetOBBEntity { // C_SoundOpvarSetAABBEntity +} + +namespace C_SoundOpvarSetOBBWindEntity { // C_SoundOpvarSetPointBase +} + +namespace C_SoundOpvarSetPathCornerEntity { // C_SoundOpvarSetPointEntity +} + +namespace C_SoundOpvarSetPointBase { // C_BaseEntity + constexpr std::ptrdiff_t m_iszStackName = 0x540; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOperatorName = 0x548; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOpvarName = 0x550; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iOpvarIndex = 0x558; // int32_t + constexpr std::ptrdiff_t m_bUseAutoCompare = 0x55C; // bool +} + +namespace C_SoundOpvarSetPointEntity { // C_SoundOpvarSetPointBase +} + +namespace C_SpotlightEnd { // C_BaseModelEntity + constexpr std::ptrdiff_t m_flLightScale = 0xCC0; // float + constexpr std::ptrdiff_t m_Radius = 0xCC4; // float +} + +namespace C_Sprite { // C_BaseModelEntity + constexpr std::ptrdiff_t m_hSpriteMaterial = 0xCD8; // CStrongHandle + constexpr std::ptrdiff_t m_hAttachedToEntity = 0xCE0; // CHandle + constexpr std::ptrdiff_t m_nAttachment = 0xCE4; // AttachmentHandle_t + constexpr std::ptrdiff_t m_flSpriteFramerate = 0xCE8; // float + constexpr std::ptrdiff_t m_flFrame = 0xCEC; // float + constexpr std::ptrdiff_t m_flDieTime = 0xCF0; // GameTime_t + constexpr std::ptrdiff_t m_nBrightness = 0xD00; // uint32_t + constexpr std::ptrdiff_t m_flBrightnessDuration = 0xD04; // float + constexpr std::ptrdiff_t m_flSpriteScale = 0xD08; // float + constexpr std::ptrdiff_t m_flScaleDuration = 0xD0C; // float + constexpr std::ptrdiff_t m_bWorldSpaceScale = 0xD10; // bool + constexpr std::ptrdiff_t m_flGlowProxySize = 0xD14; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0xD18; // float + constexpr std::ptrdiff_t m_flLastTime = 0xD1C; // GameTime_t + constexpr std::ptrdiff_t m_flMaxFrame = 0xD20; // float + constexpr std::ptrdiff_t m_flStartScale = 0xD24; // float + constexpr std::ptrdiff_t m_flDestScale = 0xD28; // float + constexpr std::ptrdiff_t m_flScaleTimeStart = 0xD2C; // GameTime_t + constexpr std::ptrdiff_t m_nStartBrightness = 0xD30; // int32_t + constexpr std::ptrdiff_t m_nDestBrightness = 0xD34; // int32_t + constexpr std::ptrdiff_t m_flBrightnessTimeStart = 0xD38; // GameTime_t + constexpr std::ptrdiff_t m_hOldSpriteMaterial = 0xD40; // CWeakHandle + constexpr std::ptrdiff_t m_nSpriteWidth = 0xDE8; // int32_t + constexpr std::ptrdiff_t m_nSpriteHeight = 0xDEC; // int32_t +} + +namespace C_SpriteOriented { // C_Sprite +} + +namespace C_Sun { // C_BaseModelEntity + constexpr std::ptrdiff_t m_fxSSSunFlareEffectIndex = 0xCC0; // ParticleIndex_t + constexpr std::ptrdiff_t m_fxSunFlareEffectIndex = 0xCC4; // ParticleIndex_t + constexpr std::ptrdiff_t m_fdistNormalize = 0xCC8; // float + constexpr std::ptrdiff_t m_vSunPos = 0xCCC; // Vector + constexpr std::ptrdiff_t m_vDirection = 0xCD8; // Vector + constexpr std::ptrdiff_t m_iszEffectName = 0xCE8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSSEffectName = 0xCF0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_clrOverlay = 0xCF8; // Color + constexpr std::ptrdiff_t m_bOn = 0xCFC; // bool + constexpr std::ptrdiff_t m_bmaxColor = 0xCFD; // bool + constexpr std::ptrdiff_t m_flSize = 0xD00; // float + constexpr std::ptrdiff_t m_flHazeScale = 0xD04; // float + constexpr std::ptrdiff_t m_flRotation = 0xD08; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0xD0C; // float + constexpr std::ptrdiff_t m_flAlphaHaze = 0xD10; // float + constexpr std::ptrdiff_t m_flAlphaScale = 0xD14; // float + constexpr std::ptrdiff_t m_flAlphaHdr = 0xD18; // float + constexpr std::ptrdiff_t m_flFarZScale = 0xD1C; // float +} + +namespace C_SunGlowOverlay { // CGlowOverlay + constexpr std::ptrdiff_t m_bModulateByDot = 0xD0; // bool +} + +namespace C_Team { // C_BaseEntity + constexpr std::ptrdiff_t m_aPlayerControllers = 0x540; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_aPlayers = 0x558; // C_NetworkUtlVectorBase> + constexpr std::ptrdiff_t m_iScore = 0x570; // int32_t + constexpr std::ptrdiff_t m_szTeamname = 0x574; // char[129] +} + +namespace C_TeamRoundTimer { // C_BaseEntity + constexpr std::ptrdiff_t m_bTimerPaused = 0x540; // bool + constexpr std::ptrdiff_t m_flTimeRemaining = 0x544; // float + constexpr std::ptrdiff_t m_flTimerEndTime = 0x548; // GameTime_t + constexpr std::ptrdiff_t m_bIsDisabled = 0x54C; // bool + constexpr std::ptrdiff_t m_bShowInHUD = 0x54D; // bool + constexpr std::ptrdiff_t m_nTimerLength = 0x550; // int32_t + constexpr std::ptrdiff_t m_nTimerInitialLength = 0x554; // int32_t + constexpr std::ptrdiff_t m_nTimerMaxLength = 0x558; // int32_t + constexpr std::ptrdiff_t m_bAutoCountdown = 0x55C; // bool + constexpr std::ptrdiff_t m_nSetupTimeLength = 0x560; // int32_t + constexpr std::ptrdiff_t m_nState = 0x564; // int32_t + constexpr std::ptrdiff_t m_bStartPaused = 0x568; // bool + constexpr std::ptrdiff_t m_bInCaptureWatchState = 0x569; // bool + constexpr std::ptrdiff_t m_flTotalTime = 0x56C; // float + constexpr std::ptrdiff_t m_bStopWatchTimer = 0x570; // bool + constexpr std::ptrdiff_t m_bFireFinished = 0x571; // bool + constexpr std::ptrdiff_t m_bFire5MinRemain = 0x572; // bool + constexpr std::ptrdiff_t m_bFire4MinRemain = 0x573; // bool + constexpr std::ptrdiff_t m_bFire3MinRemain = 0x574; // bool + constexpr std::ptrdiff_t m_bFire2MinRemain = 0x575; // bool + constexpr std::ptrdiff_t m_bFire1MinRemain = 0x576; // bool + constexpr std::ptrdiff_t m_bFire30SecRemain = 0x577; // bool + constexpr std::ptrdiff_t m_bFire10SecRemain = 0x578; // bool + constexpr std::ptrdiff_t m_bFire5SecRemain = 0x579; // bool + constexpr std::ptrdiff_t m_bFire4SecRemain = 0x57A; // bool + constexpr std::ptrdiff_t m_bFire3SecRemain = 0x57B; // bool + constexpr std::ptrdiff_t m_bFire2SecRemain = 0x57C; // bool + constexpr std::ptrdiff_t m_bFire1SecRemain = 0x57D; // bool + constexpr std::ptrdiff_t m_nOldTimerLength = 0x580; // int32_t + constexpr std::ptrdiff_t m_nOldTimerState = 0x584; // int32_t +} + +namespace C_TeamplayRules { // C_MultiplayRules +} + +namespace C_TextureBasedAnimatable { // C_BaseModelEntity + constexpr std::ptrdiff_t m_bLoop = 0xCC0; // bool + constexpr std::ptrdiff_t m_flFPS = 0xCC4; // float + constexpr std::ptrdiff_t m_hPositionKeys = 0xCC8; // CStrongHandle + constexpr std::ptrdiff_t m_hRotationKeys = 0xCD0; // CStrongHandle + constexpr std::ptrdiff_t m_vAnimationBoundsMin = 0xCD8; // Vector + constexpr std::ptrdiff_t m_vAnimationBoundsMax = 0xCE4; // Vector + constexpr std::ptrdiff_t m_flStartTime = 0xCF0; // float + constexpr std::ptrdiff_t m_flStartFrame = 0xCF4; // float +} + +namespace C_TintController { // C_BaseEntity +} + +namespace C_TonemapController2 { // C_BaseEntity + constexpr std::ptrdiff_t m_flAutoExposureMin = 0x540; // float + constexpr std::ptrdiff_t m_flAutoExposureMax = 0x544; // float + constexpr std::ptrdiff_t m_flTonemapPercentTarget = 0x548; // float + constexpr std::ptrdiff_t m_flTonemapPercentBrightPixels = 0x54C; // float + constexpr std::ptrdiff_t m_flTonemapMinAvgLum = 0x550; // float + constexpr std::ptrdiff_t m_flExposureAdaptationSpeedUp = 0x554; // float + constexpr std::ptrdiff_t m_flExposureAdaptationSpeedDown = 0x558; // float + constexpr std::ptrdiff_t m_flTonemapEVSmoothingRange = 0x55C; // float +} + +namespace C_TonemapController2Alias_env_tonemap_controller2 { // C_TonemapController2 +} + +namespace C_TriggerBuoyancy { // C_BaseTrigger + constexpr std::ptrdiff_t m_BuoyancyHelper = 0xCC8; // CBuoyancyHelper + constexpr std::ptrdiff_t m_flFluidDensity = 0xCE8; // float +} + +namespace C_TriggerLerpObject { // C_BaseTrigger +} + +namespace C_TriggerMultiple { // C_BaseTrigger +} + +namespace C_TriggerVolume { // C_BaseModelEntity +} + +namespace C_ViewmodelAttachmentModel { // CBaseAnimGraph +} + +namespace C_ViewmodelWeapon { // CBaseAnimGraph + constexpr std::ptrdiff_t m_worldModel = 0xE80; // char* +} + +namespace C_VoteController { // C_BaseEntity + constexpr std::ptrdiff_t m_iActiveIssueIndex = 0x550; // int32_t + constexpr std::ptrdiff_t m_iOnlyTeamToVote = 0x554; // int32_t + constexpr std::ptrdiff_t m_nVoteOptionCount = 0x558; // int32_t[5] + constexpr std::ptrdiff_t m_nPotentialVotes = 0x56C; // int32_t + constexpr std::ptrdiff_t m_bVotesDirty = 0x570; // bool + constexpr std::ptrdiff_t m_bTypeDirty = 0x571; // bool + constexpr std::ptrdiff_t m_bIsYesNoVote = 0x572; // bool +} + +namespace C_WaterBullet { // CBaseAnimGraph +} + +namespace C_WeaponAWP { // C_CSWeaponBaseGun +} + +namespace C_WeaponAug { // C_CSWeaponBaseGun +} + +namespace C_WeaponBaseItem { // C_CSWeaponBase + constexpr std::ptrdiff_t m_SequenceCompleteTimer = 0x1990; // CountdownTimer + constexpr std::ptrdiff_t m_bRedraw = 0x19A8; // bool +} + +namespace C_WeaponBizon { // C_CSWeaponBaseGun +} + +namespace C_WeaponCZ75a { // C_CSWeaponBaseGun +} + +namespace C_WeaponElite { // C_CSWeaponBaseGun +} + +namespace C_WeaponFamas { // C_CSWeaponBaseGun +} + +namespace C_WeaponFiveSeven { // C_CSWeaponBaseGun +} + +namespace C_WeaponG3SG1 { // C_CSWeaponBaseGun +} + +namespace C_WeaponGalilAR { // C_CSWeaponBaseGun +} + +namespace C_WeaponGlock { // C_CSWeaponBaseGun +} + +namespace C_WeaponHKP2000 { // C_CSWeaponBaseGun +} + +namespace C_WeaponM249 { // C_CSWeaponBaseGun +} + +namespace C_WeaponM4A1 { // C_CSWeaponBaseGun +} + +namespace C_WeaponM4A1Silencer { // C_CSWeaponBaseGun +} + +namespace C_WeaponMAC10 { // C_CSWeaponBaseGun +} + +namespace C_WeaponMP5SD { // C_CSWeaponBaseGun +} + +namespace C_WeaponMP7 { // C_CSWeaponBaseGun +} + +namespace C_WeaponMP9 { // C_CSWeaponBaseGun +} + +namespace C_WeaponMag7 { // C_CSWeaponBaseGun +} + +namespace C_WeaponNOVA { // C_CSWeaponBase +} + +namespace C_WeaponNegev { // C_CSWeaponBaseGun +} + +namespace C_WeaponP250 { // C_CSWeaponBaseGun +} + +namespace C_WeaponP90 { // C_CSWeaponBaseGun +} + +namespace C_WeaponRevolver { // C_CSWeaponBaseGun +} + +namespace C_WeaponSCAR20 { // C_CSWeaponBaseGun +} + +namespace C_WeaponSG556 { // C_CSWeaponBaseGun +} + +namespace C_WeaponSSG08 { // C_CSWeaponBaseGun +} + +namespace C_WeaponSawedoff { // C_CSWeaponBase +} + +namespace C_WeaponShield { // C_CSWeaponBaseGun + constexpr std::ptrdiff_t m_flDisplayHealth = 0x19B0; // float +} + +namespace C_WeaponTaser { // C_CSWeaponBaseGun + constexpr std::ptrdiff_t m_fFireTime = 0x19B0; // GameTime_t +} + +namespace C_WeaponTec9 { // C_CSWeaponBaseGun +} + +namespace C_WeaponUMP45 { // C_CSWeaponBaseGun +} + +namespace C_WeaponUSPSilencer { // C_CSWeaponBaseGun +} + +namespace C_WeaponXM1014 { // C_CSWeaponBase +} + +namespace C_World { // C_BaseModelEntity +} + +namespace C_WorldModelGloves { // CBaseAnimGraph +} + +namespace C_WorldModelNametag { // CBaseAnimGraph +} + +namespace C_WorldModelStattrak { // CBaseAnimGraph +} + +namespace C_fogplayerparams_t { + constexpr std::ptrdiff_t m_hCtrl = 0x8; // CHandle + constexpr std::ptrdiff_t m_flTransitionTime = 0xC; // float + constexpr std::ptrdiff_t m_OldColor = 0x10; // Color + constexpr std::ptrdiff_t m_flOldStart = 0x14; // float + constexpr std::ptrdiff_t m_flOldEnd = 0x18; // float + constexpr std::ptrdiff_t m_flOldMaxDensity = 0x1C; // float + constexpr std::ptrdiff_t m_flOldHDRColorScale = 0x20; // float + constexpr std::ptrdiff_t m_flOldFarZ = 0x24; // float + constexpr std::ptrdiff_t m_NewColor = 0x28; // Color + constexpr std::ptrdiff_t m_flNewStart = 0x2C; // float + constexpr std::ptrdiff_t m_flNewEnd = 0x30; // float + constexpr std::ptrdiff_t m_flNewMaxDensity = 0x34; // float + constexpr std::ptrdiff_t m_flNewHDRColorScale = 0x38; // float + constexpr std::ptrdiff_t m_flNewFarZ = 0x3C; // float +} + +namespace CompMatMutatorCondition_t { + constexpr std::ptrdiff_t m_nMutatorCondition = 0x0; // CompMatPropertyMutatorConditionType_t + constexpr std::ptrdiff_t m_strMutatorConditionContainerName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_strMutatorConditionContainerVarName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_strMutatorConditionContainerVarValue = 0x18; // CUtlString + constexpr std::ptrdiff_t m_bPassWhenTrue = 0x20; // bool +} + +namespace CompMatPropertyMutator_t { + constexpr std::ptrdiff_t m_bEnabled = 0x0; // bool + constexpr std::ptrdiff_t m_nMutatorCommandType = 0x4; // CompMatPropertyMutatorType_t + constexpr std::ptrdiff_t m_strInitWith_Container = 0x8; // CUtlString + constexpr std::ptrdiff_t m_strCopyProperty_InputContainerSrc = 0x10; // CUtlString + constexpr std::ptrdiff_t m_strCopyProperty_InputContainerProperty = 0x18; // CUtlString + constexpr std::ptrdiff_t m_strCopyProperty_TargetProperty = 0x20; // CUtlString + constexpr std::ptrdiff_t m_strRandomRollInputVars_SeedInputVar = 0x28; // CUtlString + constexpr std::ptrdiff_t m_vecRandomRollInputVars_InputVarsToRoll = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_strCopyMatchingKeys_InputContainerSrc = 0x48; // CUtlString + constexpr std::ptrdiff_t m_strCopyKeysWithSuffix_InputContainerSrc = 0x50; // CUtlString + constexpr std::ptrdiff_t m_strCopyKeysWithSuffix_FindSuffix = 0x58; // CUtlString + constexpr std::ptrdiff_t m_strCopyKeysWithSuffix_ReplaceSuffix = 0x60; // CUtlString + constexpr std::ptrdiff_t m_nSetValue_Value = 0x68; // CompositeMaterialInputLooseVariable_t + constexpr std::ptrdiff_t m_strGenerateTexture_TargetParam = 0x2D8; // CUtlString + constexpr std::ptrdiff_t m_strGenerateTexture_InitialContainer = 0x2E0; // CUtlString + constexpr std::ptrdiff_t m_nResolution = 0x2E8; // int32_t + constexpr std::ptrdiff_t m_bIsScratchTarget = 0x2EC; // bool + constexpr std::ptrdiff_t m_bSplatDebugInfo = 0x2ED; // bool + constexpr std::ptrdiff_t m_bCaptureInRenderDoc = 0x2EE; // bool + constexpr std::ptrdiff_t m_vecTexGenInstructions = 0x2F0; // CUtlVector + constexpr std::ptrdiff_t m_vecConditionalMutators = 0x308; // CUtlVector + constexpr std::ptrdiff_t m_strPopInputQueue_Container = 0x320; // CUtlString + constexpr std::ptrdiff_t m_strDrawText_InputContainerSrc = 0x328; // CUtlString + constexpr std::ptrdiff_t m_strDrawText_InputContainerProperty = 0x330; // CUtlString + constexpr std::ptrdiff_t m_vecDrawText_Position = 0x338; // Vector2D + constexpr std::ptrdiff_t m_colDrawText_Color = 0x340; // Color + constexpr std::ptrdiff_t m_strDrawText_Font = 0x348; // CUtlString + constexpr std::ptrdiff_t m_vecConditions = 0x350; // CUtlVector +} + +namespace CompositeMaterialAssemblyProcedure_t { + constexpr std::ptrdiff_t m_vecCompMatIncludes = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_vecMatchFilters = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_vecCompositeInputContainers = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_vecPropertyMutators = 0x48; // CUtlVector +} + +namespace CompositeMaterialEditorPoint_t { + constexpr std::ptrdiff_t m_ModelName = 0x0; // CResourceName + constexpr std::ptrdiff_t m_nSequenceIndex = 0xE0; // int32_t + constexpr std::ptrdiff_t m_flCycle = 0xE4; // float + constexpr std::ptrdiff_t m_KVModelStateChoices = 0xE8; // KeyValues3 + constexpr std::ptrdiff_t m_bEnableChildModel = 0xF8; // bool + constexpr std::ptrdiff_t m_ChildModelName = 0x100; // CResourceName + constexpr std::ptrdiff_t m_vecCompositeMaterialAssemblyProcedures = 0x1E0; // CUtlVector + constexpr std::ptrdiff_t m_vecCompositeMaterials = 0x1F8; // CUtlVector +} + +namespace CompositeMaterialInputContainer_t { + constexpr std::ptrdiff_t m_bEnabled = 0x0; // bool + constexpr std::ptrdiff_t m_nCompositeMaterialInputContainerSourceType = 0x4; // CompositeMaterialInputContainerSourceType_t + constexpr std::ptrdiff_t m_strSpecificContainerMaterial = 0x8; // CResourceName + constexpr std::ptrdiff_t m_strAttrName = 0xE8; // CUtlString + constexpr std::ptrdiff_t m_strAlias = 0xF0; // CUtlString + constexpr std::ptrdiff_t m_vecLooseVariables = 0xF8; // CUtlVector + constexpr std::ptrdiff_t m_strAttrNameForVar = 0x110; // CUtlString + constexpr std::ptrdiff_t m_bExposeExternally = 0x118; // bool +} + +namespace CompositeMaterialInputLooseVariable_t { + constexpr std::ptrdiff_t m_strName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_bExposeExternally = 0x8; // bool + constexpr std::ptrdiff_t m_strExposedFriendlyName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_strExposedFriendlyGroupName = 0x18; // CUtlString + constexpr std::ptrdiff_t m_bExposedVariableIsFixedRange = 0x20; // bool + constexpr std::ptrdiff_t m_strExposedVisibleWhenTrue = 0x28; // CUtlString + constexpr std::ptrdiff_t m_strExposedHiddenWhenTrue = 0x30; // CUtlString + constexpr std::ptrdiff_t m_nVariableType = 0x38; // CompositeMaterialInputLooseVariableType_t + constexpr std::ptrdiff_t m_bValueBoolean = 0x3C; // bool + constexpr std::ptrdiff_t m_nValueIntX = 0x40; // int32_t + constexpr std::ptrdiff_t m_nValueIntY = 0x44; // int32_t + constexpr std::ptrdiff_t m_nValueIntZ = 0x48; // int32_t + constexpr std::ptrdiff_t m_nValueIntW = 0x4C; // int32_t + constexpr std::ptrdiff_t m_bHasFloatBounds = 0x50; // bool + constexpr std::ptrdiff_t m_flValueFloatX = 0x54; // float + constexpr std::ptrdiff_t m_flValueFloatX_Min = 0x58; // float + constexpr std::ptrdiff_t m_flValueFloatX_Max = 0x5C; // float + constexpr std::ptrdiff_t m_flValueFloatY = 0x60; // float + constexpr std::ptrdiff_t m_flValueFloatY_Min = 0x64; // float + constexpr std::ptrdiff_t m_flValueFloatY_Max = 0x68; // float + constexpr std::ptrdiff_t m_flValueFloatZ = 0x6C; // float + constexpr std::ptrdiff_t m_flValueFloatZ_Min = 0x70; // float + constexpr std::ptrdiff_t m_flValueFloatZ_Max = 0x74; // float + constexpr std::ptrdiff_t m_flValueFloatW = 0x78; // float + constexpr std::ptrdiff_t m_flValueFloatW_Min = 0x7C; // float + constexpr std::ptrdiff_t m_flValueFloatW_Max = 0x80; // float + constexpr std::ptrdiff_t m_cValueColor4 = 0x84; // Color + constexpr std::ptrdiff_t m_nValueSystemVar = 0x88; // CompositeMaterialVarSystemVar_t + constexpr std::ptrdiff_t m_strResourceMaterial = 0x90; // CResourceName + constexpr std::ptrdiff_t m_strTextureContentAssetPath = 0x170; // CUtlString + constexpr std::ptrdiff_t m_strTextureRuntimeResourcePath = 0x178; // CResourceName + constexpr std::ptrdiff_t m_strTextureCompilationVtexTemplate = 0x258; // CUtlString + constexpr std::ptrdiff_t m_nTextureType = 0x260; // CompositeMaterialInputTextureType_t + constexpr std::ptrdiff_t m_strString = 0x268; // CUtlString +} + +namespace CompositeMaterialMatchFilter_t { + constexpr std::ptrdiff_t m_nCompositeMaterialMatchFilterType = 0x0; // CompositeMaterialMatchFilterType_t + constexpr std::ptrdiff_t m_strMatchFilter = 0x8; // CUtlString + constexpr std::ptrdiff_t m_strMatchValue = 0x10; // CUtlString + constexpr std::ptrdiff_t m_bPassWhenTrue = 0x18; // bool +} + +namespace CompositeMaterial_t { + constexpr std::ptrdiff_t m_TargetKVs = 0x8; // KeyValues3 + constexpr std::ptrdiff_t m_PreGenerationKVs = 0x18; // KeyValues3 + constexpr std::ptrdiff_t m_FinalKVs = 0x28; // KeyValues3 + constexpr std::ptrdiff_t m_vecGeneratedTextures = 0x40; // CUtlVector +} + +namespace CountdownTimer { + constexpr std::ptrdiff_t m_duration = 0x8; // float + constexpr std::ptrdiff_t m_timestamp = 0xC; // GameTime_t + constexpr std::ptrdiff_t m_timescale = 0x10; // float + constexpr std::ptrdiff_t m_nWorldGroupId = 0x14; // WorldGroupId_t +} + +namespace EngineCountdownTimer { + constexpr std::ptrdiff_t m_duration = 0x8; // float + constexpr std::ptrdiff_t m_timestamp = 0xC; // float + constexpr std::ptrdiff_t m_timescale = 0x10; // float +} + +namespace EntityRenderAttribute_t { + constexpr std::ptrdiff_t m_ID = 0x30; // CUtlStringToken + constexpr std::ptrdiff_t m_Values = 0x34; // Vector4D +} + +namespace EntitySpottedState_t { + constexpr std::ptrdiff_t m_bSpotted = 0x8; // bool + constexpr std::ptrdiff_t m_bSpottedByMask = 0xC; // uint32_t[2] +} + +namespace GeneratedTextureHandle_t { + constexpr std::ptrdiff_t m_strBitmapName = 0x0; // CUtlString +} + +namespace IClientAlphaProperty { +} + +namespace IntervalTimer { + constexpr std::ptrdiff_t m_timestamp = 0x8; // GameTime_t + constexpr std::ptrdiff_t m_nWorldGroupId = 0xC; // WorldGroupId_t +} + +namespace PhysicsRagdollPose_t { + constexpr std::ptrdiff_t __m_pChainEntity = 0x8; // CNetworkVarChainer + constexpr std::ptrdiff_t m_Transforms = 0x30; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_hOwner = 0x48; // CHandle + constexpr std::ptrdiff_t m_bDirty = 0x68; // bool +} + +namespace SellbackPurchaseEntry_t { + constexpr std::ptrdiff_t m_unDefIdx = 0x30; // uint16_t + constexpr std::ptrdiff_t m_nCost = 0x34; // int32_t + constexpr std::ptrdiff_t m_nPrevArmor = 0x38; // int32_t + constexpr std::ptrdiff_t m_bPrevHelmet = 0x3C; // bool + constexpr std::ptrdiff_t m_hItem = 0x40; // CEntityHandle +} + +namespace ServerAuthoritativeWeaponSlot_t { + constexpr std::ptrdiff_t unClass = 0x28; // uint16_t + constexpr std::ptrdiff_t unSlot = 0x2A; // uint16_t + constexpr std::ptrdiff_t unItemDefIdx = 0x2C; // uint16_t +} + +namespace TimedEvent { + constexpr std::ptrdiff_t m_TimeBetweenEvents = 0x0; // float + constexpr std::ptrdiff_t m_fNextEvent = 0x4; // float +} + +namespace VPhysicsCollisionAttribute_t { + constexpr std::ptrdiff_t m_nInteractsAs = 0x8; // uint64_t + constexpr std::ptrdiff_t m_nInteractsWith = 0x10; // uint64_t + constexpr std::ptrdiff_t m_nInteractsExclude = 0x18; // uint64_t + constexpr std::ptrdiff_t m_nEntityId = 0x20; // uint32_t + constexpr std::ptrdiff_t m_nOwnerId = 0x24; // uint32_t + constexpr std::ptrdiff_t m_nHierarchyId = 0x28; // uint16_t + constexpr std::ptrdiff_t m_nCollisionGroup = 0x2A; // uint8_t + constexpr std::ptrdiff_t m_nCollisionFunctionMask = 0x2B; // uint8_t +} + +namespace ViewAngleServerChange_t { + constexpr std::ptrdiff_t nType = 0x30; // FixAngleSet_t + constexpr std::ptrdiff_t qAngle = 0x34; // QAngle + constexpr std::ptrdiff_t nIndex = 0x40; // uint32_t +} + +namespace WeaponPurchaseCount_t { + constexpr std::ptrdiff_t m_nItemDefIndex = 0x30; // uint16_t + constexpr std::ptrdiff_t m_nCount = 0x32; // uint16_t +} + +namespace WeaponPurchaseTracker_t { + constexpr std::ptrdiff_t m_weaponPurchases = 0x8; // C_UtlVectorEmbeddedNetworkVar +} + +namespace audioparams_t { + constexpr std::ptrdiff_t localSound = 0x8; // Vector[8] + constexpr std::ptrdiff_t soundscapeIndex = 0x68; // int32_t + constexpr std::ptrdiff_t localBits = 0x6C; // uint8_t + constexpr std::ptrdiff_t soundscapeEntityListIndex = 0x70; // int32_t + constexpr std::ptrdiff_t soundEventHash = 0x74; // uint32_t +} + +namespace fogparams_t { + constexpr std::ptrdiff_t dirPrimary = 0x8; // Vector + constexpr std::ptrdiff_t colorPrimary = 0x14; // Color + constexpr std::ptrdiff_t colorSecondary = 0x18; // Color + constexpr std::ptrdiff_t colorPrimaryLerpTo = 0x1C; // Color + constexpr std::ptrdiff_t colorSecondaryLerpTo = 0x20; // Color + constexpr std::ptrdiff_t start = 0x24; // float + constexpr std::ptrdiff_t end = 0x28; // float + constexpr std::ptrdiff_t farz = 0x2C; // float + constexpr std::ptrdiff_t maxdensity = 0x30; // float + constexpr std::ptrdiff_t exponent = 0x34; // float + constexpr std::ptrdiff_t HDRColorScale = 0x38; // float + constexpr std::ptrdiff_t skyboxFogFactor = 0x3C; // float + constexpr std::ptrdiff_t skyboxFogFactorLerpTo = 0x40; // float + constexpr std::ptrdiff_t startLerpTo = 0x44; // float + constexpr std::ptrdiff_t endLerpTo = 0x48; // float + constexpr std::ptrdiff_t maxdensityLerpTo = 0x4C; // float + constexpr std::ptrdiff_t lerptime = 0x50; // GameTime_t + constexpr std::ptrdiff_t duration = 0x54; // float + constexpr std::ptrdiff_t blendtobackground = 0x58; // float + constexpr std::ptrdiff_t scattering = 0x5C; // float + constexpr std::ptrdiff_t locallightscale = 0x60; // float + constexpr std::ptrdiff_t enable = 0x64; // bool + constexpr std::ptrdiff_t blend = 0x65; // bool + constexpr std::ptrdiff_t m_bNoReflectionFog = 0x66; // bool + constexpr std::ptrdiff_t m_bPadding = 0x67; // bool +} + +namespace shard_model_desc_t { + constexpr std::ptrdiff_t m_nModelID = 0x8; // int32_t + constexpr std::ptrdiff_t m_hMaterial = 0x10; // CStrongHandle + constexpr std::ptrdiff_t m_solid = 0x18; // ShardSolid_t + constexpr std::ptrdiff_t m_ShatterPanelMode = 0x19; // ShatterPanelMode + constexpr std::ptrdiff_t m_vecPanelSize = 0x1C; // Vector2D + constexpr std::ptrdiff_t m_vecStressPositionA = 0x24; // Vector2D + constexpr std::ptrdiff_t m_vecStressPositionB = 0x2C; // Vector2D + constexpr std::ptrdiff_t m_vecPanelVertices = 0x38; // C_NetworkUtlVectorBase + constexpr std::ptrdiff_t m_flGlassHalfThickness = 0x50; // float + constexpr std::ptrdiff_t m_bHasParent = 0x54; // bool + constexpr std::ptrdiff_t m_bParentFrozen = 0x55; // bool + constexpr std::ptrdiff_t m_SurfacePropStringToken = 0x58; // CUtlStringToken +} + +namespace sky3dparams_t { + constexpr std::ptrdiff_t scale = 0x8; // int16_t + constexpr std::ptrdiff_t origin = 0xC; // Vector + constexpr std::ptrdiff_t bClip3DSkyBoxNearToWorldFar = 0x18; // bool + constexpr std::ptrdiff_t flClip3DSkyBoxNearToWorldFarOffset = 0x1C; // float + constexpr std::ptrdiff_t fog = 0x20; // fogparams_t + constexpr std::ptrdiff_t m_nWorldGroupID = 0x88; // WorldGroupId_t +} \ No newline at end of file diff --git a/HPCS2/offset/engine2.dll.hpp b/HPCS2/offset/engine2.dll.hpp new file mode 100644 index 0000000..ac1982f --- /dev/null +++ b/HPCS2/offset/engine2.dll.hpp @@ -0,0 +1,244 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace CEmptyEntityInstance { +} + +namespace CEntityComponent { +} + +namespace CEntityComponentHelper { + constexpr std::ptrdiff_t m_flags = 0x8; // uint32_t + constexpr std::ptrdiff_t m_pInfo = 0x10; // EntComponentInfo_t* + constexpr std::ptrdiff_t m_nPriority = 0x18; // int32_t + constexpr std::ptrdiff_t m_pNext = 0x20; // CEntityComponentHelper* +} + +namespace CEntityIOOutput { + constexpr std::ptrdiff_t m_Value = 0x18; // CVariantBase +} + +namespace CEntityIdentity { + constexpr std::ptrdiff_t m_nameStringableIndex = 0x14; // int32_t + constexpr std::ptrdiff_t m_name = 0x18; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_designerName = 0x20; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flags = 0x30; // uint32_t + constexpr std::ptrdiff_t m_worldGroupId = 0x38; // WorldGroupId_t + constexpr std::ptrdiff_t m_fDataObjectTypes = 0x3C; // uint32_t + constexpr std::ptrdiff_t m_PathIndex = 0x40; // ChangeAccessorFieldPathIndex_t + constexpr std::ptrdiff_t m_pPrev = 0x58; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNext = 0x60; // CEntityIdentity* + constexpr std::ptrdiff_t m_pPrevByClass = 0x68; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNextByClass = 0x70; // CEntityIdentity* +} + +namespace CEntityInstance { + constexpr std::ptrdiff_t m_iszPrivateVScripts = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pEntity = 0x10; // CEntityIdentity* + constexpr std::ptrdiff_t m_CScriptComponent = 0x28; // CScriptComponent* +} + +namespace CNetworkVarChainer { + constexpr std::ptrdiff_t m_PathIndex = 0x20; // ChangeAccessorFieldPathIndex_t +} + +namespace CScriptComponent { // CEntityComponent + constexpr std::ptrdiff_t m_scriptClassName = 0x30; // CUtlSymbolLarge +} + +namespace CVariantDefaultAllocator { +} + +namespace EngineLoopState_t { + constexpr std::ptrdiff_t m_nPlatWindowWidth = 0x18; // int32_t + constexpr std::ptrdiff_t m_nPlatWindowHeight = 0x1C; // int32_t + constexpr std::ptrdiff_t m_nRenderWidth = 0x20; // int32_t + constexpr std::ptrdiff_t m_nRenderHeight = 0x24; // int32_t +} + +namespace EntComponentInfo_t { + constexpr std::ptrdiff_t m_pName = 0x0; // char* + constexpr std::ptrdiff_t m_pCPPClassname = 0x8; // char* + constexpr std::ptrdiff_t m_pNetworkDataReferencedDescription = 0x10; // char* + constexpr std::ptrdiff_t m_pNetworkDataReferencedPtrPropDescription = 0x18; // char* + constexpr std::ptrdiff_t m_nRuntimeIndex = 0x20; // int32_t + constexpr std::ptrdiff_t m_nFlags = 0x24; // uint32_t + constexpr std::ptrdiff_t m_pBaseClassComponentHelper = 0x60; // CEntityComponentHelper* +} + +namespace EntInput_t { +} + +namespace EntOutput_t { +} + +namespace EventAdvanceTick_t { // EventSimulate_t + constexpr std::ptrdiff_t m_nCurrentTick = 0x30; // int32_t + constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34; // int32_t + constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38; // int32_t + constexpr std::ptrdiff_t m_nTotalTicks = 0x3C; // int32_t +} + +namespace EventAppShutdown_t { + constexpr std::ptrdiff_t m_nDummy0 = 0x0; // int32_t +} + +namespace EventClientAdvanceTick_t { // EventAdvanceTick_t +} + +namespace EventClientFrameSimulate_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRealTime = 0x28; // float + constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float +} + +namespace EventClientOutput_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRenderTime = 0x28; // float + constexpr std::ptrdiff_t m_flRealTime = 0x2C; // float + constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x30; // float + constexpr std::ptrdiff_t m_bRenderOnly = 0x34; // bool +} + +namespace EventClientPauseSimulate_t { // EventSimulate_t +} + +namespace EventClientPollInput_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRealTime = 0x28; // float +} + +namespace EventClientPollNetworking_t { + constexpr std::ptrdiff_t m_nTickCount = 0x0; // int32_t +} + +namespace EventClientPostAdvanceTick_t { // EventPostAdvanceTick_t +} + +namespace EventClientPostOutput_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRenderTime = 0x28; // double + constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30; // float + constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x34; // float + constexpr std::ptrdiff_t m_bRenderOnly = 0x38; // bool +} + +namespace EventClientPostSimulate_t { // EventSimulate_t +} + +namespace EventClientPreOutput_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRenderTime = 0x28; // double + constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30; // double + constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x38; // double + constexpr std::ptrdiff_t m_flRealTime = 0x40; // float + constexpr std::ptrdiff_t m_bRenderOnly = 0x44; // bool +} + +namespace EventClientPreSimulate_t { // EventSimulate_t +} + +namespace EventClientPredictionPostNetupdate_t { +} + +namespace EventClientProcessGameInput_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRealTime = 0x28; // float + constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float +} + +namespace EventClientProcessInput_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRealTime = 0x28; // float +} + +namespace EventClientProcessNetworking_t { +} + +namespace EventClientSceneSystemThreadStateChange_t { + constexpr std::ptrdiff_t m_bThreadsActive = 0x0; // bool +} + +namespace EventClientSendInput_t { + constexpr std::ptrdiff_t m_bFinalClientCommandTick = 0x0; // bool + constexpr std::ptrdiff_t m_nAdditionalClientCommandsToCreate = 0x4; // int32_t +} + +namespace EventClientSimulate_t { // EventSimulate_t +} + +namespace EventFrameBoundary_t { + constexpr std::ptrdiff_t m_flFrameTime = 0x0; // float +} + +namespace EventModInitialized_t { +} + +namespace EventPostAdvanceTick_t { // EventSimulate_t + constexpr std::ptrdiff_t m_nCurrentTick = 0x30; // int32_t + constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34; // int32_t + constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38; // int32_t + constexpr std::ptrdiff_t m_nTotalTicks = 0x3C; // int32_t +} + +namespace EventPostDataUpdate_t { + constexpr std::ptrdiff_t m_nCount = 0x0; // int32_t +} + +namespace EventPreDataUpdate_t { + constexpr std::ptrdiff_t m_nCount = 0x0; // int32_t +} + +namespace EventProfileStorageAvailable_t { + constexpr std::ptrdiff_t m_nSplitScreenSlot = 0x0; // CSplitScreenSlot +} + +namespace EventServerAdvanceTick_t { // EventAdvanceTick_t +} + +namespace EventServerPollNetworking_t { // EventSimulate_t +} + +namespace EventServerPostAdvanceTick_t { // EventPostAdvanceTick_t +} + +namespace EventServerPostSimulate_t { // EventSimulate_t +} + +namespace EventServerProcessNetworking_t { // EventSimulate_t +} + +namespace EventServerSimulate_t { // EventSimulate_t +} + +namespace EventSetTime_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_nClientOutputFrames = 0x28; // int32_t + constexpr std::ptrdiff_t m_flRealTime = 0x30; // double + constexpr std::ptrdiff_t m_flRenderTime = 0x38; // double + constexpr std::ptrdiff_t m_flRenderFrameTime = 0x40; // double + constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x48; // double + constexpr std::ptrdiff_t m_flRenderFrameTimeUnscaled = 0x50; // double + constexpr std::ptrdiff_t m_flTickRemainder = 0x58; // double +} + +namespace EventSimpleLoopFrameUpdate_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_flRealTime = 0x28; // float + constexpr std::ptrdiff_t m_flFrameTime = 0x2C; // float +} + +namespace EventSimulate_t { + constexpr std::ptrdiff_t m_LoopState = 0x0; // EngineLoopState_t + constexpr std::ptrdiff_t m_bFirstTick = 0x28; // bool + constexpr std::ptrdiff_t m_bLastTick = 0x29; // bool +} + +namespace EventSplitScreenStateChanged_t { +} \ No newline at end of file diff --git a/HPCS2/offset/host.dll.hpp b/HPCS2/offset/host.dll.hpp new file mode 100644 index 0000000..1d73aca --- /dev/null +++ b/HPCS2/offset/host.dll.hpp @@ -0,0 +1,16 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:22 +0000 + */ + +#pragma once + +#include + +namespace CAnimScriptBase { + constexpr std::ptrdiff_t m_bIsValid = 0x8; // bool +} + +namespace EmptyTestScript { // CAnimScriptBase + constexpr std::ptrdiff_t m_hTest = 0x10; // CAnimScriptParam +} \ No newline at end of file diff --git a/HPCS2/offset/interfaces.hpp b/HPCS2/offset/interfaces.hpp new file mode 100644 index 0000000..aaff864 --- /dev/null +++ b/HPCS2/offset/interfaces.hpp @@ -0,0 +1,244 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:23 +0000 + */ + +#pragma once + +#include + +namespace animationsystem_dll { // animationsystem.dll + constexpr std::ptrdiff_t AnimationSystemUtils_001 = 0x64670; + constexpr std::ptrdiff_t AnimationSystem_001 = 0x5F1D0; +} + +namespace client_dll { // client.dll + constexpr std::ptrdiff_t LegacyGameUI001 = 0x899820; + constexpr std::ptrdiff_t Source2ClientUI001 = 0x888530; + constexpr std::ptrdiff_t Source2ClientPrediction001 = 0x7A1860; + constexpr std::ptrdiff_t ClientToolsInfo_001 = 0x72DAA0; + constexpr std::ptrdiff_t Source2Client002 = 0x72DAC0; + constexpr std::ptrdiff_t GameClientExports001 = 0x72DAB0; + constexpr std::ptrdiff_t EmptyWorldService001_Client = 0x48DEF0; + constexpr std::ptrdiff_t Source2ClientConfig001 = 0x474F00; +} + +namespace engine2_dll { // engine2.dll + constexpr std::ptrdiff_t SimpleEngineLoopService_001 = 0x1E3370; + constexpr std::ptrdiff_t ClientServerEngineLoopService_001 = 0x1D9040; + constexpr std::ptrdiff_t KeyValueCache001 = 0x1D5680; + constexpr std::ptrdiff_t HostStateMgr001 = 0x1D2E80; + constexpr std::ptrdiff_t GameEventSystemServerV001 = 0x1CE520; + constexpr std::ptrdiff_t GameEventSystemClientV001 = 0x1CE510; + constexpr std::ptrdiff_t EngineServiceMgr001 = 0x1CA200; + constexpr std::ptrdiff_t VProfService_001 = 0x1B7C90; + constexpr std::ptrdiff_t ToolService_001 = 0x1B69E0; + constexpr std::ptrdiff_t StatsService_001 = 0x1B1C60; + constexpr std::ptrdiff_t SplitScreenService_001 = 0x1AEED0; + constexpr std::ptrdiff_t SoundService_001 = 0x1A9A10; + constexpr std::ptrdiff_t ScreenshotService001 = 0x1A58E0; + constexpr std::ptrdiff_t RenderService_001 = 0x1A2C40; + constexpr std::ptrdiff_t NetworkService_001 = 0x1A2750; + constexpr std::ptrdiff_t NetworkServerService_001 = 0x19D7F0; + constexpr std::ptrdiff_t NetworkP2PService_001 = 0x199200; + constexpr std::ptrdiff_t NetworkClientService_001 = 0x192E30; + constexpr std::ptrdiff_t MapListService_001 = 0x18BE00; + constexpr std::ptrdiff_t InputService_001 = 0x179C80; + constexpr std::ptrdiff_t GameUIService_001 = 0x1744A0; + constexpr std::ptrdiff_t GameResourceServiceServerV001 = 0x172200; + constexpr std::ptrdiff_t GameResourceServiceClientV001 = 0x1721F0; + constexpr std::ptrdiff_t BugService001 = 0x16B220; + constexpr std::ptrdiff_t BenchmarkService001 = 0x1699F0; + constexpr std::ptrdiff_t VENGINE_GAMEUIFUNCS_VERSION005 = 0x116F70; + constexpr std::ptrdiff_t EngineGameUI001 = 0x116300; + constexpr std::ptrdiff_t INETSUPPORT_001 = 0xE6510; + constexpr std::ptrdiff_t Source2EngineToServerStringTable001 = 0xA14C0; + constexpr std::ptrdiff_t Source2EngineToServer001 = 0x8B300; + constexpr std::ptrdiff_t Source2EngineToClientStringTable001 = 0x84020; + constexpr std::ptrdiff_t Source2EngineToClient001 = 0x5AA60; +} + +namespace filesystem_stdio_dll { // filesystem_stdio.dll + constexpr std::ptrdiff_t VAsyncFileSystem2_001 = 0x66D30; + constexpr std::ptrdiff_t VFileSystem017 = 0x66D20; +} + +namespace host_dll { // host.dll + constexpr std::ptrdiff_t Source2Host001 = 0x18E10; + constexpr std::ptrdiff_t SinglePlayerSharedMemory001 = 0x18A90; + constexpr std::ptrdiff_t SaveRestoreDataVersion001 = 0x18A80; + constexpr std::ptrdiff_t PredictionDiffManager001 = 0x16E20; + constexpr std::ptrdiff_t HostUtils001 = 0x12550; + constexpr std::ptrdiff_t GameSystem2HostHook = 0x11DA0; + constexpr std::ptrdiff_t GameModelInfo001 = 0x11CC0; + constexpr std::ptrdiff_t DebugDrawQueueManager001 = 0x11710; +} + +namespace imemanager_dll { // imemanager.dll + constexpr std::ptrdiff_t IMEManager001 = 0xC470; +} + +namespace inputsystem_dll { // inputsystem.dll + constexpr std::ptrdiff_t InputSystemVersion001 = 0x28D0; + constexpr std::ptrdiff_t InputStackSystemVersion001 = 0x16F0; +} + +namespace localize_dll { // localize.dll + constexpr std::ptrdiff_t Localize_001 = 0x3830; +} + +namespace matchmaking_dll { // matchmaking.dll + constexpr std::ptrdiff_t GameTypes001 = 0x50270; + constexpr std::ptrdiff_t MATCHFRAMEWORK_001 = 0x101030; +} + +namespace materialsystem2_dll { // materialsystem2.dll + constexpr std::ptrdiff_t MaterialUtils_001 = 0x4DB90; + constexpr std::ptrdiff_t TextLayout_001 = 0x4A2E0; + constexpr std::ptrdiff_t PostProcessingSystem_001 = 0x42A60; + constexpr std::ptrdiff_t FontManager_001 = 0x37900; + constexpr std::ptrdiff_t VMaterialSystem2_001 = 0x25EC0; +} + +namespace meshsystem_dll { // meshsystem.dll + constexpr std::ptrdiff_t MeshSystem001 = 0x7270; +} + +namespace navsystem_dll { // navsystem.dll + constexpr std::ptrdiff_t NavSystem001 = 0x76F0; +} + +namespace networksystem_dll { // networksystem.dll + constexpr std::ptrdiff_t SerializedEntitiesVersion001 = 0xD1AD0; + constexpr std::ptrdiff_t NetworkSystemVersion001 = 0xBBF90; + constexpr std::ptrdiff_t NetworkMessagesVersion001 = 0x9C030; + constexpr std::ptrdiff_t FlattenedSerializersVersion001 = 0x7B8A0; +} + +namespace panorama_dll { // panorama.dll + constexpr std::ptrdiff_t PanoramaUIEngine001 = 0x57EE0; +} + +namespace panorama_text_pango_dll { // panorama_text_pango.dll + constexpr std::ptrdiff_t PanoramaTextServices001 = 0x4CBD0; +} + +namespace panoramauiclient_dll { // panoramauiclient.dll + constexpr std::ptrdiff_t PanoramaUIClient001 = 0x12780; +} + +namespace particles_dll { // particles.dll + constexpr std::ptrdiff_t ParticleSystemMgr003 = 0x52D20; +} + +namespace pulse_system_dll { // pulse_system.dll + constexpr std::ptrdiff_t IPulseSystem_001 = 0x5B80; +} + +namespace rendersystemdx11_dll { // rendersystemdx11.dll + constexpr std::ptrdiff_t RenderUtils_001 = 0x52FD0; + constexpr std::ptrdiff_t VRenderDeviceMgrBackdoor001 = 0x4A4F0; + constexpr std::ptrdiff_t RenderDeviceMgr001 = 0x4A4E0; +} + +namespace resourcesystem_dll { // resourcesystem.dll + constexpr std::ptrdiff_t ResourceSystem013 = 0x10650; +} + +namespace scenefilecache_dll { // scenefilecache.dll + constexpr std::ptrdiff_t SceneFileCache002 = 0x68E0; + constexpr std::ptrdiff_t ResponseRulesCache001 = 0x3190; +} + +namespace scenesystem_dll { // scenesystem.dll + constexpr std::ptrdiff_t SceneUtils_001 = 0x13C370; + constexpr std::ptrdiff_t SceneSystem_002 = 0xCA160; + constexpr std::ptrdiff_t RenderingPipelines_001 = 0x8E420; +} + +namespace schemasystem_dll { // schemasystem.dll + constexpr std::ptrdiff_t SchemaSystem_001 = 0xA930; +} + +namespace server_dll { // server.dll + constexpr std::ptrdiff_t NavGameTest001 = 0xA35420; + constexpr std::ptrdiff_t ServerToolsInfo_001 = 0x838790; + constexpr std::ptrdiff_t Source2GameClients001 = 0x8387A0; + constexpr std::ptrdiff_t Source2GameEntities001 = 0x8387B0; + constexpr std::ptrdiff_t Source2Server001 = 0x8387C0; + constexpr std::ptrdiff_t EmptyWorldService001_Server = 0x58D750; + constexpr std::ptrdiff_t Source2ServerConfig001 = 0x56D760; + constexpr std::ptrdiff_t EntitySubclassUtilsV001 = 0x2CD4C0; + constexpr std::ptrdiff_t customnavsystem001 = 0x24A3F0; + constexpr std::ptrdiff_t Source2GameDirector001 = 0x151EC0; +} + +namespace soundsystem_dll { // soundsystem.dll + constexpr std::ptrdiff_t SoundOpSystem001 = 0x1567E0; + constexpr std::ptrdiff_t SoundOpSystemEdit001 = 0x8BBC0; + constexpr std::ptrdiff_t VMixEditTool001 = 0x71740; + constexpr std::ptrdiff_t SoundSystem001 = 0x46540; +} + +namespace steamaudio_dll { // steamaudio.dll + constexpr std::ptrdiff_t SteamAudio001 = 0x12EE0; +} + +namespace steamclient64_dll { // steamclient64.dll + constexpr std::ptrdiff_t IVALIDATE001 = 0x83A900; + constexpr std::ptrdiff_t CLIENTENGINE_INTERFACE_VERSION005 = 0x8367B0; + constexpr std::ptrdiff_t SteamClient020 = 0x631440; + constexpr std::ptrdiff_t SteamClient019 = 0x631430; + constexpr std::ptrdiff_t SteamClient018 = 0x631420; + constexpr std::ptrdiff_t SteamClient017 = 0x631410; + constexpr std::ptrdiff_t SteamClient016 = 0x631400; + constexpr std::ptrdiff_t SteamClient015 = 0x6313F0; + constexpr std::ptrdiff_t SteamClient014 = 0x6313E0; + constexpr std::ptrdiff_t SteamClient013 = 0x6313D0; + constexpr std::ptrdiff_t SteamClient012 = 0x6313C0; + constexpr std::ptrdiff_t SteamClient011 = 0x6313B0; + constexpr std::ptrdiff_t SteamClient010 = 0x6313A0; + constexpr std::ptrdiff_t SteamClient009 = 0x631390; + constexpr std::ptrdiff_t SteamClient008 = 0x631380; + constexpr std::ptrdiff_t SteamClient007 = 0x631370; + constexpr std::ptrdiff_t SteamClient006 = 0x631360; + constexpr std::ptrdiff_t p2pvoice002 = 0xD93D0; + constexpr std::ptrdiff_t p2pvoicesingleton002 = 0xD5D70; +} + +namespace tier0_dll { // tier0.dll + constexpr std::ptrdiff_t VStringTokenSystem001 = 0x18C100; + constexpr std::ptrdiff_t TestScriptMgr001 = 0x13F460; + constexpr std::ptrdiff_t VProcessUtils002 = 0x12F5E0; + constexpr std::ptrdiff_t VEngineCvar007 = 0x61920; +} + +namespace v8system_dll { // v8system.dll + constexpr std::ptrdiff_t Source2V8System001 = 0x1670; +} + +namespace valve_avi_dll { // valve_avi.dll + constexpr std::ptrdiff_t VAvi001 = 0x2F90; +} + +namespace valve_wmf_dll { // valve_wmf.dll + constexpr std::ptrdiff_t VMediaFoundation001 = 0x12D0; +} + +namespace vphysics2_dll { // vphysics2.dll + constexpr std::ptrdiff_t VPhysics2_Handle_Interface_001 = 0x61120; + constexpr std::ptrdiff_t VPhysics2_Interface_001 = 0x5C740; +} + +namespace vscript_dll { // vscript.dll + constexpr std::ptrdiff_t VScriptManager010 = 0x31DA0; +} + +namespace vstdlib_s64_dll { // vstdlib_s64.dll + constexpr std::ptrdiff_t IVALIDATE001 = 0x24FF0; + constexpr std::ptrdiff_t VEngineCvar002 = 0x5750; +} + +namespace worldrenderer_dll { // worldrenderer.dll + constexpr std::ptrdiff_t WorldRendererMgr001 = 0x21650; +} \ No newline at end of file diff --git a/HPCS2/offset/materialsystem2.dll.hpp b/HPCS2/offset/materialsystem2.dll.hpp new file mode 100644 index 0000000..eb40d36 --- /dev/null +++ b/HPCS2/offset/materialsystem2.dll.hpp @@ -0,0 +1,115 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace MaterialParamBuffer_t { // MaterialParam_t + constexpr std::ptrdiff_t m_value = 0x8; // CUtlBinaryBlock +} + +namespace MaterialParamFloat_t { // MaterialParam_t + constexpr std::ptrdiff_t m_flValue = 0x8; // float +} + +namespace MaterialParamInt_t { // MaterialParam_t + constexpr std::ptrdiff_t m_nValue = 0x8; // int32_t +} + +namespace MaterialParamString_t { // MaterialParam_t + constexpr std::ptrdiff_t m_value = 0x8; // CUtlString +} + +namespace MaterialParamTexture_t { // MaterialParam_t + constexpr std::ptrdiff_t m_pValue = 0x8; // CStrongHandle +} + +namespace MaterialParamVector_t { // MaterialParam_t + constexpr std::ptrdiff_t m_value = 0x8; // Vector4D +} + +namespace MaterialParam_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString +} + +namespace MaterialResourceData_t { + constexpr std::ptrdiff_t m_materialName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_shaderName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_intParams = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_floatParams = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_vectorParams = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_textureParams = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_dynamicParams = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_dynamicTextureParams = 0x88; // CUtlVector + constexpr std::ptrdiff_t m_intAttributes = 0xA0; // CUtlVector + constexpr std::ptrdiff_t m_floatAttributes = 0xB8; // CUtlVector + constexpr std::ptrdiff_t m_vectorAttributes = 0xD0; // CUtlVector + constexpr std::ptrdiff_t m_textureAttributes = 0xE8; // CUtlVector + constexpr std::ptrdiff_t m_stringAttributes = 0x100; // CUtlVector + constexpr std::ptrdiff_t m_renderAttributesUsed = 0x118; // CUtlVector +} + +namespace PostProcessingBloomParameters_t { + constexpr std::ptrdiff_t m_blendMode = 0x0; // BloomBlendMode_t + constexpr std::ptrdiff_t m_flBloomStrength = 0x4; // float + constexpr std::ptrdiff_t m_flScreenBloomStrength = 0x8; // float + constexpr std::ptrdiff_t m_flBlurBloomStrength = 0xC; // float + constexpr std::ptrdiff_t m_flBloomThreshold = 0x10; // float + constexpr std::ptrdiff_t m_flBloomThresholdWidth = 0x14; // float + constexpr std::ptrdiff_t m_flSkyboxBloomStrength = 0x18; // float + constexpr std::ptrdiff_t m_flBloomStartValue = 0x1C; // float + constexpr std::ptrdiff_t m_flBlurWeight = 0x20; // float[5] + constexpr std::ptrdiff_t m_vBlurTint = 0x34; // Vector[5] +} + +namespace PostProcessingLocalContrastParameters_t { + constexpr std::ptrdiff_t m_flLocalContrastStrength = 0x0; // float + constexpr std::ptrdiff_t m_flLocalContrastEdgeStrength = 0x4; // float + constexpr std::ptrdiff_t m_flLocalContrastVignetteStart = 0x8; // float + constexpr std::ptrdiff_t m_flLocalContrastVignetteEnd = 0xC; // float + constexpr std::ptrdiff_t m_flLocalContrastVignetteBlur = 0x10; // float +} + +namespace PostProcessingResource_t { + constexpr std::ptrdiff_t m_bHasTonemapParams = 0x0; // bool + constexpr std::ptrdiff_t m_toneMapParams = 0x4; // PostProcessingTonemapParameters_t + constexpr std::ptrdiff_t m_bHasBloomParams = 0x40; // bool + constexpr std::ptrdiff_t m_bloomParams = 0x44; // PostProcessingBloomParameters_t + constexpr std::ptrdiff_t m_bHasVignetteParams = 0xB4; // bool + constexpr std::ptrdiff_t m_vignetteParams = 0xB8; // PostProcessingVignetteParameters_t + constexpr std::ptrdiff_t m_bHasLocalContrastParams = 0xDC; // bool + constexpr std::ptrdiff_t m_localConstrastParams = 0xE0; // PostProcessingLocalContrastParameters_t + constexpr std::ptrdiff_t m_nColorCorrectionVolumeDim = 0xF4; // int32_t + constexpr std::ptrdiff_t m_colorCorrectionVolumeData = 0xF8; // CUtlBinaryBlock + constexpr std::ptrdiff_t m_bHasColorCorrection = 0x110; // bool +} + +namespace PostProcessingTonemapParameters_t { + constexpr std::ptrdiff_t m_flExposureBias = 0x0; // float + constexpr std::ptrdiff_t m_flShoulderStrength = 0x4; // float + constexpr std::ptrdiff_t m_flLinearStrength = 0x8; // float + constexpr std::ptrdiff_t m_flLinearAngle = 0xC; // float + constexpr std::ptrdiff_t m_flToeStrength = 0x10; // float + constexpr std::ptrdiff_t m_flToeNum = 0x14; // float + constexpr std::ptrdiff_t m_flToeDenom = 0x18; // float + constexpr std::ptrdiff_t m_flWhitePoint = 0x1C; // float + constexpr std::ptrdiff_t m_flLuminanceSource = 0x20; // float + constexpr std::ptrdiff_t m_flExposureBiasShadows = 0x24; // float + constexpr std::ptrdiff_t m_flExposureBiasHighlights = 0x28; // float + constexpr std::ptrdiff_t m_flMinShadowLum = 0x2C; // float + constexpr std::ptrdiff_t m_flMaxShadowLum = 0x30; // float + constexpr std::ptrdiff_t m_flMinHighlightLum = 0x34; // float + constexpr std::ptrdiff_t m_flMaxHighlightLum = 0x38; // float +} + +namespace PostProcessingVignetteParameters_t { + constexpr std::ptrdiff_t m_flVignetteStrength = 0x0; // float + constexpr std::ptrdiff_t m_vCenter = 0x4; // Vector2D + constexpr std::ptrdiff_t m_flRadius = 0xC; // float + constexpr std::ptrdiff_t m_flRoundness = 0x10; // float + constexpr std::ptrdiff_t m_flFeather = 0x14; // float + constexpr std::ptrdiff_t m_vColorTint = 0x18; // Vector +} \ No newline at end of file diff --git a/HPCS2/offset/networksystem.dll.hpp b/HPCS2/offset/networksystem.dll.hpp new file mode 100644 index 0000000..25f40df --- /dev/null +++ b/HPCS2/offset/networksystem.dll.hpp @@ -0,0 +1,12 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace ChangeAccessorFieldPathIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int16_t +} \ No newline at end of file diff --git a/HPCS2/offset/offsets.hpp b/HPCS2/offset/offsets.hpp new file mode 100644 index 0000000..a7b8719 --- /dev/null +++ b/HPCS2/offset/offsets.hpp @@ -0,0 +1,49 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:24 +0000 + */ + +#pragma once + +#include + +namespace client_dll { // client.dll + constexpr std::ptrdiff_t dwBaseEntityModel_setModel = 0x581530; + constexpr std::ptrdiff_t dwEntityList = 0x17AB958; + constexpr std::ptrdiff_t dwForceAttack = 0x16B02B0; + constexpr std::ptrdiff_t dwForceAttack2 = 0x16B0340; + constexpr std::ptrdiff_t dwForceBackward = 0x16B0580; + constexpr std::ptrdiff_t dwForceCrouch = 0x16B0850; + constexpr std::ptrdiff_t dwForceForward = 0x16B04F0; + constexpr std::ptrdiff_t dwForceJump = 0x16B07C0; + constexpr std::ptrdiff_t dwForceLeft = 0x16B0610; + constexpr std::ptrdiff_t dwForceRight = 0x16B06A0; + constexpr std::ptrdiff_t dwGameEntitySystem = 0x18D51A8; + constexpr std::ptrdiff_t dwGameEntitySystem_getBaseEntity = 0x604B40; + constexpr std::ptrdiff_t dwGameEntitySystem_getHighestEntityIndex = 0x5F6830; + constexpr std::ptrdiff_t dwGameRules = 0x1807FA8; + constexpr std::ptrdiff_t dwGlobalVars = 0x16AC100; + constexpr std::ptrdiff_t dwGlowManager = 0x1807708; + constexpr std::ptrdiff_t dwInterfaceLinkList = 0x1902EB8; + constexpr std::ptrdiff_t dwLocalPlayerController = 0x17FAC68; + constexpr std::ptrdiff_t dwLocalPlayerPawn = 0x16B7340; + constexpr std::ptrdiff_t dwPlantedC4 = 0x180EB48; + constexpr std::ptrdiff_t dwPrediction = 0x16B7210; + constexpr std::ptrdiff_t dwViewAngles = 0x18690D8; + constexpr std::ptrdiff_t dwViewMatrix = 0x180A0D0; + constexpr std::ptrdiff_t dwViewRender = 0x180A090; +} + +namespace engine2_dll { // engine2.dll + constexpr std::ptrdiff_t dwBuildNumber = 0x488514; + constexpr std::ptrdiff_t dwNetworkGameClient = 0x487AB0; + constexpr std::ptrdiff_t dwNetworkGameClient_getLocalPlayer = 0xF0; + constexpr std::ptrdiff_t dwNetworkGameClient_maxClients = 0x250; + constexpr std::ptrdiff_t dwNetworkGameClient_signOnState = 0x240; + constexpr std::ptrdiff_t dwWindowHeight = 0x5397DC; + constexpr std::ptrdiff_t dwWindowWidth = 0x5397D8; +} + +namespace inputsystem_dll { // inputsystem.dll + constexpr std::ptrdiff_t dwInputSystem = 0x35770; +} \ No newline at end of file diff --git a/HPCS2/offset/particles.dll.hpp b/HPCS2/offset/particles.dll.hpp new file mode 100644 index 0000000..16516c4 --- /dev/null +++ b/HPCS2/offset/particles.dll.hpp @@ -0,0 +1,4037 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace CBaseRendererSource2 { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flRadiusScale = 0x200; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flAlphaScale = 0x358; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flRollScale = 0x4B0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nAlpha2Field = 0x608; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecColorScale = 0x610; // CParticleCollectionRendererVecInput + constexpr std::ptrdiff_t m_nColorBlendType = 0xC68; // ParticleColorBlendType_t + constexpr std::ptrdiff_t m_nShaderType = 0xC6C; // SpriteCardShaderType_t + constexpr std::ptrdiff_t m_strShaderOverride = 0xC70; // CUtlString + constexpr std::ptrdiff_t m_flCenterXOffset = 0xC78; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flCenterYOffset = 0xDD0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flBumpStrength = 0xF28; // float + constexpr std::ptrdiff_t m_nCropTextureOverride = 0xF2C; // ParticleSequenceCropOverride_t + constexpr std::ptrdiff_t m_vecTexturesInput = 0xF30; // CUtlVector + constexpr std::ptrdiff_t m_flAnimationRate = 0xF48; // float + constexpr std::ptrdiff_t m_nAnimationType = 0xF4C; // AnimationType_t + constexpr std::ptrdiff_t m_bAnimateInFPS = 0xF50; // bool + constexpr std::ptrdiff_t m_flSelfIllumAmount = 0xF58; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flDiffuseAmount = 0x10B0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nLightingControlPoint = 0x1208; // int32_t + constexpr std::ptrdiff_t m_nSelfIllumPerParticle = 0x120C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nOutputBlendMode = 0x1210; // ParticleOutputBlendMode_t + constexpr std::ptrdiff_t m_bGammaCorrectVertexColors = 0x1214; // bool + constexpr std::ptrdiff_t m_bSaturateColorPreAlphaBlend = 0x1215; // bool + constexpr std::ptrdiff_t m_flAddSelfAmount = 0x1218; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flDesaturation = 0x1370; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flOverbrightFactor = 0x14C8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nHSVShiftControlPoint = 0x1620; // int32_t + constexpr std::ptrdiff_t m_nFogType = 0x1624; // ParticleFogType_t + constexpr std::ptrdiff_t m_flFogAmount = 0x1628; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_bTintByFOW = 0x1780; // bool + constexpr std::ptrdiff_t m_bTintByGlobalLight = 0x1781; // bool + constexpr std::ptrdiff_t m_nPerParticleAlphaReference = 0x1784; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nPerParticleAlphaRefWindow = 0x1788; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nAlphaReferenceType = 0x178C; // ParticleAlphaReferenceType_t + constexpr std::ptrdiff_t m_flAlphaReferenceSoftness = 0x1790; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flSourceAlphaValueToMapToZero = 0x18E8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flSourceAlphaValueToMapToOne = 0x1A40; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_bRefract = 0x1B98; // bool + constexpr std::ptrdiff_t m_bRefractSolid = 0x1B99; // bool + constexpr std::ptrdiff_t m_flRefractAmount = 0x1BA0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nRefractBlurRadius = 0x1CF8; // int32_t + constexpr std::ptrdiff_t m_nRefractBlurType = 0x1CFC; // BlurFilterType_t + constexpr std::ptrdiff_t m_bOnlyRenderInEffectsBloomPass = 0x1D00; // bool + constexpr std::ptrdiff_t m_bOnlyRenderInEffectsWaterPass = 0x1D01; // bool + constexpr std::ptrdiff_t m_bUseMixedResolutionRendering = 0x1D02; // bool + constexpr std::ptrdiff_t m_bOnlyRenderInEffecsGameOverlay = 0x1D03; // bool + constexpr std::ptrdiff_t m_stencilTestID = 0x1D04; // char[128] + constexpr std::ptrdiff_t m_bStencilTestExclude = 0x1D84; // bool + constexpr std::ptrdiff_t m_stencilWriteID = 0x1D85; // char[128] + constexpr std::ptrdiff_t m_bWriteStencilOnDepthPass = 0x1E05; // bool + constexpr std::ptrdiff_t m_bWriteStencilOnDepthFail = 0x1E06; // bool + constexpr std::ptrdiff_t m_bReverseZBuffering = 0x1E07; // bool + constexpr std::ptrdiff_t m_bDisableZBuffering = 0x1E08; // bool + constexpr std::ptrdiff_t m_nFeatheringMode = 0x1E0C; // ParticleDepthFeatheringMode_t + constexpr std::ptrdiff_t m_flFeatheringMinDist = 0x1E10; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flFeatheringMaxDist = 0x1F68; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flFeatheringFilter = 0x20C0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flDepthBias = 0x2218; // float + constexpr std::ptrdiff_t m_nSortMethod = 0x221C; // ParticleSortingChoiceList_t + constexpr std::ptrdiff_t m_bBlendFramesSeq0 = 0x2220; // bool + constexpr std::ptrdiff_t m_bMaxLuminanceBlendingSequence0 = 0x2221; // bool +} + +namespace CBaseTrailRenderer { // CBaseRendererSource2 + constexpr std::ptrdiff_t m_nOrientationType = 0x2470; // ParticleOrientationChoiceList_t + constexpr std::ptrdiff_t m_nOrientationControlPoint = 0x2474; // int32_t + constexpr std::ptrdiff_t m_flMinSize = 0x2478; // float + constexpr std::ptrdiff_t m_flMaxSize = 0x247C; // float + constexpr std::ptrdiff_t m_flStartFadeSize = 0x2480; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flEndFadeSize = 0x25D8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_bClampV = 0x2730; // bool +} + +namespace CGeneralRandomRotation { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flDegrees = 0x1C4; // float + constexpr std::ptrdiff_t m_flDegreesMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flDegreesMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flRotationRandExponent = 0x1D0; // float + constexpr std::ptrdiff_t m_bRandomlyFlipDirection = 0x1D4; // bool +} + +namespace CGeneralSpin { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nSpinRateDegrees = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nSpinRateMinDegrees = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_fSpinRateStopTime = 0x1CC; // float +} + +namespace CNewParticleEffect { // IParticleEffect + constexpr std::ptrdiff_t m_pNext = 0x10; // CNewParticleEffect* + constexpr std::ptrdiff_t m_pPrev = 0x18; // CNewParticleEffect* + constexpr std::ptrdiff_t m_pParticles = 0x20; // IParticleCollection* + constexpr std::ptrdiff_t m_pDebugName = 0x28; // char* + constexpr std::ptrdiff_t m_bDontRemove = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bRemove = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNeedsBBoxUpdate = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bIsFirstFrame = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bAutoUpdateBBox = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bAllocated = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bSimulate = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bShouldPerformCullCheck = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bForceNoDraw = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bShouldSave = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bDisableAggregation = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bShouldSimulateDuringGamePaused = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bShouldCheckFoW = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_vSortOrigin = 0x40; // Vector + constexpr std::ptrdiff_t m_flScale = 0x4C; // float + constexpr std::ptrdiff_t m_hOwner = 0x50; // PARTICLE_EHANDLE__* + constexpr std::ptrdiff_t m_pOwningParticleProperty = 0x58; // CParticleProperty* + constexpr std::ptrdiff_t m_flFreezeTransitionStart = 0x70; // float + constexpr std::ptrdiff_t m_flFreezeTransitionDuration = 0x74; // float + constexpr std::ptrdiff_t m_flFreezeTransitionOverride = 0x78; // float + constexpr std::ptrdiff_t m_bFreezeTransitionActive = 0x7C; // bool + constexpr std::ptrdiff_t m_bFreezeTargetState = 0x7D; // bool + constexpr std::ptrdiff_t m_bCanFreeze = 0x7E; // bool + constexpr std::ptrdiff_t m_LastMin = 0x80; // Vector + constexpr std::ptrdiff_t m_LastMax = 0x8C; // Vector + constexpr std::ptrdiff_t m_nSplitScreenUser = 0x98; // CSplitScreenSlot + constexpr std::ptrdiff_t m_vecAggregationCenter = 0x9C; // Vector + constexpr std::ptrdiff_t m_RefCount = 0xC0; // int32_t +} + +namespace CParticleBindingRealPulse { // CParticleCollectionBindingInstance +} + +namespace CParticleCollectionBindingInstance { // CBasePulseGraphInstance +} + +namespace CParticleCollectionFloatInput { // CParticleFloatInput +} + +namespace CParticleCollectionRendererFloatInput { // CParticleCollectionFloatInput +} + +namespace CParticleCollectionRendererVecInput { // CParticleCollectionVecInput +} + +namespace CParticleCollectionVecInput { // CParticleVecInput +} + +namespace CParticleFloatInput { // CParticleInput + constexpr std::ptrdiff_t m_nType = 0x10; // ParticleFloatType_t + constexpr std::ptrdiff_t m_nMapType = 0x14; // ParticleFloatMapType_t + constexpr std::ptrdiff_t m_flLiteralValue = 0x18; // float + constexpr std::ptrdiff_t m_NamedValue = 0x20; // CParticleNamedValueRef + constexpr std::ptrdiff_t m_nControlPoint = 0x60; // int32_t + constexpr std::ptrdiff_t m_nScalarAttribute = 0x64; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nVectorAttribute = 0x68; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nVectorComponent = 0x6C; // int32_t + constexpr std::ptrdiff_t m_flRandomMin = 0x70; // float + constexpr std::ptrdiff_t m_flRandomMax = 0x74; // float + constexpr std::ptrdiff_t m_bHasRandomSignFlip = 0x78; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0x7C; // int32_t + constexpr std::ptrdiff_t m_nRandomMode = 0x80; // ParticleFloatRandomMode_t + constexpr std::ptrdiff_t m_flLOD0 = 0x88; // float + constexpr std::ptrdiff_t m_flLOD1 = 0x8C; // float + constexpr std::ptrdiff_t m_flLOD2 = 0x90; // float + constexpr std::ptrdiff_t m_flLOD3 = 0x94; // float + constexpr std::ptrdiff_t m_nNoiseInputVectorAttribute = 0x98; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flNoiseOutputMin = 0x9C; // float + constexpr std::ptrdiff_t m_flNoiseOutputMax = 0xA0; // float + constexpr std::ptrdiff_t m_flNoiseScale = 0xA4; // float + constexpr std::ptrdiff_t m_vecNoiseOffsetRate = 0xA8; // Vector + constexpr std::ptrdiff_t m_flNoiseOffset = 0xB4; // float + constexpr std::ptrdiff_t m_nNoiseOctaves = 0xB8; // int32_t + constexpr std::ptrdiff_t m_nNoiseTurbulence = 0xBC; // PFNoiseTurbulence_t + constexpr std::ptrdiff_t m_nNoiseType = 0xC0; // PFNoiseType_t + constexpr std::ptrdiff_t m_nNoiseModifier = 0xC4; // PFNoiseModifier_t + constexpr std::ptrdiff_t m_flNoiseTurbulenceScale = 0xC8; // float + constexpr std::ptrdiff_t m_flNoiseTurbulenceMix = 0xCC; // float + constexpr std::ptrdiff_t m_flNoiseImgPreviewScale = 0xD0; // float + constexpr std::ptrdiff_t m_bNoiseImgPreviewLive = 0xD4; // bool + constexpr std::ptrdiff_t m_flNoCameraFallback = 0xE0; // float + constexpr std::ptrdiff_t m_bUseBoundsCenter = 0xE4; // bool + constexpr std::ptrdiff_t m_nInputMode = 0xE8; // ParticleFloatInputMode_t + constexpr std::ptrdiff_t m_flMultFactor = 0xEC; // float + constexpr std::ptrdiff_t m_flInput0 = 0xF0; // float + constexpr std::ptrdiff_t m_flInput1 = 0xF4; // float + constexpr std::ptrdiff_t m_flOutput0 = 0xF8; // float + constexpr std::ptrdiff_t m_flOutput1 = 0xFC; // float + constexpr std::ptrdiff_t m_flNotchedRangeMin = 0x100; // float + constexpr std::ptrdiff_t m_flNotchedRangeMax = 0x104; // float + constexpr std::ptrdiff_t m_flNotchedOutputOutside = 0x108; // float + constexpr std::ptrdiff_t m_flNotchedOutputInside = 0x10C; // float + constexpr std::ptrdiff_t m_nBiasType = 0x110; // ParticleFloatBiasType_t + constexpr std::ptrdiff_t m_flBiasParameter = 0x114; // float + constexpr std::ptrdiff_t m_Curve = 0x118; // CPiecewiseCurve +} + +namespace CParticleFunction { + constexpr std::ptrdiff_t m_flOpStrength = 0x8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nOpEndCapState = 0x160; // ParticleEndcapMode_t + constexpr std::ptrdiff_t m_flOpStartFadeInTime = 0x164; // float + constexpr std::ptrdiff_t m_flOpEndFadeInTime = 0x168; // float + constexpr std::ptrdiff_t m_flOpStartFadeOutTime = 0x16C; // float + constexpr std::ptrdiff_t m_flOpEndFadeOutTime = 0x170; // float + constexpr std::ptrdiff_t m_flOpFadeOscillatePeriod = 0x174; // float + constexpr std::ptrdiff_t m_bNormalizeToStopTime = 0x178; // bool + constexpr std::ptrdiff_t m_flOpTimeOffsetMin = 0x17C; // float + constexpr std::ptrdiff_t m_flOpTimeOffsetMax = 0x180; // float + constexpr std::ptrdiff_t m_nOpTimeOffsetSeed = 0x184; // int32_t + constexpr std::ptrdiff_t m_nOpTimeScaleSeed = 0x188; // int32_t + constexpr std::ptrdiff_t m_flOpTimeScaleMin = 0x18C; // float + constexpr std::ptrdiff_t m_flOpTimeScaleMax = 0x190; // float + constexpr std::ptrdiff_t m_bDisableOperator = 0x196; // bool + constexpr std::ptrdiff_t m_Notes = 0x198; // CUtlString +} + +namespace CParticleFunctionConstraint { // CParticleFunction +} + +namespace CParticleFunctionEmitter { // CParticleFunction + constexpr std::ptrdiff_t m_nEmitterIndex = 0x1B8; // int32_t +} + +namespace CParticleFunctionForce { // CParticleFunction +} + +namespace CParticleFunctionInitializer { // CParticleFunction + constexpr std::ptrdiff_t m_nAssociatedEmitterIndex = 0x1B8; // int32_t +} + +namespace CParticleFunctionOperator { // CParticleFunction +} + +namespace CParticleFunctionPreEmission { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_bRunOnce = 0x1C0; // bool +} + +namespace CParticleFunctionRenderer { // CParticleFunction + constexpr std::ptrdiff_t VisibilityInputs = 0x1B8; // CParticleVisibilityInputs + constexpr std::ptrdiff_t m_bCannotBeRefracted = 0x1FC; // bool + constexpr std::ptrdiff_t m_bSkipRenderingOnMobile = 0x1FD; // bool +} + +namespace CParticleInput { +} + +namespace CParticleModelInput { // CParticleInput + constexpr std::ptrdiff_t m_nType = 0x10; // ParticleModelType_t + constexpr std::ptrdiff_t m_NamedValue = 0x18; // CParticleNamedValueRef + constexpr std::ptrdiff_t m_nControlPoint = 0x58; // int32_t +} + +namespace CParticleProperty { +} + +namespace CParticleRemapFloatInput { // CParticleFloatInput +} + +namespace CParticleSystemDefinition { // IParticleSystemDefinition + constexpr std::ptrdiff_t m_nBehaviorVersion = 0x8; // int32_t + constexpr std::ptrdiff_t m_PreEmissionOperators = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_Emitters = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_Initializers = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_Operators = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_ForceGenerators = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_Constraints = 0x88; // CUtlVector + constexpr std::ptrdiff_t m_Renderers = 0xA0; // CUtlVector + constexpr std::ptrdiff_t m_Children = 0xB8; // CUtlVector + constexpr std::ptrdiff_t m_nFirstMultipleOverride_BackwardCompat = 0x178; // int32_t + constexpr std::ptrdiff_t m_nInitialParticles = 0x210; // int32_t + constexpr std::ptrdiff_t m_nMaxParticles = 0x214; // int32_t + constexpr std::ptrdiff_t m_nGroupID = 0x218; // int32_t + constexpr std::ptrdiff_t m_BoundingBoxMin = 0x21C; // Vector + constexpr std::ptrdiff_t m_BoundingBoxMax = 0x228; // Vector + constexpr std::ptrdiff_t m_flDepthSortBias = 0x234; // float + constexpr std::ptrdiff_t m_nSortOverridePositionCP = 0x238; // int32_t + constexpr std::ptrdiff_t m_bInfiniteBounds = 0x23C; // bool + constexpr std::ptrdiff_t m_bEnableNamedValues = 0x23D; // bool + constexpr std::ptrdiff_t m_NamedValueDomain = 0x240; // CUtlString + constexpr std::ptrdiff_t m_NamedValueLocals = 0x248; // CUtlVector + constexpr std::ptrdiff_t m_ConstantColor = 0x260; // Color + constexpr std::ptrdiff_t m_ConstantNormal = 0x264; // Vector + constexpr std::ptrdiff_t m_flConstantRadius = 0x270; // float + constexpr std::ptrdiff_t m_flConstantRotation = 0x274; // float + constexpr std::ptrdiff_t m_flConstantRotationSpeed = 0x278; // float + constexpr std::ptrdiff_t m_flConstantLifespan = 0x27C; // float + constexpr std::ptrdiff_t m_nConstantSequenceNumber = 0x280; // int32_t + constexpr std::ptrdiff_t m_nConstantSequenceNumber1 = 0x284; // int32_t + constexpr std::ptrdiff_t m_nSnapshotControlPoint = 0x288; // int32_t + constexpr std::ptrdiff_t m_hSnapshot = 0x290; // CStrongHandle + constexpr std::ptrdiff_t m_pszCullReplacementName = 0x298; // CStrongHandle + constexpr std::ptrdiff_t m_flCullRadius = 0x2A0; // float + constexpr std::ptrdiff_t m_flCullFillCost = 0x2A4; // float + constexpr std::ptrdiff_t m_nCullControlPoint = 0x2A8; // int32_t + constexpr std::ptrdiff_t m_hFallback = 0x2B0; // CStrongHandle + constexpr std::ptrdiff_t m_nFallbackMaxCount = 0x2B8; // int32_t + constexpr std::ptrdiff_t m_hLowViolenceDef = 0x2C0; // CStrongHandle + constexpr std::ptrdiff_t m_hReferenceReplacement = 0x2C8; // CStrongHandle + constexpr std::ptrdiff_t m_flPreSimulationTime = 0x2D0; // float + constexpr std::ptrdiff_t m_flStopSimulationAfterTime = 0x2D4; // float + constexpr std::ptrdiff_t m_flMaximumTimeStep = 0x2D8; // float + constexpr std::ptrdiff_t m_flMaximumSimTime = 0x2DC; // float + constexpr std::ptrdiff_t m_flMinimumSimTime = 0x2E0; // float + constexpr std::ptrdiff_t m_flMinimumTimeStep = 0x2E4; // float + constexpr std::ptrdiff_t m_nMinimumFrames = 0x2E8; // int32_t + constexpr std::ptrdiff_t m_nMinCPULevel = 0x2EC; // int32_t + constexpr std::ptrdiff_t m_nMinGPULevel = 0x2F0; // int32_t + constexpr std::ptrdiff_t m_flNoDrawTimeToGoToSleep = 0x2F4; // float + constexpr std::ptrdiff_t m_flMaxDrawDistance = 0x2F8; // float + constexpr std::ptrdiff_t m_flStartFadeDistance = 0x2FC; // float + constexpr std::ptrdiff_t m_flMaxCreationDistance = 0x300; // float + constexpr std::ptrdiff_t m_nAggregationMinAvailableParticles = 0x304; // int32_t + constexpr std::ptrdiff_t m_flAggregateRadius = 0x308; // float + constexpr std::ptrdiff_t m_bShouldBatch = 0x30C; // bool + constexpr std::ptrdiff_t m_bShouldHitboxesFallbackToRenderBounds = 0x30D; // bool + constexpr std::ptrdiff_t m_bShouldHitboxesFallbackToSnapshot = 0x30E; // bool + constexpr std::ptrdiff_t m_nViewModelEffect = 0x310; // InheritableBoolType_t + constexpr std::ptrdiff_t m_bScreenSpaceEffect = 0x314; // bool + constexpr std::ptrdiff_t m_pszTargetLayerID = 0x318; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nSkipRenderControlPoint = 0x320; // int32_t + constexpr std::ptrdiff_t m_nAllowRenderControlPoint = 0x324; // int32_t + constexpr std::ptrdiff_t m_bShouldSort = 0x328; // bool + constexpr std::ptrdiff_t m_controlPointConfigurations = 0x370; // CUtlVector +} + +namespace CParticleTransformInput { // CParticleInput + constexpr std::ptrdiff_t m_nType = 0x10; // ParticleTransformType_t + constexpr std::ptrdiff_t m_NamedValue = 0x18; // CParticleNamedValueRef + constexpr std::ptrdiff_t m_bFollowNamedValue = 0x58; // bool + constexpr std::ptrdiff_t m_bSupportsDisabled = 0x59; // bool + constexpr std::ptrdiff_t m_bUseOrientation = 0x5A; // bool + constexpr std::ptrdiff_t m_nControlPoint = 0x5C; // int32_t + constexpr std::ptrdiff_t m_nControlPointRangeMax = 0x60; // int32_t + constexpr std::ptrdiff_t m_flEndCPGrowthTime = 0x64; // float +} + +namespace CParticleVariableRef { + constexpr std::ptrdiff_t m_variableName = 0x0; // CKV3MemberNameWithStorage + constexpr std::ptrdiff_t m_variableType = 0x38; // PulseValueType_t +} + +namespace CParticleVecInput { // CParticleInput + constexpr std::ptrdiff_t m_nType = 0x10; // ParticleVecType_t + constexpr std::ptrdiff_t m_vLiteralValue = 0x14; // Vector + constexpr std::ptrdiff_t m_LiteralColor = 0x20; // Color + constexpr std::ptrdiff_t m_NamedValue = 0x28; // CParticleNamedValueRef + constexpr std::ptrdiff_t m_bFollowNamedValue = 0x68; // bool + constexpr std::ptrdiff_t m_nVectorAttribute = 0x6C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vVectorAttributeScale = 0x70; // Vector + constexpr std::ptrdiff_t m_nControlPoint = 0x7C; // int32_t + constexpr std::ptrdiff_t m_nDeltaControlPoint = 0x80; // int32_t + constexpr std::ptrdiff_t m_vCPValueScale = 0x84; // Vector + constexpr std::ptrdiff_t m_vCPRelativePosition = 0x90; // Vector + constexpr std::ptrdiff_t m_vCPRelativeDir = 0x9C; // Vector + constexpr std::ptrdiff_t m_FloatComponentX = 0xA8; // CParticleFloatInput + constexpr std::ptrdiff_t m_FloatComponentY = 0x200; // CParticleFloatInput + constexpr std::ptrdiff_t m_FloatComponentZ = 0x358; // CParticleFloatInput + constexpr std::ptrdiff_t m_FloatInterp = 0x4B0; // CParticleFloatInput + constexpr std::ptrdiff_t m_flInterpInput0 = 0x608; // float + constexpr std::ptrdiff_t m_flInterpInput1 = 0x60C; // float + constexpr std::ptrdiff_t m_vInterpOutput0 = 0x610; // Vector + constexpr std::ptrdiff_t m_vInterpOutput1 = 0x61C; // Vector + constexpr std::ptrdiff_t m_Gradient = 0x628; // CColorGradient + constexpr std::ptrdiff_t m_vRandomMin = 0x640; // Vector + constexpr std::ptrdiff_t m_vRandomMax = 0x64C; // Vector +} + +namespace CParticleVisibilityInputs { + constexpr std::ptrdiff_t m_flCameraBias = 0x0; // float + constexpr std::ptrdiff_t m_nCPin = 0x4; // int32_t + constexpr std::ptrdiff_t m_flProxyRadius = 0x8; // float + constexpr std::ptrdiff_t m_flInputMin = 0xC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x10; // float + constexpr std::ptrdiff_t m_flNoPixelVisibilityFallback = 0x14; // float + constexpr std::ptrdiff_t m_flDistanceInputMin = 0x18; // float + constexpr std::ptrdiff_t m_flDistanceInputMax = 0x1C; // float + constexpr std::ptrdiff_t m_flDotInputMin = 0x20; // float + constexpr std::ptrdiff_t m_flDotInputMax = 0x24; // float + constexpr std::ptrdiff_t m_bDotCPAngles = 0x28; // bool + constexpr std::ptrdiff_t m_bDotCameraAngles = 0x29; // bool + constexpr std::ptrdiff_t m_flAlphaScaleMin = 0x2C; // float + constexpr std::ptrdiff_t m_flAlphaScaleMax = 0x30; // float + constexpr std::ptrdiff_t m_flRadiusScaleMin = 0x34; // float + constexpr std::ptrdiff_t m_flRadiusScaleMax = 0x38; // float + constexpr std::ptrdiff_t m_flRadiusScaleFOVBase = 0x3C; // float + constexpr std::ptrdiff_t m_bRightEye = 0x40; // bool +} + +namespace CPathParameters { + constexpr std::ptrdiff_t m_nStartControlPointNumber = 0x0; // int32_t + constexpr std::ptrdiff_t m_nEndControlPointNumber = 0x4; // int32_t + constexpr std::ptrdiff_t m_nBulgeControl = 0x8; // int32_t + constexpr std::ptrdiff_t m_flBulge = 0xC; // float + constexpr std::ptrdiff_t m_flMidPoint = 0x10; // float + constexpr std::ptrdiff_t m_vStartPointOffset = 0x14; // Vector + constexpr std::ptrdiff_t m_vMidPointOffset = 0x20; // Vector + constexpr std::ptrdiff_t m_vEndOffset = 0x2C; // Vector +} + +namespace CPerParticleFloatInput { // CParticleFloatInput +} + +namespace CPerParticleVecInput { // CParticleVecInput +} + +namespace CRandomNumberGeneratorParameters { + constexpr std::ptrdiff_t m_bDistributeEvenly = 0x0; // bool + constexpr std::ptrdiff_t m_nSeed = 0x4; // int32_t +} + +namespace CSpinUpdateBase { // CParticleFunctionOperator +} + +namespace C_INIT_AddVectorToVector { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecScale = 0x1C0; // Vector + constexpr std::ptrdiff_t m_nFieldOutput = 0x1CC; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldInput = 0x1D0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vOffsetMin = 0x1D4; // Vector + constexpr std::ptrdiff_t m_vOffsetMax = 0x1E0; // Vector + constexpr std::ptrdiff_t m_randomnessParameters = 0x1EC; // CRandomNumberGeneratorParameters +} + +namespace C_INIT_AgeNoise { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_bAbsVal = 0x1C0; // bool + constexpr std::ptrdiff_t m_bAbsValInv = 0x1C1; // bool + constexpr std::ptrdiff_t m_flOffset = 0x1C4; // float + constexpr std::ptrdiff_t m_flAgeMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flAgeMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flNoiseScale = 0x1D0; // float + constexpr std::ptrdiff_t m_flNoiseScaleLoc = 0x1D4; // float + constexpr std::ptrdiff_t m_vecOffsetLoc = 0x1D8; // Vector +} + +namespace C_INIT_ChaoticAttractor { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flAParm = 0x1C0; // float + constexpr std::ptrdiff_t m_flBParm = 0x1C4; // float + constexpr std::ptrdiff_t m_flCParm = 0x1C8; // float + constexpr std::ptrdiff_t m_flDParm = 0x1CC; // float + constexpr std::ptrdiff_t m_flScale = 0x1D0; // float + constexpr std::ptrdiff_t m_flSpeedMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flSpeedMax = 0x1D8; // float + constexpr std::ptrdiff_t m_nBaseCP = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_bUniformSpeed = 0x1E0; // bool +} + +namespace C_INIT_ColorLitPerParticle { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_ColorMin = 0x1D8; // Color + constexpr std::ptrdiff_t m_ColorMax = 0x1DC; // Color + constexpr std::ptrdiff_t m_TintMin = 0x1E0; // Color + constexpr std::ptrdiff_t m_TintMax = 0x1E4; // Color + constexpr std::ptrdiff_t m_flTintPerc = 0x1E8; // float + constexpr std::ptrdiff_t m_nTintBlendMode = 0x1EC; // ParticleColorBlendMode_t + constexpr std::ptrdiff_t m_flLightAmplification = 0x1F0; // float +} + +namespace C_INIT_CreateAlongPath { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_fMaxDistance = 0x1C0; // float + constexpr std::ptrdiff_t m_PathParams = 0x1D0; // CPathParameters + constexpr std::ptrdiff_t m_bUseRandomCPs = 0x210; // bool + constexpr std::ptrdiff_t m_vEndOffset = 0x214; // Vector + constexpr std::ptrdiff_t m_bSaveOffset = 0x220; // bool +} + +namespace C_INIT_CreateFromCPs { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nIncrement = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nMinCP = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nMaxCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nDynamicCPCount = 0x1D0; // CParticleCollectionFloatInput +} + +namespace C_INIT_CreateFromParentParticles { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flVelocityScale = 0x1C0; // float + constexpr std::ptrdiff_t m_flIncrement = 0x1C4; // float + constexpr std::ptrdiff_t m_bRandomDistribution = 0x1C8; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_bSubFrame = 0x1D0; // bool +} + +namespace C_INIT_CreateFromPlaneCache { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecOffsetMin = 0x1C0; // Vector + constexpr std::ptrdiff_t m_vecOffsetMax = 0x1CC; // Vector + constexpr std::ptrdiff_t m_bUseNormal = 0x1D9; // bool +} + +namespace C_INIT_CreateInEpitrochoid { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nComponent1 = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nComponent2 = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_TransformInput = 0x1C8; // CParticleTransformInput + constexpr std::ptrdiff_t m_flParticleDensity = 0x230; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOffset = 0x388; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRadius1 = 0x4E0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRadius2 = 0x638; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bUseCount = 0x790; // bool + constexpr std::ptrdiff_t m_bUseLocalCoords = 0x791; // bool + constexpr std::ptrdiff_t m_bOffsetExistingPos = 0x792; // bool +} + +namespace C_INIT_CreateOnGrid { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nXCount = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nYCount = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nZCount = 0x470; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nXSpacing = 0x5C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nYSpacing = 0x720; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nZSpacing = 0x878; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nControlPointNumber = 0x9D0; // int32_t + constexpr std::ptrdiff_t m_bLocalSpace = 0x9D4; // bool + constexpr std::ptrdiff_t m_bCenter = 0x9D5; // bool + constexpr std::ptrdiff_t m_bHollow = 0x9D6; // bool +} + +namespace C_INIT_CreateOnModel { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_modelInput = 0x1C0; // CParticleModelInput + constexpr std::ptrdiff_t m_transformInput = 0x220; // CParticleTransformInput + constexpr std::ptrdiff_t m_nForceInModel = 0x288; // int32_t + constexpr std::ptrdiff_t m_nDesiredHitbox = 0x28C; // int32_t + constexpr std::ptrdiff_t m_nHitboxValueFromControlPointIndex = 0x290; // int32_t + constexpr std::ptrdiff_t m_vecHitBoxScale = 0x298; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_flBoneVelocity = 0x8F0; // float + constexpr std::ptrdiff_t m_flMaxBoneVelocity = 0x8F4; // float + constexpr std::ptrdiff_t m_vecDirectionBias = 0x8F8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_HitboxSetName = 0xF50; // char[128] + constexpr std::ptrdiff_t m_bLocalCoords = 0xFD0; // bool + constexpr std::ptrdiff_t m_bUseBones = 0xFD1; // bool + constexpr std::ptrdiff_t m_flShellSize = 0xFD8; // CParticleCollectionFloatInput +} + +namespace C_INIT_CreateOnModelAtHeight { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_bUseBones = 0x1C0; // bool + constexpr std::ptrdiff_t m_bForceZ = 0x1C1; // bool + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nHeightCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_bUseWaterHeight = 0x1CC; // bool + constexpr std::ptrdiff_t m_flDesiredHeight = 0x1D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_vecHitBoxScale = 0x328; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_vecDirectionBias = 0x980; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nBiasType = 0xFD8; // ParticleHitboxBiasType_t + constexpr std::ptrdiff_t m_bLocalCoords = 0xFDC; // bool + constexpr std::ptrdiff_t m_bPreferMovingBoxes = 0xFDD; // bool + constexpr std::ptrdiff_t m_HitboxSetName = 0xFDE; // char[128] + constexpr std::ptrdiff_t m_flHitboxVelocityScale = 0x1060; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flMaxBoneVelocity = 0x11B8; // CParticleCollectionFloatInput +} + +namespace C_INIT_CreateParticleImpulse { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_InputRadius = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_InputMagnitude = 0x318; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nFalloffFunction = 0x470; // ParticleFalloffFunction_t + constexpr std::ptrdiff_t m_InputFalloffExp = 0x478; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nImpulseType = 0x5D0; // ParticleImpulseType_t +} + +namespace C_INIT_CreatePhyllotaxis { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nScaleCP = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nComponent = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_fRadCentCore = 0x1CC; // float + constexpr std::ptrdiff_t m_fRadPerPoint = 0x1D0; // float + constexpr std::ptrdiff_t m_fRadPerPointTo = 0x1D4; // float + constexpr std::ptrdiff_t m_fpointAngle = 0x1D8; // float + constexpr std::ptrdiff_t m_fsizeOverall = 0x1DC; // float + constexpr std::ptrdiff_t m_fRadBias = 0x1E0; // float + constexpr std::ptrdiff_t m_fMinRad = 0x1E4; // float + constexpr std::ptrdiff_t m_fDistBias = 0x1E8; // float + constexpr std::ptrdiff_t m_bUseLocalCoords = 0x1EC; // bool + constexpr std::ptrdiff_t m_bUseWithContEmit = 0x1ED; // bool + constexpr std::ptrdiff_t m_bUseOrigRadius = 0x1EE; // bool +} + +namespace C_INIT_CreateSequentialPath { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_fMaxDistance = 0x1C0; // float + constexpr std::ptrdiff_t m_flNumToAssign = 0x1C4; // float + constexpr std::ptrdiff_t m_bLoop = 0x1C8; // bool + constexpr std::ptrdiff_t m_bCPPairs = 0x1C9; // bool + constexpr std::ptrdiff_t m_bSaveOffset = 0x1CA; // bool + constexpr std::ptrdiff_t m_PathParams = 0x1D0; // CPathParameters +} + +namespace C_INIT_CreateSequentialPathV2 { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_fMaxDistance = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flNumToAssign = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bLoop = 0x470; // bool + constexpr std::ptrdiff_t m_bCPPairs = 0x471; // bool + constexpr std::ptrdiff_t m_bSaveOffset = 0x472; // bool + constexpr std::ptrdiff_t m_PathParams = 0x480; // CPathParameters +} + +namespace C_INIT_CreateSpiralSphere { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nOverrideCP = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nDensity = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_flInitialRadius = 0x1CC; // float + constexpr std::ptrdiff_t m_flInitialSpeedMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flInitialSpeedMax = 0x1D4; // float + constexpr std::ptrdiff_t m_bUseParticleCount = 0x1D8; // bool +} + +namespace C_INIT_CreateWithinBox { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecMin = 0x1C0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecMax = 0x818; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nControlPointNumber = 0xE70; // int32_t + constexpr std::ptrdiff_t m_bLocalSpace = 0xE74; // bool + constexpr std::ptrdiff_t m_randomnessParameters = 0xE78; // CRandomNumberGeneratorParameters +} + +namespace C_INIT_CreateWithinSphereTransform { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_fRadiusMin = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_fRadiusMax = 0x318; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecDistanceBias = 0x470; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecDistanceBiasAbs = 0xAC8; // Vector + constexpr std::ptrdiff_t m_TransformInput = 0xAD8; // CParticleTransformInput + constexpr std::ptrdiff_t m_fSpeedMin = 0xB40; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_fSpeedMax = 0xC98; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_fSpeedRandExp = 0xDF0; // float + constexpr std::ptrdiff_t m_bLocalCoords = 0xDF4; // bool + constexpr std::ptrdiff_t m_flEndCPGrowthTime = 0xDF8; // float + constexpr std::ptrdiff_t m_LocalCoordinateSystemSpeedMin = 0xE00; // CPerParticleVecInput + constexpr std::ptrdiff_t m_LocalCoordinateSystemSpeedMax = 0x1458; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nFieldOutput = 0x1AB0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldVelocity = 0x1AB4; // ParticleAttributeIndex_t +} + +namespace C_INIT_CreationNoise { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bAbsVal = 0x1C4; // bool + constexpr std::ptrdiff_t m_bAbsValInv = 0x1C5; // bool + constexpr std::ptrdiff_t m_flOffset = 0x1C8; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_flNoiseScale = 0x1D4; // float + constexpr std::ptrdiff_t m_flNoiseScaleLoc = 0x1D8; // float + constexpr std::ptrdiff_t m_vecOffsetLoc = 0x1DC; // Vector + constexpr std::ptrdiff_t m_flWorldTimeScale = 0x1E8; // float +} + +namespace C_INIT_DistanceCull { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPoint = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flDistance = 0x1C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bCullInside = 0x320; // bool +} + +namespace C_INIT_DistanceToCPInit { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0x320; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x478; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x5D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nStartCP = 0x728; // int32_t + constexpr std::ptrdiff_t m_bLOS = 0x72C; // bool + constexpr std::ptrdiff_t m_CollisionGroupName = 0x72D; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x7B0; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x7B8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flLOSScale = 0x910; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x914; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x918; // bool + constexpr std::ptrdiff_t m_vecDistanceScale = 0x91C; // Vector + constexpr std::ptrdiff_t m_flRemapBias = 0x928; // float +} + +namespace C_INIT_DistanceToNeighborCull { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flDistance = 0x1C0; // CPerParticleFloatInput +} + +namespace C_INIT_GlobalScale { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nScaleControlPointNumber = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_bScaleRadius = 0x1CC; // bool + constexpr std::ptrdiff_t m_bScalePosition = 0x1CD; // bool + constexpr std::ptrdiff_t m_bScaleVelocity = 0x1CE; // bool +} + +namespace C_INIT_InheritFromParentParticles { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nIncrement = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_bRandomDistribution = 0x1CC; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0x1D0; // int32_t +} + +namespace C_INIT_InheritVelocity { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flVelocityScale = 0x1C4; // float +} + +namespace C_INIT_InitFloat { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0x318; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0x31C; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_InputStrength = 0x320; // CPerParticleFloatInput +} + +namespace C_INIT_InitFloatCollection { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0x318; // ParticleAttributeIndex_t +} + +namespace C_INIT_InitFromCPSnapshot { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nAttributeToRead = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nAttributeToWrite = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nLocalSpaceCP = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_bRandom = 0x1D0; // bool + constexpr std::ptrdiff_t m_bReverse = 0x1D1; // bool + constexpr std::ptrdiff_t m_nSnapShotIncrement = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nManualSnapshotIndex = 0x330; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nRandomSeed = 0x488; // int32_t + constexpr std::ptrdiff_t m_bLocalSpaceAngles = 0x48C; // bool +} + +namespace C_INIT_InitFromParentKilled { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nAttributeToCopy = 0x1C0; // ParticleAttributeIndex_t +} + +namespace C_INIT_InitFromVectorFieldSnapshot { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nLocalSpaceCP = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nWeightUpdateCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_bUseVerticalVelocity = 0x1CC; // bool + constexpr std::ptrdiff_t m_vecScale = 0x1D0; // CPerParticleVecInput +} + +namespace C_INIT_InitSkinnedPositionFromCPSnapshot { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nSnapshotControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_bRandom = 0x1C8; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_bRigid = 0x1D0; // bool + constexpr std::ptrdiff_t m_bSetNormal = 0x1D1; // bool + constexpr std::ptrdiff_t m_bIgnoreDt = 0x1D2; // bool + constexpr std::ptrdiff_t m_flMinNormalVelocity = 0x1D4; // float + constexpr std::ptrdiff_t m_flMaxNormalVelocity = 0x1D8; // float + constexpr std::ptrdiff_t m_flIncrement = 0x1DC; // float + constexpr std::ptrdiff_t m_nFullLoopIncrement = 0x1E0; // int32_t + constexpr std::ptrdiff_t m_nSnapShotStartPoint = 0x1E4; // int32_t + constexpr std::ptrdiff_t m_flBoneVelocity = 0x1E8; // float + constexpr std::ptrdiff_t m_flBoneVelocityMax = 0x1EC; // float + constexpr std::ptrdiff_t m_bCopyColor = 0x1F0; // bool + constexpr std::ptrdiff_t m_bCopyAlpha = 0x1F1; // bool + constexpr std::ptrdiff_t m_bSetRadius = 0x1F2; // bool +} + +namespace C_INIT_InitVec { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nOutputField = 0x818; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0x81C; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bNormalizedOutput = 0x820; // bool + constexpr std::ptrdiff_t m_bWritePreviousPosition = 0x821; // bool +} + +namespace C_INIT_InitVecCollection { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nOutputField = 0x818; // ParticleAttributeIndex_t +} + +namespace C_INIT_InitialRepulsionVelocity { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_CollisionGroupName = 0x1C0; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x240; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_vecOutputMin = 0x244; // Vector + constexpr std::ptrdiff_t m_vecOutputMax = 0x250; // Vector + constexpr std::ptrdiff_t m_nControlPointNumber = 0x25C; // int32_t + constexpr std::ptrdiff_t m_bPerParticle = 0x260; // bool + constexpr std::ptrdiff_t m_bTranslate = 0x261; // bool + constexpr std::ptrdiff_t m_bProportional = 0x262; // bool + constexpr std::ptrdiff_t m_flTraceLength = 0x264; // float + constexpr std::ptrdiff_t m_bPerParticleTR = 0x268; // bool + constexpr std::ptrdiff_t m_bInherit = 0x269; // bool + constexpr std::ptrdiff_t m_nChildCP = 0x26C; // int32_t + constexpr std::ptrdiff_t m_nChildGroupID = 0x270; // int32_t +} + +namespace C_INIT_InitialSequenceFromModel { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutputAnim = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1DC; // ParticleSetMethod_t +} + +namespace C_INIT_InitialVelocityFromHitbox { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flVelocityMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flVelocityMax = 0x1C4; // float + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_HitboxSetName = 0x1CC; // char[128] + constexpr std::ptrdiff_t m_bUseBones = 0x24C; // bool +} + +namespace C_INIT_InitialVelocityNoise { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecAbsVal = 0x1C0; // Vector + constexpr std::ptrdiff_t m_vecAbsValInv = 0x1CC; // Vector + constexpr std::ptrdiff_t m_vecOffsetLoc = 0x1D8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_flOffset = 0x830; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecOutputMin = 0x988; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecOutputMax = 0xFE0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_flNoiseScale = 0x1638; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flNoiseScaleLoc = 0x1790; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_TransformInput = 0x18E8; // CParticleTransformInput + constexpr std::ptrdiff_t m_bIgnoreDt = 0x1950; // bool +} + +namespace C_INIT_LifespanFromVelocity { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecComponentScale = 0x1C0; // Vector + constexpr std::ptrdiff_t m_flTraceOffset = 0x1CC; // float + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x1D0; // float + constexpr std::ptrdiff_t m_flTraceTolerance = 0x1D4; // float + constexpr std::ptrdiff_t m_nMaxPlanes = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_CollisionGroupName = 0x1E0; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x260; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_bIncludeWater = 0x270; // bool +} + +namespace C_INIT_ModelCull { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_bBoundBox = 0x1C4; // bool + constexpr std::ptrdiff_t m_bCullOutside = 0x1C5; // bool + constexpr std::ptrdiff_t m_bUseBones = 0x1C6; // bool + constexpr std::ptrdiff_t m_HitboxSetName = 0x1C7; // char[128] +} + +namespace C_INIT_MoveBetweenPoints { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flSpeedMin = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flSpeedMax = 0x318; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flEndSpread = 0x470; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flStartOffset = 0x5C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flEndOffset = 0x720; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nEndControlPointNumber = 0x878; // int32_t + constexpr std::ptrdiff_t m_bTrailBias = 0x87C; // bool +} + +namespace C_INIT_NormalAlignToCP { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_transformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_nControlPointAxis = 0x228; // ParticleControlPointAxis_t +} + +namespace C_INIT_NormalOffset { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_OffsetMin = 0x1C0; // Vector + constexpr std::ptrdiff_t m_OffsetMax = 0x1CC; // Vector + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_bLocalCoords = 0x1DC; // bool + constexpr std::ptrdiff_t m_bNormalize = 0x1DD; // bool +} + +namespace C_INIT_OffsetVectorToVector { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecOutputMin = 0x1C8; // Vector + constexpr std::ptrdiff_t m_vecOutputMax = 0x1D4; // Vector + constexpr std::ptrdiff_t m_randomnessParameters = 0x1E0; // CRandomNumberGeneratorParameters +} + +namespace C_INIT_Orient2DRelToCP { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nCP = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flRotOffset = 0x1C8; // float +} + +namespace C_INIT_PlaneCull { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPoint = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flDistance = 0x1C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bCullInside = 0x320; // bool +} + +namespace C_INIT_PointList { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_pointList = 0x1C8; // CUtlVector + constexpr std::ptrdiff_t m_bPlaceAlongPath = 0x1E0; // bool + constexpr std::ptrdiff_t m_bClosedLoop = 0x1E1; // bool + constexpr std::ptrdiff_t m_nNumPointsAlongPath = 0x1E4; // int32_t +} + +namespace C_INIT_PositionOffset { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_OffsetMin = 0x1C0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_OffsetMax = 0x818; // CPerParticleVecInput + constexpr std::ptrdiff_t m_TransformInput = 0xE70; // CParticleTransformInput + constexpr std::ptrdiff_t m_bLocalCoords = 0xED8; // bool + constexpr std::ptrdiff_t m_bProportional = 0xED9; // bool + constexpr std::ptrdiff_t m_randomnessParameters = 0xEDC; // CRandomNumberGeneratorParameters +} + +namespace C_INIT_PositionOffsetToCP { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumberStart = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nControlPointNumberEnd = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_bLocalCoords = 0x1C8; // bool +} + +namespace C_INIT_PositionPlaceOnGround { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flOffset = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x318; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_CollisionGroupName = 0x470; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x4F0; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_nTraceMissBehavior = 0x500; // ParticleTraceMissBehavior_t + constexpr std::ptrdiff_t m_bIncludeWater = 0x504; // bool + constexpr std::ptrdiff_t m_bSetNormal = 0x505; // bool + constexpr std::ptrdiff_t m_bSetPXYZOnly = 0x506; // bool + constexpr std::ptrdiff_t m_bTraceAlongNormal = 0x507; // bool + constexpr std::ptrdiff_t m_bOffsetonColOnly = 0x508; // bool + constexpr std::ptrdiff_t m_flOffsetByRadiusFactor = 0x50C; // float + constexpr std::ptrdiff_t m_nPreserveOffsetCP = 0x510; // int32_t + constexpr std::ptrdiff_t m_nIgnoreCP = 0x514; // int32_t +} + +namespace C_INIT_PositionWarp { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecWarpMin = 0x1C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_vecWarpMax = 0x818; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nScaleControlPointNumber = 0xE70; // int32_t + constexpr std::ptrdiff_t m_nControlPointNumber = 0xE74; // int32_t + constexpr std::ptrdiff_t m_nRadiusComponent = 0xE78; // int32_t + constexpr std::ptrdiff_t m_flWarpTime = 0xE7C; // float + constexpr std::ptrdiff_t m_flWarpStartTime = 0xE80; // float + constexpr std::ptrdiff_t m_flPrevPosScale = 0xE84; // float + constexpr std::ptrdiff_t m_bInvertWarp = 0xE88; // bool + constexpr std::ptrdiff_t m_bUseCount = 0xE89; // bool +} + +namespace C_INIT_PositionWarpScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecWarpMin = 0x1C0; // Vector + constexpr std::ptrdiff_t m_vecWarpMax = 0x1CC; // Vector + constexpr std::ptrdiff_t m_InputValue = 0x1D8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flPrevPosScale = 0x330; // float + constexpr std::ptrdiff_t m_nScaleControlPointNumber = 0x334; // int32_t + constexpr std::ptrdiff_t m_nControlPointNumber = 0x338; // int32_t +} + +namespace C_INIT_QuantizeFloat { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0x318; // ParticleAttributeIndex_t +} + +namespace C_INIT_RadiusFromCPObject { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPoint = 0x1C0; // int32_t +} + +namespace C_INIT_RandomAlpha { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nAlphaMin = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nAlphaMax = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_flAlphaRandExponent = 0x1D4; // float +} + +namespace C_INIT_RandomAlphaWindowThreshold { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flExponent = 0x1C8; // float +} + +namespace C_INIT_RandomColor { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_ColorMin = 0x1DC; // Color + constexpr std::ptrdiff_t m_ColorMax = 0x1E0; // Color + constexpr std::ptrdiff_t m_TintMin = 0x1E4; // Color + constexpr std::ptrdiff_t m_TintMax = 0x1E8; // Color + constexpr std::ptrdiff_t m_flTintPerc = 0x1EC; // float + constexpr std::ptrdiff_t m_flUpdateThreshold = 0x1F0; // float + constexpr std::ptrdiff_t m_nTintCP = 0x1F4; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1F8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nTintBlendMode = 0x1FC; // ParticleColorBlendMode_t + constexpr std::ptrdiff_t m_flLightAmplification = 0x200; // float +} + +namespace C_INIT_RandomLifeTime { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_fLifetimeMin = 0x1C0; // float + constexpr std::ptrdiff_t m_fLifetimeMax = 0x1C4; // float + constexpr std::ptrdiff_t m_fLifetimeRandExponent = 0x1C8; // float +} + +namespace C_INIT_RandomModelSequence { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_ActivityName = 0x1C0; // char[256] + constexpr std::ptrdiff_t m_SequenceName = 0x2C0; // char[256] + constexpr std::ptrdiff_t m_hModel = 0x3C0; // CStrongHandle +} + +namespace C_INIT_RandomNamedModelBodyPart { // C_INIT_RandomNamedModelElement +} + +namespace C_INIT_RandomNamedModelElement { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_hModel = 0x1C0; // CStrongHandle + constexpr std::ptrdiff_t m_names = 0x1C8; // CUtlVector + constexpr std::ptrdiff_t m_bShuffle = 0x1E0; // bool + constexpr std::ptrdiff_t m_bLinear = 0x1E1; // bool + constexpr std::ptrdiff_t m_bModelFromRenderer = 0x1E2; // bool + constexpr std::ptrdiff_t m_nFieldOutput = 0x1E4; // ParticleAttributeIndex_t +} + +namespace C_INIT_RandomNamedModelMeshGroup { // C_INIT_RandomNamedModelElement +} + +namespace C_INIT_RandomNamedModelSequence { // C_INIT_RandomNamedModelElement +} + +namespace C_INIT_RandomRadius { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flRadiusMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flRadiusMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flRadiusRandExponent = 0x1C8; // float +} + +namespace C_INIT_RandomRotation { // CGeneralRandomRotation +} + +namespace C_INIT_RandomRotationSpeed { // CGeneralRandomRotation +} + +namespace C_INIT_RandomScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flExponent = 0x1C8; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1CC; // ParticleAttributeIndex_t +} + +namespace C_INIT_RandomSecondSequence { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nSequenceMin = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nSequenceMax = 0x1C4; // int32_t +} + +namespace C_INIT_RandomSequence { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nSequenceMin = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nSequenceMax = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_bShuffle = 0x1C8; // bool + constexpr std::ptrdiff_t m_bLinear = 0x1C9; // bool + constexpr std::ptrdiff_t m_WeightedList = 0x1D0; // CUtlVector +} + +namespace C_INIT_RandomTrailLength { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flMinLength = 0x1C0; // float + constexpr std::ptrdiff_t m_flMaxLength = 0x1C4; // float + constexpr std::ptrdiff_t m_flLengthRandExponent = 0x1C8; // float +} + +namespace C_INIT_RandomVector { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecMin = 0x1C0; // Vector + constexpr std::ptrdiff_t m_vecMax = 0x1CC; // Vector + constexpr std::ptrdiff_t m_nFieldOutput = 0x1D8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_randomnessParameters = 0x1DC; // CRandomNumberGeneratorParameters +} + +namespace C_INIT_RandomVectorComponent { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flMax = 0x1C4; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nComponent = 0x1CC; // int32_t +} + +namespace C_INIT_RandomYaw { // CGeneralRandomRotation +} + +namespace C_INIT_RandomYawFlip { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flPercent = 0x1C0; // float +} + +namespace C_INIT_RemapCPtoScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nCPInput = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nField = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_flStartTime = 0x1DC; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1E0; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1E4; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_flRemapBias = 0x1E8; // float +} + +namespace C_INIT_RemapInitialDirectionToTransformToVector { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_nFieldOutput = 0x228; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0x22C; // float + constexpr std::ptrdiff_t m_flOffsetRot = 0x230; // float + constexpr std::ptrdiff_t m_vecOffsetAxis = 0x234; // Vector + constexpr std::ptrdiff_t m_bNormalize = 0x240; // bool +} + +namespace C_INIT_RemapInitialTransformDirectionToRotation { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_nFieldOutput = 0x228; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOffsetRot = 0x22C; // float + constexpr std::ptrdiff_t m_nComponent = 0x230; // int32_t +} + +namespace C_INIT_RemapInitialVisibilityScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D4; // float +} + +namespace C_INIT_RemapNamedModelBodyPartToScalar { // C_INIT_RemapNamedModelElementToScalar +} + +namespace C_INIT_RemapNamedModelElementToScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_hModel = 0x1C0; // CStrongHandle + constexpr std::ptrdiff_t m_names = 0x1C8; // CUtlVector + constexpr std::ptrdiff_t m_values = 0x1E0; // CUtlVector + constexpr std::ptrdiff_t m_nFieldInput = 0x1F8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1FC; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0x200; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bModelFromRenderer = 0x204; // bool +} + +namespace C_INIT_RemapNamedModelMeshGroupToScalar { // C_INIT_RemapNamedModelElementToScalar +} + +namespace C_INIT_RemapNamedModelSequenceToScalar { // C_INIT_RemapNamedModelElementToScalar +} + +namespace C_INIT_RemapParticleCountToNamedModelBodyPartScalar { // C_INIT_RemapParticleCountToNamedModelElementScalar +} + +namespace C_INIT_RemapParticleCountToNamedModelElementScalar { // C_INIT_RemapParticleCountToScalar + constexpr std::ptrdiff_t m_hModel = 0x1F0; // CStrongHandle + constexpr std::ptrdiff_t m_outputMinName = 0x1F8; // CUtlString + constexpr std::ptrdiff_t m_outputMaxName = 0x200; // CUtlString + constexpr std::ptrdiff_t m_bModelFromRenderer = 0x208; // bool +} + +namespace C_INIT_RemapParticleCountToNamedModelMeshGroupScalar { // C_INIT_RemapParticleCountToNamedModelElementScalar +} + +namespace C_INIT_RemapParticleCountToNamedModelSequenceScalar { // C_INIT_RemapParticleCountToNamedModelElementScalar +} + +namespace C_INIT_RemapParticleCountToScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nInputMin = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nInputMax = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nScaleControlPoint = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_nScaleControlPointField = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_flOutputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1DC; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x1E0; // bool + constexpr std::ptrdiff_t m_bInvert = 0x1E1; // bool + constexpr std::ptrdiff_t m_bWrap = 0x1E2; // bool + constexpr std::ptrdiff_t m_flRemapBias = 0x1E4; // float +} + +namespace C_INIT_RemapQAnglesToRotation { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput +} + +namespace C_INIT_RemapScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D4; // float + constexpr std::ptrdiff_t m_flStartTime = 0x1D8; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1DC; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1E0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x1E4; // bool + constexpr std::ptrdiff_t m_flRemapBias = 0x1E8; // float +} + +namespace C_INIT_RemapScalarToVector { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1CC; // float + constexpr std::ptrdiff_t m_vecOutputMin = 0x1D0; // Vector + constexpr std::ptrdiff_t m_vecOutputMax = 0x1DC; // Vector + constexpr std::ptrdiff_t m_flStartTime = 0x1E8; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1EC; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1F0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1F4; // int32_t + constexpr std::ptrdiff_t m_bLocalCoords = 0x1F8; // bool + constexpr std::ptrdiff_t m_flRemapBias = 0x1FC; // float +} + +namespace C_INIT_RemapSpeedToScalar { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_flStartTime = 0x1C8; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1CC; // float + constexpr std::ptrdiff_t m_flInputMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D8; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1DC; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1E0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bPerParticle = 0x1E4; // bool +} + +namespace C_INIT_RemapTransformOrientationToRotations { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_vecRotation = 0x228; // Vector + constexpr std::ptrdiff_t m_bUseQuat = 0x234; // bool + constexpr std::ptrdiff_t m_bWriteNormal = 0x235; // bool +} + +namespace C_INIT_RemapTransformToVector { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vInputMin = 0x1C4; // Vector + constexpr std::ptrdiff_t m_vInputMax = 0x1D0; // Vector + constexpr std::ptrdiff_t m_vOutputMin = 0x1DC; // Vector + constexpr std::ptrdiff_t m_vOutputMax = 0x1E8; // Vector + constexpr std::ptrdiff_t m_TransformInput = 0x1F8; // CParticleTransformInput + constexpr std::ptrdiff_t m_LocalSpaceTransform = 0x260; // CParticleTransformInput + constexpr std::ptrdiff_t m_flStartTime = 0x2C8; // float + constexpr std::ptrdiff_t m_flEndTime = 0x2CC; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x2D0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bOffset = 0x2D4; // bool + constexpr std::ptrdiff_t m_bAccelerate = 0x2D5; // bool + constexpr std::ptrdiff_t m_flRemapBias = 0x2D8; // float +} + +namespace C_INIT_RingWave { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_flParticlesPerOrbit = 0x228; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInitialRadius = 0x380; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flThickness = 0x4D8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInitialSpeedMin = 0x630; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInitialSpeedMax = 0x788; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRoll = 0x8E0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flPitch = 0xA38; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flYaw = 0xB90; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bEvenDistribution = 0xCE8; // bool + constexpr std::ptrdiff_t m_bXYVelocityOnly = 0xCE9; // bool +} + +namespace C_INIT_RtEnvCull { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecTestDir = 0x1C0; // Vector + constexpr std::ptrdiff_t m_vecTestNormal = 0x1CC; // Vector + constexpr std::ptrdiff_t m_bUseVelocity = 0x1D8; // bool + constexpr std::ptrdiff_t m_bCullOnMiss = 0x1D9; // bool + constexpr std::ptrdiff_t m_bLifeAdjust = 0x1DA; // bool + constexpr std::ptrdiff_t m_RtEnvName = 0x1DB; // char[128] + constexpr std::ptrdiff_t m_nRTEnvCP = 0x25C; // int32_t + constexpr std::ptrdiff_t m_nComponent = 0x260; // int32_t +} + +namespace C_INIT_ScaleVelocity { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_vecScale = 0x1C0; // CParticleCollectionVecInput +} + +namespace C_INIT_SequenceFromCP { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_bKillUnused = 0x1C0; // bool + constexpr std::ptrdiff_t m_bRadiusScale = 0x1C1; // bool + constexpr std::ptrdiff_t m_nCP = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_vecOffset = 0x1C8; // Vector +} + +namespace C_INIT_SequenceLifeTime { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flFramerate = 0x1C0; // float +} + +namespace C_INIT_SetHitboxToClosest { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nDesiredHitbox = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_vecHitBoxScale = 0x1C8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_HitboxSetName = 0x820; // char[128] + constexpr std::ptrdiff_t m_bUseBones = 0x8A0; // bool + constexpr std::ptrdiff_t m_bUseClosestPointOnHitbox = 0x8A1; // bool + constexpr std::ptrdiff_t m_nTestType = 0x8A4; // ClosestPointTestType_t + constexpr std::ptrdiff_t m_flHybridRatio = 0x8A8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bUpdatePosition = 0xA00; // bool +} + +namespace C_INIT_SetHitboxToModel { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nForceInModel = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nDesiredHitbox = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_vecHitBoxScale = 0x1D0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_vecDirectionBias = 0x828; // Vector + constexpr std::ptrdiff_t m_bMaintainHitbox = 0x834; // bool + constexpr std::ptrdiff_t m_bUseBones = 0x835; // bool + constexpr std::ptrdiff_t m_HitboxSetName = 0x836; // char[128] + constexpr std::ptrdiff_t m_flShellSize = 0x8B8; // CParticleCollectionFloatInput +} + +namespace C_INIT_SetRigidAttachment { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldInput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bLocalSpace = 0x1CC; // bool +} + +namespace C_INIT_SetVectorAttributeToVectorExpression { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nExpression = 0x1C0; // VectorExpressionType_t + constexpr std::ptrdiff_t m_vInput1 = 0x1C8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vInput2 = 0x820; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nOutputField = 0xE78; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0xE7C; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bNormalizedOutput = 0xE80; // bool +} + +namespace C_INIT_StatusEffect { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nDetail2Combo = 0x1C0; // Detail2Combo_t + constexpr std::ptrdiff_t m_flDetail2Rotation = 0x1C4; // float + constexpr std::ptrdiff_t m_flDetail2Scale = 0x1C8; // float + constexpr std::ptrdiff_t m_flDetail2BlendFactor = 0x1CC; // float + constexpr std::ptrdiff_t m_flColorWarpIntensity = 0x1D0; // float + constexpr std::ptrdiff_t m_flDiffuseWarpBlendToFull = 0x1D4; // float + constexpr std::ptrdiff_t m_flEnvMapIntensity = 0x1D8; // float + constexpr std::ptrdiff_t m_flAmbientScale = 0x1DC; // float + constexpr std::ptrdiff_t m_specularColor = 0x1E0; // Color + constexpr std::ptrdiff_t m_flSpecularScale = 0x1E4; // float + constexpr std::ptrdiff_t m_flSpecularExponent = 0x1E8; // float + constexpr std::ptrdiff_t m_flSpecularExponentBlendToFull = 0x1EC; // float + constexpr std::ptrdiff_t m_flSpecularBlendToFull = 0x1F0; // float + constexpr std::ptrdiff_t m_rimLightColor = 0x1F4; // Color + constexpr std::ptrdiff_t m_flRimLightScale = 0x1F8; // float + constexpr std::ptrdiff_t m_flReflectionsTintByBaseBlendToNone = 0x1FC; // float + constexpr std::ptrdiff_t m_flMetalnessBlendToFull = 0x200; // float + constexpr std::ptrdiff_t m_flSelfIllumBlendToFull = 0x204; // float +} + +namespace C_INIT_StatusEffectCitadel { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_flSFXColorWarpAmount = 0x1C0; // float + constexpr std::ptrdiff_t m_flSFXNormalAmount = 0x1C4; // float + constexpr std::ptrdiff_t m_flSFXMetalnessAmount = 0x1C8; // float + constexpr std::ptrdiff_t m_flSFXRoughnessAmount = 0x1CC; // float + constexpr std::ptrdiff_t m_flSFXSelfIllumAmount = 0x1D0; // float + constexpr std::ptrdiff_t m_flSFXSScale = 0x1D4; // float + constexpr std::ptrdiff_t m_flSFXSScrollX = 0x1D8; // float + constexpr std::ptrdiff_t m_flSFXSScrollY = 0x1DC; // float + constexpr std::ptrdiff_t m_flSFXSScrollZ = 0x1E0; // float + constexpr std::ptrdiff_t m_flSFXSOffsetX = 0x1E4; // float + constexpr std::ptrdiff_t m_flSFXSOffsetY = 0x1E8; // float + constexpr std::ptrdiff_t m_flSFXSOffsetZ = 0x1EC; // float + constexpr std::ptrdiff_t m_nDetailCombo = 0x1F0; // DetailCombo_t + constexpr std::ptrdiff_t m_flSFXSDetailAmount = 0x1F4; // float + constexpr std::ptrdiff_t m_flSFXSDetailScale = 0x1F8; // float + constexpr std::ptrdiff_t m_flSFXSDetailScrollX = 0x1FC; // float + constexpr std::ptrdiff_t m_flSFXSDetailScrollY = 0x200; // float + constexpr std::ptrdiff_t m_flSFXSDetailScrollZ = 0x204; // float + constexpr std::ptrdiff_t m_flSFXSUseModelUVs = 0x208; // float +} + +namespace C_INIT_VelocityFromCP { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_velocityInput = 0x1C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_transformInput = 0x818; // CParticleTransformInput + constexpr std::ptrdiff_t m_flVelocityScale = 0x880; // float + constexpr std::ptrdiff_t m_bDirectionOnly = 0x884; // bool +} + +namespace C_INIT_VelocityFromNormal { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_fSpeedMin = 0x1C0; // float + constexpr std::ptrdiff_t m_fSpeedMax = 0x1C4; // float + constexpr std::ptrdiff_t m_bIgnoreDt = 0x1C8; // bool +} + +namespace C_INIT_VelocityRadialRandom { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_fSpeedMin = 0x1C4; // float + constexpr std::ptrdiff_t m_fSpeedMax = 0x1C8; // float + constexpr std::ptrdiff_t m_vecLocalCoordinateSystemSpeedScale = 0x1CC; // Vector + constexpr std::ptrdiff_t m_bIgnoreDelta = 0x1D9; // bool +} + +namespace C_INIT_VelocityRandom { // CParticleFunctionInitializer + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_fSpeedMin = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_fSpeedMax = 0x320; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_LocalCoordinateSystemSpeedMin = 0x478; // CPerParticleVecInput + constexpr std::ptrdiff_t m_LocalCoordinateSystemSpeedMax = 0xAD0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_bIgnoreDT = 0x1128; // bool + constexpr std::ptrdiff_t m_randomnessParameters = 0x112C; // CRandomNumberGeneratorParameters +} + +namespace C_OP_AlphaDecay { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flMinAlpha = 0x1C0; // float +} + +namespace C_OP_AttractToControlPoint { // CParticleFunctionForce + constexpr std::ptrdiff_t m_vecComponentScale = 0x1D0; // Vector + constexpr std::ptrdiff_t m_fForceAmount = 0x1E0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_fFalloffPower = 0x338; // float + constexpr std::ptrdiff_t m_TransformInput = 0x340; // CParticleTransformInput + constexpr std::ptrdiff_t m_fForceAmountMin = 0x3A8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bApplyMinForce = 0x500; // bool +} + +namespace C_OP_BasicMovement { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_Gravity = 0x1C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_fDrag = 0x818; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nMaxConstraintPasses = 0x970; // int32_t +} + +namespace C_OP_BoxConstraint { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_vecMin = 0x1C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_vecMax = 0x818; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nCP = 0xE70; // int32_t + constexpr std::ptrdiff_t m_bLocalSpace = 0xE74; // bool + constexpr std::ptrdiff_t m_bAccountForRadius = 0xE75; // bool +} + +namespace C_OP_CPOffsetToPercentageBetweenCPs { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flInputMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flInputBias = 0x1C8; // float + constexpr std::ptrdiff_t m_nStartCP = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_nEndCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nOffsetCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nOuputCP = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nInputCP = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_bRadialCheck = 0x1E0; // bool + constexpr std::ptrdiff_t m_bScaleOffset = 0x1E1; // bool + constexpr std::ptrdiff_t m_vecOffset = 0x1E4; // Vector +} + +namespace C_OP_CPVelocityForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_flScale = 0x1D8; // CPerParticleFloatInput +} + +namespace C_OP_CalculateVectorAttribute { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_vStartValue = 0x1C0; // Vector + constexpr std::ptrdiff_t m_nFieldInput1 = 0x1CC; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputScale1 = 0x1D0; // float + constexpr std::ptrdiff_t m_nFieldInput2 = 0x1D4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputScale2 = 0x1D8; // float + constexpr std::ptrdiff_t m_nControlPointInput1 = 0x1DC; // ControlPointReference_t + constexpr std::ptrdiff_t m_flControlPointScale1 = 0x1F0; // float + constexpr std::ptrdiff_t m_nControlPointInput2 = 0x1F4; // ControlPointReference_t + constexpr std::ptrdiff_t m_flControlPointScale2 = 0x208; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x20C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vFinalOutputScale = 0x210; // Vector +} + +namespace C_OP_Callback { // CParticleFunctionRenderer +} + +namespace C_OP_ChladniWave { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0x320; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x478; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x5D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecWaveLength = 0x728; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecHarmonics = 0xD80; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nSetMethod = 0x13D8; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_nLocalSpaceControlPoint = 0x13DC; // int32_t + constexpr std::ptrdiff_t m_b3D = 0x13E0; // bool +} + +namespace C_OP_ChooseRandomChildrenInGroup { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nChildGroupID = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_flNumberOfChildren = 0x1D8; // CParticleCollectionFloatInput +} + +namespace C_OP_ClampScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOutputMin = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x320; // CPerParticleFloatInput +} + +namespace C_OP_ClampVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecOutputMin = 0x1C8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecOutputMax = 0x820; // CPerParticleVecInput +} + +namespace C_OP_CollideWithParentParticles { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_flParentRadiusScale = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRadiusScale = 0x318; // CPerParticleFloatInput +} + +namespace C_OP_CollideWithSelf { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_flRadiusScale = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flMinimumSpeed = 0x318; // CPerParticleFloatInput +} + +namespace C_OP_ColorAdjustHSL { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flHueAdjust = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flSaturationAdjust = 0x318; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flLightnessAdjust = 0x470; // CPerParticleFloatInput +} + +namespace C_OP_ColorInterpolate { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_ColorFade = 0x1C0; // Color + constexpr std::ptrdiff_t m_flFadeStartTime = 0x1D0; // float + constexpr std::ptrdiff_t m_flFadeEndTime = 0x1D4; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1D8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bEaseInOut = 0x1DC; // bool + constexpr std::ptrdiff_t m_bUseNewCode = 0x1DD; // bool +} + +namespace C_OP_ColorInterpolateRandom { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_ColorFadeMin = 0x1C0; // Color + constexpr std::ptrdiff_t m_ColorFadeMax = 0x1DC; // Color + constexpr std::ptrdiff_t m_flFadeStartTime = 0x1EC; // float + constexpr std::ptrdiff_t m_flFadeEndTime = 0x1F0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1F4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bEaseInOut = 0x1F8; // bool +} + +namespace C_OP_ConnectParentParticleToNearest { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFirstControlPoint = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nSecondControlPoint = 0x1C4; // int32_t +} + +namespace C_OP_ConstrainDistance { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_fMinDistance = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_fMaxDistance = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nControlPointNumber = 0x470; // int32_t + constexpr std::ptrdiff_t m_CenterOffset = 0x474; // Vector + constexpr std::ptrdiff_t m_bGlobalCenter = 0x480; // bool +} + +namespace C_OP_ConstrainDistanceToPath { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_fMinDistance = 0x1C0; // float + constexpr std::ptrdiff_t m_flMaxDistance0 = 0x1C4; // float + constexpr std::ptrdiff_t m_flMaxDistanceMid = 0x1C8; // float + constexpr std::ptrdiff_t m_flMaxDistance1 = 0x1CC; // float + constexpr std::ptrdiff_t m_PathParameters = 0x1D0; // CPathParameters + constexpr std::ptrdiff_t m_flTravelTime = 0x210; // float + constexpr std::ptrdiff_t m_nFieldScale = 0x214; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nManualTField = 0x218; // ParticleAttributeIndex_t +} + +namespace C_OP_ConstrainDistanceToUserSpecifiedPath { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_fMinDistance = 0x1C0; // float + constexpr std::ptrdiff_t m_flMaxDistance = 0x1C4; // float + constexpr std::ptrdiff_t m_flTimeScale = 0x1C8; // float + constexpr std::ptrdiff_t m_bLoopedPath = 0x1CC; // bool + constexpr std::ptrdiff_t m_pointList = 0x1D0; // CUtlVector +} + +namespace C_OP_ConstrainLineLength { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_flMinDistance = 0x1C0; // float + constexpr std::ptrdiff_t m_flMaxDistance = 0x1C4; // float +} + +namespace C_OP_ContinuousEmitter { // CParticleFunctionEmitter + constexpr std::ptrdiff_t m_flEmissionDuration = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flStartTime = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flEmitRate = 0x470; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flEmissionScale = 0x5C8; // float + constexpr std::ptrdiff_t m_flScalePerParentParticle = 0x5CC; // float + constexpr std::ptrdiff_t m_bInitFromKilledParentParticles = 0x5D0; // bool + constexpr std::ptrdiff_t m_nSnapshotControlPoint = 0x5D4; // int32_t + constexpr std::ptrdiff_t m_nLimitPerUpdate = 0x5D8; // int32_t + constexpr std::ptrdiff_t m_bForceEmitOnFirstUpdate = 0x5DC; // bool + constexpr std::ptrdiff_t m_bForceEmitOnLastUpdate = 0x5DD; // bool +} + +namespace C_OP_ControlPointToRadialScreenSpace { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCPIn = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_vecCP1Pos = 0x1D4; // Vector + constexpr std::ptrdiff_t m_nCPOut = 0x1E0; // int32_t + constexpr std::ptrdiff_t m_nCPOutField = 0x1E4; // int32_t + constexpr std::ptrdiff_t m_nCPSSPosOut = 0x1E8; // int32_t +} + +namespace C_OP_ControlpointLight { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nControlPoint1 = 0x650; // int32_t + constexpr std::ptrdiff_t m_nControlPoint2 = 0x654; // int32_t + constexpr std::ptrdiff_t m_nControlPoint3 = 0x658; // int32_t + constexpr std::ptrdiff_t m_nControlPoint4 = 0x65C; // int32_t + constexpr std::ptrdiff_t m_vecCPOffset1 = 0x660; // Vector + constexpr std::ptrdiff_t m_vecCPOffset2 = 0x66C; // Vector + constexpr std::ptrdiff_t m_vecCPOffset3 = 0x678; // Vector + constexpr std::ptrdiff_t m_vecCPOffset4 = 0x684; // Vector + constexpr std::ptrdiff_t m_LightFiftyDist1 = 0x690; // float + constexpr std::ptrdiff_t m_LightZeroDist1 = 0x694; // float + constexpr std::ptrdiff_t m_LightFiftyDist2 = 0x698; // float + constexpr std::ptrdiff_t m_LightZeroDist2 = 0x69C; // float + constexpr std::ptrdiff_t m_LightFiftyDist3 = 0x6A0; // float + constexpr std::ptrdiff_t m_LightZeroDist3 = 0x6A4; // float + constexpr std::ptrdiff_t m_LightFiftyDist4 = 0x6A8; // float + constexpr std::ptrdiff_t m_LightZeroDist4 = 0x6AC; // float + constexpr std::ptrdiff_t m_LightColor1 = 0x6B0; // Color + constexpr std::ptrdiff_t m_LightColor2 = 0x6B4; // Color + constexpr std::ptrdiff_t m_LightColor3 = 0x6B8; // Color + constexpr std::ptrdiff_t m_LightColor4 = 0x6BC; // Color + constexpr std::ptrdiff_t m_bLightType1 = 0x6C0; // bool + constexpr std::ptrdiff_t m_bLightType2 = 0x6C1; // bool + constexpr std::ptrdiff_t m_bLightType3 = 0x6C2; // bool + constexpr std::ptrdiff_t m_bLightType4 = 0x6C3; // bool + constexpr std::ptrdiff_t m_bLightDynamic1 = 0x6C4; // bool + constexpr std::ptrdiff_t m_bLightDynamic2 = 0x6C5; // bool + constexpr std::ptrdiff_t m_bLightDynamic3 = 0x6C6; // bool + constexpr std::ptrdiff_t m_bLightDynamic4 = 0x6C7; // bool + constexpr std::ptrdiff_t m_bUseNormal = 0x6C8; // bool + constexpr std::ptrdiff_t m_bUseHLambert = 0x6C9; // bool + constexpr std::ptrdiff_t m_bClampLowerRange = 0x6CE; // bool + constexpr std::ptrdiff_t m_bClampUpperRange = 0x6CF; // bool +} + +namespace C_OP_Cull { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flCullPerc = 0x1C0; // float + constexpr std::ptrdiff_t m_flCullStart = 0x1C4; // float + constexpr std::ptrdiff_t m_flCullEnd = 0x1C8; // float + constexpr std::ptrdiff_t m_flCullExp = 0x1CC; // float +} + +namespace C_OP_CurlNoiseForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_nNoiseType = 0x1D0; // ParticleDirectionNoiseType_t + constexpr std::ptrdiff_t m_vecNoiseFreq = 0x1D8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecNoiseScale = 0x830; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecOffset = 0xE88; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecOffsetRate = 0x14E0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_flWorleySeed = 0x1B38; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flWorleyJitter = 0x1C90; // CPerParticleFloatInput +} + +namespace C_OP_CycleScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nDestField = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flStartValue = 0x1C4; // float + constexpr std::ptrdiff_t m_flEndValue = 0x1C8; // float + constexpr std::ptrdiff_t m_flCycleTime = 0x1CC; // float + constexpr std::ptrdiff_t m_bDoNotRepeatCycle = 0x1D0; // bool + constexpr std::ptrdiff_t m_bSynchronizeParticles = 0x1D1; // bool + constexpr std::ptrdiff_t m_nCPScale = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nCPFieldMin = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nCPFieldMax = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_nSetMethod = 0x1E0; // ParticleSetMethod_t +} + +namespace C_OP_CylindricalDistanceToTransform { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0x320; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x478; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x5D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_TransformStart = 0x728; // CParticleTransformInput + constexpr std::ptrdiff_t m_TransformEnd = 0x790; // CParticleTransformInput + constexpr std::ptrdiff_t m_nSetMethod = 0x7F8; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x7FC; // bool + constexpr std::ptrdiff_t m_bAdditive = 0x7FD; // bool + constexpr std::ptrdiff_t m_bCapsule = 0x7FE; // bool +} + +namespace C_OP_DampenToCP { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flRange = 0x1C4; // float + constexpr std::ptrdiff_t m_flScale = 0x1C8; // float +} + +namespace C_OP_Decay { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_bRopeDecay = 0x1C0; // bool + constexpr std::ptrdiff_t m_bForcePreserveParticleOrder = 0x1C1; // bool +} + +namespace C_OP_DecayClampCount { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCount = 0x1C0; // CParticleCollectionFloatInput +} + +namespace C_OP_DecayMaintainCount { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nParticlesToMaintain = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flDecayDelay = 0x1C4; // float + constexpr std::ptrdiff_t m_nSnapshotControlPoint = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_bLifespanDecay = 0x1CC; // bool + constexpr std::ptrdiff_t m_flScale = 0x1D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bKillNewest = 0x328; // bool +} + +namespace C_OP_DecayOffscreen { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flOffscreenTime = 0x1C0; // CParticleCollectionFloatInput +} + +namespace C_OP_DensityForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flRadiusScale = 0x1D0; // float + constexpr std::ptrdiff_t m_flForceScale = 0x1D4; // float + constexpr std::ptrdiff_t m_flTargetDensity = 0x1D8; // float +} + +namespace C_OP_DifferencePreviousParticle { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D4; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1D8; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x1DC; // bool + constexpr std::ptrdiff_t m_bSetPreviousParticle = 0x1DD; // bool +} + +namespace C_OP_Diffusion { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flRadiusScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nVoxelGridResolution = 0x1C8; // int32_t +} + +namespace C_OP_DirectionBetweenVecsToVec { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecPoint1 = 0x1C8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecPoint2 = 0x820; // CPerParticleVecInput +} + +namespace C_OP_DistanceBetweenCPsToCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nStartCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nEndCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nOutputCP = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nOutputCPField = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_bSetOnce = 0x1E0; // bool + constexpr std::ptrdiff_t m_flInputMin = 0x1E4; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1E8; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1EC; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1F0; // float + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x1F4; // float + constexpr std::ptrdiff_t m_flLOSScale = 0x1F8; // float + constexpr std::ptrdiff_t m_bLOS = 0x1FC; // bool + constexpr std::ptrdiff_t m_CollisionGroupName = 0x1FD; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x280; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_nSetParent = 0x284; // ParticleParentSetMode_t +} + +namespace C_OP_DistanceBetweenTransforms { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_TransformStart = 0x1C8; // CParticleTransformInput + constexpr std::ptrdiff_t m_TransformEnd = 0x230; // CParticleTransformInput + constexpr std::ptrdiff_t m_flInputMin = 0x298; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0x3F0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x548; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x6A0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x7F8; // float + constexpr std::ptrdiff_t m_flLOSScale = 0x7FC; // float + constexpr std::ptrdiff_t m_CollisionGroupName = 0x800; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x880; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_bLOS = 0x884; // bool + constexpr std::ptrdiff_t m_nSetMethod = 0x888; // ParticleSetMethod_t +} + +namespace C_OP_DistanceBetweenVecs { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecPoint1 = 0x1C8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecPoint2 = 0x820; // CPerParticleVecInput + constexpr std::ptrdiff_t m_flInputMin = 0xE78; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0xFD0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x1128; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x1280; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nSetMethod = 0x13D8; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bDeltaTime = 0x13DC; // bool +} + +namespace C_OP_DistanceCull { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPoint = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_vecPointOffset = 0x1C4; // Vector + constexpr std::ptrdiff_t m_flDistance = 0x1D0; // float + constexpr std::ptrdiff_t m_bCullInside = 0x1D4; // bool +} + +namespace C_OP_DistanceToTransform { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0x320; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x478; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x5D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_TransformStart = 0x728; // CParticleTransformInput + constexpr std::ptrdiff_t m_bLOS = 0x790; // bool + constexpr std::ptrdiff_t m_CollisionGroupName = 0x791; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x814; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x818; // float + constexpr std::ptrdiff_t m_flLOSScale = 0x81C; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x820; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x824; // bool + constexpr std::ptrdiff_t m_bAdditive = 0x825; // bool + constexpr std::ptrdiff_t m_vecComponentScale = 0x828; // CPerParticleVecInput +} + +namespace C_OP_DragRelativeToPlane { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flDragAtPlane = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flFalloff = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bDirectional = 0x470; // bool + constexpr std::ptrdiff_t m_vecPlaneNormal = 0x478; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nControlPointNumber = 0xAD0; // int32_t +} + +namespace C_OP_DriveCPFromGlobalSoundFloat { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nOutputControlPoint = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nOutputField = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1D8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1DC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1E0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1E4; // float + constexpr std::ptrdiff_t m_StackName = 0x1E8; // CUtlString + constexpr std::ptrdiff_t m_OperatorName = 0x1F0; // CUtlString + constexpr std::ptrdiff_t m_FieldName = 0x1F8; // CUtlString +} + +namespace C_OP_EnableChildrenFromParentParticleCount { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nChildGroupID = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nFirstChild = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nNumChildrenToEnable = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bDisableChildren = 0x330; // bool + constexpr std::ptrdiff_t m_bPlayEndcapOnStop = 0x331; // bool + constexpr std::ptrdiff_t m_bDestroyImmediately = 0x332; // bool +} + +namespace C_OP_EndCapDecay { // CParticleFunctionOperator +} + +namespace C_OP_EndCapTimedDecay { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flDecayTime = 0x1C0; // float +} + +namespace C_OP_EndCapTimedFreeze { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flFreezeTime = 0x1C0; // CParticleCollectionFloatInput +} + +namespace C_OP_ExternalGameImpulseForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flForceScale = 0x1D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bRopes = 0x328; // bool + constexpr std::ptrdiff_t m_bRopesZOnly = 0x329; // bool + constexpr std::ptrdiff_t m_bExplosions = 0x32A; // bool + constexpr std::ptrdiff_t m_bParticles = 0x32B; // bool +} + +namespace C_OP_ExternalWindForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_vecSamplePosition = 0x1D0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecScale = 0x828; // CPerParticleVecInput + constexpr std::ptrdiff_t m_bSampleWind = 0xE80; // bool + constexpr std::ptrdiff_t m_bSampleWater = 0xE81; // bool + constexpr std::ptrdiff_t m_bDampenNearWaterPlane = 0xE82; // bool + constexpr std::ptrdiff_t m_bSampleGravity = 0xE83; // bool + constexpr std::ptrdiff_t m_vecGravityForce = 0xE88; // CPerParticleVecInput + constexpr std::ptrdiff_t m_bUseBasicMovementGravity = 0x14E0; // bool + constexpr std::ptrdiff_t m_flLocalGravityScale = 0x14E8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flLocalBuoyancyScale = 0x1640; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecBuoyancyForce = 0x1798; // CPerParticleVecInput +} + +namespace C_OP_FadeAndKill { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flStartFadeInTime = 0x1C0; // float + constexpr std::ptrdiff_t m_flEndFadeInTime = 0x1C4; // float + constexpr std::ptrdiff_t m_flStartFadeOutTime = 0x1C8; // float + constexpr std::ptrdiff_t m_flEndFadeOutTime = 0x1CC; // float + constexpr std::ptrdiff_t m_flStartAlpha = 0x1D0; // float + constexpr std::ptrdiff_t m_flEndAlpha = 0x1D4; // float + constexpr std::ptrdiff_t m_bForcePreserveParticleOrder = 0x1D8; // bool +} + +namespace C_OP_FadeAndKillForTracers { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flStartFadeInTime = 0x1C0; // float + constexpr std::ptrdiff_t m_flEndFadeInTime = 0x1C4; // float + constexpr std::ptrdiff_t m_flStartFadeOutTime = 0x1C8; // float + constexpr std::ptrdiff_t m_flEndFadeOutTime = 0x1CC; // float + constexpr std::ptrdiff_t m_flStartAlpha = 0x1D0; // float + constexpr std::ptrdiff_t m_flEndAlpha = 0x1D4; // float +} + +namespace C_OP_FadeIn { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flFadeInTimeMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flFadeInTimeMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flFadeInTimeExp = 0x1C8; // float + constexpr std::ptrdiff_t m_bProportional = 0x1CC; // bool +} + +namespace C_OP_FadeInSimple { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flFadeInTime = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t +} + +namespace C_OP_FadeOut { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flFadeOutTimeMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flFadeOutTimeMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flFadeOutTimeExp = 0x1C8; // float + constexpr std::ptrdiff_t m_flFadeBias = 0x1CC; // float + constexpr std::ptrdiff_t m_bProportional = 0x200; // bool + constexpr std::ptrdiff_t m_bEaseInAndOut = 0x201; // bool +} + +namespace C_OP_FadeOutSimple { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flFadeOutTime = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t +} + +namespace C_OP_ForceBasedOnDistanceToPlane { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flMinDist = 0x1D0; // float + constexpr std::ptrdiff_t m_vecForceAtMinDist = 0x1D4; // Vector + constexpr std::ptrdiff_t m_flMaxDist = 0x1E0; // float + constexpr std::ptrdiff_t m_vecForceAtMaxDist = 0x1E4; // Vector + constexpr std::ptrdiff_t m_vecPlaneNormal = 0x1F0; // Vector + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1FC; // int32_t + constexpr std::ptrdiff_t m_flExponent = 0x200; // float +} + +namespace C_OP_ForceControlPointStub { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_ControlPoint = 0x1D0; // int32_t +} + +namespace C_OP_GlobalLight { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flScale = 0x1C0; // float + constexpr std::ptrdiff_t m_bClampLowerRange = 0x1C4; // bool + constexpr std::ptrdiff_t m_bClampUpperRange = 0x1C5; // bool +} + +namespace C_OP_HSVShiftToCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nColorCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nColorGemEnableCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nOutputCP = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_DefaultHSVColor = 0x1DC; // Color +} + +namespace C_OP_InheritFromParentParticles { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nIncrement = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_bRandomDistribution = 0x1CC; // bool +} + +namespace C_OP_InheritFromParentParticlesV2 { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nIncrement = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_bRandomDistribution = 0x1CC; // bool + constexpr std::ptrdiff_t m_nMissingParentBehavior = 0x1D0; // MissingParentInheritBehavior_t +} + +namespace C_OP_InheritFromPeerSystem { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldInput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nIncrement = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nGroupID = 0x1CC; // int32_t +} + +namespace C_OP_InstantaneousEmitter { // CParticleFunctionEmitter + constexpr std::ptrdiff_t m_nParticlesToEmit = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flStartTime = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInitFromKilledParentParticles = 0x470; // float + constexpr std::ptrdiff_t m_flParentParticleScale = 0x478; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nMaxEmittedPerFrame = 0x5D0; // int32_t + constexpr std::ptrdiff_t m_nSnapshotControlPoint = 0x5D4; // int32_t +} + +namespace C_OP_InterpolateRadius { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flStartTime = 0x1C0; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1C4; // float + constexpr std::ptrdiff_t m_flStartScale = 0x1C8; // float + constexpr std::ptrdiff_t m_flEndScale = 0x1CC; // float + constexpr std::ptrdiff_t m_bEaseInAndOut = 0x1D0; // bool + constexpr std::ptrdiff_t m_flBias = 0x1D4; // float +} + +namespace C_OP_LagCompensation { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nDesiredVelocityCP = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nLatencyCP = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nLatencyCPField = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nDesiredVelocityCPField = 0x1CC; // int32_t +} + +namespace C_OP_LerpEndCapScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOutput = 0x1C4; // float + constexpr std::ptrdiff_t m_flLerpTime = 0x1C8; // float +} + +namespace C_OP_LerpEndCapVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecOutput = 0x1C4; // Vector + constexpr std::ptrdiff_t m_flLerpTime = 0x1D0; // float +} + +namespace C_OP_LerpScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOutput = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flStartTime = 0x320; // float + constexpr std::ptrdiff_t m_flEndTime = 0x324; // float +} + +namespace C_OP_LerpToInitialPosition { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flInterpolation = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nCacheField = 0x320; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0x328; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_vecScale = 0x480; // CParticleCollectionVecInput +} + +namespace C_OP_LerpToOtherAttribute { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flInterpolation = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nFieldInputFrom = 0x318; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldInput = 0x31C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x320; // ParticleAttributeIndex_t +} + +namespace C_OP_LerpVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecOutput = 0x1C4; // Vector + constexpr std::ptrdiff_t m_flStartTime = 0x1D0; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1D4; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1D8; // ParticleSetMethod_t +} + +namespace C_OP_LightningSnapshotGenerator { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCPSnapshot = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPStartPnt = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nCPEndPnt = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_flSegments = 0x1E0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOffset = 0x338; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOffsetDecay = 0x490; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flRecalcRate = 0x5E8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flUVScale = 0x740; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flUVOffset = 0x898; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flSplitRate = 0x9F0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flBranchTwist = 0xB48; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nBranchBehavior = 0xCA0; // ParticleLightnintBranchBehavior_t + constexpr std::ptrdiff_t m_flRadiusStart = 0xCA8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flRadiusEnd = 0xE00; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flDedicatedPool = 0xF58; // CParticleCollectionFloatInput +} + +namespace C_OP_LocalAccelerationForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_nCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nScaleCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_vecAccel = 0x1D8; // CParticleCollectionVecInput +} + +namespace C_OP_LockPoints { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nMinCol = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nMaxCol = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nMinRow = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nMaxRow = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_nControlPoint = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_flBlendValue = 0x1D4; // float +} + +namespace C_OP_LockToBone { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_modelInput = 0x1C0; // CParticleModelInput + constexpr std::ptrdiff_t m_transformInput = 0x220; // CParticleTransformInput + constexpr std::ptrdiff_t m_flLifeTimeFadeStart = 0x288; // float + constexpr std::ptrdiff_t m_flLifeTimeFadeEnd = 0x28C; // float + constexpr std::ptrdiff_t m_flJumpThreshold = 0x290; // float + constexpr std::ptrdiff_t m_flPrevPosScale = 0x294; // float + constexpr std::ptrdiff_t m_HitboxSetName = 0x298; // char[128] + constexpr std::ptrdiff_t m_bRigid = 0x318; // bool + constexpr std::ptrdiff_t m_bUseBones = 0x319; // bool + constexpr std::ptrdiff_t m_nFieldOutput = 0x31C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutputPrev = 0x320; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nRotationSetType = 0x324; // ParticleRotationLockType_t + constexpr std::ptrdiff_t m_bRigidRotationLock = 0x328; // bool + constexpr std::ptrdiff_t m_vecRotation = 0x330; // CPerParticleVecInput + constexpr std::ptrdiff_t m_flRotLerp = 0x988; // CPerParticleFloatInput +} + +namespace C_OP_LockToPointList { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_pointList = 0x1C8; // CUtlVector + constexpr std::ptrdiff_t m_bPlaceAlongPath = 0x1E0; // bool + constexpr std::ptrdiff_t m_bClosedLoop = 0x1E1; // bool + constexpr std::ptrdiff_t m_nNumPointsAlongPath = 0x1E4; // int32_t +} + +namespace C_OP_LockToSavedSequentialPath { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flFadeStart = 0x1C4; // float + constexpr std::ptrdiff_t m_flFadeEnd = 0x1C8; // float + constexpr std::ptrdiff_t m_bCPPairs = 0x1CC; // bool + constexpr std::ptrdiff_t m_PathParams = 0x1D0; // CPathParameters +} + +namespace C_OP_LockToSavedSequentialPathV2 { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flFadeStart = 0x1C0; // float + constexpr std::ptrdiff_t m_flFadeEnd = 0x1C4; // float + constexpr std::ptrdiff_t m_bCPPairs = 0x1C8; // bool + constexpr std::ptrdiff_t m_PathParams = 0x1D0; // CPathParameters +} + +namespace C_OP_MaintainEmitter { // CParticleFunctionEmitter + constexpr std::ptrdiff_t m_nParticlesToMaintain = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flStartTime = 0x318; // float + constexpr std::ptrdiff_t m_flEmissionDuration = 0x320; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flEmissionRate = 0x478; // float + constexpr std::ptrdiff_t m_nSnapshotControlPoint = 0x47C; // int32_t + constexpr std::ptrdiff_t m_bEmitInstantaneously = 0x480; // bool + constexpr std::ptrdiff_t m_bFinalEmitOnStop = 0x481; // bool + constexpr std::ptrdiff_t m_flScale = 0x488; // CParticleCollectionFloatInput +} + +namespace C_OP_MaintainSequentialPath { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_fMaxDistance = 0x1C0; // float + constexpr std::ptrdiff_t m_flNumToAssign = 0x1C4; // float + constexpr std::ptrdiff_t m_flCohesionStrength = 0x1C8; // float + constexpr std::ptrdiff_t m_flTolerance = 0x1CC; // float + constexpr std::ptrdiff_t m_bLoop = 0x1D0; // bool + constexpr std::ptrdiff_t m_bUseParticleCount = 0x1D1; // bool + constexpr std::ptrdiff_t m_PathParams = 0x1E0; // CPathParameters +} + +namespace C_OP_MaxVelocity { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flMaxVelocity = 0x1C0; // float + constexpr std::ptrdiff_t m_flMinVelocity = 0x1C4; // float + constexpr std::ptrdiff_t m_nOverrideCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nOverrideCPField = 0x1CC; // int32_t +} + +namespace C_OP_ModelCull { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_bBoundBox = 0x1C4; // bool + constexpr std::ptrdiff_t m_bCullOutside = 0x1C5; // bool + constexpr std::ptrdiff_t m_bUseBones = 0x1C6; // bool + constexpr std::ptrdiff_t m_HitboxSetName = 0x1C7; // char[128] +} + +namespace C_OP_ModelDampenMovement { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_bBoundBox = 0x1C4; // bool + constexpr std::ptrdiff_t m_bOutside = 0x1C5; // bool + constexpr std::ptrdiff_t m_bUseBones = 0x1C6; // bool + constexpr std::ptrdiff_t m_HitboxSetName = 0x1C7; // char[128] + constexpr std::ptrdiff_t m_vecPosOffset = 0x248; // CPerParticleVecInput + constexpr std::ptrdiff_t m_fDrag = 0x8A0; // float +} + +namespace C_OP_MoveToHitbox { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_modelInput = 0x1C0; // CParticleModelInput + constexpr std::ptrdiff_t m_transformInput = 0x220; // CParticleTransformInput + constexpr std::ptrdiff_t m_flLifeTimeLerpStart = 0x28C; // float + constexpr std::ptrdiff_t m_flLifeTimeLerpEnd = 0x290; // float + constexpr std::ptrdiff_t m_flPrevPosScale = 0x294; // float + constexpr std::ptrdiff_t m_HitboxSetName = 0x298; // char[128] + constexpr std::ptrdiff_t m_bUseBones = 0x318; // bool + constexpr std::ptrdiff_t m_nLerpType = 0x31C; // HitboxLerpType_t + constexpr std::ptrdiff_t m_flInterpolation = 0x320; // CPerParticleFloatInput +} + +namespace C_OP_MovementLoopInsideSphere { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCP = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flDistance = 0x1C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_vecScale = 0x320; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nDistSqrAttr = 0x978; // ParticleAttributeIndex_t +} + +namespace C_OP_MovementMaintainOffset { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_vecOffset = 0x1C0; // Vector + constexpr std::ptrdiff_t m_nCP = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_bRadiusScale = 0x1D0; // bool +} + +namespace C_OP_MovementMoveAlongSkinnedCPSnapshot { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nSnapshotControlPointNumber = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_bSetNormal = 0x1C8; // bool + constexpr std::ptrdiff_t m_bSetRadius = 0x1C9; // bool + constexpr std::ptrdiff_t m_flInterpolation = 0x1D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flTValue = 0x328; // CPerParticleFloatInput +} + +namespace C_OP_MovementPlaceOnGround { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flOffset = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x318; // float + constexpr std::ptrdiff_t m_flTolerance = 0x31C; // float + constexpr std::ptrdiff_t m_flTraceOffset = 0x320; // float + constexpr std::ptrdiff_t m_flLerpRate = 0x324; // float + constexpr std::ptrdiff_t m_CollisionGroupName = 0x328; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x3A8; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_nRefCP1 = 0x3AC; // int32_t + constexpr std::ptrdiff_t m_nRefCP2 = 0x3B0; // int32_t + constexpr std::ptrdiff_t m_nLerpCP = 0x3B4; // int32_t + constexpr std::ptrdiff_t m_nTraceMissBehavior = 0x3C0; // ParticleTraceMissBehavior_t + constexpr std::ptrdiff_t m_bIncludeShotHull = 0x3C4; // bool + constexpr std::ptrdiff_t m_bIncludeWater = 0x3C5; // bool + constexpr std::ptrdiff_t m_bSetNormal = 0x3C8; // bool + constexpr std::ptrdiff_t m_bScaleOffset = 0x3C9; // bool + constexpr std::ptrdiff_t m_nPreserveOffsetCP = 0x3CC; // int32_t + constexpr std::ptrdiff_t m_nIgnoreCP = 0x3D0; // int32_t +} + +namespace C_OP_MovementRigidAttachToCP { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nScaleControlPoint = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nScaleCPField = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nFieldInput = 0x1CC; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1D0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bOffsetLocal = 0x1D4; // bool +} + +namespace C_OP_MovementRotateParticleAroundAxis { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_vecRotAxis = 0x1C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_flRotRate = 0x818; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_TransformInput = 0x970; // CParticleTransformInput + constexpr std::ptrdiff_t m_bLocalSpace = 0x9D8; // bool +} + +namespace C_OP_MovementSkinnedPositionFromCPSnapshot { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nSnapshotControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_bRandom = 0x1C8; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_bSetNormal = 0x1D0; // bool + constexpr std::ptrdiff_t m_bSetRadius = 0x1D1; // bool + constexpr std::ptrdiff_t m_flIncrement = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nFullLoopIncrement = 0x330; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nSnapShotStartPoint = 0x488; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInterpolation = 0x5E0; // CPerParticleFloatInput +} + +namespace C_OP_Noise { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOutputMin = 0x1C4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1C8; // float + constexpr std::ptrdiff_t m_fl4NoiseScale = 0x1CC; // float + constexpr std::ptrdiff_t m_bAdditive = 0x1D0; // bool + constexpr std::ptrdiff_t m_flNoiseAnimationTimeScale = 0x1D4; // float +} + +namespace C_OP_NoiseEmitter { // CParticleFunctionEmitter + constexpr std::ptrdiff_t m_flEmissionDuration = 0x1C0; // float + constexpr std::ptrdiff_t m_flStartTime = 0x1C4; // float + constexpr std::ptrdiff_t m_flEmissionScale = 0x1C8; // float + constexpr std::ptrdiff_t m_nScaleControlPoint = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_nScaleControlPointField = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nWorldNoisePoint = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_bAbsVal = 0x1D8; // bool + constexpr std::ptrdiff_t m_bAbsValInv = 0x1D9; // bool + constexpr std::ptrdiff_t m_flOffset = 0x1DC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1E0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1E4; // float + constexpr std::ptrdiff_t m_flNoiseScale = 0x1E8; // float + constexpr std::ptrdiff_t m_flWorldNoiseScale = 0x1EC; // float + constexpr std::ptrdiff_t m_vecOffsetLoc = 0x1F0; // Vector + constexpr std::ptrdiff_t m_flWorldTimeScale = 0x1FC; // float +} + +namespace C_OP_NormalLock { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t +} + +namespace C_OP_NormalizeVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0x1C4; // float +} + +namespace C_OP_Orient2DRelToCP { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flRotOffset = 0x1C0; // float + constexpr std::ptrdiff_t m_flSpinStrength = 0x1C4; // float + constexpr std::ptrdiff_t m_nCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1CC; // ParticleAttributeIndex_t +} + +namespace C_OP_OrientTo2dDirection { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flRotOffset = 0x1C0; // float + constexpr std::ptrdiff_t m_flSpinStrength = 0x1C4; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C8; // ParticleAttributeIndex_t +} + +namespace C_OP_OscillateScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_RateMin = 0x1C0; // float + constexpr std::ptrdiff_t m_RateMax = 0x1C4; // float + constexpr std::ptrdiff_t m_FrequencyMin = 0x1C8; // float + constexpr std::ptrdiff_t m_FrequencyMax = 0x1CC; // float + constexpr std::ptrdiff_t m_nField = 0x1D0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bProportional = 0x1D4; // bool + constexpr std::ptrdiff_t m_bProportionalOp = 0x1D5; // bool + constexpr std::ptrdiff_t m_flStartTime_min = 0x1D8; // float + constexpr std::ptrdiff_t m_flStartTime_max = 0x1DC; // float + constexpr std::ptrdiff_t m_flEndTime_min = 0x1E0; // float + constexpr std::ptrdiff_t m_flEndTime_max = 0x1E4; // float + constexpr std::ptrdiff_t m_flOscMult = 0x1E8; // float + constexpr std::ptrdiff_t m_flOscAdd = 0x1EC; // float +} + +namespace C_OP_OscillateScalarSimple { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_Rate = 0x1C0; // float + constexpr std::ptrdiff_t m_Frequency = 0x1C4; // float + constexpr std::ptrdiff_t m_nField = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOscMult = 0x1CC; // float + constexpr std::ptrdiff_t m_flOscAdd = 0x1D0; // float +} + +namespace C_OP_OscillateVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_RateMin = 0x1C0; // Vector + constexpr std::ptrdiff_t m_RateMax = 0x1CC; // Vector + constexpr std::ptrdiff_t m_FrequencyMin = 0x1D8; // Vector + constexpr std::ptrdiff_t m_FrequencyMax = 0x1E4; // Vector + constexpr std::ptrdiff_t m_nField = 0x1F0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bProportional = 0x1F4; // bool + constexpr std::ptrdiff_t m_bProportionalOp = 0x1F5; // bool + constexpr std::ptrdiff_t m_bOffset = 0x1F6; // bool + constexpr std::ptrdiff_t m_flStartTime_min = 0x1F8; // float + constexpr std::ptrdiff_t m_flStartTime_max = 0x1FC; // float + constexpr std::ptrdiff_t m_flEndTime_min = 0x200; // float + constexpr std::ptrdiff_t m_flEndTime_max = 0x204; // float + constexpr std::ptrdiff_t m_flOscMult = 0x208; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOscAdd = 0x360; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRateScale = 0x4B8; // CPerParticleFloatInput +} + +namespace C_OP_OscillateVectorSimple { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_Rate = 0x1C0; // Vector + constexpr std::ptrdiff_t m_Frequency = 0x1CC; // Vector + constexpr std::ptrdiff_t m_nField = 0x1D8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOscMult = 0x1DC; // float + constexpr std::ptrdiff_t m_flOscAdd = 0x1E0; // float + constexpr std::ptrdiff_t m_bOffset = 0x1E4; // bool +} + +namespace C_OP_ParentVortices { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flForceScale = 0x1D0; // float + constexpr std::ptrdiff_t m_vecTwistAxis = 0x1D4; // Vector + constexpr std::ptrdiff_t m_bFlipBasedOnYaw = 0x1E0; // bool +} + +namespace C_OP_ParticlePhysics { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_Gravity = 0x1C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_fDrag = 0x818; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nMaxConstraintPasses = 0x970; // int32_t +} + +namespace C_OP_PerParticleForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flForceScale = 0x1D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vForce = 0x328; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nCP = 0x980; // int32_t +} + +namespace C_OP_PercentageBetweenTransformLerpCPs { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C4; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1C8; // float + constexpr std::ptrdiff_t m_TransformStart = 0x1D0; // CParticleTransformInput + constexpr std::ptrdiff_t m_TransformEnd = 0x238; // CParticleTransformInput + constexpr std::ptrdiff_t m_nOutputStartCP = 0x2A0; // int32_t + constexpr std::ptrdiff_t m_nOutputStartField = 0x2A4; // int32_t + constexpr std::ptrdiff_t m_nOutputEndCP = 0x2A8; // int32_t + constexpr std::ptrdiff_t m_nOutputEndField = 0x2AC; // int32_t + constexpr std::ptrdiff_t m_nSetMethod = 0x2B0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x2B4; // bool + constexpr std::ptrdiff_t m_bRadialCheck = 0x2B5; // bool +} + +namespace C_OP_PercentageBetweenTransforms { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C4; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1C8; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_TransformStart = 0x1D8; // CParticleTransformInput + constexpr std::ptrdiff_t m_TransformEnd = 0x240; // CParticleTransformInput + constexpr std::ptrdiff_t m_nSetMethod = 0x2A8; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x2AC; // bool + constexpr std::ptrdiff_t m_bRadialCheck = 0x2AD; // bool +} + +namespace C_OP_PercentageBetweenTransformsVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C4; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1C8; // float + constexpr std::ptrdiff_t m_vecOutputMin = 0x1CC; // Vector + constexpr std::ptrdiff_t m_vecOutputMax = 0x1D8; // Vector + constexpr std::ptrdiff_t m_TransformStart = 0x1E8; // CParticleTransformInput + constexpr std::ptrdiff_t m_TransformEnd = 0x250; // CParticleTransformInput + constexpr std::ptrdiff_t m_nSetMethod = 0x2B8; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x2BC; // bool + constexpr std::ptrdiff_t m_bRadialCheck = 0x2BD; // bool +} + +namespace C_OP_PinParticleToCP { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_vecOffset = 0x1C8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_bOffsetLocal = 0x820; // bool + constexpr std::ptrdiff_t m_nParticleSelection = 0x824; // ParticleSelection_t + constexpr std::ptrdiff_t m_nParticleNumber = 0x828; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nPinBreakType = 0x980; // ParticlePinDistance_t + constexpr std::ptrdiff_t m_flBreakDistance = 0x988; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flBreakSpeed = 0xAE0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flAge = 0xC38; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nBreakControlPointNumber = 0xD90; // int32_t + constexpr std::ptrdiff_t m_nBreakControlPointNumber2 = 0xD94; // int32_t + constexpr std::ptrdiff_t m_flBreakValue = 0xD98; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInterpolation = 0xEF0; // CPerParticleFloatInput +} + +namespace C_OP_PlanarConstraint { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_PointOnPlane = 0x1C0; // Vector + constexpr std::ptrdiff_t m_PlaneNormal = 0x1CC; // Vector + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_bGlobalOrigin = 0x1DC; // bool + constexpr std::ptrdiff_t m_bGlobalNormal = 0x1DD; // bool + constexpr std::ptrdiff_t m_flRadiusScale = 0x1E0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flMaximumDistanceToCP = 0x338; // CParticleCollectionFloatInput +} + +namespace C_OP_PlaneCull { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nPlaneControlPoint = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_vecPlaneDirection = 0x1C4; // Vector + constexpr std::ptrdiff_t m_bLocalSpace = 0x1D0; // bool + constexpr std::ptrdiff_t m_flPlaneOffset = 0x1D4; // float +} + +namespace C_OP_PlayEndCapWhenFinished { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_bFireOnEmissionEnd = 0x1D0; // bool + constexpr std::ptrdiff_t m_bIncludeChildren = 0x1D1; // bool +} + +namespace C_OP_PointVectorAtNextParticle { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInterpolation = 0x1C8; // CPerParticleFloatInput +} + +namespace C_OP_PositionLock { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_flStartTime_min = 0x228; // float + constexpr std::ptrdiff_t m_flStartTime_max = 0x22C; // float + constexpr std::ptrdiff_t m_flStartTime_exp = 0x230; // float + constexpr std::ptrdiff_t m_flEndTime_min = 0x234; // float + constexpr std::ptrdiff_t m_flEndTime_max = 0x238; // float + constexpr std::ptrdiff_t m_flEndTime_exp = 0x23C; // float + constexpr std::ptrdiff_t m_flRange = 0x240; // float + constexpr std::ptrdiff_t m_flRangeBias = 0x248; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flJumpThreshold = 0x3A0; // float + constexpr std::ptrdiff_t m_flPrevPosScale = 0x3A4; // float + constexpr std::ptrdiff_t m_bLockRot = 0x3A8; // bool + constexpr std::ptrdiff_t m_vecScale = 0x3B0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nFieldOutput = 0xA08; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutputPrev = 0xA0C; // ParticleAttributeIndex_t +} + +namespace C_OP_QuantizeCPComponent { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_flInputValue = 0x1D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nCPOutput = 0x328; // int32_t + constexpr std::ptrdiff_t m_nOutVectorField = 0x32C; // int32_t + constexpr std::ptrdiff_t m_flQuantizeValue = 0x330; // CParticleCollectionFloatInput +} + +namespace C_OP_QuantizeFloat { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0x318; // ParticleAttributeIndex_t +} + +namespace C_OP_RadiusDecay { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flMinRadius = 0x1C0; // float +} + +namespace C_OP_RampCPLinearRandom { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nOutControlPointNumber = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_vecRateMin = 0x1D4; // Vector + constexpr std::ptrdiff_t m_vecRateMax = 0x1E0; // Vector +} + +namespace C_OP_RampScalarLinear { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_RateMin = 0x1C0; // float + constexpr std::ptrdiff_t m_RateMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flStartTime_min = 0x1C8; // float + constexpr std::ptrdiff_t m_flStartTime_max = 0x1CC; // float + constexpr std::ptrdiff_t m_flEndTime_min = 0x1D0; // float + constexpr std::ptrdiff_t m_flEndTime_max = 0x1D4; // float + constexpr std::ptrdiff_t m_nField = 0x200; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bProportionalOp = 0x204; // bool +} + +namespace C_OP_RampScalarLinearSimple { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_Rate = 0x1C0; // float + constexpr std::ptrdiff_t m_flStartTime = 0x1C4; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1C8; // float + constexpr std::ptrdiff_t m_nField = 0x1F0; // ParticleAttributeIndex_t +} + +namespace C_OP_RampScalarSpline { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_RateMin = 0x1C0; // float + constexpr std::ptrdiff_t m_RateMax = 0x1C4; // float + constexpr std::ptrdiff_t m_flStartTime_min = 0x1C8; // float + constexpr std::ptrdiff_t m_flStartTime_max = 0x1CC; // float + constexpr std::ptrdiff_t m_flEndTime_min = 0x1D0; // float + constexpr std::ptrdiff_t m_flEndTime_max = 0x1D4; // float + constexpr std::ptrdiff_t m_flBias = 0x1D8; // float + constexpr std::ptrdiff_t m_nField = 0x200; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bProportionalOp = 0x204; // bool + constexpr std::ptrdiff_t m_bEaseOut = 0x205; // bool +} + +namespace C_OP_RampScalarSplineSimple { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_Rate = 0x1C0; // float + constexpr std::ptrdiff_t m_flStartTime = 0x1C4; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1C8; // float + constexpr std::ptrdiff_t m_nField = 0x1F0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bEaseOut = 0x1F4; // bool +} + +namespace C_OP_RandomForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_MinForce = 0x1D0; // Vector + constexpr std::ptrdiff_t m_MaxForce = 0x1DC; // Vector +} + +namespace C_OP_ReadFromNeighboringParticle { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nIncrement = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_DistanceCheck = 0x1D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInterpolation = 0x328; // CPerParticleFloatInput +} + +namespace C_OP_ReinitializeScalarEndCap { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOutputMin = 0x1C4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1C8; // float +} + +namespace C_OP_RemapAverageHitboxSpeedtoCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nInControlPointNumber = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nOutControlPointNumber = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nField = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nHitboxDataType = 0x1DC; // ParticleHitboxDataSelection_t + constexpr std::ptrdiff_t m_flInputMin = 0x1E0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0x338; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x490; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x5E8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nHeightControlPointNumber = 0x740; // int32_t + constexpr std::ptrdiff_t m_vecComparisonVelocity = 0x748; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_HitboxSetName = 0xDA0; // char[128] +} + +namespace C_OP_RemapAverageScalarValuetoCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nOutControlPointNumber = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nOutVectorField = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nField = 0x1D8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1DC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1E0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1E4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1E8; // float +} + +namespace C_OP_RemapBoundingVolumetoCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nOutControlPointNumber = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1DC; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1E0; // float +} + +namespace C_OP_RemapCPVelocityToVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPoint = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0x1C8; // float + constexpr std::ptrdiff_t m_bNormalize = 0x1CC; // bool +} + +namespace C_OP_RemapCPtoCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nInputControlPoint = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nOutputControlPoint = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nInputField = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nOutputField = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1E0; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1E4; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1E8; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1EC; // float + constexpr std::ptrdiff_t m_bDerivative = 0x1F0; // bool + constexpr std::ptrdiff_t m_flInterpRate = 0x1F4; // float +} + +namespace C_OP_RemapCPtoScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCPInput = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nField = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_flStartTime = 0x1DC; // float + constexpr std::ptrdiff_t m_flEndTime = 0x1E0; // float + constexpr std::ptrdiff_t m_flInterpRate = 0x1E4; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1E8; // ParticleSetMethod_t +} + +namespace C_OP_RemapCPtoVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCPInput = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nLocalSpaceCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_vInputMin = 0x1CC; // Vector + constexpr std::ptrdiff_t m_vInputMax = 0x1D8; // Vector + constexpr std::ptrdiff_t m_vOutputMin = 0x1E4; // Vector + constexpr std::ptrdiff_t m_vOutputMax = 0x1F0; // Vector + constexpr std::ptrdiff_t m_flStartTime = 0x1FC; // float + constexpr std::ptrdiff_t m_flEndTime = 0x200; // float + constexpr std::ptrdiff_t m_flInterpRate = 0x204; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x208; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bOffset = 0x20C; // bool + constexpr std::ptrdiff_t m_bAccelerate = 0x20D; // bool +} + +namespace C_OP_RemapControlPointDirectionToVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0x1C4; // float + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C8; // int32_t +} + +namespace C_OP_RemapControlPointOrientationToRotation { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCP = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flOffsetRot = 0x1C8; // float + constexpr std::ptrdiff_t m_nComponent = 0x1CC; // int32_t +} + +namespace C_OP_RemapCrossProductOfTwoVectorsToVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_InputVec1 = 0x1C0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_InputVec2 = 0x818; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nFieldOutput = 0xE70; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bNormalize = 0xE74; // bool +} + +namespace C_OP_RemapDensityGradientToVectorAttribute { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flRadiusScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t +} + +namespace C_OP_RemapDensityToVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flRadiusScale = 0x1C0; // float + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flDensityMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flDensityMax = 0x1CC; // float + constexpr std::ptrdiff_t m_vecOutputMin = 0x1D0; // Vector + constexpr std::ptrdiff_t m_vecOutputMax = 0x1DC; // Vector + constexpr std::ptrdiff_t m_bUseParentDensity = 0x1E8; // bool + constexpr std::ptrdiff_t m_nVoxelGridResolution = 0x1EC; // int32_t +} + +namespace C_OP_RemapDirectionToCPToVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCP = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0x1C8; // float + constexpr std::ptrdiff_t m_flOffsetRot = 0x1CC; // float + constexpr std::ptrdiff_t m_vecOffsetAxis = 0x1D0; // Vector + constexpr std::ptrdiff_t m_bNormalize = 0x1DC; // bool + constexpr std::ptrdiff_t m_nFieldStrength = 0x1E0; // ParticleAttributeIndex_t +} + +namespace C_OP_RemapDistanceToLineSegmentBase { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCP0 = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nCP1 = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_flMinInputValue = 0x1C8; // float + constexpr std::ptrdiff_t m_flMaxInputValue = 0x1CC; // float + constexpr std::ptrdiff_t m_bInfiniteLine = 0x1D0; // bool +} + +namespace C_OP_RemapDistanceToLineSegmentToScalar { // C_OP_RemapDistanceToLineSegmentBase + constexpr std::ptrdiff_t m_nFieldOutput = 0x1E0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flMinOutputValue = 0x1E4; // float + constexpr std::ptrdiff_t m_flMaxOutputValue = 0x1E8; // float +} + +namespace C_OP_RemapDistanceToLineSegmentToVector { // C_OP_RemapDistanceToLineSegmentBase + constexpr std::ptrdiff_t m_nFieldOutput = 0x1E0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vMinOutputValue = 0x1E4; // Vector + constexpr std::ptrdiff_t m_vMaxOutputValue = 0x1F0; // Vector +} + +namespace C_OP_RemapDotProductToCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nInputCP1 = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nInputCP2 = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nOutputCP = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nOutVectorField = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1E0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInputMax = 0x338; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x490; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x5E8; // CParticleCollectionFloatInput +} + +namespace C_OP_RemapDotProductToScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nInputCP1 = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nInputCP2 = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_bUseParticleVelocity = 0x1DC; // bool + constexpr std::ptrdiff_t m_nSetMethod = 0x1E0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bActiveRange = 0x1E4; // bool + constexpr std::ptrdiff_t m_bUseParticleNormal = 0x1E5; // bool +} + +namespace C_OP_RemapExternalWindToCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPOutput = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_vecScale = 0x1D8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_bSetMagnitude = 0x830; // bool + constexpr std::ptrdiff_t m_nOutVectorField = 0x834; // int32_t +} + +namespace C_OP_RemapModelVolumetoCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nBBoxType = 0x1D0; // BBoxVolumeType_t + constexpr std::ptrdiff_t m_nInControlPointNumber = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nOutControlPointNumber = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nOutControlPointMaxNumber = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_nField = 0x1E0; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1E4; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1E8; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1EC; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1F0; // float +} + +namespace C_OP_RemapNamedModelBodyPartEndCap { // C_OP_RemapNamedModelElementEndCap +} + +namespace C_OP_RemapNamedModelBodyPartOnceTimed { // C_OP_RemapNamedModelElementOnceTimed +} + +namespace C_OP_RemapNamedModelElementEndCap { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_hModel = 0x1C0; // CStrongHandle + constexpr std::ptrdiff_t m_inNames = 0x1C8; // CUtlVector + constexpr std::ptrdiff_t m_outNames = 0x1E0; // CUtlVector + constexpr std::ptrdiff_t m_fallbackNames = 0x1F8; // CUtlVector + constexpr std::ptrdiff_t m_bModelFromRenderer = 0x210; // bool + constexpr std::ptrdiff_t m_nFieldInput = 0x214; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x218; // ParticleAttributeIndex_t +} + +namespace C_OP_RemapNamedModelElementOnceTimed { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_hModel = 0x1C0; // CStrongHandle + constexpr std::ptrdiff_t m_inNames = 0x1C8; // CUtlVector + constexpr std::ptrdiff_t m_outNames = 0x1E0; // CUtlVector + constexpr std::ptrdiff_t m_fallbackNames = 0x1F8; // CUtlVector + constexpr std::ptrdiff_t m_bModelFromRenderer = 0x210; // bool + constexpr std::ptrdiff_t m_bProportional = 0x211; // bool + constexpr std::ptrdiff_t m_nFieldInput = 0x214; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x218; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flRemapTime = 0x21C; // float +} + +namespace C_OP_RemapNamedModelMeshGroupEndCap { // C_OP_RemapNamedModelElementEndCap +} + +namespace C_OP_RemapNamedModelMeshGroupOnceTimed { // C_OP_RemapNamedModelElementOnceTimed +} + +namespace C_OP_RemapNamedModelSequenceEndCap { // C_OP_RemapNamedModelElementEndCap +} + +namespace C_OP_RemapNamedModelSequenceOnceTimed { // C_OP_RemapNamedModelElementOnceTimed +} + +namespace C_OP_RemapParticleCountOnScalarEndCap { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nInputMin = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nInputMax = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_flOutputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_bBackwards = 0x1D4; // bool + constexpr std::ptrdiff_t m_nSetMethod = 0x1D8; // ParticleSetMethod_t +} + +namespace C_OP_RemapParticleCountToScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nInputMin = 0x1C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nInputMax = 0x320; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOutputMin = 0x478; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOutputMax = 0x5D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bActiveRange = 0x728; // bool + constexpr std::ptrdiff_t m_nSetMethod = 0x72C; // ParticleSetMethod_t +} + +namespace C_OP_RemapSDFDistanceToScalarAttribute { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nVectorFieldInput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flMinDistance = 0x1C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flMaxDistance = 0x320; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flValueBelowMin = 0x478; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flValueAtMin = 0x5D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flValueAtMax = 0x728; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flValueAboveMax = 0x880; // CParticleCollectionFloatInput +} + +namespace C_OP_RemapSDFDistanceToVectorAttribute { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nVectorFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nVectorFieldInput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flMinDistance = 0x1C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flMaxDistance = 0x320; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_vValueBelowMin = 0x478; // Vector + constexpr std::ptrdiff_t m_vValueAtMin = 0x484; // Vector + constexpr std::ptrdiff_t m_vValueAtMax = 0x490; // Vector + constexpr std::ptrdiff_t m_vValueAboveMax = 0x49C; // Vector +} + +namespace C_OP_RemapSDFGradientToVectorAttribute { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t +} + +namespace C_OP_RemapScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D4; // float + constexpr std::ptrdiff_t m_bOldCode = 0x1D8; // bool +} + +namespace C_OP_RemapScalarEndCap { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D4; // float +} + +namespace C_OP_RemapScalarOnceTimed { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_bProportional = 0x1C0; // bool + constexpr std::ptrdiff_t m_nFieldInput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_flRemapTime = 0x1DC; // float +} + +namespace C_OP_RemapSpeed { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C4; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1C8; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1D4; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bIgnoreDelta = 0x1D8; // bool +} + +namespace C_OP_RemapSpeedtoCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nInControlPointNumber = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nOutControlPointNumber = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nField = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_flInputMin = 0x1DC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1E0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1E4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1E8; // float + constexpr std::ptrdiff_t m_bUseDeltaV = 0x1EC; // bool +} + +namespace C_OP_RemapTransformOrientationToRotations { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_vecRotation = 0x228; // Vector + constexpr std::ptrdiff_t m_bUseQuat = 0x234; // bool + constexpr std::ptrdiff_t m_bWriteNormal = 0x235; // bool +} + +namespace C_OP_RemapTransformOrientationToYaw { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput + constexpr std::ptrdiff_t m_nFieldOutput = 0x228; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flRotOffset = 0x22C; // float + constexpr std::ptrdiff_t m_flSpinStrength = 0x230; // float +} + +namespace C_OP_RemapTransformToVelocity { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_TransformInput = 0x1C0; // CParticleTransformInput +} + +namespace C_OP_RemapTransformVisibilityToScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nSetMethod = 0x1C0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_TransformInput = 0x1C8; // CParticleTransformInput + constexpr std::ptrdiff_t m_nFieldOutput = 0x230; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x234; // float + constexpr std::ptrdiff_t m_flInputMax = 0x238; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x23C; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x240; // float + constexpr std::ptrdiff_t m_flRadius = 0x244; // float +} + +namespace C_OP_RemapTransformVisibilityToVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nSetMethod = 0x1C0; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_TransformInput = 0x1C8; // CParticleTransformInput + constexpr std::ptrdiff_t m_nFieldOutput = 0x230; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x234; // float + constexpr std::ptrdiff_t m_flInputMax = 0x238; // float + constexpr std::ptrdiff_t m_vecOutputMin = 0x23C; // Vector + constexpr std::ptrdiff_t m_vecOutputMax = 0x248; // Vector + constexpr std::ptrdiff_t m_flRadius = 0x254; // float +} + +namespace C_OP_RemapVectorComponentToScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nComponent = 0x1C8; // int32_t +} + +namespace C_OP_RemapVectortoCP { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nOutControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldInput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nParticleNumber = 0x1C8; // int32_t +} + +namespace C_OP_RemapVelocityToVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0x1C4; // float + constexpr std::ptrdiff_t m_bNormalize = 0x1C8; // bool +} + +namespace C_OP_RemapVisibilityScalar { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldInput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1C8; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1CC; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D4; // float + constexpr std::ptrdiff_t m_flRadiusScale = 0x1D8; // float +} + +namespace C_OP_RenderAsModels { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_ModelList = 0x200; // CUtlVector + constexpr std::ptrdiff_t m_flModelScale = 0x21C; // float + constexpr std::ptrdiff_t m_bFitToModelSize = 0x220; // bool + constexpr std::ptrdiff_t m_bNonUniformScaling = 0x221; // bool + constexpr std::ptrdiff_t m_nXAxisScalingAttribute = 0x224; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nYAxisScalingAttribute = 0x228; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nZAxisScalingAttribute = 0x22C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSizeCullBloat = 0x230; // int32_t +} + +namespace C_OP_RenderBlobs { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_cubeWidth = 0x200; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_cutoffRadius = 0x358; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_renderRadius = 0x4B0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nScaleCP = 0x608; // int32_t + constexpr std::ptrdiff_t m_MaterialVars = 0x610; // CUtlVector + constexpr std::ptrdiff_t m_hMaterial = 0x640; // CStrongHandle +} + +namespace C_OP_RenderCables { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flRadiusScale = 0x200; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flAlphaScale = 0x358; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_vecColorScale = 0x4B0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nColorBlendType = 0xB08; // ParticleColorBlendType_t + constexpr std::ptrdiff_t m_hMaterial = 0xB10; // CStrongHandle + constexpr std::ptrdiff_t m_nTextureRepetitionMode = 0xB18; // TextureRepetitionMode_t + constexpr std::ptrdiff_t m_flTextureRepeatsPerSegment = 0xB20; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flTextureRepeatsCircumference = 0xC78; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flColorMapOffsetV = 0xDD0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flColorMapOffsetU = 0xF28; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flNormalMapOffsetV = 0x1080; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flNormalMapOffsetU = 0x11D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bDrawCableCaps = 0x1330; // bool + constexpr std::ptrdiff_t m_flCapRoundness = 0x1334; // float + constexpr std::ptrdiff_t m_flCapOffsetAmount = 0x1338; // float + constexpr std::ptrdiff_t m_flTessScale = 0x133C; // float + constexpr std::ptrdiff_t m_nMinTesselation = 0x1340; // int32_t + constexpr std::ptrdiff_t m_nMaxTesselation = 0x1344; // int32_t + constexpr std::ptrdiff_t m_nRoundness = 0x1348; // int32_t + constexpr std::ptrdiff_t m_LightingTransform = 0x1350; // CParticleTransformInput + constexpr std::ptrdiff_t m_MaterialFloatVars = 0x13B8; // CUtlVector + constexpr std::ptrdiff_t m_MaterialVecVars = 0x13E8; // CUtlVector +} + +namespace C_OP_RenderClothForce { // CParticleFunctionRenderer +} + +namespace C_OP_RenderDeferredLight { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_bUseAlphaTestWindow = 0x200; // bool + constexpr std::ptrdiff_t m_bUseTexture = 0x201; // bool + constexpr std::ptrdiff_t m_flRadiusScale = 0x204; // float + constexpr std::ptrdiff_t m_flAlphaScale = 0x208; // float + constexpr std::ptrdiff_t m_nAlpha2Field = 0x20C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecColorScale = 0x210; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nColorBlendType = 0x868; // ParticleColorBlendType_t + constexpr std::ptrdiff_t m_flLightDistance = 0x86C; // float + constexpr std::ptrdiff_t m_flStartFalloff = 0x870; // float + constexpr std::ptrdiff_t m_flDistanceFalloff = 0x874; // float + constexpr std::ptrdiff_t m_flSpotFoV = 0x878; // float + constexpr std::ptrdiff_t m_nAlphaTestPointField = 0x87C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nAlphaTestRangeField = 0x880; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nAlphaTestSharpnessField = 0x884; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_hTexture = 0x888; // CStrongHandle + constexpr std::ptrdiff_t m_nHSVShiftControlPoint = 0x890; // int32_t +} + +namespace C_OP_RenderFlattenGrass { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flFlattenStrength = 0x200; // float + constexpr std::ptrdiff_t m_nStrengthFieldOverride = 0x204; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flRadiusScale = 0x208; // float +} + +namespace C_OP_RenderGpuImplicit { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_bUsePerParticleRadius = 0x200; // bool + constexpr std::ptrdiff_t m_fGridSize = 0x208; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_fRadiusScale = 0x360; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_fIsosurfaceThreshold = 0x4B8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nScaleCP = 0x610; // int32_t + constexpr std::ptrdiff_t m_hMaterial = 0x618; // CStrongHandle +} + +namespace C_OP_RenderLightBeam { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_vColorBlend = 0x200; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nColorBlendType = 0x858; // ParticleColorBlendType_t + constexpr std::ptrdiff_t m_flBrightnessLumensPerMeter = 0x860; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bCastShadows = 0x9B8; // bool + constexpr std::ptrdiff_t m_flSkirt = 0x9C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flRange = 0xB18; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flThickness = 0xC70; // CParticleCollectionFloatInput +} + +namespace C_OP_RenderLights { // C_OP_RenderPoints + constexpr std::ptrdiff_t m_flAnimationRate = 0x210; // float + constexpr std::ptrdiff_t m_nAnimationType = 0x214; // AnimationType_t + constexpr std::ptrdiff_t m_bAnimateInFPS = 0x218; // bool + constexpr std::ptrdiff_t m_flMinSize = 0x21C; // float + constexpr std::ptrdiff_t m_flMaxSize = 0x220; // float + constexpr std::ptrdiff_t m_flStartFadeSize = 0x224; // float + constexpr std::ptrdiff_t m_flEndFadeSize = 0x228; // float +} + +namespace C_OP_RenderMaterialProxy { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_nMaterialControlPoint = 0x200; // int32_t + constexpr std::ptrdiff_t m_nProxyType = 0x204; // MaterialProxyType_t + constexpr std::ptrdiff_t m_MaterialVars = 0x208; // CUtlVector + constexpr std::ptrdiff_t m_hOverrideMaterial = 0x220; // CStrongHandle + constexpr std::ptrdiff_t m_flMaterialOverrideEnabled = 0x228; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_vecColorScale = 0x380; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_flAlpha = 0x9D8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nColorBlendType = 0xB30; // ParticleColorBlendType_t +} + +namespace C_OP_RenderModels { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_bOnlyRenderInEffectsBloomPass = 0x200; // bool + constexpr std::ptrdiff_t m_bOnlyRenderInEffectsWaterPass = 0x201; // bool + constexpr std::ptrdiff_t m_bUseMixedResolutionRendering = 0x202; // bool + constexpr std::ptrdiff_t m_bOnlyRenderInEffecsGameOverlay = 0x203; // bool + constexpr std::ptrdiff_t m_ModelList = 0x208; // CUtlVector + constexpr std::ptrdiff_t m_nBodyGroupField = 0x224; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSubModelField = 0x228; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bIgnoreNormal = 0x22C; // bool + constexpr std::ptrdiff_t m_bOrientZ = 0x22D; // bool + constexpr std::ptrdiff_t m_bCenterOffset = 0x22E; // bool + constexpr std::ptrdiff_t m_vecLocalOffset = 0x230; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vecLocalRotation = 0x888; // CPerParticleVecInput + constexpr std::ptrdiff_t m_bIgnoreRadius = 0xEE0; // bool + constexpr std::ptrdiff_t m_nModelScaleCP = 0xEE4; // int32_t + constexpr std::ptrdiff_t m_vecComponentScale = 0xEE8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_bLocalScale = 0x1540; // bool + constexpr std::ptrdiff_t m_nSizeCullBloat = 0x1544; // int32_t + constexpr std::ptrdiff_t m_bAnimated = 0x1548; // bool + constexpr std::ptrdiff_t m_flAnimationRate = 0x154C; // float + constexpr std::ptrdiff_t m_bScaleAnimationRate = 0x1550; // bool + constexpr std::ptrdiff_t m_bForceLoopingAnimation = 0x1551; // bool + constexpr std::ptrdiff_t m_bResetAnimOnStop = 0x1552; // bool + constexpr std::ptrdiff_t m_bManualAnimFrame = 0x1553; // bool + constexpr std::ptrdiff_t m_nAnimationScaleField = 0x1554; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nAnimationField = 0x1558; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nManualFrameField = 0x155C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_ActivityName = 0x1560; // char[256] + constexpr std::ptrdiff_t m_SequenceName = 0x1660; // char[256] + constexpr std::ptrdiff_t m_bEnableClothSimulation = 0x1760; // bool + constexpr std::ptrdiff_t m_hOverrideMaterial = 0x1768; // CStrongHandle + constexpr std::ptrdiff_t m_bOverrideTranslucentMaterials = 0x1770; // bool + constexpr std::ptrdiff_t m_nSkin = 0x1778; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_MaterialVars = 0x18D0; // CUtlVector + constexpr std::ptrdiff_t m_modelInput = 0x18E8; // CParticleModelInput + constexpr std::ptrdiff_t m_nLOD = 0x1948; // int32_t + constexpr std::ptrdiff_t m_EconSlotName = 0x194C; // char[256] + constexpr std::ptrdiff_t m_bOriginalModel = 0x1A4C; // bool + constexpr std::ptrdiff_t m_bSuppressTint = 0x1A4D; // bool + constexpr std::ptrdiff_t m_bUseRawMeshGroup = 0x1A4E; // bool + constexpr std::ptrdiff_t m_bDisableShadows = 0x1A4F; // bool + constexpr std::ptrdiff_t m_bAcceptsDecals = 0x1A50; // bool + constexpr std::ptrdiff_t m_bForceDrawInterlevedWithSiblings = 0x1A51; // bool + constexpr std::ptrdiff_t m_bDoNotDrawInParticlePass = 0x1A52; // bool + constexpr std::ptrdiff_t m_szRenderAttribute = 0x1A53; // char[260] + constexpr std::ptrdiff_t m_flRadiusScale = 0x1B58; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flAlphaScale = 0x1CB0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flRollScale = 0x1E08; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nAlpha2Field = 0x1F60; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecColorScale = 0x1F68; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nColorBlendType = 0x25C0; // ParticleColorBlendType_t +} + +namespace C_OP_RenderOmni2Light { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_nLightType = 0x200; // ParticleOmni2LightTypeChoiceList_t + constexpr std::ptrdiff_t m_vColorBlend = 0x208; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nColorBlendType = 0x860; // ParticleColorBlendType_t + constexpr std::ptrdiff_t m_nBrightnessUnit = 0x864; // ParticleLightUnitChoiceList_t + constexpr std::ptrdiff_t m_flBrightnessLumens = 0x868; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flBrightnessCandelas = 0x9C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bCastShadows = 0xB18; // bool + constexpr std::ptrdiff_t m_flLuminaireRadius = 0xB20; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flSkirt = 0xC78; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRange = 0xDD0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInnerConeAngle = 0xF28; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flOuterConeAngle = 0x1080; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_hLightCookie = 0x11D8; // CStrongHandle + constexpr std::ptrdiff_t m_bSphericalCookie = 0x11E0; // bool +} + +namespace C_OP_RenderPoints { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_hMaterial = 0x200; // CStrongHandle +} + +namespace C_OP_RenderPostProcessing { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flPostProcessStrength = 0x200; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_hPostTexture = 0x358; // CStrongHandle + constexpr std::ptrdiff_t m_nPriority = 0x360; // ParticlePostProcessPriorityGroup_t +} + +namespace C_OP_RenderProjected { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_bProjectCharacter = 0x200; // bool + constexpr std::ptrdiff_t m_bProjectWorld = 0x201; // bool + constexpr std::ptrdiff_t m_bProjectWater = 0x202; // bool + constexpr std::ptrdiff_t m_bFlipHorizontal = 0x203; // bool + constexpr std::ptrdiff_t m_bEnableProjectedDepthControls = 0x204; // bool + constexpr std::ptrdiff_t m_flMinProjectionDepth = 0x208; // float + constexpr std::ptrdiff_t m_flMaxProjectionDepth = 0x20C; // float + constexpr std::ptrdiff_t m_hProjectedMaterial = 0x210; // CStrongHandle + constexpr std::ptrdiff_t m_flAnimationTimeScale = 0x218; // float + constexpr std::ptrdiff_t m_bOrientToNormal = 0x21C; // bool + constexpr std::ptrdiff_t m_MaterialVars = 0x220; // CUtlVector +} + +namespace C_OP_RenderRopes { // CBaseRendererSource2 + constexpr std::ptrdiff_t m_bEnableFadingAndClamping = 0x2470; // bool + constexpr std::ptrdiff_t m_flMinSize = 0x2474; // float + constexpr std::ptrdiff_t m_flMaxSize = 0x2478; // float + constexpr std::ptrdiff_t m_flStartFadeSize = 0x247C; // float + constexpr std::ptrdiff_t m_flEndFadeSize = 0x2480; // float + constexpr std::ptrdiff_t m_flStartFadeDot = 0x2484; // float + constexpr std::ptrdiff_t m_flEndFadeDot = 0x2488; // float + constexpr std::ptrdiff_t m_flRadiusTaper = 0x248C; // float + constexpr std::ptrdiff_t m_nMinTesselation = 0x2490; // int32_t + constexpr std::ptrdiff_t m_nMaxTesselation = 0x2494; // int32_t + constexpr std::ptrdiff_t m_flTessScale = 0x2498; // float + constexpr std::ptrdiff_t m_flTextureVWorldSize = 0x24A0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flTextureVScrollRate = 0x25F8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flTextureVOffset = 0x2750; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nTextureVParamsCP = 0x28A8; // int32_t + constexpr std::ptrdiff_t m_bClampV = 0x28AC; // bool + constexpr std::ptrdiff_t m_nScaleCP1 = 0x28B0; // int32_t + constexpr std::ptrdiff_t m_nScaleCP2 = 0x28B4; // int32_t + constexpr std::ptrdiff_t m_flScaleVSizeByControlPointDistance = 0x28B8; // float + constexpr std::ptrdiff_t m_flScaleVScrollByControlPointDistance = 0x28BC; // float + constexpr std::ptrdiff_t m_flScaleVOffsetByControlPointDistance = 0x28C0; // float + constexpr std::ptrdiff_t m_bUseScalarForTextureCoordinate = 0x28C5; // bool + constexpr std::ptrdiff_t m_nScalarFieldForTextureCoordinate = 0x28C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScalarAttributeTextureCoordScale = 0x28CC; // float + constexpr std::ptrdiff_t m_bReverseOrder = 0x28D0; // bool + constexpr std::ptrdiff_t m_bClosedLoop = 0x28D1; // bool + constexpr std::ptrdiff_t m_nOrientationType = 0x28D4; // ParticleOrientationChoiceList_t + constexpr std::ptrdiff_t m_nVectorFieldForOrientation = 0x28D8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bDrawAsOpaque = 0x28DC; // bool + constexpr std::ptrdiff_t m_bGenerateNormals = 0x28DD; // bool +} + +namespace C_OP_RenderScreenShake { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flDurationScale = 0x200; // float + constexpr std::ptrdiff_t m_flRadiusScale = 0x204; // float + constexpr std::ptrdiff_t m_flFrequencyScale = 0x208; // float + constexpr std::ptrdiff_t m_flAmplitudeScale = 0x20C; // float + constexpr std::ptrdiff_t m_nRadiusField = 0x210; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nDurationField = 0x214; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFrequencyField = 0x218; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nAmplitudeField = 0x21C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFilterCP = 0x220; // int32_t +} + +namespace C_OP_RenderScreenVelocityRotate { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flRotateRateDegrees = 0x200; // float + constexpr std::ptrdiff_t m_flForwardDegrees = 0x204; // float +} + +namespace C_OP_RenderSound { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flDurationScale = 0x200; // float + constexpr std::ptrdiff_t m_flSndLvlScale = 0x204; // float + constexpr std::ptrdiff_t m_flPitchScale = 0x208; // float + constexpr std::ptrdiff_t m_flVolumeScale = 0x20C; // float + constexpr std::ptrdiff_t m_nSndLvlField = 0x210; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nDurationField = 0x214; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nPitchField = 0x218; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nVolumeField = 0x21C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nChannel = 0x220; // int32_t + constexpr std::ptrdiff_t m_nCPReference = 0x224; // int32_t + constexpr std::ptrdiff_t m_pszSoundName = 0x228; // char[256] + constexpr std::ptrdiff_t m_bSuppressStopSoundEvent = 0x328; // bool +} + +namespace C_OP_RenderSprites { // CBaseRendererSource2 + constexpr std::ptrdiff_t m_nSequenceOverride = 0x2470; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nOrientationType = 0x25C8; // ParticleOrientationChoiceList_t + constexpr std::ptrdiff_t m_nOrientationControlPoint = 0x25CC; // int32_t + constexpr std::ptrdiff_t m_bUseYawWithNormalAligned = 0x25D0; // bool + constexpr std::ptrdiff_t m_flMinSize = 0x25D4; // float + constexpr std::ptrdiff_t m_flMaxSize = 0x25D8; // float + constexpr std::ptrdiff_t m_flAlphaAdjustWithSizeAdjust = 0x25DC; // float + constexpr std::ptrdiff_t m_flStartFadeSize = 0x25E0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flEndFadeSize = 0x2738; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flStartFadeDot = 0x2890; // float + constexpr std::ptrdiff_t m_flEndFadeDot = 0x2894; // float + constexpr std::ptrdiff_t m_bDistanceAlpha = 0x2898; // bool + constexpr std::ptrdiff_t m_bSoftEdges = 0x2899; // bool + constexpr std::ptrdiff_t m_flEdgeSoftnessStart = 0x289C; // float + constexpr std::ptrdiff_t m_flEdgeSoftnessEnd = 0x28A0; // float + constexpr std::ptrdiff_t m_bOutline = 0x28A4; // bool + constexpr std::ptrdiff_t m_OutlineColor = 0x28A5; // Color + constexpr std::ptrdiff_t m_nOutlineAlpha = 0x28AC; // int32_t + constexpr std::ptrdiff_t m_flOutlineStart0 = 0x28B0; // float + constexpr std::ptrdiff_t m_flOutlineStart1 = 0x28B4; // float + constexpr std::ptrdiff_t m_flOutlineEnd0 = 0x28B8; // float + constexpr std::ptrdiff_t m_flOutlineEnd1 = 0x28BC; // float + constexpr std::ptrdiff_t m_nLightingMode = 0x28C0; // ParticleLightingQuality_t + constexpr std::ptrdiff_t m_flLightingTessellation = 0x28C8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flLightingDirectionality = 0x2A20; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_bParticleShadows = 0x2B78; // bool + constexpr std::ptrdiff_t m_flShadowDensity = 0x2B7C; // float +} + +namespace C_OP_RenderStandardLight { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_nLightType = 0x200; // ParticleLightTypeChoiceList_t + constexpr std::ptrdiff_t m_vecColorScale = 0x208; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_nColorBlendType = 0x860; // ParticleColorBlendType_t + constexpr std::ptrdiff_t m_flIntensity = 0x868; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bCastShadows = 0x9C0; // bool + constexpr std::ptrdiff_t m_flTheta = 0x9C8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flPhi = 0xB20; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flRadiusMultiplier = 0xC78; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nAttenuationStyle = 0xDD0; // StandardLightingAttenuationStyle_t + constexpr std::ptrdiff_t m_flFalloffLinearity = 0xDD8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flFiftyPercentFalloff = 0xF30; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flZeroPercentFalloff = 0x1088; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bRenderDiffuse = 0x11E0; // bool + constexpr std::ptrdiff_t m_bRenderSpecular = 0x11E1; // bool + constexpr std::ptrdiff_t m_lightCookie = 0x11E8; // CUtlString + constexpr std::ptrdiff_t m_nPriority = 0x11F0; // int32_t + constexpr std::ptrdiff_t m_nFogLightingMode = 0x11F4; // ParticleLightFogLightingMode_t + constexpr std::ptrdiff_t m_flFogContribution = 0x11F8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_nCapsuleLightBehavior = 0x1350; // ParticleLightBehaviorChoiceList_t + constexpr std::ptrdiff_t m_flCapsuleLength = 0x1354; // float + constexpr std::ptrdiff_t m_bReverseOrder = 0x1358; // bool + constexpr std::ptrdiff_t m_bClosedLoop = 0x1359; // bool + constexpr std::ptrdiff_t m_nPrevPntSource = 0x135C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flMaxLength = 0x1360; // float + constexpr std::ptrdiff_t m_flMinLength = 0x1364; // float + constexpr std::ptrdiff_t m_bIgnoreDT = 0x1368; // bool + constexpr std::ptrdiff_t m_flConstrainRadiusToLengthRatio = 0x136C; // float + constexpr std::ptrdiff_t m_flLengthScale = 0x1370; // float + constexpr std::ptrdiff_t m_flLengthFadeInTime = 0x1374; // float +} + +namespace C_OP_RenderStatusEffect { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_pTextureColorWarp = 0x200; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureDetail2 = 0x208; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureDiffuseWarp = 0x210; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureFresnelColorWarp = 0x218; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureFresnelWarp = 0x220; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureSpecularWarp = 0x228; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureEnvMap = 0x230; // CStrongHandle +} + +namespace C_OP_RenderStatusEffectCitadel { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_pTextureColorWarp = 0x200; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureNormal = 0x208; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureMetalness = 0x210; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureRoughness = 0x218; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureSelfIllum = 0x220; // CStrongHandle + constexpr std::ptrdiff_t m_pTextureDetail = 0x228; // CStrongHandle +} + +namespace C_OP_RenderText { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_OutlineColor = 0x200; // Color + constexpr std::ptrdiff_t m_DefaultText = 0x208; // CUtlString +} + +namespace C_OP_RenderTonemapController { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flTonemapLevel = 0x200; // float + constexpr std::ptrdiff_t m_flTonemapWeight = 0x204; // float + constexpr std::ptrdiff_t m_nTonemapLevelField = 0x208; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nTonemapWeightField = 0x20C; // ParticleAttributeIndex_t +} + +namespace C_OP_RenderTrails { // CBaseTrailRenderer + constexpr std::ptrdiff_t m_bEnableFadingAndClamping = 0x2740; // bool + constexpr std::ptrdiff_t m_flStartFadeDot = 0x2744; // float + constexpr std::ptrdiff_t m_flEndFadeDot = 0x2748; // float + constexpr std::ptrdiff_t m_nPrevPntSource = 0x274C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flMaxLength = 0x2750; // float + constexpr std::ptrdiff_t m_flMinLength = 0x2754; // float + constexpr std::ptrdiff_t m_bIgnoreDT = 0x2758; // bool + constexpr std::ptrdiff_t m_flConstrainRadiusToLengthRatio = 0x275C; // float + constexpr std::ptrdiff_t m_flLengthScale = 0x2760; // float + constexpr std::ptrdiff_t m_flLengthFadeInTime = 0x2764; // float + constexpr std::ptrdiff_t m_flRadiusHeadTaper = 0x2768; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecHeadColorScale = 0x28C0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_flHeadAlphaScale = 0x2F18; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRadiusTaper = 0x3070; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecTailColorScale = 0x31C8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_flTailAlphaScale = 0x3820; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nHorizCropField = 0x3978; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nVertCropField = 0x397C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flForwardShift = 0x3980; // float + constexpr std::ptrdiff_t m_bFlipUVBasedOnPitchYaw = 0x3984; // bool +} + +namespace C_OP_RenderTreeShake { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_flPeakStrength = 0x200; // float + constexpr std::ptrdiff_t m_nPeakStrengthFieldOverride = 0x204; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flRadius = 0x208; // float + constexpr std::ptrdiff_t m_nRadiusFieldOverride = 0x20C; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flShakeDuration = 0x210; // float + constexpr std::ptrdiff_t m_flTransitionTime = 0x214; // float + constexpr std::ptrdiff_t m_flTwistAmount = 0x218; // float + constexpr std::ptrdiff_t m_flRadialAmount = 0x21C; // float + constexpr std::ptrdiff_t m_flControlPointOrientationAmount = 0x220; // float + constexpr std::ptrdiff_t m_nControlPointForLinearDirection = 0x224; // int32_t +} + +namespace C_OP_RenderVRHapticEvent { // CParticleFunctionRenderer + constexpr std::ptrdiff_t m_nHand = 0x200; // ParticleVRHandChoiceList_t + constexpr std::ptrdiff_t m_nOutputHandCP = 0x204; // int32_t + constexpr std::ptrdiff_t m_nOutputField = 0x208; // int32_t + constexpr std::ptrdiff_t m_flAmplitude = 0x210; // CPerParticleFloatInput +} + +namespace C_OP_RepeatedTriggerChildGroup { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nChildGroupID = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_flClusterRefireTime = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flClusterSize = 0x330; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flClusterCooldown = 0x488; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bLimitChildCount = 0x5E0; // bool +} + +namespace C_OP_RestartAfterDuration { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flDurationMin = 0x1C0; // float + constexpr std::ptrdiff_t m_flDurationMax = 0x1C4; // float + constexpr std::ptrdiff_t m_nCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nCPField = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_nChildGroupID = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_bOnlyChildren = 0x1D4; // bool +} + +namespace C_OP_RopeSpringConstraint { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_flRestLength = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flMinDistance = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flMaxDistance = 0x470; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flAdjustmentScale = 0x5C8; // float + constexpr std::ptrdiff_t m_flInitialRestingLength = 0x5D0; // CParticleCollectionFloatInput +} + +namespace C_OP_RotateVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecRotAxisMin = 0x1C4; // Vector + constexpr std::ptrdiff_t m_vecRotAxisMax = 0x1D0; // Vector + constexpr std::ptrdiff_t m_flRotRateMin = 0x1DC; // float + constexpr std::ptrdiff_t m_flRotRateMax = 0x1E0; // float + constexpr std::ptrdiff_t m_bNormalize = 0x1E4; // bool + constexpr std::ptrdiff_t m_flScale = 0x1E8; // CPerParticleFloatInput +} + +namespace C_OP_RtEnvCull { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_vecTestDir = 0x1C0; // Vector + constexpr std::ptrdiff_t m_vecTestNormal = 0x1CC; // Vector + constexpr std::ptrdiff_t m_bCullOnMiss = 0x1D8; // bool + constexpr std::ptrdiff_t m_bStickInsteadOfCull = 0x1D9; // bool + constexpr std::ptrdiff_t m_RtEnvName = 0x1DA; // char[128] + constexpr std::ptrdiff_t m_nRTEnvCP = 0x25C; // int32_t + constexpr std::ptrdiff_t m_nComponent = 0x260; // int32_t +} + +namespace C_OP_SDFConstraint { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_flMinDist = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flMaxDist = 0x318; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nMaxIterations = 0x470; // int32_t +} + +namespace C_OP_SDFForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flForceScale = 0x1D0; // float +} + +namespace C_OP_SDFLighting { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_vLightingDir = 0x1C0; // Vector + constexpr std::ptrdiff_t m_vTint_0 = 0x1CC; // Vector + constexpr std::ptrdiff_t m_vTint_1 = 0x1D8; // Vector +} + +namespace C_OP_SelectivelyEnableChildren { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nChildGroupID = 0x1D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nFirstChild = 0x328; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nNumChildrenToEnable = 0x480; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bPlayEndcapOnStop = 0x5D8; // bool + constexpr std::ptrdiff_t m_bDestroyImmediately = 0x5D9; // bool +} + +namespace C_OP_SequenceFromModel { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nFieldOutputAnim = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flInputMin = 0x1CC; // float + constexpr std::ptrdiff_t m_flInputMax = 0x1D0; // float + constexpr std::ptrdiff_t m_flOutputMin = 0x1D4; // float + constexpr std::ptrdiff_t m_flOutputMax = 0x1D8; // float + constexpr std::ptrdiff_t m_nSetMethod = 0x1DC; // ParticleSetMethod_t +} + +namespace C_OP_SetAttributeToScalarExpression { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nExpression = 0x1C0; // ScalarExpressionType_t + constexpr std::ptrdiff_t m_flInput1 = 0x1C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flInput2 = 0x320; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0x478; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0x47C; // ParticleSetMethod_t +} + +namespace C_OP_SetCPOrientationToDirection { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nInputControlPoint = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nOutputControlPoint = 0x1C4; // int32_t +} + +namespace C_OP_SetCPOrientationToGroundNormal { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flInterpRate = 0x1C0; // float + constexpr std::ptrdiff_t m_flMaxTraceLength = 0x1C4; // float + constexpr std::ptrdiff_t m_flTolerance = 0x1C8; // float + constexpr std::ptrdiff_t m_flTraceOffset = 0x1CC; // float + constexpr std::ptrdiff_t m_CollisionGroupName = 0x1D0; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x250; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_nInputCP = 0x254; // int32_t + constexpr std::ptrdiff_t m_nOutputCP = 0x258; // int32_t + constexpr std::ptrdiff_t m_bIncludeWater = 0x268; // bool +} + +namespace C_OP_SetCPOrientationToPointAtCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nInputCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nOutputCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_flInterpolation = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_b2DOrientation = 0x330; // bool + constexpr std::ptrdiff_t m_bAvoidSingularity = 0x331; // bool + constexpr std::ptrdiff_t m_bPointAway = 0x332; // bool +} + +namespace C_OP_SetCPtoVector { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCPInput = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C4; // ParticleAttributeIndex_t +} + +namespace C_OP_SetChildControlPoints { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nChildGroupID = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFirstControlPoint = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nNumControlPoints = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nFirstSourcePoint = 0x1D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bReverse = 0x328; // bool + constexpr std::ptrdiff_t m_bSetOrientation = 0x329; // bool +} + +namespace C_OP_SetControlPointFieldFromVectorExpression { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nExpression = 0x1D0; // VectorFloatExpressionType_t + constexpr std::ptrdiff_t m_vecInput1 = 0x1D8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_vecInput2 = 0x830; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_flOutputRemap = 0xE88; // CParticleRemapFloatInput + constexpr std::ptrdiff_t m_nOutputCP = 0xFE0; // int32_t + constexpr std::ptrdiff_t m_nOutVectorField = 0xFE4; // int32_t +} + +namespace C_OP_SetControlPointFieldToScalarExpression { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nExpression = 0x1D0; // ScalarExpressionType_t + constexpr std::ptrdiff_t m_flInput1 = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInput2 = 0x330; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flOutputRemap = 0x488; // CParticleRemapFloatInput + constexpr std::ptrdiff_t m_nOutputCP = 0x5E0; // int32_t + constexpr std::ptrdiff_t m_nOutVectorField = 0x5E4; // int32_t +} + +namespace C_OP_SetControlPointFieldToWater { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nSourceCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nDestCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nCPField = 0x1D8; // int32_t +} + +namespace C_OP_SetControlPointFromObjectScale { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCPInput = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPOutput = 0x1D4; // int32_t +} + +namespace C_OP_SetControlPointOrientation { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_bUseWorldLocation = 0x1D0; // bool + constexpr std::ptrdiff_t m_bRandomize = 0x1D2; // bool + constexpr std::ptrdiff_t m_bSetOnce = 0x1D3; // bool + constexpr std::ptrdiff_t m_nCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nHeadLocation = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_vecRotation = 0x1DC; // QAngle + constexpr std::ptrdiff_t m_vecRotationB = 0x1E8; // QAngle + constexpr std::ptrdiff_t m_flInterpolation = 0x1F8; // CParticleCollectionFloatInput +} + +namespace C_OP_SetControlPointOrientationToCPVelocity { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCPInput = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPOutput = 0x1D4; // int32_t +} + +namespace C_OP_SetControlPointPositionToRandomActiveCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCP1 = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nHeadLocationMin = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nHeadLocationMax = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_flResetRate = 0x1E0; // CParticleCollectionFloatInput +} + +namespace C_OP_SetControlPointPositionToTimeOfDayValue { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_pszTimeOfDayParameter = 0x1D4; // char[128] + constexpr std::ptrdiff_t m_vecDefaultValue = 0x254; // Vector +} + +namespace C_OP_SetControlPointPositions { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_bUseWorldLocation = 0x1D0; // bool + constexpr std::ptrdiff_t m_bOrient = 0x1D1; // bool + constexpr std::ptrdiff_t m_bSetOnce = 0x1D2; // bool + constexpr std::ptrdiff_t m_nCP1 = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nCP2 = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nCP3 = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_nCP4 = 0x1E0; // int32_t + constexpr std::ptrdiff_t m_vecCP1Pos = 0x1E4; // Vector + constexpr std::ptrdiff_t m_vecCP2Pos = 0x1F0; // Vector + constexpr std::ptrdiff_t m_vecCP3Pos = 0x1FC; // Vector + constexpr std::ptrdiff_t m_vecCP4Pos = 0x208; // Vector + constexpr std::ptrdiff_t m_nHeadLocation = 0x214; // int32_t +} + +namespace C_OP_SetControlPointRotation { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_vecRotAxis = 0x1D0; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_flRotRate = 0x828; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nCP = 0x980; // int32_t + constexpr std::ptrdiff_t m_nLocalCP = 0x984; // int32_t +} + +namespace C_OP_SetControlPointToCPVelocity { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCPInput = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPOutputVel = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_bNormalize = 0x1D8; // bool + constexpr std::ptrdiff_t m_nCPOutputMag = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_nCPField = 0x1E0; // int32_t + constexpr std::ptrdiff_t m_vecComparisonVelocity = 0x1E8; // CParticleCollectionVecInput +} + +namespace C_OP_SetControlPointToCenter { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCP1 = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_vecCP1Pos = 0x1D4; // Vector + constexpr std::ptrdiff_t m_nSetParent = 0x1E0; // ParticleParentSetMode_t +} + +namespace C_OP_SetControlPointToHMD { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCP1 = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_vecCP1Pos = 0x1D4; // Vector + constexpr std::ptrdiff_t m_bOrientToHMD = 0x1E0; // bool +} + +namespace C_OP_SetControlPointToHand { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCP1 = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nHand = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_vecCP1Pos = 0x1D8; // Vector + constexpr std::ptrdiff_t m_bOrientToHand = 0x1E4; // bool +} + +namespace C_OP_SetControlPointToImpactPoint { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCPOut = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPIn = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_flUpdateRate = 0x1D8; // float + constexpr std::ptrdiff_t m_flTraceLength = 0x1E0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flStartOffset = 0x338; // float + constexpr std::ptrdiff_t m_flOffset = 0x33C; // float + constexpr std::ptrdiff_t m_vecTraceDir = 0x340; // Vector + constexpr std::ptrdiff_t m_CollisionGroupName = 0x34C; // char[128] + constexpr std::ptrdiff_t m_nTraceSet = 0x3CC; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_bSetToEndpoint = 0x3D0; // bool + constexpr std::ptrdiff_t m_bTraceToClosestSurface = 0x3D1; // bool + constexpr std::ptrdiff_t m_bIncludeWater = 0x3D2; // bool +} + +namespace C_OP_SetControlPointToPlayer { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCP1 = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_vecCP1Pos = 0x1D4; // Vector + constexpr std::ptrdiff_t m_bOrientToEyes = 0x1E0; // bool +} + +namespace C_OP_SetControlPointToVectorExpression { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nExpression = 0x1D0; // VectorExpressionType_t + constexpr std::ptrdiff_t m_nOutputCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_vInput1 = 0x1D8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_vInput2 = 0x830; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_bNormalizedOutput = 0xE88; // bool +} + +namespace C_OP_SetControlPointToWaterSurface { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nSourceCP = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nDestCP = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nFlowCP = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nActiveCP = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_nActiveCPField = 0x1E0; // int32_t + constexpr std::ptrdiff_t m_flRetestRate = 0x1E8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bAdaptiveThreshold = 0x340; // bool +} + +namespace C_OP_SetControlPointsToModelParticles { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_HitboxSetName = 0x1C0; // char[128] + constexpr std::ptrdiff_t m_AttachmentName = 0x240; // char[128] + constexpr std::ptrdiff_t m_nFirstControlPoint = 0x2C0; // int32_t + constexpr std::ptrdiff_t m_nNumControlPoints = 0x2C4; // int32_t + constexpr std::ptrdiff_t m_nFirstSourcePoint = 0x2C8; // int32_t + constexpr std::ptrdiff_t m_bSkin = 0x2CC; // bool + constexpr std::ptrdiff_t m_bAttachment = 0x2CD; // bool +} + +namespace C_OP_SetControlPointsToParticle { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nChildGroupID = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFirstControlPoint = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nNumControlPoints = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nFirstSourcePoint = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_bSetOrientation = 0x1D0; // bool + constexpr std::ptrdiff_t m_nOrientationMode = 0x1D4; // ParticleOrientationSetMode_t + constexpr std::ptrdiff_t m_nSetParent = 0x1D8; // ParticleParentSetMode_t +} + +namespace C_OP_SetFloat { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0x318; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0x31C; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_Lerp = 0x320; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bUseNewCode = 0x478; // bool +} + +namespace C_OP_SetFloatAttributeToVectorExpression { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nExpression = 0x1C0; // VectorFloatExpressionType_t + constexpr std::ptrdiff_t m_vInput1 = 0x1C8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vInput2 = 0x820; // CPerParticleVecInput + constexpr std::ptrdiff_t m_flOutputRemap = 0xE78; // CParticleRemapFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0xFD0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0xFD4; // ParticleSetMethod_t +} + +namespace C_OP_SetFloatCollection { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nOutputField = 0x318; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0x31C; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_Lerp = 0x320; // CParticleCollectionFloatInput +} + +namespace C_OP_SetFromCPSnapshot { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nAttributeToRead = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nAttributeToWrite = 0x1C8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nLocalSpaceCP = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_bRandom = 0x1D0; // bool + constexpr std::ptrdiff_t m_bReverse = 0x1D1; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nSnapShotStartPoint = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nSnapShotIncrement = 0x330; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_flInterpolation = 0x488; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bSubSample = 0x5E0; // bool +} + +namespace C_OP_SetGravityToCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nCPInput = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPOutput = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_flScale = 0x1D8; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bSetOrientation = 0x330; // bool + constexpr std::ptrdiff_t m_bSetZDown = 0x331; // bool +} + +namespace C_OP_SetParentControlPointsToChildCP { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_nChildGroupID = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nChildControlPoint = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nNumControlPoints = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_nFirstSourcePoint = 0x1DC; // int32_t + constexpr std::ptrdiff_t m_bSetOrientation = 0x1E0; // bool +} + +namespace C_OP_SetPerChildControlPoint { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nChildGroupID = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFirstControlPoint = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nNumControlPoints = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nParticleIncrement = 0x1D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_nFirstSourcePoint = 0x328; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bSetOrientation = 0x480; // bool + constexpr std::ptrdiff_t m_nOrientationField = 0x484; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_bNumBasedOnParticleCount = 0x488; // bool +} + +namespace C_OP_SetPerChildControlPointFromAttribute { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nChildGroupID = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nFirstControlPoint = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nNumControlPoints = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nParticleIncrement = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_nFirstSourcePoint = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_bNumBasedOnParticleCount = 0x1D4; // bool + constexpr std::ptrdiff_t m_nAttributeToRead = 0x1D8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nCPField = 0x1DC; // int32_t +} + +namespace C_OP_SetRandomControlPointPosition { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_bUseWorldLocation = 0x1D0; // bool + constexpr std::ptrdiff_t m_bOrient = 0x1D1; // bool + constexpr std::ptrdiff_t m_nCP1 = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_nHeadLocation = 0x1D8; // int32_t + constexpr std::ptrdiff_t m_flReRandomRate = 0x1E0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_vecCPMinPos = 0x338; // Vector + constexpr std::ptrdiff_t m_vecCPMaxPos = 0x344; // Vector + constexpr std::ptrdiff_t m_flInterpolation = 0x350; // CParticleCollectionFloatInput +} + +namespace C_OP_SetSimulationRate { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_flSimulationScale = 0x1D0; // CParticleCollectionFloatInput +} + +namespace C_OP_SetSingleControlPointPosition { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_bSetOnce = 0x1D0; // bool + constexpr std::ptrdiff_t m_nCP1 = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_vecCP1Pos = 0x1D8; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_transformInput = 0x830; // CParticleTransformInput +} + +namespace C_OP_SetToCP { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_vecOffset = 0x1C4; // Vector + constexpr std::ptrdiff_t m_bOffsetLocal = 0x1D0; // bool +} + +namespace C_OP_SetVariable { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_variableReference = 0x1D0; // CParticleVariableRef + constexpr std::ptrdiff_t m_transformInput = 0x210; // CParticleTransformInput + constexpr std::ptrdiff_t m_positionOffset = 0x278; // Vector + constexpr std::ptrdiff_t m_rotationOffset = 0x284; // QAngle + constexpr std::ptrdiff_t m_vecInput = 0x290; // CParticleCollectionVecInput + constexpr std::ptrdiff_t m_floatInput = 0x8E8; // CParticleCollectionFloatInput +} + +namespace C_OP_SetVec { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_InputValue = 0x1C0; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nOutputField = 0x818; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0x81C; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_Lerp = 0x820; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bNormalizedOutput = 0x978; // bool +} + +namespace C_OP_SetVectorAttributeToVectorExpression { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nExpression = 0x1C0; // VectorExpressionType_t + constexpr std::ptrdiff_t m_vInput1 = 0x1C8; // CPerParticleVecInput + constexpr std::ptrdiff_t m_vInput2 = 0x820; // CPerParticleVecInput + constexpr std::ptrdiff_t m_nOutputField = 0xE78; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nSetMethod = 0xE7C; // ParticleSetMethod_t + constexpr std::ptrdiff_t m_bNormalizedOutput = 0xE80; // bool +} + +namespace C_OP_ShapeMatchingConstraint { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_flShapeRestorationTime = 0x1C0; // float +} + +namespace C_OP_SnapshotRigidSkinToBones { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_bTransformNormals = 0x1C0; // bool + constexpr std::ptrdiff_t m_bTransformRadii = 0x1C1; // bool + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C4; // int32_t +} + +namespace C_OP_SnapshotSkinToBones { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_bTransformNormals = 0x1C0; // bool + constexpr std::ptrdiff_t m_bTransformRadii = 0x1C1; // bool + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_flLifeTimeFadeStart = 0x1C8; // float + constexpr std::ptrdiff_t m_flLifeTimeFadeEnd = 0x1CC; // float + constexpr std::ptrdiff_t m_flJumpThreshold = 0x1D0; // float + constexpr std::ptrdiff_t m_flPrevPosScale = 0x1D4; // float +} + +namespace C_OP_Spin { // CGeneralSpin +} + +namespace C_OP_SpinUpdate { // CSpinUpdateBase +} + +namespace C_OP_SpinYaw { // CGeneralSpin +} + +namespace C_OP_SpringToVectorConstraint { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_flRestLength = 0x1C0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flMinDistance = 0x318; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flMaxDistance = 0x470; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRestingLength = 0x5C8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecAnchorVector = 0x720; // CPerParticleVecInput +} + +namespace C_OP_StopAfterCPDuration { // CParticleFunctionPreEmission + constexpr std::ptrdiff_t m_flDuration = 0x1D0; // CParticleCollectionFloatInput + constexpr std::ptrdiff_t m_bDestroyImmediately = 0x328; // bool + constexpr std::ptrdiff_t m_bPlayEndCap = 0x329; // bool +} + +namespace C_OP_TeleportBeam { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nCPPosition = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nCPVelocity = 0x1C4; // int32_t + constexpr std::ptrdiff_t m_nCPMisc = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_nCPColor = 0x1CC; // int32_t + constexpr std::ptrdiff_t m_nCPInvalidColor = 0x1D0; // int32_t + constexpr std::ptrdiff_t m_nCPExtraArcData = 0x1D4; // int32_t + constexpr std::ptrdiff_t m_vGravity = 0x1D8; // Vector + constexpr std::ptrdiff_t m_flArcMaxDuration = 0x1E4; // float + constexpr std::ptrdiff_t m_flSegmentBreak = 0x1E8; // float + constexpr std::ptrdiff_t m_flArcSpeed = 0x1EC; // float + constexpr std::ptrdiff_t m_flAlpha = 0x1F0; // float +} + +namespace C_OP_TimeVaryingForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flStartLerpTime = 0x1D0; // float + constexpr std::ptrdiff_t m_StartingForce = 0x1D4; // Vector + constexpr std::ptrdiff_t m_flEndLerpTime = 0x1E0; // float + constexpr std::ptrdiff_t m_EndingForce = 0x1E4; // Vector +} + +namespace C_OP_TurbulenceForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_flNoiseCoordScale0 = 0x1D0; // float + constexpr std::ptrdiff_t m_flNoiseCoordScale1 = 0x1D4; // float + constexpr std::ptrdiff_t m_flNoiseCoordScale2 = 0x1D8; // float + constexpr std::ptrdiff_t m_flNoiseCoordScale3 = 0x1DC; // float + constexpr std::ptrdiff_t m_vecNoiseAmount0 = 0x1E0; // Vector + constexpr std::ptrdiff_t m_vecNoiseAmount1 = 0x1EC; // Vector + constexpr std::ptrdiff_t m_vecNoiseAmount2 = 0x1F8; // Vector + constexpr std::ptrdiff_t m_vecNoiseAmount3 = 0x204; // Vector +} + +namespace C_OP_TwistAroundAxis { // CParticleFunctionForce + constexpr std::ptrdiff_t m_fForceAmount = 0x1D0; // float + constexpr std::ptrdiff_t m_TwistAxis = 0x1D4; // Vector + constexpr std::ptrdiff_t m_bLocalSpace = 0x1E0; // bool + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1E4; // int32_t +} + +namespace C_OP_UpdateLightSource { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_vColorTint = 0x1C0; // Color + constexpr std::ptrdiff_t m_flBrightnessScale = 0x1C4; // float + constexpr std::ptrdiff_t m_flRadiusScale = 0x1C8; // float + constexpr std::ptrdiff_t m_flMinimumLightingRadius = 0x1CC; // float + constexpr std::ptrdiff_t m_flMaximumLightingRadius = 0x1D0; // float + constexpr std::ptrdiff_t m_flPositionDampingConstant = 0x1D4; // float +} + +namespace C_OP_VectorFieldSnapshot { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nControlPointNumber = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_nAttributeToWrite = 0x1C4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nLocalSpaceCP = 0x1C8; // int32_t + constexpr std::ptrdiff_t m_flInterpolation = 0x1D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_vecScale = 0x328; // CPerParticleVecInput + constexpr std::ptrdiff_t m_flBoundaryDampening = 0x980; // float + constexpr std::ptrdiff_t m_bSetVelocity = 0x984; // bool + constexpr std::ptrdiff_t m_bLockToSurface = 0x985; // bool + constexpr std::ptrdiff_t m_flGridSpacing = 0x988; // float +} + +namespace C_OP_VectorNoise { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_nFieldOutput = 0x1C0; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_vecOutputMin = 0x1C4; // Vector + constexpr std::ptrdiff_t m_vecOutputMax = 0x1D0; // Vector + constexpr std::ptrdiff_t m_fl4NoiseScale = 0x1DC; // float + constexpr std::ptrdiff_t m_bAdditive = 0x1E0; // bool + constexpr std::ptrdiff_t m_bOffset = 0x1E1; // bool + constexpr std::ptrdiff_t m_flNoiseAnimationTimeScale = 0x1E4; // float +} + +namespace C_OP_VelocityDecay { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flMinVelocity = 0x1C0; // float +} + +namespace C_OP_VelocityMatchingForce { // CParticleFunctionOperator + constexpr std::ptrdiff_t m_flDirScale = 0x1C0; // float + constexpr std::ptrdiff_t m_flSpdScale = 0x1C4; // float + constexpr std::ptrdiff_t m_nCPBroadcast = 0x1C8; // int32_t +} + +namespace C_OP_WindForce { // CParticleFunctionForce + constexpr std::ptrdiff_t m_vForce = 0x1D0; // Vector +} + +namespace C_OP_WorldCollideConstraint { // CParticleFunctionConstraint +} + +namespace C_OP_WorldTraceConstraint { // CParticleFunctionConstraint + constexpr std::ptrdiff_t m_nCP = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_vecCpOffset = 0x1C4; // Vector + constexpr std::ptrdiff_t m_nCollisionMode = 0x1D0; // ParticleCollisionMode_t + constexpr std::ptrdiff_t m_nCollisionModeMin = 0x1D4; // ParticleCollisionMode_t + constexpr std::ptrdiff_t m_nTraceSet = 0x1D8; // ParticleTraceSet_t + constexpr std::ptrdiff_t m_CollisionGroupName = 0x1DC; // char[128] + constexpr std::ptrdiff_t m_bWorldOnly = 0x25C; // bool + constexpr std::ptrdiff_t m_bBrushOnly = 0x25D; // bool + constexpr std::ptrdiff_t m_bIncludeWater = 0x25E; // bool + constexpr std::ptrdiff_t m_nIgnoreCP = 0x260; // int32_t + constexpr std::ptrdiff_t m_flCpMovementTolerance = 0x264; // float + constexpr std::ptrdiff_t m_flRetestRate = 0x268; // float + constexpr std::ptrdiff_t m_flTraceTolerance = 0x26C; // float + constexpr std::ptrdiff_t m_flCollisionConfirmationSpeed = 0x270; // float + constexpr std::ptrdiff_t m_nMaxTracesPerFrame = 0x274; // float + constexpr std::ptrdiff_t m_flRadiusScale = 0x278; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flBounceAmount = 0x3D0; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flSlideAmount = 0x528; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_flRandomDirScale = 0x680; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_bDecayBounce = 0x7D8; // bool + constexpr std::ptrdiff_t m_bKillonContact = 0x7D9; // bool + constexpr std::ptrdiff_t m_flMinSpeed = 0x7DC; // float + constexpr std::ptrdiff_t m_bSetNormal = 0x7E0; // bool + constexpr std::ptrdiff_t m_nStickOnCollisionField = 0x7E4; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flStopSpeed = 0x7E8; // CPerParticleFloatInput + constexpr std::ptrdiff_t m_nEntityStickDataField = 0x940; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_nEntityStickNormalField = 0x944; // ParticleAttributeIndex_t +} + +namespace CollisionGroupContext_t { + constexpr std::ptrdiff_t m_nCollisionGroupNumber = 0x0; // int32_t +} + +namespace ControlPointReference_t { + constexpr std::ptrdiff_t m_controlPointNameString = 0x0; // int32_t + constexpr std::ptrdiff_t m_vOffsetFromControlPoint = 0x4; // Vector + constexpr std::ptrdiff_t m_bOffsetInLocalSpace = 0x10; // bool +} + +namespace FloatInputMaterialVariable_t { + constexpr std::ptrdiff_t m_strVariable = 0x0; // CUtlString + constexpr std::ptrdiff_t m_flInput = 0x8; // CParticleCollectionFloatInput +} + +namespace IControlPointEditorData { +} + +namespace IParticleCollection { +} + +namespace IParticleEffect { +} + +namespace IParticleSystemDefinition { +} + +namespace MaterialVariable_t { + constexpr std::ptrdiff_t m_strVariable = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nVariableField = 0x8; // ParticleAttributeIndex_t + constexpr std::ptrdiff_t m_flScale = 0xC; // float +} + +namespace ModelReference_t { + constexpr std::ptrdiff_t m_model = 0x0; // CStrongHandle + constexpr std::ptrdiff_t m_flRelativeProbabilityOfSpawn = 0x8; // float +} + +namespace PARTICLE_EHANDLE__ { + constexpr std::ptrdiff_t unused = 0x0; // int32_t +} + +namespace PARTICLE_WORLD_HANDLE__ { + constexpr std::ptrdiff_t unused = 0x0; // int32_t +} + +namespace ParticleAttributeIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace ParticleChildrenInfo_t { + constexpr std::ptrdiff_t m_ChildRef = 0x0; // CStrongHandle + constexpr std::ptrdiff_t m_flDelay = 0x8; // float + constexpr std::ptrdiff_t m_bEndCap = 0xC; // bool + constexpr std::ptrdiff_t m_bDisableChild = 0xD; // bool + constexpr std::ptrdiff_t m_nDetailLevel = 0x10; // ParticleDetailLevel_t +} + +namespace ParticleControlPointConfiguration_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_drivers = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_previewState = 0x20; // ParticlePreviewState_t +} + +namespace ParticleControlPointDriver_t { + constexpr std::ptrdiff_t m_iControlPoint = 0x0; // int32_t + constexpr std::ptrdiff_t m_iAttachType = 0x4; // ParticleAttachment_t + constexpr std::ptrdiff_t m_attachmentName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_vecOffset = 0x10; // Vector + constexpr std::ptrdiff_t m_angOffset = 0x1C; // QAngle + constexpr std::ptrdiff_t m_entityName = 0x28; // CUtlString +} + +namespace ParticleNamedValueConfiguration_t { + constexpr std::ptrdiff_t m_ConfigName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_ConfigValue = 0x8; // KeyValues3 + constexpr std::ptrdiff_t m_iAttachType = 0x18; // ParticleAttachment_t + constexpr std::ptrdiff_t m_BoundEntityPath = 0x20; // CUtlString + constexpr std::ptrdiff_t m_strEntityScope = 0x28; // CUtlString + constexpr std::ptrdiff_t m_strAttachmentName = 0x30; // CUtlString +} + +namespace ParticleNamedValueSource_t { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_IsPublic = 0x8; // bool + constexpr std::ptrdiff_t m_ValueType = 0xC; // PulseValueType_t + constexpr std::ptrdiff_t m_DefaultConfig = 0x10; // ParticleNamedValueConfiguration_t + constexpr std::ptrdiff_t m_NamedConfigs = 0x48; // CUtlVector +} + +namespace ParticlePreviewBodyGroup_t { + constexpr std::ptrdiff_t m_bodyGroupName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nValue = 0x8; // int32_t +} + +namespace ParticlePreviewState_t { + constexpr std::ptrdiff_t m_previewModel = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nModSpecificData = 0x8; // uint32_t + constexpr std::ptrdiff_t m_groundType = 0xC; // PetGroundType_t + constexpr std::ptrdiff_t m_sequenceName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_nFireParticleOnSequenceFrame = 0x18; // int32_t + constexpr std::ptrdiff_t m_hitboxSetName = 0x20; // CUtlString + constexpr std::ptrdiff_t m_materialGroupName = 0x28; // CUtlString + constexpr std::ptrdiff_t m_vecBodyGroups = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_flPlaybackSpeed = 0x48; // float + constexpr std::ptrdiff_t m_flParticleSimulationRate = 0x4C; // float + constexpr std::ptrdiff_t m_bShouldDrawHitboxes = 0x50; // bool + constexpr std::ptrdiff_t m_bShouldDrawAttachments = 0x51; // bool + constexpr std::ptrdiff_t m_bShouldDrawAttachmentNames = 0x52; // bool + constexpr std::ptrdiff_t m_bShouldDrawControlPointAxes = 0x53; // bool + constexpr std::ptrdiff_t m_bAnimationNonLooping = 0x54; // bool + constexpr std::ptrdiff_t m_vecPreviewGravity = 0x58; // Vector +} + +namespace PointDefinitionWithTimeValues_t { // PointDefinition_t + constexpr std::ptrdiff_t m_flTimeDuration = 0x14; // float +} + +namespace PointDefinition_t { + constexpr std::ptrdiff_t m_nControlPoint = 0x0; // int32_t + constexpr std::ptrdiff_t m_bLocalCoords = 0x4; // bool + constexpr std::ptrdiff_t m_vOffset = 0x8; // Vector +} + +namespace SequenceWeightedList_t { + constexpr std::ptrdiff_t m_nSequence = 0x0; // int32_t + constexpr std::ptrdiff_t m_flRelativeWeight = 0x4; // float +} + +namespace TextureControls_t { + constexpr std::ptrdiff_t m_flFinalTextureScaleU = 0x0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flFinalTextureScaleV = 0x158; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flFinalTextureOffsetU = 0x2B0; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flFinalTextureOffsetV = 0x408; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flFinalTextureUVRotation = 0x560; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flZoomScale = 0x6B8; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_flDistortion = 0x810; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_bRandomizeOffsets = 0x968; // bool + constexpr std::ptrdiff_t m_bClampUVs = 0x969; // bool + constexpr std::ptrdiff_t m_nPerParticleBlend = 0x96C; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nPerParticleScale = 0x970; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nPerParticleOffsetU = 0x974; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nPerParticleOffsetV = 0x978; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nPerParticleRotation = 0x97C; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nPerParticleZoom = 0x980; // SpriteCardPerParticleScale_t + constexpr std::ptrdiff_t m_nPerParticleDistortion = 0x984; // SpriteCardPerParticleScale_t +} + +namespace TextureGroup_t { + constexpr std::ptrdiff_t m_bEnabled = 0x0; // bool + constexpr std::ptrdiff_t m_bReplaceTextureWithGradient = 0x1; // bool + constexpr std::ptrdiff_t m_hTexture = 0x8; // CStrongHandle + constexpr std::ptrdiff_t m_Gradient = 0x10; // CColorGradient + constexpr std::ptrdiff_t m_nTextureType = 0x28; // SpriteCardTextureType_t + constexpr std::ptrdiff_t m_nTextureChannels = 0x2C; // SpriteCardTextureChannel_t + constexpr std::ptrdiff_t m_nTextureBlendMode = 0x30; // ParticleTextureLayerBlendType_t + constexpr std::ptrdiff_t m_flTextureBlend = 0x38; // CParticleCollectionRendererFloatInput + constexpr std::ptrdiff_t m_TextureControls = 0x190; // TextureControls_t +} + +namespace VecInputMaterialVariable_t { + constexpr std::ptrdiff_t m_strVariable = 0x0; // CUtlString + constexpr std::ptrdiff_t m_vecInput = 0x8; // CParticleCollectionVecInput +} \ No newline at end of file diff --git a/HPCS2/offset/pulse_system.dll.hpp b/HPCS2/offset/pulse_system.dll.hpp new file mode 100644 index 0000000..e2cbd0d --- /dev/null +++ b/HPCS2/offset/pulse_system.dll.hpp @@ -0,0 +1,352 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace CBasePulseGraphInstance { +} + +namespace CPulseCell_Base { + constexpr std::ptrdiff_t m_nEditorNodeID = 0x8; // PulseDocNodeID_t +} + +namespace CPulseCell_BaseFlow { // CPulseCell_Base +} + +namespace CPulseCell_BaseValue { // CPulseCell_Base +} + +namespace CPulseCell_BaseYieldingInflow { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Inflow_BaseEntrypoint { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_EntryChunk = 0x48; // PulseRuntimeChunkIndex_t + constexpr std::ptrdiff_t m_RegisterMap = 0x50; // PulseRegisterMap_t +} + +namespace CPulseCell_Inflow_EntOutputHandler { // CPulseCell_Inflow_BaseEntrypoint + constexpr std::ptrdiff_t m_SourceEntity = 0x70; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SourceOutput = 0x78; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_TargetInput = 0x80; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_ExpectedParamType = 0x88; // CPulseValueFullType +} + +namespace CPulseCell_Inflow_EventHandler { // CPulseCell_Inflow_BaseEntrypoint + constexpr std::ptrdiff_t m_EventName = 0x70; // CUtlSymbolLarge +} + +namespace CPulseCell_Inflow_GraphHook { // CPulseCell_Inflow_BaseEntrypoint + constexpr std::ptrdiff_t m_HookName = 0x70; // CUtlSymbolLarge +} + +namespace CPulseCell_Inflow_Method { // CPulseCell_Inflow_BaseEntrypoint + constexpr std::ptrdiff_t m_MethodName = 0x70; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Description = 0x78; // CUtlString + constexpr std::ptrdiff_t m_bIsPublic = 0x80; // bool + constexpr std::ptrdiff_t m_ReturnType = 0x88; // CPulseValueFullType + constexpr std::ptrdiff_t m_Args = 0x98; // CUtlVector +} + +namespace CPulseCell_Inflow_Wait { // CPulseCell_BaseYieldingInflow + constexpr std::ptrdiff_t m_WakeResume = 0x48; // CPulse_ResumePoint +} + +namespace CPulseCell_Inflow_Yield { // CPulseCell_BaseYieldingInflow + constexpr std::ptrdiff_t m_UnyieldResume = 0x48; // CPulse_ResumePoint +} + +namespace CPulseCell_Outflow_CycleOrdered { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Outputs = 0x48; // CUtlVector +} + +namespace CPulseCell_Outflow_CycleOrdered_InstanceState_t { + constexpr std::ptrdiff_t m_nNextIndex = 0x0; // int32_t +} + +namespace CPulseCell_Outflow_CycleRandom { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Outputs = 0x48; // CUtlVector +} + +namespace CPulseCell_Outflow_CycleShuffled { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Outputs = 0x48; // CUtlVector +} + +namespace CPulseCell_Outflow_CycleShuffled_InstanceState_t { + constexpr std::ptrdiff_t m_Shuffle = 0x0; // CUtlVectorFixedGrowable + constexpr std::ptrdiff_t m_nNextShuffle = 0x20; // int32_t +} + +namespace CPulseCell_Outflow_IntSwitch { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_DefaultCaseOutflow = 0x48; // CPulse_OutflowConnection + constexpr std::ptrdiff_t m_CaseOutflows = 0x58; // CUtlVector +} + +namespace CPulseCell_Outflow_SimultaneousParallel { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Outputs = 0x48; // CUtlVector +} + +namespace CPulseCell_Outflow_StringSwitch { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_DefaultCaseOutflow = 0x48; // CPulse_OutflowConnection + constexpr std::ptrdiff_t m_CaseOutflows = 0x58; // CUtlVector +} + +namespace CPulseCell_Outflow_TestExplicitYesNo { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Yes = 0x48; // CPulse_OutflowConnection + constexpr std::ptrdiff_t m_No = 0x58; // CPulse_OutflowConnection +} + +namespace CPulseCell_Outflow_TestRandomYesNo { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Yes = 0x48; // CPulse_OutflowConnection + constexpr std::ptrdiff_t m_No = 0x58; // CPulse_OutflowConnection +} + +namespace CPulseCell_Step_CallExternalMethod { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_MethodName = 0x48; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_ExpectedArgs = 0x50; // CUtlVector +} + +namespace CPulseCell_Step_DebugLog { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Step_PublicOutput { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_OutputIndex = 0x48; // PulseRuntimeOutputIndex_t +} + +namespace CPulseCell_Step_TestDomainCreateFakeEntity { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Step_TestDomainDestroyFakeEntity { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Step_TestDomainEntFire { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Input = 0x48; // CUtlString +} + +namespace CPulseCell_Step_TestDomainTracepoint { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Test_MultiInflow_NoDefault { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Test_MultiInflow_WithDefault { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Test_NoInflow { // CPulseCell_BaseFlow +} + +namespace CPulseCell_Val_TestDomainFindEntityByName { // CPulseCell_BaseValue +} + +namespace CPulseCell_Val_TestDomainGetEntityName { // CPulseCell_BaseValue +} + +namespace CPulseCell_Value_RandomInt { // CPulseCell_BaseValue +} + +namespace CPulseCell_Value_TestValue50 { // CPulseCell_BaseValue +} + +namespace CPulseExecCursor { +} + +namespace CPulseGraphDef { + constexpr std::ptrdiff_t m_DomainIdentifier = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_ParentMapName = 0x10; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Chunks = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_Cells = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_Vars = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_PublicOutputs = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_InvokeBindings = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_CallInfos = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_OutputConnections = 0xA8; // CUtlVector +} + +namespace CPulseGraphInstance_TestDomain { // CBasePulseGraphInstance + constexpr std::ptrdiff_t m_bIsRunningUnitTests = 0xD0; // bool + constexpr std::ptrdiff_t m_bExplicitTimeStepping = 0xD1; // bool + constexpr std::ptrdiff_t m_bExpectingToDestroyWithYieldedCursors = 0xD2; // bool + constexpr std::ptrdiff_t m_nNextValidateIndex = 0xD4; // int32_t + constexpr std::ptrdiff_t m_Tracepoints = 0xD8; // CUtlVector + constexpr std::ptrdiff_t m_bTestYesOrNoPath = 0xF0; // bool +} + +namespace CPulseGraphInstance_TestDomain_Derived { // CPulseGraphInstance_TestDomain + constexpr std::ptrdiff_t m_nInstanceValueX = 0xF8; // int32_t +} + +namespace CPulseGraphInstance_TurtleGraphics { // CBasePulseGraphInstance +} + +namespace CPulseMathlib { +} + +namespace CPulseRuntimeMethodArg { + constexpr std::ptrdiff_t m_Name = 0x0; // CKV3MemberNameWithStorage + constexpr std::ptrdiff_t m_Description = 0x38; // CUtlString + constexpr std::ptrdiff_t m_Type = 0x40; // CPulseValueFullType +} + +namespace CPulseTestFuncs_DerivedDomain { +} + +namespace CPulseTestFuncs_LibraryA { +} + +namespace CPulseTestScriptLib { +} + +namespace CPulseTurtleGraphicsCursor { // CPulseExecCursor + constexpr std::ptrdiff_t m_Color = 0x188; // Color + constexpr std::ptrdiff_t m_vPos = 0x18C; // Vector2D + constexpr std::ptrdiff_t m_flHeadingDeg = 0x194; // float + constexpr std::ptrdiff_t m_bPenUp = 0x198; // bool +} + +namespace CPulse_CallInfo { + constexpr std::ptrdiff_t m_PortName = 0x0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nEditorNodeID = 0x8; // PulseDocNodeID_t + constexpr std::ptrdiff_t m_RegisterMap = 0x10; // PulseRegisterMap_t + constexpr std::ptrdiff_t m_CallMethodID = 0x30; // PulseDocNodeID_t + constexpr std::ptrdiff_t m_nSrcChunk = 0x34; // PulseRuntimeChunkIndex_t + constexpr std::ptrdiff_t m_nSrcInstruction = 0x38; // int32_t +} + +namespace CPulse_Chunk { + constexpr std::ptrdiff_t m_Instructions = 0x0; // CUtlLeanVector + constexpr std::ptrdiff_t m_Registers = 0x10; // CUtlLeanVector + constexpr std::ptrdiff_t m_InstructionEditorIDs = 0x20; // CUtlLeanVector +} + +namespace CPulse_InvokeBinding { + constexpr std::ptrdiff_t m_RegisterMap = 0x0; // PulseRegisterMap_t + constexpr std::ptrdiff_t m_FuncName = 0x20; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nCellIndex = 0x28; // PulseRuntimeCellIndex_t + constexpr std::ptrdiff_t m_InstanceType = 0x30; // CPulseValueFullType + constexpr std::ptrdiff_t m_nSrcChunk = 0x40; // PulseRuntimeChunkIndex_t + constexpr std::ptrdiff_t m_nSrcInstruction = 0x44; // int32_t +} + +namespace CPulse_OutflowConnection { + constexpr std::ptrdiff_t m_SourceOutflowName = 0x0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nDestChunk = 0x8; // PulseRuntimeChunkIndex_t + constexpr std::ptrdiff_t m_nInstruction = 0xC; // int32_t +} + +namespace CPulse_OutputConnection { + constexpr std::ptrdiff_t m_SourceOutput = 0x0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_TargetEntity = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_TargetInput = 0x10; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Param = 0x18; // CUtlSymbolLarge +} + +namespace CPulse_PublicOutput { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Description = 0x8; // CUtlString + constexpr std::ptrdiff_t m_ParamType = 0x10; // CPulseValueFullType +} + +namespace CPulse_RegisterInfo { + constexpr std::ptrdiff_t m_nReg = 0x0; // PulseRuntimeRegisterIndex_t + constexpr std::ptrdiff_t m_Type = 0x8; // CPulseValueFullType + constexpr std::ptrdiff_t m_OriginName = 0x18; // CKV3MemberNameWithStorage + constexpr std::ptrdiff_t m_nWrittenByInstruction = 0x50; // int32_t + constexpr std::ptrdiff_t m_nLastReadByInstruction = 0x54; // int32_t +} + +namespace CPulse_ResumePoint { // CPulse_OutflowConnection +} + +namespace CPulse_Variable { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Description = 0x8; // CUtlString + constexpr std::ptrdiff_t m_Type = 0x10; // CPulseValueFullType + constexpr std::ptrdiff_t m_DefaultValue = 0x20; // KeyValues3 + constexpr std::ptrdiff_t m_bIsPublic = 0x32; // bool +} + +namespace CTestDomainDerived_Cursor { // CPulseExecCursor + constexpr std::ptrdiff_t m_nCursorValueA = 0x188; // int32_t + constexpr std::ptrdiff_t m_nCursorValueB = 0x18C; // int32_t +} + +namespace FakeEntity_t { + constexpr std::ptrdiff_t m_nHandle = 0x0; // PulseTestEHandle_t + constexpr std::ptrdiff_t m_Name = 0x8; // CUtlString + constexpr std::ptrdiff_t m_Class = 0x10; // CUtlString + constexpr std::ptrdiff_t m_bDestroyed = 0x18; // bool + constexpr std::ptrdiff_t m_pAssociatedGraphInstance = 0x20; // CPulseGraphInstance_TestDomain* + constexpr std::ptrdiff_t m_bFuncWasCalled = 0x28; // bool + constexpr std::ptrdiff_t m_fValue = 0x2C; // float +} + +namespace PGDInstruction_t { + constexpr std::ptrdiff_t m_nCode = 0x0; // PulseInstructionCode_t + constexpr std::ptrdiff_t m_nVar = 0x4; // PulseRuntimeVarIndex_t + constexpr std::ptrdiff_t m_nReg0 = 0x8; // PulseRuntimeRegisterIndex_t + constexpr std::ptrdiff_t m_nReg1 = 0xA; // PulseRuntimeRegisterIndex_t + constexpr std::ptrdiff_t m_nReg2 = 0xC; // PulseRuntimeRegisterIndex_t + constexpr std::ptrdiff_t m_nInvokeBindingIndex = 0x10; // PulseRuntimeInvokeIndex_t + constexpr std::ptrdiff_t m_nChunk = 0x14; // PulseRuntimeChunkIndex_t + constexpr std::ptrdiff_t m_nDestInstruction = 0x18; // int32_t + constexpr std::ptrdiff_t m_nCallInfoIndex = 0x1C; // PulseRuntimeCallInfoIndex_t + constexpr std::ptrdiff_t m_Arg0Name = 0x20; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Arg1Name = 0x28; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bLiteralBool = 0x30; // bool + constexpr std::ptrdiff_t m_nLiteralInt = 0x34; // int32_t + constexpr std::ptrdiff_t m_flLiteralFloat = 0x38; // float + constexpr std::ptrdiff_t m_LiteralString = 0x40; // CBufferString + constexpr std::ptrdiff_t m_vLiteralVec3 = 0x50; // Vector +} + +namespace PulseDocNodeID_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseRegisterMap_t { + constexpr std::ptrdiff_t m_Inparams = 0x0; // KeyValues3 + constexpr std::ptrdiff_t m_Outparams = 0x10; // KeyValues3 +} + +namespace PulseRuntimeCallInfoIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseRuntimeCellIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseRuntimeChunkIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseRuntimeEntrypointIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseRuntimeInvokeIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseRuntimeOutputIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseRuntimeRegisterIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int16_t +} + +namespace PulseRuntimeStateOffset_t { + constexpr std::ptrdiff_t m_Value = 0x0; // uint16_t +} + +namespace PulseRuntimeVarIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PulseTestEHandle_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} \ No newline at end of file diff --git a/HPCS2/offset/rendersystemdx11.dll.hpp b/HPCS2/offset/rendersystemdx11.dll.hpp new file mode 100644 index 0000000..a211d27 --- /dev/null +++ b/HPCS2/offset/rendersystemdx11.dll.hpp @@ -0,0 +1,29 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace RenderInputLayoutField_t { + constexpr std::ptrdiff_t m_pSemanticName = 0x0; // uint8_t[32] + constexpr std::ptrdiff_t m_nSemanticIndex = 0x20; // int32_t + constexpr std::ptrdiff_t m_Format = 0x24; // uint32_t + constexpr std::ptrdiff_t m_nOffset = 0x28; // int32_t + constexpr std::ptrdiff_t m_nSlot = 0x2C; // int32_t + constexpr std::ptrdiff_t m_nSlotType = 0x30; // RenderSlotType_t + constexpr std::ptrdiff_t m_nInstanceStepRate = 0x34; // int32_t +} + +namespace VsInputSignatureElement_t { + constexpr std::ptrdiff_t m_pName = 0x0; // char[64] + constexpr std::ptrdiff_t m_pSemantic = 0x40; // char[64] + constexpr std::ptrdiff_t m_pD3DSemanticName = 0x80; // char[64] + constexpr std::ptrdiff_t m_nD3DSemanticIndex = 0xC0; // int32_t +} + +namespace VsInputSignature_t { + constexpr std::ptrdiff_t m_elems = 0x0; // CUtlVector +} \ No newline at end of file diff --git a/HPCS2/offset/resourcesystem.dll.hpp b/HPCS2/offset/resourcesystem.dll.hpp new file mode 100644 index 0000000..bd2c3a2 --- /dev/null +++ b/HPCS2/offset/resourcesystem.dll.hpp @@ -0,0 +1,213 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace AABB_t { + constexpr std::ptrdiff_t m_vMinBounds = 0x0; // Vector + constexpr std::ptrdiff_t m_vMaxBounds = 0xC; // Vector +} + +namespace CFuseProgram { + constexpr std::ptrdiff_t m_programBuffer = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_variablesRead = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_variablesWritten = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_nMaxTempVarsUsed = 0x48; // int32_t +} + +namespace CFuseSymbolTable { + constexpr std::ptrdiff_t m_constants = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_variables = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_functions = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_constantMap = 0x48; // CUtlHashtable + constexpr std::ptrdiff_t m_variableMap = 0x68; // CUtlHashtable + constexpr std::ptrdiff_t m_functionMap = 0x88; // CUtlHashtable +} + +namespace ConstantInfo_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nameToken = 0x8; // CUtlStringToken + constexpr std::ptrdiff_t m_flValue = 0xC; // float +} + +namespace FourQuaternions { + constexpr std::ptrdiff_t x = 0x0; // fltx4 + constexpr std::ptrdiff_t y = 0x10; // fltx4 + constexpr std::ptrdiff_t z = 0x20; // fltx4 + constexpr std::ptrdiff_t w = 0x30; // fltx4 +} + +namespace FunctionInfo_t { + constexpr std::ptrdiff_t m_name = 0x8; // CUtlString + constexpr std::ptrdiff_t m_nameToken = 0x10; // CUtlStringToken + constexpr std::ptrdiff_t m_nParamCount = 0x14; // int32_t + constexpr std::ptrdiff_t m_nIndex = 0x18; // FuseFunctionIndex_t + constexpr std::ptrdiff_t m_bIsPure = 0x1A; // bool +} + +namespace FuseFunctionIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // uint16_t +} + +namespace FuseVariableIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // uint16_t +} + +namespace InfoForResourceTypeCAnimData { +} + +namespace InfoForResourceTypeCAnimationGroup { +} + +namespace InfoForResourceTypeCCSGOEconItem { +} + +namespace InfoForResourceTypeCChoreoSceneFileData { +} + +namespace InfoForResourceTypeCCompositeMaterialKit { +} + +namespace InfoForResourceTypeCDACGameDefsData { +} + +namespace InfoForResourceTypeCDOTANovelsList { +} + +namespace InfoForResourceTypeCDOTAPatchNotesList { +} + +namespace InfoForResourceTypeCDotaItemDefinitionResource { +} + +namespace InfoForResourceTypeCEntityLump { +} + +namespace InfoForResourceTypeCJavaScriptResource { +} + +namespace InfoForResourceTypeCModel { +} + +namespace InfoForResourceTypeCMorphSetData { +} + +namespace InfoForResourceTypeCNmClip { +} + +namespace InfoForResourceTypeCNmSkeleton { +} + +namespace InfoForResourceTypeCPanoramaDynamicImages { +} + +namespace InfoForResourceTypeCPanoramaLayout { +} + +namespace InfoForResourceTypeCPanoramaStyle { +} + +namespace InfoForResourceTypeCPhysAggregateData { +} + +namespace InfoForResourceTypeCPostProcessingResource { +} + +namespace InfoForResourceTypeCRenderMesh { +} + +namespace InfoForResourceTypeCResponseRulesList { +} + +namespace InfoForResourceTypeCSequenceGroupData { +} + +namespace InfoForResourceTypeCSmartProp { +} + +namespace InfoForResourceTypeCTextureBase { +} + +namespace InfoForResourceTypeCTypeScriptResource { +} + +namespace InfoForResourceTypeCVDataResource { +} + +namespace InfoForResourceTypeCVMixListResource { +} + +namespace InfoForResourceTypeCVPhysXSurfacePropertiesList { +} + +namespace InfoForResourceTypeCVSoundEventScriptList { +} + +namespace InfoForResourceTypeCVSoundStackScriptList { +} + +namespace InfoForResourceTypeCVoxelVisibility { +} + +namespace InfoForResourceTypeCWorldNode { +} + +namespace InfoForResourceTypeIAnimGraphModelBinding { +} + +namespace InfoForResourceTypeIMaterial2 { +} + +namespace InfoForResourceTypeIParticleSnapshot { +} + +namespace InfoForResourceTypeIParticleSystemDefinition { +} + +namespace InfoForResourceTypeIPulseGraphDef { +} + +namespace InfoForResourceTypeIVectorGraphic { +} + +namespace InfoForResourceTypeManifestTestResource_t { +} + +namespace InfoForResourceTypeProceduralTestResource_t { +} + +namespace InfoForResourceTypeTestResource_t { +} + +namespace InfoForResourceTypeVSound_t { +} + +namespace InfoForResourceTypeWorld_t { +} + +namespace ManifestTestResource_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_child = 0x8; // CStrongHandle +} + +namespace PackedAABB_t { + constexpr std::ptrdiff_t m_nPackedMin = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nPackedMax = 0x4; // uint32_t +} + +namespace TestResource_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString +} + +namespace VariableInfo_t { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nameToken = 0x8; // CUtlStringToken + constexpr std::ptrdiff_t m_nIndex = 0xC; // FuseVariableIndex_t + constexpr std::ptrdiff_t m_nNumComponents = 0xE; // uint8_t + constexpr std::ptrdiff_t m_eVarType = 0xF; // FuseVariableType_t + constexpr std::ptrdiff_t m_eAccess = 0x10; // FuseVariableAccess_t +} \ No newline at end of file diff --git a/HPCS2/offset/scenesystem.dll.hpp b/HPCS2/offset/scenesystem.dll.hpp new file mode 100644 index 0000000..40c2600 --- /dev/null +++ b/HPCS2/offset/scenesystem.dll.hpp @@ -0,0 +1,61 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace CSSDSEndFrameViewInfo { + constexpr std::ptrdiff_t m_nViewId = 0x0; // uint64_t + constexpr std::ptrdiff_t m_ViewName = 0x8; // CUtlString +} + +namespace CSSDSMsg_EndFrame { + constexpr std::ptrdiff_t m_Views = 0x0; // CUtlVector +} + +namespace CSSDSMsg_LayerBase { + constexpr std::ptrdiff_t m_viewId = 0x0; // SceneViewId_t + constexpr std::ptrdiff_t m_ViewName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_nLayerIndex = 0x18; // int32_t + constexpr std::ptrdiff_t m_nLayerId = 0x20; // uint64_t + constexpr std::ptrdiff_t m_LayerName = 0x28; // CUtlString + constexpr std::ptrdiff_t m_displayText = 0x30; // CUtlString +} + +namespace CSSDSMsg_PostLayer { // CSSDSMsg_LayerBase +} + +namespace CSSDSMsg_PreLayer { // CSSDSMsg_LayerBase +} + +namespace CSSDSMsg_ViewRender { + constexpr std::ptrdiff_t m_viewId = 0x0; // SceneViewId_t + constexpr std::ptrdiff_t m_ViewName = 0x10; // CUtlString +} + +namespace CSSDSMsg_ViewTarget { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_TextureId = 0x8; // uint64_t + constexpr std::ptrdiff_t m_nWidth = 0x10; // int32_t + constexpr std::ptrdiff_t m_nHeight = 0x14; // int32_t + constexpr std::ptrdiff_t m_nRequestedWidth = 0x18; // int32_t + constexpr std::ptrdiff_t m_nRequestedHeight = 0x1C; // int32_t + constexpr std::ptrdiff_t m_nNumMipLevels = 0x20; // int32_t + constexpr std::ptrdiff_t m_nDepth = 0x24; // int32_t + constexpr std::ptrdiff_t m_nMultisampleNumSamples = 0x28; // int32_t + constexpr std::ptrdiff_t m_nFormat = 0x2C; // int32_t +} + +namespace CSSDSMsg_ViewTargetList { + constexpr std::ptrdiff_t m_viewId = 0x0; // SceneViewId_t + constexpr std::ptrdiff_t m_ViewName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_Targets = 0x18; // CUtlVector +} + +namespace SceneViewId_t { + constexpr std::ptrdiff_t m_nViewId = 0x0; // uint64_t + constexpr std::ptrdiff_t m_nFrameCount = 0x8; // uint64_t +} \ No newline at end of file diff --git a/HPCS2/offset/schemasystem.dll.hpp b/HPCS2/offset/schemasystem.dll.hpp new file mode 100644 index 0000000..5cf2755 --- /dev/null +++ b/HPCS2/offset/schemasystem.dll.hpp @@ -0,0 +1,57 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace CExampleSchemaVData_Monomorphic { + constexpr std::ptrdiff_t m_nExample1 = 0x0; // int32_t + constexpr std::ptrdiff_t m_nExample2 = 0x4; // int32_t +} + +namespace CExampleSchemaVData_PolymorphicBase { + constexpr std::ptrdiff_t m_nBase = 0x8; // int32_t +} + +namespace CExampleSchemaVData_PolymorphicDerivedA { // CExampleSchemaVData_PolymorphicBase + constexpr std::ptrdiff_t m_nDerivedA = 0x10; // int32_t +} + +namespace CExampleSchemaVData_PolymorphicDerivedB { // CExampleSchemaVData_PolymorphicBase + constexpr std::ptrdiff_t m_nDerivedB = 0x10; // int32_t +} + +namespace CSchemaSystemInternalRegistration { + constexpr std::ptrdiff_t m_Vector2D = 0x0; // Vector2D + constexpr std::ptrdiff_t m_Vector = 0x8; // Vector + constexpr std::ptrdiff_t m_VectorAligned = 0x20; // VectorAligned + constexpr std::ptrdiff_t m_Quaternion = 0x30; // Quaternion + constexpr std::ptrdiff_t m_QAngle = 0x40; // QAngle + constexpr std::ptrdiff_t m_RotationVector = 0x4C; // RotationVector + constexpr std::ptrdiff_t m_RadianEuler = 0x58; // RadianEuler + constexpr std::ptrdiff_t m_DegreeEuler = 0x64; // DegreeEuler + constexpr std::ptrdiff_t m_QuaternionStorage = 0x70; // QuaternionStorage + constexpr std::ptrdiff_t m_matrix3x4_t = 0x80; // matrix3x4_t + constexpr std::ptrdiff_t m_matrix3x4a_t = 0xB0; // matrix3x4a_t + constexpr std::ptrdiff_t m_Color = 0xE0; // Color + constexpr std::ptrdiff_t m_Vector4D = 0xE4; // Vector4D + constexpr std::ptrdiff_t m_CTransform = 0x100; // CTransform + constexpr std::ptrdiff_t m_pKeyValues = 0x120; // KeyValues* + constexpr std::ptrdiff_t m_CUtlBinaryBlock = 0x128; // CUtlBinaryBlock + constexpr std::ptrdiff_t m_CUtlString = 0x140; // CUtlString + constexpr std::ptrdiff_t m_CUtlSymbol = 0x148; // CUtlSymbol + constexpr std::ptrdiff_t m_stringToken = 0x14C; // CUtlStringToken + constexpr std::ptrdiff_t m_stringTokenWithStorage = 0x150; // CUtlStringTokenWithStorage + constexpr std::ptrdiff_t m_ResourceTypes = 0x168; // CResourceArray> + constexpr std::ptrdiff_t m_KV3 = 0x170; // KeyValues3 +} + +namespace InfoForResourceTypeCResourceManifestInternal { +} + +namespace ResourceId_t { + constexpr std::ptrdiff_t m_Value = 0x0; // uint64_t +} \ No newline at end of file diff --git a/HPCS2/offset/server.dll.hpp b/HPCS2/offset/server.dll.hpp new file mode 100644 index 0000000..71bef97 --- /dev/null +++ b/HPCS2/offset/server.dll.hpp @@ -0,0 +1,7168 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:21 +0000 + */ + +#pragma once + +#include + +namespace ActiveModelConfig_t { + constexpr std::ptrdiff_t m_Handle = 0x28; // ModelConfigHandle_t + constexpr std::ptrdiff_t m_Name = 0x30; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_AssociatedEntities = 0x38; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_AssociatedEntityNames = 0x50; // CNetworkUtlVectorBase +} + +namespace AmmoIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int8_t +} + +namespace AmmoTypeInfo_t { + constexpr std::ptrdiff_t m_nMaxCarry = 0x10; // int32_t + constexpr std::ptrdiff_t m_nSplashSize = 0x1C; // CRangeInt + constexpr std::ptrdiff_t m_nFlags = 0x24; // AmmoFlags_t + constexpr std::ptrdiff_t m_flMass = 0x28; // float + constexpr std::ptrdiff_t m_flSpeed = 0x2C; // CRangeFloat +} + +namespace AnimationUpdateListHandle_t { + constexpr std::ptrdiff_t m_Value = 0x0; // uint32_t +} + +namespace CAISound { // CPointEntity + constexpr std::ptrdiff_t m_iSoundType = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_iSoundContext = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_iVolume = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_iSoundIndex = 0x4BC; // int32_t + constexpr std::ptrdiff_t m_flDuration = 0x4C0; // float + constexpr std::ptrdiff_t m_iszProxyEntityName = 0x4C8; // CUtlSymbolLarge +} + +namespace CAI_ChangeHintGroup { // CBaseEntity + constexpr std::ptrdiff_t m_iSearchType = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_strSearchName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_strNewHintGroup = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flRadius = 0x4C8; // float +} + +namespace CAI_ChangeTarget { // CBaseEntity + constexpr std::ptrdiff_t m_iszNewTarget = 0x4B0; // CUtlSymbolLarge +} + +namespace CAI_Expresser { + constexpr std::ptrdiff_t m_flStopTalkTime = 0x38; // GameTime_t + constexpr std::ptrdiff_t m_flStopTalkTimeWithoutDelay = 0x3C; // GameTime_t + constexpr std::ptrdiff_t m_flBlockedTalkTime = 0x40; // GameTime_t + constexpr std::ptrdiff_t m_voicePitch = 0x44; // int32_t + constexpr std::ptrdiff_t m_flLastTimeAcceptedSpeak = 0x48; // GameTime_t + constexpr std::ptrdiff_t m_bAllowSpeakingInterrupts = 0x4C; // bool + constexpr std::ptrdiff_t m_bConsiderSceneInvolvementAsSpeech = 0x4D; // bool + constexpr std::ptrdiff_t m_nLastSpokenPriority = 0x50; // int32_t + constexpr std::ptrdiff_t m_pOuter = 0x58; // CBaseFlex* +} + +namespace CAI_ExpresserWithFollowup { // CAI_Expresser + constexpr std::ptrdiff_t m_pPostponedFollowup = 0x60; // ResponseFollowup* +} + +namespace CAK47 { // CCSWeaponBaseGun +} + +namespace CAmbientGeneric { // CPointEntity + constexpr std::ptrdiff_t m_radius = 0x4B0; // float + constexpr std::ptrdiff_t m_flMaxRadius = 0x4B4; // float + constexpr std::ptrdiff_t m_iSoundLevel = 0x4B8; // soundlevel_t + constexpr std::ptrdiff_t m_dpv = 0x4BC; // dynpitchvol_t + constexpr std::ptrdiff_t m_fActive = 0x520; // bool + constexpr std::ptrdiff_t m_fLooping = 0x521; // bool + constexpr std::ptrdiff_t m_iszSound = 0x528; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sSourceEntName = 0x530; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hSoundSource = 0x538; // CHandle + constexpr std::ptrdiff_t m_nSoundSourceEntIndex = 0x53C; // CEntityIndex +} + +namespace CAnimEventListener { // CAnimEventListenerBase +} + +namespace CAnimEventListenerBase { +} + +namespace CAnimEventQueueListener { // CAnimEventListenerBase +} + +namespace CAnimGraphControllerBase { +} + +namespace CAnimGraphNetworkedVariables { + constexpr std::ptrdiff_t m_PredNetBoolVariables = 0x8; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetByteVariables = 0x20; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetUInt16Variables = 0x38; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetIntVariables = 0x50; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetUInt32Variables = 0x68; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetUInt64Variables = 0x80; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetFloatVariables = 0x98; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetVectorVariables = 0xB0; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PredNetQuaternionVariables = 0xC8; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetBoolVariables = 0xE0; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetByteVariables = 0xF8; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetUInt16Variables = 0x110; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetIntVariables = 0x128; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetUInt32Variables = 0x140; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetUInt64Variables = 0x158; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetFloatVariables = 0x170; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetVectorVariables = 0x188; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_OwnerOnlyPredNetQuaternionVariables = 0x1A0; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_nBoolVariablesCount = 0x1B8; // int32_t + constexpr std::ptrdiff_t m_nOwnerOnlyBoolVariablesCount = 0x1BC; // int32_t + constexpr std::ptrdiff_t m_nRandomSeedOffset = 0x1C0; // int32_t + constexpr std::ptrdiff_t m_flLastTeleportTime = 0x1C4; // float +} + +namespace CAnimGraphTagRef { + constexpr std::ptrdiff_t m_nTagIndex = 0x0; // int32_t + constexpr std::ptrdiff_t m_tagName = 0x10; // CGlobalSymbol +} + +namespace CAttributeContainer { // CAttributeManager + constexpr std::ptrdiff_t m_Item = 0x50; // CEconItemView +} + +namespace CAttributeList { + constexpr std::ptrdiff_t m_Attributes = 0x8; // CUtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_pManager = 0x58; // CAttributeManager* +} + +namespace CAttributeManager { + constexpr std::ptrdiff_t m_Providers = 0x8; // CUtlVector> + constexpr std::ptrdiff_t m_iReapplyProvisionParity = 0x20; // int32_t + constexpr std::ptrdiff_t m_hOuter = 0x24; // CHandle + constexpr std::ptrdiff_t m_bPreventLoopback = 0x28; // bool + constexpr std::ptrdiff_t m_ProviderType = 0x2C; // attributeprovidertypes_t + constexpr std::ptrdiff_t m_CachedResults = 0x30; // CUtlVector +} + +namespace CAttributeManager_cached_attribute_float_t { + constexpr std::ptrdiff_t flIn = 0x0; // float + constexpr std::ptrdiff_t iAttribHook = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t flOut = 0x10; // float +} + +namespace CBarnLight { // CBaseModelEntity + constexpr std::ptrdiff_t m_bEnabled = 0x700; // bool + constexpr std::ptrdiff_t m_nColorMode = 0x704; // int32_t + constexpr std::ptrdiff_t m_Color = 0x708; // Color + constexpr std::ptrdiff_t m_flColorTemperature = 0x70C; // float + constexpr std::ptrdiff_t m_flBrightness = 0x710; // float + constexpr std::ptrdiff_t m_flBrightnessScale = 0x714; // float + constexpr std::ptrdiff_t m_nDirectLight = 0x718; // int32_t + constexpr std::ptrdiff_t m_nBakedShadowIndex = 0x71C; // int32_t + constexpr std::ptrdiff_t m_nLuminaireShape = 0x720; // int32_t + constexpr std::ptrdiff_t m_flLuminaireSize = 0x724; // float + constexpr std::ptrdiff_t m_flLuminaireAnisotropy = 0x728; // float + constexpr std::ptrdiff_t m_LightStyleString = 0x730; // CUtlString + constexpr std::ptrdiff_t m_flLightStyleStartTime = 0x738; // GameTime_t + constexpr std::ptrdiff_t m_QueuedLightStyleStrings = 0x740; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_LightStyleEvents = 0x758; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_LightStyleTargets = 0x770; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_StyleEvent = 0x788; // CEntityIOOutput[4] + constexpr std::ptrdiff_t m_hLightCookie = 0x848; // CStrongHandle + constexpr std::ptrdiff_t m_flShape = 0x850; // float + constexpr std::ptrdiff_t m_flSoftX = 0x854; // float + constexpr std::ptrdiff_t m_flSoftY = 0x858; // float + constexpr std::ptrdiff_t m_flSkirt = 0x85C; // float + constexpr std::ptrdiff_t m_flSkirtNear = 0x860; // float + constexpr std::ptrdiff_t m_vSizeParams = 0x864; // Vector + constexpr std::ptrdiff_t m_flRange = 0x870; // float + constexpr std::ptrdiff_t m_vShear = 0x874; // Vector + constexpr std::ptrdiff_t m_nBakeSpecularToCubemaps = 0x880; // int32_t + constexpr std::ptrdiff_t m_vBakeSpecularToCubemapsSize = 0x884; // Vector + constexpr std::ptrdiff_t m_nCastShadows = 0x890; // int32_t + constexpr std::ptrdiff_t m_nShadowMapSize = 0x894; // int32_t + constexpr std::ptrdiff_t m_nShadowPriority = 0x898; // int32_t + constexpr std::ptrdiff_t m_bContactShadow = 0x89C; // bool + constexpr std::ptrdiff_t m_nBounceLight = 0x8A0; // int32_t + constexpr std::ptrdiff_t m_flBounceScale = 0x8A4; // float + constexpr std::ptrdiff_t m_flMinRoughness = 0x8A8; // float + constexpr std::ptrdiff_t m_vAlternateColor = 0x8AC; // Vector + constexpr std::ptrdiff_t m_fAlternateColorBrightness = 0x8B8; // float + constexpr std::ptrdiff_t m_nFog = 0x8BC; // int32_t + constexpr std::ptrdiff_t m_flFogStrength = 0x8C0; // float + constexpr std::ptrdiff_t m_nFogShadows = 0x8C4; // int32_t + constexpr std::ptrdiff_t m_flFogScale = 0x8C8; // float + constexpr std::ptrdiff_t m_flFadeSizeStart = 0x8CC; // float + constexpr std::ptrdiff_t m_flFadeSizeEnd = 0x8D0; // float + constexpr std::ptrdiff_t m_flShadowFadeSizeStart = 0x8D4; // float + constexpr std::ptrdiff_t m_flShadowFadeSizeEnd = 0x8D8; // float + constexpr std::ptrdiff_t m_bPrecomputedFieldsValid = 0x8DC; // bool + constexpr std::ptrdiff_t m_vPrecomputedBoundsMins = 0x8E0; // Vector + constexpr std::ptrdiff_t m_vPrecomputedBoundsMaxs = 0x8EC; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBOrigin = 0x8F8; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBAngles = 0x904; // QAngle + constexpr std::ptrdiff_t m_vPrecomputedOBBExtent = 0x910; // Vector + constexpr std::ptrdiff_t m_bPvsModifyEntity = 0x91C; // bool +} + +namespace CBaseAnimGraph { // CBaseModelEntity + constexpr std::ptrdiff_t m_bInitiallyPopulateInterpHistory = 0x700; // bool + constexpr std::ptrdiff_t m_bShouldAnimateDuringGameplayPause = 0x701; // bool + constexpr std::ptrdiff_t m_pChoreoServices = 0x708; // IChoreoServices* + constexpr std::ptrdiff_t m_bAnimGraphUpdateEnabled = 0x710; // bool + constexpr std::ptrdiff_t m_flMaxSlopeDistance = 0x714; // float + constexpr std::ptrdiff_t m_vLastSlopeCheckPos = 0x718; // Vector + constexpr std::ptrdiff_t m_bAnimGraphDirty = 0x724; // bool + constexpr std::ptrdiff_t m_vecForce = 0x728; // Vector + constexpr std::ptrdiff_t m_nForceBone = 0x734; // int32_t + constexpr std::ptrdiff_t m_pRagdollPose = 0x748; // PhysicsRagdollPose_t* + constexpr std::ptrdiff_t m_bClientRagdoll = 0x750; // bool +} + +namespace CBaseAnimGraphController { // CSkeletonAnimationController + constexpr std::ptrdiff_t m_baseLayer = 0x18; // CNetworkedSequenceOperation + constexpr std::ptrdiff_t m_animGraphNetworkedVars = 0x40; // CAnimGraphNetworkedVariables + constexpr std::ptrdiff_t m_bSequenceFinished = 0x218; // bool + constexpr std::ptrdiff_t m_flLastEventCycle = 0x21C; // float + constexpr std::ptrdiff_t m_flLastEventAnimTime = 0x220; // float + constexpr std::ptrdiff_t m_flPlaybackRate = 0x224; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_flPrevAnimTime = 0x22C; // float + constexpr std::ptrdiff_t m_bClientSideAnimation = 0x230; // bool + constexpr std::ptrdiff_t m_bNetworkedAnimationInputsChanged = 0x231; // bool + constexpr std::ptrdiff_t m_nNewSequenceParity = 0x234; // int32_t + constexpr std::ptrdiff_t m_nResetEventsParity = 0x238; // int32_t + constexpr std::ptrdiff_t m_nAnimLoopMode = 0x23C; // AnimLoopMode_t + constexpr std::ptrdiff_t m_hAnimationUpdate = 0x2DC; // AnimationUpdateListHandle_t +} + +namespace CBaseButton { // CBaseToggle + constexpr std::ptrdiff_t m_angMoveEntitySpace = 0x780; // QAngle + constexpr std::ptrdiff_t m_fStayPushed = 0x78C; // bool + constexpr std::ptrdiff_t m_fRotating = 0x78D; // bool + constexpr std::ptrdiff_t m_ls = 0x790; // locksound_t + constexpr std::ptrdiff_t m_sUseSound = 0x7B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sLockedSound = 0x7B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sUnlockedSound = 0x7C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bLocked = 0x7C8; // bool + constexpr std::ptrdiff_t m_bDisabled = 0x7C9; // bool + constexpr std::ptrdiff_t m_flUseLockedTime = 0x7CC; // GameTime_t + constexpr std::ptrdiff_t m_bSolidBsp = 0x7D0; // bool + constexpr std::ptrdiff_t m_OnDamaged = 0x7D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPressed = 0x800; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUseLocked = 0x828; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnIn = 0x850; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnOut = 0x878; // CEntityIOOutput + constexpr std::ptrdiff_t m_nState = 0x8A0; // int32_t + constexpr std::ptrdiff_t m_hConstraint = 0x8A4; // CEntityHandle + constexpr std::ptrdiff_t m_hConstraintParent = 0x8A8; // CEntityHandle + constexpr std::ptrdiff_t m_bForceNpcExclude = 0x8AC; // bool + constexpr std::ptrdiff_t m_sGlowEntity = 0x8B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_glowEntity = 0x8B8; // CHandle + constexpr std::ptrdiff_t m_usable = 0x8BC; // bool + constexpr std::ptrdiff_t m_szDisplayText = 0x8C0; // CUtlSymbolLarge +} + +namespace CBaseCSGrenade { // CCSWeaponBase + constexpr std::ptrdiff_t m_bRedraw = 0xE18; // bool + constexpr std::ptrdiff_t m_bIsHeldByPlayer = 0xE19; // bool + constexpr std::ptrdiff_t m_bPinPulled = 0xE1A; // bool + constexpr std::ptrdiff_t m_bJumpThrow = 0xE1B; // bool + constexpr std::ptrdiff_t m_eThrowStatus = 0xE1C; // EGrenadeThrowState + constexpr std::ptrdiff_t m_fThrowTime = 0xE20; // GameTime_t + constexpr std::ptrdiff_t m_flThrowStrength = 0xE24; // float + constexpr std::ptrdiff_t m_flThrowStrengthApproach = 0xE28; // float + constexpr std::ptrdiff_t m_fDropTime = 0xE2C; // GameTime_t +} + +namespace CBaseCSGrenadeProjectile { // CBaseGrenade + constexpr std::ptrdiff_t m_vInitialVelocity = 0x9C8; // Vector + constexpr std::ptrdiff_t m_nBounces = 0x9D4; // int32_t + constexpr std::ptrdiff_t m_nExplodeEffectIndex = 0x9D8; // CStrongHandle + constexpr std::ptrdiff_t m_nExplodeEffectTickBegin = 0x9E0; // int32_t + constexpr std::ptrdiff_t m_vecExplodeEffectOrigin = 0x9E4; // Vector + constexpr std::ptrdiff_t m_flSpawnTime = 0x9F0; // GameTime_t + constexpr std::ptrdiff_t m_unOGSExtraFlags = 0x9F4; // uint8_t + constexpr std::ptrdiff_t m_bDetonationRecorded = 0x9F5; // bool + constexpr std::ptrdiff_t m_flDetonateTime = 0x9F8; // GameTime_t + constexpr std::ptrdiff_t m_nItemIndex = 0x9FC; // uint16_t + constexpr std::ptrdiff_t m_vecOriginalSpawnLocation = 0xA00; // Vector + constexpr std::ptrdiff_t m_flLastBounceSoundTime = 0xA0C; // GameTime_t + constexpr std::ptrdiff_t m_vecGrenadeSpin = 0xA10; // RotationVector + constexpr std::ptrdiff_t m_vecLastHitSurfaceNormal = 0xA1C; // Vector + constexpr std::ptrdiff_t m_nTicksAtZeroVelocity = 0xA28; // int32_t +} + +namespace CBaseClientUIEntity { // CBaseModelEntity + constexpr std::ptrdiff_t m_bEnabled = 0x700; // bool + constexpr std::ptrdiff_t m_DialogXMLName = 0x708; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_PanelClassName = 0x710; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_PanelID = 0x718; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_CustomOutput0 = 0x720; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput1 = 0x748; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput2 = 0x770; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput3 = 0x798; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput4 = 0x7C0; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput5 = 0x7E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput6 = 0x810; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput7 = 0x838; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput8 = 0x860; // CEntityIOOutput + constexpr std::ptrdiff_t m_CustomOutput9 = 0x888; // CEntityIOOutput +} + +namespace CBaseCombatCharacter { // CBaseFlex + constexpr std::ptrdiff_t m_bForceServerRagdoll = 0x920; // bool + constexpr std::ptrdiff_t m_hMyWearables = 0x928; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_flFieldOfView = 0x940; // float + constexpr std::ptrdiff_t m_impactEnergyScale = 0x944; // float + constexpr std::ptrdiff_t m_LastHitGroup = 0x948; // HitGroup_t + constexpr std::ptrdiff_t m_bApplyStressDamage = 0x94C; // bool + constexpr std::ptrdiff_t m_bloodColor = 0x950; // int32_t + constexpr std::ptrdiff_t m_navMeshID = 0x9B0; // int32_t + constexpr std::ptrdiff_t m_iDamageCount = 0x9B4; // int32_t + constexpr std::ptrdiff_t m_pVecRelationships = 0x9B8; // CUtlVector* + constexpr std::ptrdiff_t m_strRelationships = 0x9C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_eHull = 0x9C8; // Hull_t + constexpr std::ptrdiff_t m_nNavHullIdx = 0x9CC; // uint32_t +} + +namespace CBaseDMStart { // CPointEntity + constexpr std::ptrdiff_t m_Master = 0x4B0; // CUtlSymbolLarge +} + +namespace CBaseDoor { // CBaseToggle + constexpr std::ptrdiff_t m_angMoveEntitySpace = 0x790; // QAngle + constexpr std::ptrdiff_t m_vecMoveDirParentSpace = 0x79C; // Vector + constexpr std::ptrdiff_t m_ls = 0x7A8; // locksound_t + constexpr std::ptrdiff_t m_bForceClosed = 0x7C8; // bool + constexpr std::ptrdiff_t m_bDoorGroup = 0x7C9; // bool + constexpr std::ptrdiff_t m_bLocked = 0x7CA; // bool + constexpr std::ptrdiff_t m_bIgnoreDebris = 0x7CB; // bool + constexpr std::ptrdiff_t m_eSpawnPosition = 0x7CC; // FuncDoorSpawnPos_t + constexpr std::ptrdiff_t m_flBlockDamage = 0x7D0; // float + constexpr std::ptrdiff_t m_NoiseMoving = 0x7D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_NoiseArrived = 0x7E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_NoiseMovingClosed = 0x7E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_NoiseArrivedClosed = 0x7F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_ChainTarget = 0x7F8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_OnBlockedClosing = 0x800; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnBlockedOpening = 0x828; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUnblockedClosing = 0x850; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUnblockedOpening = 0x878; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFullyClosed = 0x8A0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFullyOpen = 0x8C8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnClose = 0x8F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnOpen = 0x918; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnLockedUse = 0x940; // CEntityIOOutput + constexpr std::ptrdiff_t m_bLoopMoveSound = 0x968; // bool + constexpr std::ptrdiff_t m_bCreateNavObstacle = 0x980; // bool + constexpr std::ptrdiff_t m_isChaining = 0x981; // bool + constexpr std::ptrdiff_t m_bIsUsable = 0x982; // bool +} + +namespace CBaseEntity { // CEntityInstance + constexpr std::ptrdiff_t m_CBodyComponent = 0x30; // CBodyComponent* + constexpr std::ptrdiff_t m_NetworkTransmitComponent = 0x38; // CNetworkTransmitComponent + constexpr std::ptrdiff_t m_aThinkFunctions = 0x228; // CUtlVector + constexpr std::ptrdiff_t m_iCurrentThinkContext = 0x240; // int32_t + constexpr std::ptrdiff_t m_nLastThinkTick = 0x244; // GameTick_t + constexpr std::ptrdiff_t m_isSteadyState = 0x250; // CBitVec<64> + constexpr std::ptrdiff_t m_lastNetworkChange = 0x258; // float + constexpr std::ptrdiff_t m_ResponseContexts = 0x268; // CUtlVector + constexpr std::ptrdiff_t m_iszResponseContext = 0x280; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iHealth = 0x2A8; // int32_t + constexpr std::ptrdiff_t m_iMaxHealth = 0x2AC; // int32_t + constexpr std::ptrdiff_t m_lifeState = 0x2B0; // uint8_t + constexpr std::ptrdiff_t m_flDamageAccumulator = 0x2B4; // float + constexpr std::ptrdiff_t m_bTakesDamage = 0x2B8; // bool + constexpr std::ptrdiff_t m_nTakeDamageFlags = 0x2BC; // TakeDamageFlags_t + constexpr std::ptrdiff_t m_MoveCollide = 0x2C1; // MoveCollide_t + constexpr std::ptrdiff_t m_MoveType = 0x2C2; // MoveType_t + constexpr std::ptrdiff_t m_nWaterTouch = 0x2C3; // uint8_t + constexpr std::ptrdiff_t m_nSlimeTouch = 0x2C4; // uint8_t + constexpr std::ptrdiff_t m_bRestoreInHierarchy = 0x2C5; // bool + constexpr std::ptrdiff_t m_target = 0x2C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flMoveDoneTime = 0x2D0; // float + constexpr std::ptrdiff_t m_hDamageFilter = 0x2D4; // CHandle + constexpr std::ptrdiff_t m_iszDamageFilterName = 0x2D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nSubclassID = 0x2E0; // CUtlStringToken + constexpr std::ptrdiff_t m_flAnimTime = 0x2F0; // float + constexpr std::ptrdiff_t m_flSimulationTime = 0x2F4; // float + constexpr std::ptrdiff_t m_flCreateTime = 0x2F8; // GameTime_t + constexpr std::ptrdiff_t m_bClientSideRagdoll = 0x2FC; // bool + constexpr std::ptrdiff_t m_ubInterpolationFrame = 0x2FD; // uint8_t + constexpr std::ptrdiff_t m_vPrevVPhysicsUpdatePos = 0x300; // Vector + constexpr std::ptrdiff_t m_iTeamNum = 0x30C; // uint8_t + constexpr std::ptrdiff_t m_iGlobalname = 0x310; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iSentToClients = 0x318; // int32_t + constexpr std::ptrdiff_t m_flSpeed = 0x31C; // float + constexpr std::ptrdiff_t m_sUniqueHammerID = 0x320; // CUtlString + constexpr std::ptrdiff_t m_spawnflags = 0x328; // uint32_t + constexpr std::ptrdiff_t m_nNextThinkTick = 0x32C; // GameTick_t + constexpr std::ptrdiff_t m_nSimulationTick = 0x330; // int32_t + constexpr std::ptrdiff_t m_OnKilled = 0x338; // CEntityIOOutput + constexpr std::ptrdiff_t m_fFlags = 0x360; // uint32_t + constexpr std::ptrdiff_t m_vecAbsVelocity = 0x364; // Vector + constexpr std::ptrdiff_t m_vecVelocity = 0x370; // CNetworkVelocityVector + constexpr std::ptrdiff_t m_vecBaseVelocity = 0x3A0; // Vector + constexpr std::ptrdiff_t m_nPushEnumCount = 0x3AC; // int32_t + constexpr std::ptrdiff_t m_pCollision = 0x3B0; // CCollisionProperty* + constexpr std::ptrdiff_t m_hEffectEntity = 0x3B8; // CHandle + constexpr std::ptrdiff_t m_hOwnerEntity = 0x3BC; // CHandle + constexpr std::ptrdiff_t m_fEffects = 0x3C0; // uint32_t + constexpr std::ptrdiff_t m_hGroundEntity = 0x3C4; // CHandle + constexpr std::ptrdiff_t m_flFriction = 0x3C8; // float + constexpr std::ptrdiff_t m_flElasticity = 0x3CC; // float + constexpr std::ptrdiff_t m_flGravityScale = 0x3D0; // float + constexpr std::ptrdiff_t m_flTimeScale = 0x3D4; // float + constexpr std::ptrdiff_t m_flWaterLevel = 0x3D8; // float + constexpr std::ptrdiff_t m_bSimulatedEveryTick = 0x3DC; // bool + constexpr std::ptrdiff_t m_bAnimatedEveryTick = 0x3DD; // bool + constexpr std::ptrdiff_t m_bDisableLowViolence = 0x3DE; // bool + constexpr std::ptrdiff_t m_nWaterType = 0x3DF; // uint8_t + constexpr std::ptrdiff_t m_iEFlags = 0x3E0; // int32_t + constexpr std::ptrdiff_t m_OnUser1 = 0x3E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUser2 = 0x410; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUser3 = 0x438; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUser4 = 0x460; // CEntityIOOutput + constexpr std::ptrdiff_t m_iInitialTeamNum = 0x488; // int32_t + constexpr std::ptrdiff_t m_flNavIgnoreUntilTime = 0x48C; // GameTime_t + constexpr std::ptrdiff_t m_vecAngVelocity = 0x490; // QAngle + constexpr std::ptrdiff_t m_bNetworkQuantizeOriginAndAngles = 0x49C; // bool + constexpr std::ptrdiff_t m_bLagCompensate = 0x49D; // bool + constexpr std::ptrdiff_t m_flOverriddenFriction = 0x4A0; // float + constexpr std::ptrdiff_t m_pBlocker = 0x4A4; // CHandle + constexpr std::ptrdiff_t m_flLocalTime = 0x4A8; // float + constexpr std::ptrdiff_t m_flVPhysicsUpdateLocalTime = 0x4AC; // float +} + +namespace CBaseFilter { // CLogicalEntity + constexpr std::ptrdiff_t m_bNegated = 0x4B0; // bool + constexpr std::ptrdiff_t m_OnPass = 0x4B8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFail = 0x4E0; // CEntityIOOutput +} + +namespace CBaseFire { // CBaseEntity + constexpr std::ptrdiff_t m_flScale = 0x4B0; // float + constexpr std::ptrdiff_t m_flStartScale = 0x4B4; // float + constexpr std::ptrdiff_t m_flScaleTime = 0x4B8; // float + constexpr std::ptrdiff_t m_nFlags = 0x4BC; // uint32_t +} + +namespace CBaseFlex { // CBaseAnimGraph + constexpr std::ptrdiff_t m_flexWeight = 0x890; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_vLookTargetPosition = 0x8A8; // Vector + constexpr std::ptrdiff_t m_blinktoggle = 0x8B4; // bool + constexpr std::ptrdiff_t m_flAllowResponsesEndTime = 0x908; // GameTime_t + constexpr std::ptrdiff_t m_flLastFlexAnimationTime = 0x90C; // GameTime_t + constexpr std::ptrdiff_t m_nNextSceneEventId = 0x910; // uint32_t + constexpr std::ptrdiff_t m_bUpdateLayerPriorities = 0x914; // bool +} + +namespace CBaseFlexAlias_funCBaseFlex { // CBaseFlex +} + +namespace CBaseGrenade { // CBaseFlex + constexpr std::ptrdiff_t m_OnPlayerPickup = 0x928; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnExplode = 0x950; // CEntityIOOutput + constexpr std::ptrdiff_t m_bHasWarnedAI = 0x978; // bool + constexpr std::ptrdiff_t m_bIsSmokeGrenade = 0x979; // bool + constexpr std::ptrdiff_t m_bIsLive = 0x97A; // bool + constexpr std::ptrdiff_t m_DmgRadius = 0x97C; // float + constexpr std::ptrdiff_t m_flDetonateTime = 0x980; // GameTime_t + constexpr std::ptrdiff_t m_flWarnAITime = 0x984; // float + constexpr std::ptrdiff_t m_flDamage = 0x988; // float + constexpr std::ptrdiff_t m_iszBounceSound = 0x990; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_ExplosionSound = 0x998; // CUtlString + constexpr std::ptrdiff_t m_hThrower = 0x9A4; // CHandle + constexpr std::ptrdiff_t m_flNextAttack = 0x9BC; // GameTime_t + constexpr std::ptrdiff_t m_hOriginalThrower = 0x9C0; // CHandle +} + +namespace CBaseIssue { + constexpr std::ptrdiff_t m_szTypeString = 0x20; // char[64] + constexpr std::ptrdiff_t m_szDetailsString = 0x60; // char[260] + constexpr std::ptrdiff_t m_iNumYesVotes = 0x164; // int32_t + constexpr std::ptrdiff_t m_iNumNoVotes = 0x168; // int32_t + constexpr std::ptrdiff_t m_iNumPotentialVotes = 0x16C; // int32_t + constexpr std::ptrdiff_t m_pVoteController = 0x170; // CVoteController* +} + +namespace CBaseModelEntity { // CBaseEntity + constexpr std::ptrdiff_t m_CRenderComponent = 0x4B0; // CRenderComponent* + constexpr std::ptrdiff_t m_CHitboxComponent = 0x4B8; // CHitboxComponent + constexpr std::ptrdiff_t m_flDissolveStartTime = 0x4E0; // GameTime_t + constexpr std::ptrdiff_t m_OnIgnite = 0x4E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_nRenderMode = 0x510; // RenderMode_t + constexpr std::ptrdiff_t m_nRenderFX = 0x511; // RenderFx_t + constexpr std::ptrdiff_t m_bAllowFadeInView = 0x512; // bool + constexpr std::ptrdiff_t m_clrRender = 0x513; // Color + constexpr std::ptrdiff_t m_vecRenderAttributes = 0x518; // CUtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_bRenderToCubemaps = 0x568; // bool + constexpr std::ptrdiff_t m_Collision = 0x570; // CCollisionProperty + constexpr std::ptrdiff_t m_Glow = 0x620; // CGlowProperty + constexpr std::ptrdiff_t m_flGlowBackfaceMult = 0x678; // float + constexpr std::ptrdiff_t m_fadeMinDist = 0x67C; // float + constexpr std::ptrdiff_t m_fadeMaxDist = 0x680; // float + constexpr std::ptrdiff_t m_flFadeScale = 0x684; // float + constexpr std::ptrdiff_t m_flShadowStrength = 0x688; // float + constexpr std::ptrdiff_t m_nObjectCulling = 0x68C; // uint8_t + constexpr std::ptrdiff_t m_nAddDecal = 0x690; // int32_t + constexpr std::ptrdiff_t m_vDecalPosition = 0x694; // Vector + constexpr std::ptrdiff_t m_vDecalForwardAxis = 0x6A0; // Vector + constexpr std::ptrdiff_t m_flDecalHealBloodRate = 0x6AC; // float + constexpr std::ptrdiff_t m_flDecalHealHeightRate = 0x6B0; // float + constexpr std::ptrdiff_t m_ConfigEntitiesToPropagateMaterialDecalsTo = 0x6B8; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_vecViewOffset = 0x6D0; // CNetworkViewOffsetVector +} + +namespace CBaseMoveBehavior { // CPathKeyFrame + constexpr std::ptrdiff_t m_iPositionInterpolator = 0x510; // int32_t + constexpr std::ptrdiff_t m_iRotationInterpolator = 0x514; // int32_t + constexpr std::ptrdiff_t m_flAnimStartTime = 0x518; // float + constexpr std::ptrdiff_t m_flAnimEndTime = 0x51C; // float + constexpr std::ptrdiff_t m_flAverageSpeedAcrossFrame = 0x520; // float + constexpr std::ptrdiff_t m_pCurrentKeyFrame = 0x528; // CPathKeyFrame* + constexpr std::ptrdiff_t m_pTargetKeyFrame = 0x530; // CPathKeyFrame* + constexpr std::ptrdiff_t m_pPreKeyFrame = 0x538; // CPathKeyFrame* + constexpr std::ptrdiff_t m_pPostKeyFrame = 0x540; // CPathKeyFrame* + constexpr std::ptrdiff_t m_flTimeIntoFrame = 0x548; // float + constexpr std::ptrdiff_t m_iDirection = 0x54C; // int32_t +} + +namespace CBasePlatTrain { // CBaseToggle + constexpr std::ptrdiff_t m_NoiseMoving = 0x780; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_NoiseArrived = 0x788; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_volume = 0x798; // float + constexpr std::ptrdiff_t m_flTWidth = 0x79C; // float + constexpr std::ptrdiff_t m_flTLength = 0x7A0; // float +} + +namespace CBasePlayerController { // CBaseEntity + constexpr std::ptrdiff_t m_nInButtonsWhichAreToggles = 0x4B8; // uint64_t + constexpr std::ptrdiff_t m_nTickBase = 0x4C0; // uint32_t + constexpr std::ptrdiff_t m_hPawn = 0x4F0; // CHandle + constexpr std::ptrdiff_t m_nSplitScreenSlot = 0x4F4; // CSplitScreenSlot + constexpr std::ptrdiff_t m_hSplitOwner = 0x4F8; // CHandle + constexpr std::ptrdiff_t m_hSplitScreenPlayers = 0x500; // CUtlVector> + constexpr std::ptrdiff_t m_bIsHLTV = 0x518; // bool + constexpr std::ptrdiff_t m_iConnected = 0x51C; // PlayerConnectedState + constexpr std::ptrdiff_t m_iszPlayerName = 0x520; // char[128] + constexpr std::ptrdiff_t m_szNetworkIDString = 0x5A0; // CUtlString + constexpr std::ptrdiff_t m_fLerpTime = 0x5A8; // float + constexpr std::ptrdiff_t m_bLagCompensation = 0x5AC; // bool + constexpr std::ptrdiff_t m_bPredict = 0x5AD; // bool + constexpr std::ptrdiff_t m_bAutoKickDisabled = 0x5AE; // bool + constexpr std::ptrdiff_t m_bIsLowViolence = 0x5AF; // bool + constexpr std::ptrdiff_t m_bGamePaused = 0x5B0; // bool + constexpr std::ptrdiff_t m_nUsecTimestampLastUserCmdReceived = 0x640; // int64_t + constexpr std::ptrdiff_t m_iIgnoreGlobalChat = 0x658; // ChatIgnoreType_t + constexpr std::ptrdiff_t m_flLastPlayerTalkTime = 0x65C; // float + constexpr std::ptrdiff_t m_flLastEntitySteadyState = 0x660; // float + constexpr std::ptrdiff_t m_nAvailableEntitySteadyState = 0x664; // int32_t + constexpr std::ptrdiff_t m_bHasAnySteadyStateEnts = 0x668; // bool + constexpr std::ptrdiff_t m_steamID = 0x678; // uint64_t + constexpr std::ptrdiff_t m_iDesiredFOV = 0x680; // uint32_t +} + +namespace CBasePlayerPawn { // CBaseCombatCharacter + constexpr std::ptrdiff_t m_pWeaponServices = 0x9D0; // CPlayer_WeaponServices* + constexpr std::ptrdiff_t m_pItemServices = 0x9D8; // CPlayer_ItemServices* + constexpr std::ptrdiff_t m_pAutoaimServices = 0x9E0; // CPlayer_AutoaimServices* + constexpr std::ptrdiff_t m_pObserverServices = 0x9E8; // CPlayer_ObserverServices* + constexpr std::ptrdiff_t m_pWaterServices = 0x9F0; // CPlayer_WaterServices* + constexpr std::ptrdiff_t m_pUseServices = 0x9F8; // CPlayer_UseServices* + constexpr std::ptrdiff_t m_pFlashlightServices = 0xA00; // CPlayer_FlashlightServices* + constexpr std::ptrdiff_t m_pCameraServices = 0xA08; // CPlayer_CameraServices* + constexpr std::ptrdiff_t m_pMovementServices = 0xA10; // CPlayer_MovementServices* + constexpr std::ptrdiff_t m_ServerViewAngleChanges = 0xA20; // CUtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_nHighestGeneratedServerViewAngleChangeIndex = 0xA70; // uint32_t + constexpr std::ptrdiff_t v_angle = 0xA74; // QAngle + constexpr std::ptrdiff_t v_anglePrevious = 0xA80; // QAngle + constexpr std::ptrdiff_t m_iHideHUD = 0xA8C; // uint32_t + constexpr std::ptrdiff_t m_skybox3d = 0xA90; // sky3dparams_t + constexpr std::ptrdiff_t m_fTimeLastHurt = 0xB20; // GameTime_t + constexpr std::ptrdiff_t m_flDeathTime = 0xB24; // GameTime_t + constexpr std::ptrdiff_t m_fNextSuicideTime = 0xB28; // GameTime_t + constexpr std::ptrdiff_t m_fInitHUD = 0xB2C; // bool + constexpr std::ptrdiff_t m_pExpresser = 0xB30; // CAI_Expresser* + constexpr std::ptrdiff_t m_hController = 0xB38; // CHandle + constexpr std::ptrdiff_t m_fHltvReplayDelay = 0xB40; // float + constexpr std::ptrdiff_t m_fHltvReplayEnd = 0xB44; // float + constexpr std::ptrdiff_t m_iHltvReplayEntity = 0xB48; // CEntityIndex +} + +namespace CBasePlayerVData { // CEntitySubclassVDataBase + constexpr std::ptrdiff_t m_sModelName = 0x28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_flHeadDamageMultiplier = 0x108; // CSkillFloat + constexpr std::ptrdiff_t m_flChestDamageMultiplier = 0x118; // CSkillFloat + constexpr std::ptrdiff_t m_flStomachDamageMultiplier = 0x128; // CSkillFloat + constexpr std::ptrdiff_t m_flArmDamageMultiplier = 0x138; // CSkillFloat + constexpr std::ptrdiff_t m_flLegDamageMultiplier = 0x148; // CSkillFloat + constexpr std::ptrdiff_t m_flHoldBreathTime = 0x158; // float + constexpr std::ptrdiff_t m_flDrowningDamageInterval = 0x15C; // float + constexpr std::ptrdiff_t m_nDrowningDamageInitial = 0x160; // int32_t + constexpr std::ptrdiff_t m_nDrowningDamageMax = 0x164; // int32_t + constexpr std::ptrdiff_t m_nWaterSpeed = 0x168; // int32_t + constexpr std::ptrdiff_t m_flUseRange = 0x16C; // float + constexpr std::ptrdiff_t m_flUseAngleTolerance = 0x170; // float + constexpr std::ptrdiff_t m_flCrouchTime = 0x174; // float +} + +namespace CBasePlayerWeapon { // CEconEntity + constexpr std::ptrdiff_t m_nNextPrimaryAttackTick = 0xC18; // GameTick_t + constexpr std::ptrdiff_t m_flNextPrimaryAttackTickRatio = 0xC1C; // float + constexpr std::ptrdiff_t m_nNextSecondaryAttackTick = 0xC20; // GameTick_t + constexpr std::ptrdiff_t m_flNextSecondaryAttackTickRatio = 0xC24; // float + constexpr std::ptrdiff_t m_iClip1 = 0xC28; // int32_t + constexpr std::ptrdiff_t m_iClip2 = 0xC2C; // int32_t + constexpr std::ptrdiff_t m_pReserveAmmo = 0xC30; // int32_t[2] + constexpr std::ptrdiff_t m_OnPlayerUse = 0xC38; // CEntityIOOutput +} + +namespace CBasePlayerWeaponVData { // CEntitySubclassVDataBase + constexpr std::ptrdiff_t m_szWorldModel = 0x28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_bBuiltRightHanded = 0x108; // bool + constexpr std::ptrdiff_t m_bAllowFlipping = 0x109; // bool + constexpr std::ptrdiff_t m_bIsFullAuto = 0x10A; // bool + constexpr std::ptrdiff_t m_nNumBullets = 0x10C; // int32_t + constexpr std::ptrdiff_t m_sMuzzleAttachment = 0x110; // CUtlString + constexpr std::ptrdiff_t m_szMuzzleFlashParticle = 0x118; // CResourceNameTyped> + constexpr std::ptrdiff_t m_iFlags = 0x1F8; // ItemFlagTypes_t + constexpr std::ptrdiff_t m_nPrimaryAmmoType = 0x1F9; // AmmoIndex_t + constexpr std::ptrdiff_t m_nSecondaryAmmoType = 0x1FA; // AmmoIndex_t + constexpr std::ptrdiff_t m_iMaxClip1 = 0x1FC; // int32_t + constexpr std::ptrdiff_t m_iMaxClip2 = 0x200; // int32_t + constexpr std::ptrdiff_t m_iDefaultClip1 = 0x204; // int32_t + constexpr std::ptrdiff_t m_iDefaultClip2 = 0x208; // int32_t + constexpr std::ptrdiff_t m_iWeight = 0x20C; // int32_t + constexpr std::ptrdiff_t m_bAutoSwitchTo = 0x210; // bool + constexpr std::ptrdiff_t m_bAutoSwitchFrom = 0x211; // bool + constexpr std::ptrdiff_t m_iRumbleEffect = 0x214; // RumbleEffect_t + constexpr std::ptrdiff_t m_aShootSounds = 0x218; // CUtlMap + constexpr std::ptrdiff_t m_iSlot = 0x238; // int32_t + constexpr std::ptrdiff_t m_iPosition = 0x23C; // int32_t +} + +namespace CBaseProp { // CBaseAnimGraph + constexpr std::ptrdiff_t m_bModelOverrodeBlockLOS = 0x890; // bool + constexpr std::ptrdiff_t m_iShapeType = 0x894; // int32_t + constexpr std::ptrdiff_t m_bConformToCollisionBounds = 0x898; // bool + constexpr std::ptrdiff_t m_mPreferredCatchTransform = 0x89C; // matrix3x4_t +} + +namespace CBasePropDoor { // CDynamicProp + constexpr std::ptrdiff_t m_flAutoReturnDelay = 0xB18; // float + constexpr std::ptrdiff_t m_hDoorList = 0xB20; // CUtlVector> + constexpr std::ptrdiff_t m_nHardwareType = 0xB38; // int32_t + constexpr std::ptrdiff_t m_bNeedsHardware = 0xB3C; // bool + constexpr std::ptrdiff_t m_eDoorState = 0xB40; // DoorState_t + constexpr std::ptrdiff_t m_bLocked = 0xB44; // bool + constexpr std::ptrdiff_t m_closedPosition = 0xB48; // Vector + constexpr std::ptrdiff_t m_closedAngles = 0xB54; // QAngle + constexpr std::ptrdiff_t m_hBlocker = 0xB60; // CHandle + constexpr std::ptrdiff_t m_bFirstBlocked = 0xB64; // bool + constexpr std::ptrdiff_t m_ls = 0xB68; // locksound_t + constexpr std::ptrdiff_t m_bForceClosed = 0xB88; // bool + constexpr std::ptrdiff_t m_vecLatchWorldPosition = 0xB8C; // Vector + constexpr std::ptrdiff_t m_hActivator = 0xB98; // CHandle + constexpr std::ptrdiff_t m_SoundMoving = 0xBA8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundOpen = 0xBB0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundClose = 0xBB8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundLock = 0xBC0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundUnlock = 0xBC8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundLatch = 0xBD0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundPound = 0xBD8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundJiggle = 0xBE0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_SoundLockedAnim = 0xBE8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_numCloseAttempts = 0xBF0; // int32_t + constexpr std::ptrdiff_t m_nPhysicsMaterial = 0xBF4; // CUtlStringToken + constexpr std::ptrdiff_t m_SlaveName = 0xBF8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hMaster = 0xC00; // CHandle + constexpr std::ptrdiff_t m_OnBlockedClosing = 0xC08; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnBlockedOpening = 0xC30; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUnblockedClosing = 0xC58; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUnblockedOpening = 0xC80; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFullyClosed = 0xCA8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFullyOpen = 0xCD0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnClose = 0xCF8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnOpen = 0xD20; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnLockedUse = 0xD48; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAjarOpen = 0xD70; // CEntityIOOutput +} + +namespace CBaseToggle { // CBaseModelEntity + constexpr std::ptrdiff_t m_toggle_state = 0x700; // TOGGLE_STATE + constexpr std::ptrdiff_t m_flMoveDistance = 0x704; // float + constexpr std::ptrdiff_t m_flWait = 0x708; // float + constexpr std::ptrdiff_t m_flLip = 0x70C; // float + constexpr std::ptrdiff_t m_bAlwaysFireBlockedOutputs = 0x710; // bool + constexpr std::ptrdiff_t m_vecPosition1 = 0x714; // Vector + constexpr std::ptrdiff_t m_vecPosition2 = 0x720; // Vector + constexpr std::ptrdiff_t m_vecMoveAng = 0x72C; // QAngle + constexpr std::ptrdiff_t m_vecAngle1 = 0x738; // QAngle + constexpr std::ptrdiff_t m_vecAngle2 = 0x744; // QAngle + constexpr std::ptrdiff_t m_flHeight = 0x750; // float + constexpr std::ptrdiff_t m_hActivator = 0x754; // CHandle + constexpr std::ptrdiff_t m_vecFinalDest = 0x758; // Vector + constexpr std::ptrdiff_t m_vecFinalAngle = 0x764; // QAngle + constexpr std::ptrdiff_t m_movementType = 0x770; // int32_t + constexpr std::ptrdiff_t m_sMaster = 0x778; // CUtlSymbolLarge +} + +namespace CBaseTrigger { // CBaseToggle + constexpr std::ptrdiff_t m_bDisabled = 0x780; // bool + constexpr std::ptrdiff_t m_iFilterName = 0x788; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFilter = 0x790; // CHandle + constexpr std::ptrdiff_t m_OnStartTouch = 0x798; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnStartTouchAll = 0x7C0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnEndTouch = 0x7E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnEndTouchAll = 0x810; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTouching = 0x838; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnNotTouching = 0x860; // CEntityIOOutput + constexpr std::ptrdiff_t m_hTouchingEntities = 0x888; // CUtlVector> + constexpr std::ptrdiff_t m_bClientSidePredicted = 0x8A0; // bool +} + +namespace CBaseViewModel { // CBaseAnimGraph + constexpr std::ptrdiff_t m_vecLastFacing = 0x898; // Vector + constexpr std::ptrdiff_t m_nViewModelIndex = 0x8A4; // uint32_t + constexpr std::ptrdiff_t m_nAnimationParity = 0x8A8; // uint32_t + constexpr std::ptrdiff_t m_flAnimationStartTime = 0x8AC; // float + constexpr std::ptrdiff_t m_hWeapon = 0x8B0; // CHandle + constexpr std::ptrdiff_t m_sVMName = 0x8B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sAnimationPrefix = 0x8C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hOldLayerSequence = 0x8C8; // HSequence + constexpr std::ptrdiff_t m_oldLayer = 0x8CC; // int32_t + constexpr std::ptrdiff_t m_oldLayerStartTime = 0x8D0; // float + constexpr std::ptrdiff_t m_hControlPanel = 0x8D4; // CHandle +} + +namespace CBeam { // CBaseModelEntity + constexpr std::ptrdiff_t m_flFrameRate = 0x700; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0x704; // float + constexpr std::ptrdiff_t m_flFireTime = 0x708; // GameTime_t + constexpr std::ptrdiff_t m_flDamage = 0x70C; // float + constexpr std::ptrdiff_t m_nNumBeamEnts = 0x710; // uint8_t + constexpr std::ptrdiff_t m_hBaseMaterial = 0x718; // CStrongHandle + constexpr std::ptrdiff_t m_nHaloIndex = 0x720; // CStrongHandle + constexpr std::ptrdiff_t m_nBeamType = 0x728; // BeamType_t + constexpr std::ptrdiff_t m_nBeamFlags = 0x72C; // uint32_t + constexpr std::ptrdiff_t m_hAttachEntity = 0x730; // CHandle[10] + constexpr std::ptrdiff_t m_nAttachIndex = 0x758; // AttachmentHandle_t[10] + constexpr std::ptrdiff_t m_fWidth = 0x764; // float + constexpr std::ptrdiff_t m_fEndWidth = 0x768; // float + constexpr std::ptrdiff_t m_fFadeLength = 0x76C; // float + constexpr std::ptrdiff_t m_fHaloScale = 0x770; // float + constexpr std::ptrdiff_t m_fAmplitude = 0x774; // float + constexpr std::ptrdiff_t m_fStartFrame = 0x778; // float + constexpr std::ptrdiff_t m_fSpeed = 0x77C; // float + constexpr std::ptrdiff_t m_flFrame = 0x780; // float + constexpr std::ptrdiff_t m_nClipStyle = 0x784; // BeamClipStyle_t + constexpr std::ptrdiff_t m_bTurnedOff = 0x788; // bool + constexpr std::ptrdiff_t m_vecEndPos = 0x78C; // Vector + constexpr std::ptrdiff_t m_hEndEntity = 0x798; // CHandle + constexpr std::ptrdiff_t m_nDissolveType = 0x79C; // int32_t +} + +namespace CBlood { // CPointEntity + constexpr std::ptrdiff_t m_vecSprayAngles = 0x4B0; // QAngle + constexpr std::ptrdiff_t m_vecSprayDir = 0x4BC; // Vector + constexpr std::ptrdiff_t m_flAmount = 0x4C8; // float + constexpr std::ptrdiff_t m_Color = 0x4CC; // int32_t +} + +namespace CBodyComponent { // CEntityComponent + constexpr std::ptrdiff_t m_pSceneNode = 0x8; // CGameSceneNode* + constexpr std::ptrdiff_t __m_pChainEntity = 0x20; // CNetworkVarChainer +} + +namespace CBodyComponentBaseAnimGraph { // CBodyComponentSkeletonInstance + constexpr std::ptrdiff_t m_animationController = 0x480; // CBaseAnimGraphController + constexpr std::ptrdiff_t __m_pChainEntity = 0x760; // CNetworkVarChainer +} + +namespace CBodyComponentBaseModelEntity { // CBodyComponentSkeletonInstance + constexpr std::ptrdiff_t __m_pChainEntity = 0x480; // CNetworkVarChainer +} + +namespace CBodyComponentPoint { // CBodyComponent + constexpr std::ptrdiff_t m_sceneNode = 0x50; // CGameSceneNode + constexpr std::ptrdiff_t __m_pChainEntity = 0x1A0; // CNetworkVarChainer +} + +namespace CBodyComponentSkeletonInstance { // CBodyComponent + constexpr std::ptrdiff_t m_skeletonInstance = 0x50; // CSkeletonInstance + constexpr std::ptrdiff_t __m_pChainEntity = 0x450; // CNetworkVarChainer +} + +namespace CBombTarget { // CBaseTrigger + constexpr std::ptrdiff_t m_OnBombExplode = 0x8A8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnBombPlanted = 0x8D0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnBombDefused = 0x8F8; // CEntityIOOutput + constexpr std::ptrdiff_t m_bIsBombSiteB = 0x920; // bool + constexpr std::ptrdiff_t m_bIsHeistBombTarget = 0x921; // bool + constexpr std::ptrdiff_t m_bBombPlantedHere = 0x922; // bool + constexpr std::ptrdiff_t m_szMountTarget = 0x928; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hInstructorHint = 0x930; // CHandle + constexpr std::ptrdiff_t m_nBombSiteDesignation = 0x934; // int32_t +} + +namespace CBot { + constexpr std::ptrdiff_t m_pController = 0x10; // CCSPlayerController* + constexpr std::ptrdiff_t m_pPlayer = 0x18; // CCSPlayerPawn* + constexpr std::ptrdiff_t m_bHasSpawned = 0x20; // bool + constexpr std::ptrdiff_t m_id = 0x24; // uint32_t + constexpr std::ptrdiff_t m_isRunning = 0xB0; // bool + constexpr std::ptrdiff_t m_isCrouching = 0xB1; // bool + constexpr std::ptrdiff_t m_forwardSpeed = 0xB4; // float + constexpr std::ptrdiff_t m_leftSpeed = 0xB8; // float + constexpr std::ptrdiff_t m_verticalSpeed = 0xBC; // float + constexpr std::ptrdiff_t m_buttonFlags = 0xC0; // uint64_t + constexpr std::ptrdiff_t m_jumpTimestamp = 0xC8; // float + constexpr std::ptrdiff_t m_viewForward = 0xCC; // Vector + constexpr std::ptrdiff_t m_postureStackIndex = 0xE8; // int32_t +} + +namespace CBreachCharge { // CCSWeaponBase +} + +namespace CBreachChargeProjectile { // CBaseGrenade +} + +namespace CBreakable { // CBaseModelEntity + constexpr std::ptrdiff_t m_Material = 0x710; // Materials + constexpr std::ptrdiff_t m_hBreaker = 0x714; // CHandle + constexpr std::ptrdiff_t m_Explosion = 0x718; // Explosions + constexpr std::ptrdiff_t m_iszSpawnObject = 0x720; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flPressureDelay = 0x728; // float + constexpr std::ptrdiff_t m_iMinHealthDmg = 0x72C; // int32_t + constexpr std::ptrdiff_t m_iszPropData = 0x730; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_impactEnergyScale = 0x738; // float + constexpr std::ptrdiff_t m_nOverrideBlockLOS = 0x73C; // EOverrideBlockLOS_t + constexpr std::ptrdiff_t m_OnBreak = 0x740; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnHealthChanged = 0x768; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_flDmgModBullet = 0x790; // float + constexpr std::ptrdiff_t m_flDmgModClub = 0x794; // float + constexpr std::ptrdiff_t m_flDmgModExplosive = 0x798; // float + constexpr std::ptrdiff_t m_flDmgModFire = 0x79C; // float + constexpr std::ptrdiff_t m_iszPhysicsDamageTableName = 0x7A0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszBasePropData = 0x7A8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iInteractions = 0x7B0; // int32_t + constexpr std::ptrdiff_t m_PerformanceMode = 0x7B4; // PerformanceMode_t + constexpr std::ptrdiff_t m_hPhysicsAttacker = 0x7B8; // CHandle + constexpr std::ptrdiff_t m_flLastPhysicsInfluenceTime = 0x7BC; // GameTime_t +} + +namespace CBreakableProp { // CBaseProp + constexpr std::ptrdiff_t m_OnBreak = 0x8E0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnHealthChanged = 0x908; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnTakeDamage = 0x930; // CEntityIOOutput + constexpr std::ptrdiff_t m_impactEnergyScale = 0x958; // float + constexpr std::ptrdiff_t m_iMinHealthDmg = 0x95C; // int32_t + constexpr std::ptrdiff_t m_preferredCarryAngles = 0x960; // QAngle + constexpr std::ptrdiff_t m_flPressureDelay = 0x96C; // float + constexpr std::ptrdiff_t m_hBreaker = 0x970; // CHandle + constexpr std::ptrdiff_t m_PerformanceMode = 0x974; // PerformanceMode_t + constexpr std::ptrdiff_t m_flDmgModBullet = 0x978; // float + constexpr std::ptrdiff_t m_flDmgModClub = 0x97C; // float + constexpr std::ptrdiff_t m_flDmgModExplosive = 0x980; // float + constexpr std::ptrdiff_t m_flDmgModFire = 0x984; // float + constexpr std::ptrdiff_t m_iszPhysicsDamageTableName = 0x988; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszBasePropData = 0x990; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iInteractions = 0x998; // int32_t + constexpr std::ptrdiff_t m_flPreventDamageBeforeTime = 0x99C; // GameTime_t + constexpr std::ptrdiff_t m_bHasBreakPiecesOrCommands = 0x9A0; // bool + constexpr std::ptrdiff_t m_explodeDamage = 0x9A4; // float + constexpr std::ptrdiff_t m_explodeRadius = 0x9A8; // float + constexpr std::ptrdiff_t m_explosionDelay = 0x9B0; // float + constexpr std::ptrdiff_t m_explosionBuildupSound = 0x9B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_explosionCustomEffect = 0x9C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_explosionCustomSound = 0x9C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_explosionModifier = 0x9D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hPhysicsAttacker = 0x9D8; // CHandle + constexpr std::ptrdiff_t m_flLastPhysicsInfluenceTime = 0x9DC; // GameTime_t + constexpr std::ptrdiff_t m_bOriginalBlockLOS = 0x9E0; // bool + constexpr std::ptrdiff_t m_flDefaultFadeScale = 0x9E4; // float + constexpr std::ptrdiff_t m_hLastAttacker = 0x9E8; // CHandle + constexpr std::ptrdiff_t m_hFlareEnt = 0x9EC; // CHandle + constexpr std::ptrdiff_t m_bUsePuntSound = 0x9F0; // bool + constexpr std::ptrdiff_t m_iszPuntSound = 0x9F8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_noGhostCollision = 0xA00; // bool +} + +namespace CBreakableStageHelper { + constexpr std::ptrdiff_t m_nCurrentStage = 0x8; // int32_t + constexpr std::ptrdiff_t m_nStageCount = 0xC; // int32_t +} + +namespace CBtActionAim { // CBtNode + constexpr std::ptrdiff_t m_szSensorInputKey = 0x68; // CUtlString + constexpr std::ptrdiff_t m_szAimReadyKey = 0x80; // CUtlString + constexpr std::ptrdiff_t m_flZoomCooldownTimestamp = 0x88; // float + constexpr std::ptrdiff_t m_bDoneAiming = 0x8C; // bool + constexpr std::ptrdiff_t m_flLerpStartTime = 0x90; // float + constexpr std::ptrdiff_t m_flNextLookTargetLerpTime = 0x94; // float + constexpr std::ptrdiff_t m_flPenaltyReductionRatio = 0x98; // float + constexpr std::ptrdiff_t m_NextLookTarget = 0x9C; // QAngle + constexpr std::ptrdiff_t m_AimTimer = 0xA8; // CountdownTimer + constexpr std::ptrdiff_t m_SniperHoldTimer = 0xC0; // CountdownTimer + constexpr std::ptrdiff_t m_FocusIntervalTimer = 0xD8; // CountdownTimer + constexpr std::ptrdiff_t m_bAcquired = 0xF0; // bool +} + +namespace CBtActionCombatPositioning { // CBtNode + constexpr std::ptrdiff_t m_szSensorInputKey = 0x68; // CUtlString + constexpr std::ptrdiff_t m_szIsAttackingKey = 0x80; // CUtlString + constexpr std::ptrdiff_t m_ActionTimer = 0x88; // CountdownTimer + constexpr std::ptrdiff_t m_bCrouching = 0xA0; // bool +} + +namespace CBtActionMoveTo { // CBtNode + constexpr std::ptrdiff_t m_szDestinationInputKey = 0x60; // CUtlString + constexpr std::ptrdiff_t m_szHidingSpotInputKey = 0x68; // CUtlString + constexpr std::ptrdiff_t m_szThreatInputKey = 0x70; // CUtlString + constexpr std::ptrdiff_t m_vecDestination = 0x78; // Vector + constexpr std::ptrdiff_t m_bAutoLookAdjust = 0x84; // bool + constexpr std::ptrdiff_t m_bComputePath = 0x85; // bool + constexpr std::ptrdiff_t m_flDamagingAreasPenaltyCost = 0x88; // float + constexpr std::ptrdiff_t m_CheckApproximateCornersTimer = 0x90; // CountdownTimer + constexpr std::ptrdiff_t m_CheckHighPriorityItem = 0xA8; // CountdownTimer + constexpr std::ptrdiff_t m_RepathTimer = 0xC0; // CountdownTimer + constexpr std::ptrdiff_t m_flArrivalEpsilon = 0xD8; // float + constexpr std::ptrdiff_t m_flAdditionalArrivalEpsilon2D = 0xDC; // float + constexpr std::ptrdiff_t m_flHidingSpotCheckDistanceThreshold = 0xE0; // float + constexpr std::ptrdiff_t m_flNearestAreaDistanceThreshold = 0xE4; // float +} + +namespace CBtActionParachutePositioning { // CBtNode + constexpr std::ptrdiff_t m_ActionTimer = 0x58; // CountdownTimer +} + +namespace CBtNode { +} + +namespace CBtNodeComposite { // CBtNode +} + +namespace CBtNodeCondition { // CBtNodeDecorator + constexpr std::ptrdiff_t m_bNegated = 0x58; // bool +} + +namespace CBtNodeConditionInactive { // CBtNodeCondition + constexpr std::ptrdiff_t m_flRoundStartThresholdSeconds = 0x78; // float + constexpr std::ptrdiff_t m_flSensorInactivityThresholdSeconds = 0x7C; // float + constexpr std::ptrdiff_t m_SensorInactivityTimer = 0x80; // CountdownTimer +} + +namespace CBtNodeDecorator { // CBtNode +} + +namespace CBubbling { // CBaseModelEntity + constexpr std::ptrdiff_t m_density = 0x700; // int32_t + constexpr std::ptrdiff_t m_frequency = 0x704; // int32_t + constexpr std::ptrdiff_t m_state = 0x708; // int32_t +} + +namespace CBumpMine { // CCSWeaponBase +} + +namespace CBumpMineProjectile { // CBaseGrenade +} + +namespace CBuoyancyHelper { + constexpr std::ptrdiff_t m_flFluidDensity = 0x18; // float +} + +namespace CBuyZone { // CBaseTrigger + constexpr std::ptrdiff_t m_LegacyTeamNum = 0x8A8; // int32_t +} + +namespace CC4 { // CCSWeaponBase + constexpr std::ptrdiff_t m_vecLastValidPlayerHeldPosition = 0xE18; // Vector + constexpr std::ptrdiff_t m_vecLastValidDroppedPosition = 0xE24; // Vector + constexpr std::ptrdiff_t m_bDoValidDroppedPositionCheck = 0xE30; // bool + constexpr std::ptrdiff_t m_bStartedArming = 0xE31; // bool + constexpr std::ptrdiff_t m_fArmedTime = 0xE34; // GameTime_t + constexpr std::ptrdiff_t m_bBombPlacedAnimation = 0xE38; // bool + constexpr std::ptrdiff_t m_bIsPlantingViaUse = 0xE39; // bool + constexpr std::ptrdiff_t m_entitySpottedState = 0xE40; // EntitySpottedState_t + constexpr std::ptrdiff_t m_nSpotRules = 0xE58; // int32_t + constexpr std::ptrdiff_t m_bPlayedArmingBeeps = 0xE5C; // bool[7] + constexpr std::ptrdiff_t m_bBombPlanted = 0xE63; // bool + constexpr std::ptrdiff_t m_bDroppedFromDeath = 0xE64; // bool +} + +namespace CCSBot { // CBot + constexpr std::ptrdiff_t m_lastCoopSpawnPoint = 0xF0; // CHandle + constexpr std::ptrdiff_t m_eyePosition = 0x100; // Vector + constexpr std::ptrdiff_t m_name = 0x10C; // char[64] + constexpr std::ptrdiff_t m_combatRange = 0x14C; // float + constexpr std::ptrdiff_t m_isRogue = 0x150; // bool + constexpr std::ptrdiff_t m_rogueTimer = 0x158; // CountdownTimer + constexpr std::ptrdiff_t m_diedLastRound = 0x174; // bool + constexpr std::ptrdiff_t m_safeTime = 0x178; // float + constexpr std::ptrdiff_t m_wasSafe = 0x17C; // bool + constexpr std::ptrdiff_t m_blindFire = 0x184; // bool + constexpr std::ptrdiff_t m_surpriseTimer = 0x188; // CountdownTimer + constexpr std::ptrdiff_t m_bAllowActive = 0x1A0; // bool + constexpr std::ptrdiff_t m_isFollowing = 0x1A1; // bool + constexpr std::ptrdiff_t m_leader = 0x1A4; // CHandle + constexpr std::ptrdiff_t m_followTimestamp = 0x1A8; // float + constexpr std::ptrdiff_t m_allowAutoFollowTime = 0x1AC; // float + constexpr std::ptrdiff_t m_hurryTimer = 0x1B0; // CountdownTimer + constexpr std::ptrdiff_t m_alertTimer = 0x1C8; // CountdownTimer + constexpr std::ptrdiff_t m_sneakTimer = 0x1E0; // CountdownTimer + constexpr std::ptrdiff_t m_panicTimer = 0x1F8; // CountdownTimer + constexpr std::ptrdiff_t m_stateTimestamp = 0x4C8; // float + constexpr std::ptrdiff_t m_isAttacking = 0x4CC; // bool + constexpr std::ptrdiff_t m_isOpeningDoor = 0x4CD; // bool + constexpr std::ptrdiff_t m_taskEntity = 0x4D4; // CHandle + constexpr std::ptrdiff_t m_goalPosition = 0x4E4; // Vector + constexpr std::ptrdiff_t m_goalEntity = 0x4F0; // CHandle + constexpr std::ptrdiff_t m_avoid = 0x4F4; // CHandle + constexpr std::ptrdiff_t m_avoidTimestamp = 0x4F8; // float + constexpr std::ptrdiff_t m_isStopping = 0x4FC; // bool + constexpr std::ptrdiff_t m_hasVisitedEnemySpawn = 0x4FD; // bool + constexpr std::ptrdiff_t m_stillTimer = 0x500; // IntervalTimer + constexpr std::ptrdiff_t m_bEyeAnglesUnderPathFinderControl = 0x510; // bool + constexpr std::ptrdiff_t m_pathIndex = 0x6608; // int32_t + constexpr std::ptrdiff_t m_areaEnteredTimestamp = 0x660C; // GameTime_t + constexpr std::ptrdiff_t m_repathTimer = 0x6610; // CountdownTimer + constexpr std::ptrdiff_t m_avoidFriendTimer = 0x6628; // CountdownTimer + constexpr std::ptrdiff_t m_isFriendInTheWay = 0x6640; // bool + constexpr std::ptrdiff_t m_politeTimer = 0x6648; // CountdownTimer + constexpr std::ptrdiff_t m_isWaitingBehindFriend = 0x6660; // bool + constexpr std::ptrdiff_t m_pathLadderEnd = 0x668C; // float + constexpr std::ptrdiff_t m_mustRunTimer = 0x66D8; // CountdownTimer + constexpr std::ptrdiff_t m_waitTimer = 0x66F0; // CountdownTimer + constexpr std::ptrdiff_t m_updateTravelDistanceTimer = 0x6708; // CountdownTimer + constexpr std::ptrdiff_t m_playerTravelDistance = 0x6720; // float[64] + constexpr std::ptrdiff_t m_travelDistancePhase = 0x6820; // uint8_t + constexpr std::ptrdiff_t m_hostageEscortCount = 0x69B8; // uint8_t + constexpr std::ptrdiff_t m_hostageEscortCountTimestamp = 0x69BC; // float + constexpr std::ptrdiff_t m_desiredTeam = 0x69C0; // int32_t + constexpr std::ptrdiff_t m_hasJoined = 0x69C4; // bool + constexpr std::ptrdiff_t m_isWaitingForHostage = 0x69C5; // bool + constexpr std::ptrdiff_t m_inhibitWaitingForHostageTimer = 0x69C8; // CountdownTimer + constexpr std::ptrdiff_t m_waitForHostageTimer = 0x69E0; // CountdownTimer + constexpr std::ptrdiff_t m_noisePosition = 0x69F8; // Vector + constexpr std::ptrdiff_t m_noiseTravelDistance = 0x6A04; // float + constexpr std::ptrdiff_t m_noiseTimestamp = 0x6A08; // float + constexpr std::ptrdiff_t m_noiseSource = 0x6A10; // CCSPlayerPawn* + constexpr std::ptrdiff_t m_noiseBendTimer = 0x6A28; // CountdownTimer + constexpr std::ptrdiff_t m_bentNoisePosition = 0x6A40; // Vector + constexpr std::ptrdiff_t m_bendNoisePositionValid = 0x6A4C; // bool + constexpr std::ptrdiff_t m_lookAroundStateTimestamp = 0x6A50; // float + constexpr std::ptrdiff_t m_lookAheadAngle = 0x6A54; // float + constexpr std::ptrdiff_t m_forwardAngle = 0x6A58; // float + constexpr std::ptrdiff_t m_inhibitLookAroundTimestamp = 0x6A5C; // float + constexpr std::ptrdiff_t m_lookAtSpot = 0x6A64; // Vector + constexpr std::ptrdiff_t m_lookAtSpotDuration = 0x6A74; // float + constexpr std::ptrdiff_t m_lookAtSpotTimestamp = 0x6A78; // float + constexpr std::ptrdiff_t m_lookAtSpotAngleTolerance = 0x6A7C; // float + constexpr std::ptrdiff_t m_lookAtSpotClearIfClose = 0x6A80; // bool + constexpr std::ptrdiff_t m_lookAtSpotAttack = 0x6A81; // bool + constexpr std::ptrdiff_t m_lookAtDesc = 0x6A88; // char* + constexpr std::ptrdiff_t m_peripheralTimestamp = 0x6A90; // float + constexpr std::ptrdiff_t m_approachPointCount = 0x6C18; // uint8_t + constexpr std::ptrdiff_t m_approachPointViewPosition = 0x6C1C; // Vector + constexpr std::ptrdiff_t m_viewSteadyTimer = 0x6C28; // IntervalTimer + constexpr std::ptrdiff_t m_tossGrenadeTimer = 0x6C40; // CountdownTimer + constexpr std::ptrdiff_t m_isAvoidingGrenade = 0x6C60; // CountdownTimer + constexpr std::ptrdiff_t m_spotCheckTimestamp = 0x6C80; // float + constexpr std::ptrdiff_t m_checkedHidingSpotCount = 0x7088; // int32_t + constexpr std::ptrdiff_t m_lookPitch = 0x708C; // float + constexpr std::ptrdiff_t m_lookPitchVel = 0x7090; // float + constexpr std::ptrdiff_t m_lookYaw = 0x7094; // float + constexpr std::ptrdiff_t m_lookYawVel = 0x7098; // float + constexpr std::ptrdiff_t m_targetSpot = 0x709C; // Vector + constexpr std::ptrdiff_t m_targetSpotVelocity = 0x70A8; // Vector + constexpr std::ptrdiff_t m_targetSpotPredicted = 0x70B4; // Vector + constexpr std::ptrdiff_t m_aimError = 0x70C0; // QAngle + constexpr std::ptrdiff_t m_aimGoal = 0x70CC; // QAngle + constexpr std::ptrdiff_t m_targetSpotTime = 0x70D8; // GameTime_t + constexpr std::ptrdiff_t m_aimFocus = 0x70DC; // float + constexpr std::ptrdiff_t m_aimFocusInterval = 0x70E0; // float + constexpr std::ptrdiff_t m_aimFocusNextUpdate = 0x70E4; // GameTime_t + constexpr std::ptrdiff_t m_ignoreEnemiesTimer = 0x70F0; // CountdownTimer + constexpr std::ptrdiff_t m_enemy = 0x7108; // CHandle + constexpr std::ptrdiff_t m_isEnemyVisible = 0x710C; // bool + constexpr std::ptrdiff_t m_visibleEnemyParts = 0x710D; // uint8_t + constexpr std::ptrdiff_t m_lastEnemyPosition = 0x7110; // Vector + constexpr std::ptrdiff_t m_lastSawEnemyTimestamp = 0x711C; // float + constexpr std::ptrdiff_t m_firstSawEnemyTimestamp = 0x7120; // float + constexpr std::ptrdiff_t m_currentEnemyAcquireTimestamp = 0x7124; // float + constexpr std::ptrdiff_t m_enemyDeathTimestamp = 0x7128; // float + constexpr std::ptrdiff_t m_friendDeathTimestamp = 0x712C; // float + constexpr std::ptrdiff_t m_isLastEnemyDead = 0x7130; // bool + constexpr std::ptrdiff_t m_nearbyEnemyCount = 0x7134; // int32_t + constexpr std::ptrdiff_t m_bomber = 0x7340; // CHandle + constexpr std::ptrdiff_t m_nearbyFriendCount = 0x7344; // int32_t + constexpr std::ptrdiff_t m_closestVisibleFriend = 0x7348; // CHandle + constexpr std::ptrdiff_t m_closestVisibleHumanFriend = 0x734C; // CHandle + constexpr std::ptrdiff_t m_attentionInterval = 0x7350; // IntervalTimer + constexpr std::ptrdiff_t m_attacker = 0x7360; // CHandle + constexpr std::ptrdiff_t m_attackedTimestamp = 0x7364; // float + constexpr std::ptrdiff_t m_burnedByFlamesTimer = 0x7368; // IntervalTimer + constexpr std::ptrdiff_t m_lastVictimID = 0x7378; // int32_t + constexpr std::ptrdiff_t m_isAimingAtEnemy = 0x737C; // bool + constexpr std::ptrdiff_t m_isRapidFiring = 0x737D; // bool + constexpr std::ptrdiff_t m_equipTimer = 0x7380; // IntervalTimer + constexpr std::ptrdiff_t m_zoomTimer = 0x7390; // CountdownTimer + constexpr std::ptrdiff_t m_fireWeaponTimestamp = 0x73A8; // GameTime_t + constexpr std::ptrdiff_t m_lookForWeaponsOnGroundTimer = 0x73B0; // CountdownTimer + constexpr std::ptrdiff_t m_bIsSleeping = 0x73C8; // bool + constexpr std::ptrdiff_t m_isEnemySniperVisible = 0x73C9; // bool + constexpr std::ptrdiff_t m_sawEnemySniperTimer = 0x73D0; // CountdownTimer + constexpr std::ptrdiff_t m_enemyQueueIndex = 0x7488; // uint8_t + constexpr std::ptrdiff_t m_enemyQueueCount = 0x7489; // uint8_t + constexpr std::ptrdiff_t m_enemyQueueAttendIndex = 0x748A; // uint8_t + constexpr std::ptrdiff_t m_isStuck = 0x748B; // bool + constexpr std::ptrdiff_t m_stuckTimestamp = 0x748C; // GameTime_t + constexpr std::ptrdiff_t m_stuckSpot = 0x7490; // Vector + constexpr std::ptrdiff_t m_wiggleTimer = 0x74A0; // CountdownTimer + constexpr std::ptrdiff_t m_stuckJumpTimer = 0x74B8; // CountdownTimer + constexpr std::ptrdiff_t m_nextCleanupCheckTimestamp = 0x74D0; // GameTime_t + constexpr std::ptrdiff_t m_avgVel = 0x74D4; // float[10] + constexpr std::ptrdiff_t m_avgVelIndex = 0x74FC; // int32_t + constexpr std::ptrdiff_t m_avgVelCount = 0x7500; // int32_t + constexpr std::ptrdiff_t m_lastOrigin = 0x7504; // Vector + constexpr std::ptrdiff_t m_lastRadioRecievedTimestamp = 0x7514; // float + constexpr std::ptrdiff_t m_lastRadioSentTimestamp = 0x7518; // float + constexpr std::ptrdiff_t m_radioSubject = 0x751C; // CHandle + constexpr std::ptrdiff_t m_radioPosition = 0x7520; // Vector + constexpr std::ptrdiff_t m_voiceEndTimestamp = 0x752C; // float + constexpr std::ptrdiff_t m_lastValidReactionQueueFrame = 0x7538; // int32_t +} + +namespace CCSGOPlayerAnimGraphState { +} + +namespace CCSGOViewModel { // CPredictedViewModel + constexpr std::ptrdiff_t m_bShouldIgnoreOffsetAndAccuracy = 0x8D8; // bool + constexpr std::ptrdiff_t m_nWeaponParity = 0x8DC; // uint32_t + constexpr std::ptrdiff_t m_nOldWeaponParity = 0x8E0; // uint32_t +} + +namespace CCSGO_TeamIntroCharacterPosition { // CCSGO_TeamPreviewCharacterPosition +} + +namespace CCSGO_TeamIntroCounterTerroristPosition { // CCSGO_TeamIntroCharacterPosition +} + +namespace CCSGO_TeamIntroTerroristPosition { // CCSGO_TeamIntroCharacterPosition +} + +namespace CCSGO_TeamPreviewCharacterPosition { // CBaseEntity + constexpr std::ptrdiff_t m_nVariant = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_nRandom = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_nOrdinal = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_sWeaponName = 0x4C0; // CUtlString + constexpr std::ptrdiff_t m_xuid = 0x4C8; // uint64_t + constexpr std::ptrdiff_t m_agentItem = 0x4D0; // CEconItemView + constexpr std::ptrdiff_t m_glovesItem = 0x748; // CEconItemView + constexpr std::ptrdiff_t m_weaponItem = 0x9C0; // CEconItemView +} + +namespace CCSGO_TeamSelectCharacterPosition { // CCSGO_TeamPreviewCharacterPosition +} + +namespace CCSGO_TeamSelectCounterTerroristPosition { // CCSGO_TeamSelectCharacterPosition +} + +namespace CCSGO_TeamSelectTerroristPosition { // CCSGO_TeamSelectCharacterPosition +} + +namespace CCSGO_WingmanIntroCharacterPosition { // CCSGO_TeamIntroCharacterPosition +} + +namespace CCSGO_WingmanIntroCounterTerroristPosition { // CCSGO_WingmanIntroCharacterPosition +} + +namespace CCSGO_WingmanIntroTerroristPosition { // CCSGO_WingmanIntroCharacterPosition +} + +namespace CCSGameModeRules { + constexpr std::ptrdiff_t __m_pChainEntity = 0x8; // CNetworkVarChainer +} + +namespace CCSGameModeRules_Deathmatch { // CCSGameModeRules + constexpr std::ptrdiff_t m_bFirstThink = 0x30; // bool + constexpr std::ptrdiff_t m_bFirstThinkAfterConnected = 0x31; // bool + constexpr std::ptrdiff_t m_flDMBonusStartTime = 0x34; // GameTime_t + constexpr std::ptrdiff_t m_flDMBonusTimeLength = 0x38; // float + constexpr std::ptrdiff_t m_nDMBonusWeaponLoadoutSlot = 0x3C; // int16_t +} + +namespace CCSGameModeRules_Noop { // CCSGameModeRules +} + +namespace CCSGameModeRules_Scripted { // CCSGameModeRules +} + +namespace CCSGameModeScript { // CBasePulseGraphInstance +} + +namespace CCSGameRules { // CTeamplayRules + constexpr std::ptrdiff_t __m_pChainEntity = 0x98; // CNetworkVarChainer + constexpr std::ptrdiff_t m_coopMissionManager = 0xC0; // CHandle + constexpr std::ptrdiff_t m_bFreezePeriod = 0xC4; // bool + constexpr std::ptrdiff_t m_bWarmupPeriod = 0xC5; // bool + constexpr std::ptrdiff_t m_fWarmupPeriodEnd = 0xC8; // GameTime_t + constexpr std::ptrdiff_t m_fWarmupPeriodStart = 0xCC; // GameTime_t + constexpr std::ptrdiff_t m_nTotalPausedTicks = 0xD0; // int32_t + constexpr std::ptrdiff_t m_nPauseStartTick = 0xD4; // int32_t + constexpr std::ptrdiff_t m_bServerPaused = 0xD8; // bool + constexpr std::ptrdiff_t m_bGamePaused = 0xD9; // bool + constexpr std::ptrdiff_t m_bTerroristTimeOutActive = 0xDA; // bool + constexpr std::ptrdiff_t m_bCTTimeOutActive = 0xDB; // bool + constexpr std::ptrdiff_t m_flTerroristTimeOutRemaining = 0xDC; // float + constexpr std::ptrdiff_t m_flCTTimeOutRemaining = 0xE0; // float + constexpr std::ptrdiff_t m_nTerroristTimeOuts = 0xE4; // int32_t + constexpr std::ptrdiff_t m_nCTTimeOuts = 0xE8; // int32_t + constexpr std::ptrdiff_t m_bTechnicalTimeOut = 0xEC; // bool + constexpr std::ptrdiff_t m_bMatchWaitingForResume = 0xED; // bool + constexpr std::ptrdiff_t m_iRoundTime = 0xF0; // int32_t + constexpr std::ptrdiff_t m_fMatchStartTime = 0xF4; // float + constexpr std::ptrdiff_t m_fRoundStartTime = 0xF8; // GameTime_t + constexpr std::ptrdiff_t m_flRestartRoundTime = 0xFC; // GameTime_t + constexpr std::ptrdiff_t m_bGameRestart = 0x100; // bool + constexpr std::ptrdiff_t m_flGameStartTime = 0x104; // float + constexpr std::ptrdiff_t m_timeUntilNextPhaseStarts = 0x108; // float + constexpr std::ptrdiff_t m_gamePhase = 0x10C; // int32_t + constexpr std::ptrdiff_t m_totalRoundsPlayed = 0x110; // int32_t + constexpr std::ptrdiff_t m_nRoundsPlayedThisPhase = 0x114; // int32_t + constexpr std::ptrdiff_t m_nOvertimePlaying = 0x118; // int32_t + constexpr std::ptrdiff_t m_iHostagesRemaining = 0x11C; // int32_t + constexpr std::ptrdiff_t m_bAnyHostageReached = 0x120; // bool + constexpr std::ptrdiff_t m_bMapHasBombTarget = 0x121; // bool + constexpr std::ptrdiff_t m_bMapHasRescueZone = 0x122; // bool + constexpr std::ptrdiff_t m_bMapHasBuyZone = 0x123; // bool + constexpr std::ptrdiff_t m_bIsQueuedMatchmaking = 0x124; // bool + constexpr std::ptrdiff_t m_nQueuedMatchmakingMode = 0x128; // int32_t + constexpr std::ptrdiff_t m_bIsValveDS = 0x12C; // bool + constexpr std::ptrdiff_t m_bLogoMap = 0x12D; // bool + constexpr std::ptrdiff_t m_bPlayAllStepSoundsOnServer = 0x12E; // bool + constexpr std::ptrdiff_t m_iSpectatorSlotCount = 0x130; // int32_t + constexpr std::ptrdiff_t m_MatchDevice = 0x134; // int32_t + constexpr std::ptrdiff_t m_bHasMatchStarted = 0x138; // bool + constexpr std::ptrdiff_t m_nNextMapInMapgroup = 0x13C; // int32_t + constexpr std::ptrdiff_t m_szTournamentEventName = 0x140; // char[512] + constexpr std::ptrdiff_t m_szTournamentEventStage = 0x340; // char[512] + constexpr std::ptrdiff_t m_szMatchStatTxt = 0x540; // char[512] + constexpr std::ptrdiff_t m_szTournamentPredictionsTxt = 0x740; // char[512] + constexpr std::ptrdiff_t m_nTournamentPredictionsPct = 0x940; // int32_t + constexpr std::ptrdiff_t m_flCMMItemDropRevealStartTime = 0x944; // GameTime_t + constexpr std::ptrdiff_t m_flCMMItemDropRevealEndTime = 0x948; // GameTime_t + constexpr std::ptrdiff_t m_bIsDroppingItems = 0x94C; // bool + constexpr std::ptrdiff_t m_bIsQuestEligible = 0x94D; // bool + constexpr std::ptrdiff_t m_bIsHltvActive = 0x94E; // bool + constexpr std::ptrdiff_t m_nGuardianModeWaveNumber = 0x950; // int32_t + constexpr std::ptrdiff_t m_nGuardianModeSpecialKillsRemaining = 0x954; // int32_t + constexpr std::ptrdiff_t m_nGuardianModeSpecialWeaponNeeded = 0x958; // int32_t + constexpr std::ptrdiff_t m_nGuardianGrenadesToGiveBots = 0x95C; // int32_t + constexpr std::ptrdiff_t m_nNumHeaviesToSpawn = 0x960; // int32_t + constexpr std::ptrdiff_t m_numGlobalGiftsGiven = 0x964; // uint32_t + constexpr std::ptrdiff_t m_numGlobalGifters = 0x968; // uint32_t + constexpr std::ptrdiff_t m_numGlobalGiftsPeriodSeconds = 0x96C; // uint32_t + constexpr std::ptrdiff_t m_arrFeaturedGiftersAccounts = 0x970; // uint32_t[4] + constexpr std::ptrdiff_t m_arrFeaturedGiftersGifts = 0x980; // uint32_t[4] + constexpr std::ptrdiff_t m_arrProhibitedItemIndices = 0x990; // uint16_t[100] + constexpr std::ptrdiff_t m_arrTournamentActiveCasterAccounts = 0xA58; // uint32_t[4] + constexpr std::ptrdiff_t m_numBestOfMaps = 0xA68; // int32_t + constexpr std::ptrdiff_t m_nHalloweenMaskListSeed = 0xA6C; // int32_t + constexpr std::ptrdiff_t m_bBombDropped = 0xA70; // bool + constexpr std::ptrdiff_t m_bBombPlanted = 0xA71; // bool + constexpr std::ptrdiff_t m_iRoundWinStatus = 0xA74; // int32_t + constexpr std::ptrdiff_t m_eRoundWinReason = 0xA78; // int32_t + constexpr std::ptrdiff_t m_bTCantBuy = 0xA7C; // bool + constexpr std::ptrdiff_t m_bCTCantBuy = 0xA7D; // bool + constexpr std::ptrdiff_t m_flGuardianBuyUntilTime = 0xA80; // GameTime_t + constexpr std::ptrdiff_t m_iMatchStats_RoundResults = 0xA84; // int32_t[30] + constexpr std::ptrdiff_t m_iMatchStats_PlayersAlive_CT = 0xAFC; // int32_t[30] + constexpr std::ptrdiff_t m_iMatchStats_PlayersAlive_T = 0xB74; // int32_t[30] + constexpr std::ptrdiff_t m_TeamRespawnWaveTimes = 0xBEC; // float[32] + constexpr std::ptrdiff_t m_flNextRespawnWave = 0xC6C; // GameTime_t[32] + constexpr std::ptrdiff_t m_nServerQuestID = 0xCEC; // int32_t + constexpr std::ptrdiff_t m_vMinimapMins = 0xCF0; // Vector + constexpr std::ptrdiff_t m_vMinimapMaxs = 0xCFC; // Vector + constexpr std::ptrdiff_t m_MinimapVerticalSectionHeights = 0xD08; // float[8] + constexpr std::ptrdiff_t m_bDontIncrementCoopWave = 0xD28; // bool + constexpr std::ptrdiff_t m_bSpawnedTerrorHuntHeavy = 0xD29; // bool + constexpr std::ptrdiff_t m_nEndMatchMapGroupVoteTypes = 0xD2C; // int32_t[10] + constexpr std::ptrdiff_t m_nEndMatchMapGroupVoteOptions = 0xD54; // int32_t[10] + constexpr std::ptrdiff_t m_nEndMatchMapVoteWinner = 0xD7C; // int32_t + constexpr std::ptrdiff_t m_iNumConsecutiveCTLoses = 0xD80; // int32_t + constexpr std::ptrdiff_t m_iNumConsecutiveTerroristLoses = 0xD84; // int32_t + constexpr std::ptrdiff_t m_bHasHostageBeenTouched = 0xDA0; // bool + constexpr std::ptrdiff_t m_flIntermissionStartTime = 0xDA4; // GameTime_t + constexpr std::ptrdiff_t m_flIntermissionEndTime = 0xDA8; // GameTime_t + constexpr std::ptrdiff_t m_bLevelInitialized = 0xDAC; // bool + constexpr std::ptrdiff_t m_iTotalRoundsPlayed = 0xDB0; // int32_t + constexpr std::ptrdiff_t m_iUnBalancedRounds = 0xDB4; // int32_t + constexpr std::ptrdiff_t m_endMatchOnRoundReset = 0xDB8; // bool + constexpr std::ptrdiff_t m_endMatchOnThink = 0xDB9; // bool + constexpr std::ptrdiff_t m_iFreezeTime = 0xDBC; // int32_t + constexpr std::ptrdiff_t m_iNumTerrorist = 0xDC0; // int32_t + constexpr std::ptrdiff_t m_iNumCT = 0xDC4; // int32_t + constexpr std::ptrdiff_t m_iNumSpawnableTerrorist = 0xDC8; // int32_t + constexpr std::ptrdiff_t m_iNumSpawnableCT = 0xDCC; // int32_t + constexpr std::ptrdiff_t m_arrSelectedHostageSpawnIndices = 0xDD0; // CUtlVector + constexpr std::ptrdiff_t m_bFirstConnected = 0xDE8; // bool + constexpr std::ptrdiff_t m_bCompleteReset = 0xDE9; // bool + constexpr std::ptrdiff_t m_bPickNewTeamsOnReset = 0xDEA; // bool + constexpr std::ptrdiff_t m_bScrambleTeamsOnRestart = 0xDEB; // bool + constexpr std::ptrdiff_t m_bSwapTeamsOnRestart = 0xDEC; // bool + constexpr std::ptrdiff_t m_nEndMatchTiedVotes = 0xDF8; // CUtlVector + constexpr std::ptrdiff_t m_bNeedToAskPlayersForContinueVote = 0xE14; // bool + constexpr std::ptrdiff_t m_numQueuedMatchmakingAccounts = 0xE18; // uint32_t + constexpr std::ptrdiff_t m_pQueuedMatchmakingReservationString = 0xE20; // char* + constexpr std::ptrdiff_t m_numTotalTournamentDrops = 0xE28; // uint32_t + constexpr std::ptrdiff_t m_numSpectatorsCountMax = 0xE2C; // uint32_t + constexpr std::ptrdiff_t m_numSpectatorsCountMaxTV = 0xE30; // uint32_t + constexpr std::ptrdiff_t m_numSpectatorsCountMaxLnk = 0xE34; // uint32_t + constexpr std::ptrdiff_t m_bForceTeamChangeSilent = 0xE40; // bool + constexpr std::ptrdiff_t m_bLoadingRoundBackupData = 0xE41; // bool + constexpr std::ptrdiff_t m_nMatchInfoShowType = 0xE78; // int32_t + constexpr std::ptrdiff_t m_flMatchInfoDecidedTime = 0xE7C; // float + constexpr std::ptrdiff_t m_flCoopRespawnAndHealTime = 0xE98; // float + constexpr std::ptrdiff_t m_coopBonusCoinsFound = 0xE9C; // int32_t + constexpr std::ptrdiff_t m_coopBonusPistolsOnly = 0xEA0; // bool + constexpr std::ptrdiff_t m_coopPlayersInDeploymentZone = 0xEA1; // bool + constexpr std::ptrdiff_t m_coopMissionDeadPlayerRespawnEnabled = 0xEA2; // bool + constexpr std::ptrdiff_t mTeamDMLastWinningTeamNumber = 0xEA4; // int32_t + constexpr std::ptrdiff_t mTeamDMLastThinkTime = 0xEA8; // float + constexpr std::ptrdiff_t m_flTeamDMLastAnnouncementTime = 0xEAC; // float + constexpr std::ptrdiff_t m_iAccountTerrorist = 0xEB0; // int32_t + constexpr std::ptrdiff_t m_iAccountCT = 0xEB4; // int32_t + constexpr std::ptrdiff_t m_iSpawnPointCount_Terrorist = 0xEB8; // int32_t + constexpr std::ptrdiff_t m_iSpawnPointCount_CT = 0xEBC; // int32_t + constexpr std::ptrdiff_t m_iMaxNumTerrorists = 0xEC0; // int32_t + constexpr std::ptrdiff_t m_iMaxNumCTs = 0xEC4; // int32_t + constexpr std::ptrdiff_t m_iLoserBonus = 0xEC8; // int32_t + constexpr std::ptrdiff_t m_iLoserBonusMostRecentTeam = 0xECC; // int32_t + constexpr std::ptrdiff_t m_tmNextPeriodicThink = 0xED0; // float + constexpr std::ptrdiff_t m_bVoiceWonMatchBragFired = 0xED4; // bool + constexpr std::ptrdiff_t m_fWarmupNextChatNoticeTime = 0xED8; // float + constexpr std::ptrdiff_t m_iHostagesRescued = 0xEE0; // int32_t + constexpr std::ptrdiff_t m_iHostagesTouched = 0xEE4; // int32_t + constexpr std::ptrdiff_t m_flNextHostageAnnouncement = 0xEE8; // float + constexpr std::ptrdiff_t m_bNoTerroristsKilled = 0xEEC; // bool + constexpr std::ptrdiff_t m_bNoCTsKilled = 0xEED; // bool + constexpr std::ptrdiff_t m_bNoEnemiesKilled = 0xEEE; // bool + constexpr std::ptrdiff_t m_bCanDonateWeapons = 0xEEF; // bool + constexpr std::ptrdiff_t m_firstKillTime = 0xEF4; // float + constexpr std::ptrdiff_t m_firstBloodTime = 0xEFC; // float + constexpr std::ptrdiff_t m_hostageWasInjured = 0xF18; // bool + constexpr std::ptrdiff_t m_hostageWasKilled = 0xF19; // bool + constexpr std::ptrdiff_t m_bVoteCalled = 0xF28; // bool + constexpr std::ptrdiff_t m_bServerVoteOnReset = 0xF29; // bool + constexpr std::ptrdiff_t m_flVoteCheckThrottle = 0xF2C; // float + constexpr std::ptrdiff_t m_bBuyTimeEnded = 0xF30; // bool + constexpr std::ptrdiff_t m_nLastFreezeEndBeep = 0xF34; // int32_t + constexpr std::ptrdiff_t m_bTargetBombed = 0xF38; // bool + constexpr std::ptrdiff_t m_bBombDefused = 0xF39; // bool + constexpr std::ptrdiff_t m_bMapHasBombZone = 0xF3A; // bool + constexpr std::ptrdiff_t m_vecMainCTSpawnPos = 0xF58; // Vector + constexpr std::ptrdiff_t m_CTSpawnPointsMasterList = 0xF68; // CUtlVector + constexpr std::ptrdiff_t m_TerroristSpawnPointsMasterList = 0xF80; // CUtlVector + constexpr std::ptrdiff_t m_iNextCTSpawnPoint = 0xF98; // int32_t + constexpr std::ptrdiff_t m_iNextTerroristSpawnPoint = 0xF9C; // int32_t + constexpr std::ptrdiff_t m_CTSpawnPoints = 0xFA0; // CUtlVector + constexpr std::ptrdiff_t m_TerroristSpawnPoints = 0xFB8; // CUtlVector + constexpr std::ptrdiff_t m_bIsUnreservedGameServer = 0xFD0; // bool + constexpr std::ptrdiff_t m_fAutobalanceDisplayTime = 0xFD4; // float + constexpr std::ptrdiff_t m_bAllowWeaponSwitch = 0x1240; // bool + constexpr std::ptrdiff_t m_bRoundTimeWarningTriggered = 0x1241; // bool + constexpr std::ptrdiff_t m_phaseChangeAnnouncementTime = 0x1244; // GameTime_t + constexpr std::ptrdiff_t m_fNextUpdateTeamClanNamesTime = 0x1248; // float + constexpr std::ptrdiff_t m_flLastThinkTime = 0x124C; // GameTime_t + constexpr std::ptrdiff_t m_fAccumulatedRoundOffDamage = 0x1250; // float + constexpr std::ptrdiff_t m_nShorthandedBonusLastEvalRound = 0x1254; // int32_t + constexpr std::ptrdiff_t m_bMatchAbortedDueToPlayerBan = 0x14D0; // bool + constexpr std::ptrdiff_t m_bHasTriggeredRoundStartMusic = 0x14D1; // bool + constexpr std::ptrdiff_t m_bHasTriggeredCoopSpawnReset = 0x14D2; // bool + constexpr std::ptrdiff_t m_bSwitchingTeamsAtRoundReset = 0x14D3; // bool + constexpr std::ptrdiff_t m_pGameModeRules = 0x14F0; // CCSGameModeRules* + constexpr std::ptrdiff_t m_BtGlobalBlackboard = 0x14F8; // KeyValues3 + constexpr std::ptrdiff_t m_hPlayerResource = 0x1560; // CHandle + constexpr std::ptrdiff_t m_RetakeRules = 0x1568; // CRetakeGameRules + constexpr std::ptrdiff_t m_GuardianBotSkillLevelMax = 0x174C; // int32_t + constexpr std::ptrdiff_t m_GuardianBotSkillLevelMin = 0x1750; // int32_t + constexpr std::ptrdiff_t m_arrTeamUniqueKillWeaponsMatch = 0x1758; // CUtlVector[4] + constexpr std::ptrdiff_t m_bTeamLastKillUsedUniqueWeaponMatch = 0x17B8; // bool[4] + constexpr std::ptrdiff_t m_nMatchEndCount = 0x17E0; // uint8_t + constexpr std::ptrdiff_t m_nTTeamIntroVariant = 0x17E4; // int32_t + constexpr std::ptrdiff_t m_nCTTeamIntroVariant = 0x17E8; // int32_t + constexpr std::ptrdiff_t m_bTeamIntroPeriod = 0x17EC; // bool + constexpr std::ptrdiff_t m_fTeamIntroPeriodEnd = 0x17F0; // GameTime_t + constexpr std::ptrdiff_t m_bPlayedTeamIntroVO = 0x17F4; // bool + constexpr std::ptrdiff_t m_flLastPerfSampleTime = 0x5800; // double + constexpr std::ptrdiff_t m_bSkipNextServerPerfSample = 0x5808; // bool +} + +namespace CCSGameRulesProxy { // CGameRulesProxy + constexpr std::ptrdiff_t m_pGameRules = 0x4B0; // CCSGameRules* +} + +namespace CCSMinimapBoundary { // CBaseEntity +} + +namespace CCSObserverPawn { // CCSPlayerPawnBase +} + +namespace CCSObserver_CameraServices { // CCSPlayerBase_CameraServices +} + +namespace CCSObserver_MovementServices { // CPlayer_MovementServices +} + +namespace CCSObserver_ObserverServices { // CPlayer_ObserverServices +} + +namespace CCSObserver_UseServices { // CPlayer_UseServices +} + +namespace CCSObserver_ViewModelServices { // CPlayer_ViewModelServices +} + +namespace CCSPlace { // CServerOnlyModelEntity + constexpr std::ptrdiff_t m_name = 0x708; // CUtlSymbolLarge +} + +namespace CCSPlayerBase_CameraServices { // CPlayer_CameraServices + constexpr std::ptrdiff_t m_iFOV = 0x170; // uint32_t + constexpr std::ptrdiff_t m_iFOVStart = 0x174; // uint32_t + constexpr std::ptrdiff_t m_flFOVTime = 0x178; // GameTime_t + constexpr std::ptrdiff_t m_flFOVRate = 0x17C; // float + constexpr std::ptrdiff_t m_hZoomOwner = 0x180; // CHandle + constexpr std::ptrdiff_t m_hTriggerFogList = 0x188; // CUtlVector> + constexpr std::ptrdiff_t m_hLastFogTrigger = 0x1A0; // CHandle +} + +namespace CCSPlayerController { // CBasePlayerController + constexpr std::ptrdiff_t m_pInGameMoneyServices = 0x6B0; // CCSPlayerController_InGameMoneyServices* + constexpr std::ptrdiff_t m_pInventoryServices = 0x6B8; // CCSPlayerController_InventoryServices* + constexpr std::ptrdiff_t m_pActionTrackingServices = 0x6C0; // CCSPlayerController_ActionTrackingServices* + constexpr std::ptrdiff_t m_pDamageServices = 0x6C8; // CCSPlayerController_DamageServices* + constexpr std::ptrdiff_t m_iPing = 0x6D0; // uint32_t + constexpr std::ptrdiff_t m_bHasCommunicationAbuseMute = 0x6D4; // bool + constexpr std::ptrdiff_t m_szCrosshairCodes = 0x6D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iPendingTeamNum = 0x6E0; // uint8_t + constexpr std::ptrdiff_t m_flForceTeamTime = 0x6E4; // GameTime_t + constexpr std::ptrdiff_t m_iCompTeammateColor = 0x6E8; // int32_t + constexpr std::ptrdiff_t m_bEverPlayedOnTeam = 0x6EC; // bool + constexpr std::ptrdiff_t m_bAttemptedToGetColor = 0x6ED; // bool + constexpr std::ptrdiff_t m_iTeammatePreferredColor = 0x6F0; // int32_t + constexpr std::ptrdiff_t m_bTeamChanged = 0x6F4; // bool + constexpr std::ptrdiff_t m_bInSwitchTeam = 0x6F5; // bool + constexpr std::ptrdiff_t m_bHasSeenJoinGame = 0x6F6; // bool + constexpr std::ptrdiff_t m_bJustBecameSpectator = 0x6F7; // bool + constexpr std::ptrdiff_t m_bSwitchTeamsOnNextRoundReset = 0x6F8; // bool + constexpr std::ptrdiff_t m_bRemoveAllItemsOnNextRoundReset = 0x6F9; // bool + constexpr std::ptrdiff_t m_szClan = 0x700; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_szClanName = 0x708; // char[32] + constexpr std::ptrdiff_t m_iCoachingTeam = 0x728; // int32_t + constexpr std::ptrdiff_t m_nPlayerDominated = 0x730; // uint64_t + constexpr std::ptrdiff_t m_nPlayerDominatingMe = 0x738; // uint64_t + constexpr std::ptrdiff_t m_iCompetitiveRanking = 0x740; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveWins = 0x744; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveRankType = 0x748; // int8_t + constexpr std::ptrdiff_t m_iCompetitiveRankingPredicted_Win = 0x74C; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveRankingPredicted_Loss = 0x750; // int32_t + constexpr std::ptrdiff_t m_iCompetitiveRankingPredicted_Tie = 0x754; // int32_t + constexpr std::ptrdiff_t m_nEndMatchNextMapVote = 0x758; // int32_t + constexpr std::ptrdiff_t m_unActiveQuestId = 0x75C; // uint16_t + constexpr std::ptrdiff_t m_nQuestProgressReason = 0x760; // QuestProgress::Reason + constexpr std::ptrdiff_t m_unPlayerTvControlFlags = 0x764; // uint32_t + constexpr std::ptrdiff_t m_iDraftIndex = 0x790; // int32_t + constexpr std::ptrdiff_t m_msQueuedModeDisconnectionTimestamp = 0x794; // uint32_t + constexpr std::ptrdiff_t m_uiAbandonRecordedReason = 0x798; // uint32_t + constexpr std::ptrdiff_t m_bEverFullyConnected = 0x79C; // bool + constexpr std::ptrdiff_t m_bAbandonAllowsSurrender = 0x79D; // bool + constexpr std::ptrdiff_t m_bAbandonOffersInstantSurrender = 0x79E; // bool + constexpr std::ptrdiff_t m_bDisconnection1MinWarningPrinted = 0x79F; // bool + constexpr std::ptrdiff_t m_bScoreReported = 0x7A0; // bool + constexpr std::ptrdiff_t m_nDisconnectionTick = 0x7A4; // int32_t + constexpr std::ptrdiff_t m_bControllingBot = 0x7B0; // bool + constexpr std::ptrdiff_t m_bHasControlledBotThisRound = 0x7B1; // bool + constexpr std::ptrdiff_t m_bHasBeenControlledByPlayerThisRound = 0x7B2; // bool + constexpr std::ptrdiff_t m_nBotsControlledThisRound = 0x7B4; // int32_t + constexpr std::ptrdiff_t m_bCanControlObservedBot = 0x7B8; // bool + constexpr std::ptrdiff_t m_hPlayerPawn = 0x7BC; // CHandle + constexpr std::ptrdiff_t m_hObserverPawn = 0x7C0; // CHandle + constexpr std::ptrdiff_t m_DesiredObserverMode = 0x7C4; // int32_t + constexpr std::ptrdiff_t m_hDesiredObserverTarget = 0x7C8; // CEntityHandle + constexpr std::ptrdiff_t m_bPawnIsAlive = 0x7CC; // bool + constexpr std::ptrdiff_t m_iPawnHealth = 0x7D0; // uint32_t + constexpr std::ptrdiff_t m_iPawnArmor = 0x7D4; // int32_t + constexpr std::ptrdiff_t m_bPawnHasDefuser = 0x7D8; // bool + constexpr std::ptrdiff_t m_bPawnHasHelmet = 0x7D9; // bool + constexpr std::ptrdiff_t m_nPawnCharacterDefIndex = 0x7DA; // uint16_t + constexpr std::ptrdiff_t m_iPawnLifetimeStart = 0x7DC; // int32_t + constexpr std::ptrdiff_t m_iPawnLifetimeEnd = 0x7E0; // int32_t + constexpr std::ptrdiff_t m_iPawnBotDifficulty = 0x7E4; // int32_t + constexpr std::ptrdiff_t m_hOriginalControllerOfCurrentPawn = 0x7E8; // CHandle + constexpr std::ptrdiff_t m_iScore = 0x7EC; // int32_t + constexpr std::ptrdiff_t m_iRoundScore = 0x7F0; // int32_t + constexpr std::ptrdiff_t m_iRoundsWon = 0x7F4; // int32_t + constexpr std::ptrdiff_t m_vecKills = 0x7F8; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_iMVPs = 0x810; // int32_t + constexpr std::ptrdiff_t m_nUpdateCounter = 0x814; // int32_t + constexpr std::ptrdiff_t m_flSmoothedPing = 0x818; // float + constexpr std::ptrdiff_t m_lastHeldVoteTimer = 0xF8C0; // IntervalTimer + constexpr std::ptrdiff_t m_bShowHints = 0xF8D8; // bool + constexpr std::ptrdiff_t m_iNextTimeCheck = 0xF8DC; // int32_t + constexpr std::ptrdiff_t m_bJustDidTeamKill = 0xF8E0; // bool + constexpr std::ptrdiff_t m_bPunishForTeamKill = 0xF8E1; // bool + constexpr std::ptrdiff_t m_bGaveTeamDamageWarning = 0xF8E2; // bool + constexpr std::ptrdiff_t m_bGaveTeamDamageWarningThisRound = 0xF8E3; // bool + constexpr std::ptrdiff_t m_LastTeamDamageWarningTime = 0xF8E4; // GameTime_t +} + +namespace CCSPlayerController_ActionTrackingServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_perRoundStats = 0x40; // CUtlVectorEmbeddedNetworkVar + constexpr std::ptrdiff_t m_matchStats = 0x90; // CSMatchStats_t + constexpr std::ptrdiff_t m_iNumRoundKills = 0x148; // int32_t + constexpr std::ptrdiff_t m_iNumRoundKillsHeadshots = 0x14C; // int32_t + constexpr std::ptrdiff_t m_unTotalRoundDamageDealt = 0x150; // uint32_t +} + +namespace CCSPlayerController_DamageServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_nSendUpdate = 0x40; // int32_t + constexpr std::ptrdiff_t m_DamageList = 0x48; // CUtlVectorEmbeddedNetworkVar +} + +namespace CCSPlayerController_InGameMoneyServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_bReceivesMoneyNextRound = 0x40; // bool + constexpr std::ptrdiff_t m_iAccountMoneyEarnedForNextRound = 0x44; // int32_t + constexpr std::ptrdiff_t m_iAccount = 0x48; // int32_t + constexpr std::ptrdiff_t m_iStartAccount = 0x4C; // int32_t + constexpr std::ptrdiff_t m_iTotalCashSpent = 0x50; // int32_t + constexpr std::ptrdiff_t m_iCashSpentThisRound = 0x54; // int32_t +} + +namespace CCSPlayerController_InventoryServices { // CPlayerControllerComponent + constexpr std::ptrdiff_t m_unMusicID = 0x40; // uint16_t + constexpr std::ptrdiff_t m_rank = 0x44; // MedalRank_t[6] + constexpr std::ptrdiff_t m_nPersonaDataPublicLevel = 0x5C; // int32_t + constexpr std::ptrdiff_t m_nPersonaDataPublicCommendsLeader = 0x60; // int32_t + constexpr std::ptrdiff_t m_nPersonaDataPublicCommendsTeacher = 0x64; // int32_t + constexpr std::ptrdiff_t m_nPersonaDataPublicCommendsFriendly = 0x68; // int32_t + constexpr std::ptrdiff_t m_unEquippedPlayerSprayIDs = 0xF48; // uint32_t[1] + constexpr std::ptrdiff_t m_vecServerAuthoritativeWeaponSlots = 0xF50; // CUtlVectorEmbeddedNetworkVar +} + +namespace CCSPlayerPawn { // CCSPlayerPawnBase + constexpr std::ptrdiff_t m_pBulletServices = 0x1550; // CCSPlayer_BulletServices* + constexpr std::ptrdiff_t m_pHostageServices = 0x1558; // CCSPlayer_HostageServices* + constexpr std::ptrdiff_t m_pBuyServices = 0x1560; // CCSPlayer_BuyServices* + constexpr std::ptrdiff_t m_pActionTrackingServices = 0x1568; // CCSPlayer_ActionTrackingServices* + constexpr std::ptrdiff_t m_pRadioServices = 0x1570; // CCSPlayer_RadioServices* + constexpr std::ptrdiff_t m_pDamageReactServices = 0x1578; // CCSPlayer_DamageReactServices* + constexpr std::ptrdiff_t m_nCharacterDefIndex = 0x1580; // uint16_t + constexpr std::ptrdiff_t m_hPreviousModel = 0x1588; // CStrongHandle + constexpr std::ptrdiff_t m_bHasFemaleVoice = 0x1590; // bool + constexpr std::ptrdiff_t m_strVOPrefix = 0x1598; // CUtlString + constexpr std::ptrdiff_t m_szLastPlaceName = 0x15A0; // char[18] + constexpr std::ptrdiff_t m_bInBuyZone = 0x1660; // bool + constexpr std::ptrdiff_t m_bWasInBuyZone = 0x1661; // bool + constexpr std::ptrdiff_t m_bInHostageRescueZone = 0x1662; // bool + constexpr std::ptrdiff_t m_bInBombZone = 0x1663; // bool + constexpr std::ptrdiff_t m_bWasInHostageRescueZone = 0x1664; // bool + constexpr std::ptrdiff_t m_iRetakesOffering = 0x1668; // int32_t + constexpr std::ptrdiff_t m_iRetakesOfferingCard = 0x166C; // int32_t + constexpr std::ptrdiff_t m_bRetakesHasDefuseKit = 0x1670; // bool + constexpr std::ptrdiff_t m_bRetakesMVPLastRound = 0x1671; // bool + constexpr std::ptrdiff_t m_iRetakesMVPBoostItem = 0x1674; // int32_t + constexpr std::ptrdiff_t m_RetakesMVPBoostExtraUtility = 0x1678; // loadout_slot_t + constexpr std::ptrdiff_t m_flHealthShotBoostExpirationTime = 0x167C; // GameTime_t + constexpr std::ptrdiff_t m_flLandseconds = 0x1680; // float + constexpr std::ptrdiff_t m_aimPunchAngle = 0x1684; // QAngle + constexpr std::ptrdiff_t m_aimPunchAngleVel = 0x1690; // QAngle + constexpr std::ptrdiff_t m_aimPunchTickBase = 0x169C; // int32_t + constexpr std::ptrdiff_t m_aimPunchTickFraction = 0x16A0; // float + constexpr std::ptrdiff_t m_aimPunchCache = 0x16A8; // CUtlVector + constexpr std::ptrdiff_t m_bIsBuyMenuOpen = 0x16C0; // bool + constexpr std::ptrdiff_t m_xLastHeadBoneTransform = 0x1C30; // CTransform + constexpr std::ptrdiff_t m_bLastHeadBoneTransformIsValid = 0x1C50; // bool + constexpr std::ptrdiff_t m_lastLandTime = 0x1C54; // GameTime_t + constexpr std::ptrdiff_t m_bOnGroundLastTick = 0x1C58; // bool + constexpr std::ptrdiff_t m_iPlayerLocked = 0x1C5C; // int32_t + constexpr std::ptrdiff_t m_flTimeOfLastInjury = 0x1C64; // GameTime_t + constexpr std::ptrdiff_t m_flNextSprayDecalTime = 0x1C68; // GameTime_t + constexpr std::ptrdiff_t m_bNextSprayDecalTimeExpedited = 0x1C6C; // bool + constexpr std::ptrdiff_t m_nRagdollDamageBone = 0x1C70; // int32_t + constexpr std::ptrdiff_t m_vRagdollDamageForce = 0x1C74; // Vector + constexpr std::ptrdiff_t m_vRagdollDamagePosition = 0x1C80; // Vector + constexpr std::ptrdiff_t m_szRagdollDamageWeaponName = 0x1C8C; // char[64] + constexpr std::ptrdiff_t m_bRagdollDamageHeadshot = 0x1CCC; // bool + constexpr std::ptrdiff_t m_vRagdollServerOrigin = 0x1CD0; // Vector + constexpr std::ptrdiff_t m_EconGloves = 0x1CE0; // CEconItemView + constexpr std::ptrdiff_t m_qDeathEyeAngles = 0x1F58; // QAngle + constexpr std::ptrdiff_t m_bSkipOneHeadConstraintUpdate = 0x1F64; // bool +} + +namespace CCSPlayerPawnBase { // CBasePlayerPawn + constexpr std::ptrdiff_t m_CTouchExpansionComponent = 0xB68; // CTouchExpansionComponent + constexpr std::ptrdiff_t m_pPingServices = 0xBB8; // CCSPlayer_PingServices* + constexpr std::ptrdiff_t m_pViewModelServices = 0xBC0; // CPlayer_ViewModelServices* + constexpr std::ptrdiff_t m_iDisplayHistoryBits = 0xBC8; // uint32_t + constexpr std::ptrdiff_t m_flLastAttackedTeammate = 0xBCC; // float + constexpr std::ptrdiff_t m_hOriginalController = 0xBD0; // CHandle + constexpr std::ptrdiff_t m_blindUntilTime = 0xBD4; // GameTime_t + constexpr std::ptrdiff_t m_blindStartTime = 0xBD8; // GameTime_t + constexpr std::ptrdiff_t m_allowAutoFollowTime = 0xBDC; // GameTime_t + constexpr std::ptrdiff_t m_entitySpottedState = 0xBE0; // EntitySpottedState_t + constexpr std::ptrdiff_t m_nSpotRules = 0xBF8; // int32_t + constexpr std::ptrdiff_t m_iPlayerState = 0xBFC; // CSPlayerState + constexpr std::ptrdiff_t m_chickenIdleSoundTimer = 0xC08; // CountdownTimer + constexpr std::ptrdiff_t m_chickenJumpSoundTimer = 0xC20; // CountdownTimer + constexpr std::ptrdiff_t m_vecLastBookmarkedPosition = 0xCD8; // Vector + constexpr std::ptrdiff_t m_flLastDistanceTraveledNotice = 0xCE4; // float + constexpr std::ptrdiff_t m_flAccumulatedDistanceTraveled = 0xCE8; // float + constexpr std::ptrdiff_t m_flLastFriendlyFireDamageReductionRatio = 0xCEC; // float + constexpr std::ptrdiff_t m_bRespawning = 0xCF0; // bool + constexpr std::ptrdiff_t m_nLastPickupPriority = 0xCF4; // int32_t + constexpr std::ptrdiff_t m_flLastPickupPriorityTime = 0xCF8; // float + constexpr std::ptrdiff_t m_bIsScoped = 0xCFC; // bool + constexpr std::ptrdiff_t m_bIsWalking = 0xCFD; // bool + constexpr std::ptrdiff_t m_bResumeZoom = 0xCFE; // bool + constexpr std::ptrdiff_t m_bIsDefusing = 0xCFF; // bool + constexpr std::ptrdiff_t m_bIsGrabbingHostage = 0xD00; // bool + constexpr std::ptrdiff_t m_iBlockingUseActionInProgress = 0xD04; // CSPlayerBlockingUseAction_t + constexpr std::ptrdiff_t m_fImmuneToGunGameDamageTime = 0xD08; // GameTime_t + constexpr std::ptrdiff_t m_bGunGameImmunity = 0xD0C; // bool + constexpr std::ptrdiff_t m_fMolotovDamageTime = 0xD10; // float + constexpr std::ptrdiff_t m_bHasMovedSinceSpawn = 0xD14; // bool + constexpr std::ptrdiff_t m_bCanMoveDuringFreezePeriod = 0xD15; // bool + constexpr std::ptrdiff_t m_flGuardianTooFarDistFrac = 0xD18; // float + constexpr std::ptrdiff_t m_flNextGuardianTooFarHurtTime = 0xD1C; // float + constexpr std::ptrdiff_t m_flDetectedByEnemySensorTime = 0xD20; // GameTime_t + constexpr std::ptrdiff_t m_flDealtDamageToEnemyMostRecentTimestamp = 0xD24; // float + constexpr std::ptrdiff_t m_flLastEquippedHelmetTime = 0xD28; // GameTime_t + constexpr std::ptrdiff_t m_flLastEquippedArmorTime = 0xD2C; // GameTime_t + constexpr std::ptrdiff_t m_nHeavyAssaultSuitCooldownRemaining = 0xD30; // int32_t + constexpr std::ptrdiff_t m_bResetArmorNextSpawn = 0xD34; // bool + constexpr std::ptrdiff_t m_flLastBumpMineBumpTime = 0xD38; // GameTime_t + constexpr std::ptrdiff_t m_flEmitSoundTime = 0xD3C; // GameTime_t + constexpr std::ptrdiff_t m_iNumSpawns = 0xD40; // int32_t + constexpr std::ptrdiff_t m_iShouldHaveCash = 0xD44; // int32_t + constexpr std::ptrdiff_t m_bInvalidSteamLogonDelayed = 0xD48; // bool + constexpr std::ptrdiff_t m_flLastAction = 0xD4C; // GameTime_t + constexpr std::ptrdiff_t m_flNameChangeHistory = 0xD50; // float[5] + constexpr std::ptrdiff_t m_fLastGivenDefuserTime = 0xD64; // float + constexpr std::ptrdiff_t m_fLastGivenBombTime = 0xD68; // float + constexpr std::ptrdiff_t m_bHasNightVision = 0xD6C; // bool + constexpr std::ptrdiff_t m_bNightVisionOn = 0xD6D; // bool + constexpr std::ptrdiff_t m_fNextRadarUpdateTime = 0xD70; // float + constexpr std::ptrdiff_t m_flLastMoneyUpdateTime = 0xD74; // float + constexpr std::ptrdiff_t m_MenuStringBuffer = 0xD78; // char[1024] + constexpr std::ptrdiff_t m_fIntroCamTime = 0x1178; // float + constexpr std::ptrdiff_t m_nMyCollisionGroup = 0x117C; // int32_t + constexpr std::ptrdiff_t m_bInNoDefuseArea = 0x1180; // bool + constexpr std::ptrdiff_t m_bKilledByTaser = 0x1181; // bool + constexpr std::ptrdiff_t m_iMoveState = 0x1184; // int32_t + constexpr std::ptrdiff_t m_grenadeParameterStashTime = 0x1188; // GameTime_t + constexpr std::ptrdiff_t m_bGrenadeParametersStashed = 0x118C; // bool + constexpr std::ptrdiff_t m_angStashedShootAngles = 0x1190; // QAngle + constexpr std::ptrdiff_t m_vecStashedGrenadeThrowPosition = 0x119C; // Vector + constexpr std::ptrdiff_t m_vecStashedVelocity = 0x11A8; // Vector + constexpr std::ptrdiff_t m_angShootAngleHistory = 0x11B4; // QAngle[2] + constexpr std::ptrdiff_t m_vecThrowPositionHistory = 0x11CC; // Vector[2] + constexpr std::ptrdiff_t m_vecVelocityHistory = 0x11E4; // Vector[2] + constexpr std::ptrdiff_t m_bDiedAirborne = 0x11FC; // bool + constexpr std::ptrdiff_t m_iBombSiteIndex = 0x1200; // CEntityIndex + constexpr std::ptrdiff_t m_nWhichBombZone = 0x1204; // int32_t + constexpr std::ptrdiff_t m_bInBombZoneTrigger = 0x1208; // bool + constexpr std::ptrdiff_t m_bWasInBombZoneTrigger = 0x1209; // bool + constexpr std::ptrdiff_t m_iDirection = 0x120C; // int32_t + constexpr std::ptrdiff_t m_iShotsFired = 0x1210; // int32_t + constexpr std::ptrdiff_t m_ArmorValue = 0x1214; // int32_t + constexpr std::ptrdiff_t m_flFlinchStack = 0x1218; // float + constexpr std::ptrdiff_t m_flVelocityModifier = 0x121C; // float + constexpr std::ptrdiff_t m_flHitHeading = 0x1220; // float + constexpr std::ptrdiff_t m_nHitBodyPart = 0x1224; // int32_t + constexpr std::ptrdiff_t m_iHostagesKilled = 0x1228; // int32_t + constexpr std::ptrdiff_t m_vecTotalBulletForce = 0x122C; // Vector + constexpr std::ptrdiff_t m_flFlashDuration = 0x1238; // float + constexpr std::ptrdiff_t m_flFlashMaxAlpha = 0x123C; // float + constexpr std::ptrdiff_t m_flProgressBarStartTime = 0x1240; // float + constexpr std::ptrdiff_t m_iProgressBarDuration = 0x1244; // int32_t + constexpr std::ptrdiff_t m_bWaitForNoAttack = 0x1248; // bool + constexpr std::ptrdiff_t m_flLowerBodyYawTarget = 0x124C; // float + constexpr std::ptrdiff_t m_bStrafing = 0x1250; // bool + constexpr std::ptrdiff_t m_lastStandingPos = 0x1254; // Vector + constexpr std::ptrdiff_t m_ignoreLadderJumpTime = 0x1260; // float + constexpr std::ptrdiff_t m_ladderSurpressionTimer = 0x1268; // CountdownTimer + constexpr std::ptrdiff_t m_lastLadderNormal = 0x1280; // Vector + constexpr std::ptrdiff_t m_lastLadderPos = 0x128C; // Vector + constexpr std::ptrdiff_t m_thirdPersonHeading = 0x1298; // QAngle + constexpr std::ptrdiff_t m_flSlopeDropOffset = 0x12A4; // float + constexpr std::ptrdiff_t m_flSlopeDropHeight = 0x12A8; // float + constexpr std::ptrdiff_t m_vHeadConstraintOffset = 0x12AC; // Vector + constexpr std::ptrdiff_t m_iLastWeaponFireUsercmd = 0x12C0; // int32_t + constexpr std::ptrdiff_t m_angEyeAngles = 0x12C4; // QAngle + constexpr std::ptrdiff_t m_bVCollisionInitted = 0x12D0; // bool + constexpr std::ptrdiff_t m_storedSpawnPosition = 0x12D4; // Vector + constexpr std::ptrdiff_t m_storedSpawnAngle = 0x12E0; // QAngle + constexpr std::ptrdiff_t m_bIsSpawning = 0x12EC; // bool + constexpr std::ptrdiff_t m_bHideTargetID = 0x12ED; // bool + constexpr std::ptrdiff_t m_nNumDangerZoneDamageHits = 0x12F0; // int32_t + constexpr std::ptrdiff_t m_bHud_MiniScoreHidden = 0x12F4; // bool + constexpr std::ptrdiff_t m_bHud_RadarHidden = 0x12F5; // bool + constexpr std::ptrdiff_t m_nLastKillerIndex = 0x12F8; // CEntityIndex + constexpr std::ptrdiff_t m_nLastConcurrentKilled = 0x12FC; // int32_t + constexpr std::ptrdiff_t m_nDeathCamMusic = 0x1300; // int32_t + constexpr std::ptrdiff_t m_iAddonBits = 0x1304; // int32_t + constexpr std::ptrdiff_t m_iPrimaryAddon = 0x1308; // int32_t + constexpr std::ptrdiff_t m_iSecondaryAddon = 0x130C; // int32_t + constexpr std::ptrdiff_t m_currentDeafnessFilter = 0x1310; // CUtlStringToken + constexpr std::ptrdiff_t m_NumEnemiesKilledThisSpawn = 0x1314; // int32_t + constexpr std::ptrdiff_t m_NumEnemiesKilledThisRound = 0x1318; // int32_t + constexpr std::ptrdiff_t m_NumEnemiesAtRoundStart = 0x131C; // int32_t + constexpr std::ptrdiff_t m_wasNotKilledNaturally = 0x1320; // bool + constexpr std::ptrdiff_t m_vecPlayerPatchEconIndices = 0x1324; // uint32_t[5] + constexpr std::ptrdiff_t m_iDeathFlags = 0x1338; // int32_t + constexpr std::ptrdiff_t m_hPet = 0x133C; // CHandle + constexpr std::ptrdiff_t m_unCurrentEquipmentValue = 0x1508; // uint16_t + constexpr std::ptrdiff_t m_unRoundStartEquipmentValue = 0x150A; // uint16_t + constexpr std::ptrdiff_t m_unFreezetimeEndEquipmentValue = 0x150C; // uint16_t + constexpr std::ptrdiff_t m_nSurvivalTeamNumber = 0x1510; // int32_t + constexpr std::ptrdiff_t m_bHasDeathInfo = 0x1514; // bool + constexpr std::ptrdiff_t m_flDeathInfoTime = 0x1518; // float + constexpr std::ptrdiff_t m_vecDeathInfoOrigin = 0x151C; // Vector + constexpr std::ptrdiff_t m_bKilledByHeadshot = 0x1528; // bool + constexpr std::ptrdiff_t m_LastHitBox = 0x152C; // int32_t + constexpr std::ptrdiff_t m_LastHealth = 0x1530; // int32_t + constexpr std::ptrdiff_t m_flLastCollisionCeiling = 0x1534; // float + constexpr std::ptrdiff_t m_flLastCollisionCeilingChangeTime = 0x1538; // float + constexpr std::ptrdiff_t m_pBot = 0x1540; // CCSBot* + constexpr std::ptrdiff_t m_bBotAllowActive = 0x1548; // bool + constexpr std::ptrdiff_t m_bCommittingSuicideOnTeamChange = 0x1549; // bool +} + +namespace CCSPlayerResource { // CBaseEntity + constexpr std::ptrdiff_t m_bHostageAlive = 0x4B0; // bool[12] + constexpr std::ptrdiff_t m_isHostageFollowingSomeone = 0x4BC; // bool[12] + constexpr std::ptrdiff_t m_iHostageEntityIDs = 0x4C8; // CEntityIndex[12] + constexpr std::ptrdiff_t m_bombsiteCenterA = 0x4F8; // Vector + constexpr std::ptrdiff_t m_bombsiteCenterB = 0x504; // Vector + constexpr std::ptrdiff_t m_hostageRescueX = 0x510; // int32_t[4] + constexpr std::ptrdiff_t m_hostageRescueY = 0x520; // int32_t[4] + constexpr std::ptrdiff_t m_hostageRescueZ = 0x530; // int32_t[4] + constexpr std::ptrdiff_t m_bEndMatchNextMapAllVoted = 0x540; // bool + constexpr std::ptrdiff_t m_foundGoalPositions = 0x541; // bool +} + +namespace CCSPlayer_ActionTrackingServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_hLastWeaponBeforeC4AutoSwitch = 0x208; // CHandle + constexpr std::ptrdiff_t m_bIsRescuing = 0x23C; // bool + constexpr std::ptrdiff_t m_weaponPurchasesThisMatch = 0x240; // WeaponPurchaseTracker_t + constexpr std::ptrdiff_t m_weaponPurchasesThisRound = 0x298; // WeaponPurchaseTracker_t +} + +namespace CCSPlayer_BulletServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_totalHitsOnServer = 0x40; // int32_t +} + +namespace CCSPlayer_BuyServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_vecSellbackPurchaseEntries = 0xC8; // CUtlVectorEmbeddedNetworkVar +} + +namespace CCSPlayer_CameraServices { // CCSPlayerBase_CameraServices +} + +namespace CCSPlayer_DamageReactServices { // CPlayerPawnComponent +} + +namespace CCSPlayer_HostageServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_hCarriedHostage = 0x40; // CHandle + constexpr std::ptrdiff_t m_hCarriedHostageProp = 0x44; // CHandle +} + +namespace CCSPlayer_ItemServices { // CPlayer_ItemServices + constexpr std::ptrdiff_t m_bHasDefuser = 0x40; // bool + constexpr std::ptrdiff_t m_bHasHelmet = 0x41; // bool + constexpr std::ptrdiff_t m_bHasHeavyArmor = 0x42; // bool +} + +namespace CCSPlayer_MovementServices { // CPlayer_MovementServices_Humanoid + constexpr std::ptrdiff_t m_flMaxFallVelocity = 0x220; // float + constexpr std::ptrdiff_t m_vecLadderNormal = 0x224; // Vector + constexpr std::ptrdiff_t m_nLadderSurfacePropIndex = 0x230; // int32_t + constexpr std::ptrdiff_t m_flDuckAmount = 0x234; // float + constexpr std::ptrdiff_t m_flDuckSpeed = 0x238; // float + constexpr std::ptrdiff_t m_bDuckOverride = 0x23C; // bool + constexpr std::ptrdiff_t m_bDesiresDuck = 0x23D; // bool + constexpr std::ptrdiff_t m_flDuckOffset = 0x240; // float + constexpr std::ptrdiff_t m_nDuckTimeMsecs = 0x244; // uint32_t + constexpr std::ptrdiff_t m_nDuckJumpTimeMsecs = 0x248; // uint32_t + constexpr std::ptrdiff_t m_nJumpTimeMsecs = 0x24C; // uint32_t + constexpr std::ptrdiff_t m_flLastDuckTime = 0x250; // float + constexpr std::ptrdiff_t m_vecLastPositionAtFullCrouchSpeed = 0x260; // Vector2D + constexpr std::ptrdiff_t m_duckUntilOnGround = 0x268; // bool + constexpr std::ptrdiff_t m_bHasWalkMovedSinceLastJump = 0x269; // bool + constexpr std::ptrdiff_t m_bInStuckTest = 0x26A; // bool + constexpr std::ptrdiff_t m_flStuckCheckTime = 0x278; // float[64][2] + constexpr std::ptrdiff_t m_nTraceCount = 0x478; // int32_t + constexpr std::ptrdiff_t m_StuckLast = 0x47C; // int32_t + constexpr std::ptrdiff_t m_bSpeedCropped = 0x480; // bool + constexpr std::ptrdiff_t m_nOldWaterLevel = 0x484; // int32_t + constexpr std::ptrdiff_t m_flWaterEntryTime = 0x488; // float + constexpr std::ptrdiff_t m_vecForward = 0x48C; // Vector + constexpr std::ptrdiff_t m_vecLeft = 0x498; // Vector + constexpr std::ptrdiff_t m_vecUp = 0x4A4; // Vector + constexpr std::ptrdiff_t m_vecPreviouslyPredictedOrigin = 0x4B0; // Vector + constexpr std::ptrdiff_t m_bMadeFootstepNoise = 0x4BC; // bool + constexpr std::ptrdiff_t m_iFootsteps = 0x4C0; // int32_t + constexpr std::ptrdiff_t m_bOldJumpPressed = 0x4C4; // bool + constexpr std::ptrdiff_t m_flJumpPressedTime = 0x4C8; // float + constexpr std::ptrdiff_t m_flJumpUntil = 0x4CC; // float + constexpr std::ptrdiff_t m_flJumpVel = 0x4D0; // float + constexpr std::ptrdiff_t m_fStashGrenadeParameterWhen = 0x4D4; // GameTime_t + constexpr std::ptrdiff_t m_nButtonDownMaskPrev = 0x4D8; // uint64_t + constexpr std::ptrdiff_t m_flOffsetTickCompleteTime = 0x4E0; // float + constexpr std::ptrdiff_t m_flOffsetTickStashedSpeed = 0x4E4; // float + constexpr std::ptrdiff_t m_flStamina = 0x4E8; // float +} + +namespace CCSPlayer_PingServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_flPlayerPingTokens = 0x40; // GameTime_t[5] + constexpr std::ptrdiff_t m_hPlayerPing = 0x54; // CHandle +} + +namespace CCSPlayer_RadioServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_flGotHostageTalkTimer = 0x40; // GameTime_t + constexpr std::ptrdiff_t m_flDefusingTalkTimer = 0x44; // GameTime_t + constexpr std::ptrdiff_t m_flC4PlantTalkTimer = 0x48; // GameTime_t + constexpr std::ptrdiff_t m_flRadioTokenSlots = 0x4C; // GameTime_t[3] + constexpr std::ptrdiff_t m_bIgnoreRadio = 0x58; // bool +} + +namespace CCSPlayer_UseServices { // CPlayer_UseServices + constexpr std::ptrdiff_t m_hLastKnownUseEntity = 0x40; // CHandle + constexpr std::ptrdiff_t m_flLastUseTimeStamp = 0x44; // GameTime_t + constexpr std::ptrdiff_t m_flTimeStartedHoldingUse = 0x48; // GameTime_t + constexpr std::ptrdiff_t m_flTimeLastUsedWindow = 0x4C; // GameTime_t +} + +namespace CCSPlayer_ViewModelServices { // CPlayer_ViewModelServices + constexpr std::ptrdiff_t m_hViewModel = 0x40; // CHandle[3] +} + +namespace CCSPlayer_WaterServices { // CPlayer_WaterServices + constexpr std::ptrdiff_t m_NextDrownDamageTime = 0x40; // float + constexpr std::ptrdiff_t m_nDrownDmgRate = 0x44; // int32_t + constexpr std::ptrdiff_t m_AirFinishedTime = 0x48; // GameTime_t + constexpr std::ptrdiff_t m_flWaterJumpTime = 0x4C; // float + constexpr std::ptrdiff_t m_vecWaterJumpVel = 0x50; // Vector + constexpr std::ptrdiff_t m_flSwimSoundTime = 0x5C; // float +} + +namespace CCSPlayer_WeaponServices { // CPlayer_WeaponServices + constexpr std::ptrdiff_t m_flNextAttack = 0xB0; // GameTime_t + constexpr std::ptrdiff_t m_bIsLookingAtWeapon = 0xB4; // bool + constexpr std::ptrdiff_t m_bIsHoldingLookAtWeapon = 0xB5; // bool + constexpr std::ptrdiff_t m_hSavedWeapon = 0xB8; // CHandle + constexpr std::ptrdiff_t m_nTimeToMelee = 0xBC; // int32_t + constexpr std::ptrdiff_t m_nTimeToSecondary = 0xC0; // int32_t + constexpr std::ptrdiff_t m_nTimeToPrimary = 0xC4; // int32_t + constexpr std::ptrdiff_t m_nTimeToSniperRifle = 0xC8; // int32_t + constexpr std::ptrdiff_t m_bIsBeingGivenItem = 0xCC; // bool + constexpr std::ptrdiff_t m_bIsPickingUpItemWithUse = 0xCD; // bool + constexpr std::ptrdiff_t m_bPickedUpWeapon = 0xCE; // bool +} + +namespace CCSPulseServerFuncs_Globals { +} + +namespace CCSSprite { // CSprite +} + +namespace CCSTeam { // CTeam + constexpr std::ptrdiff_t m_nLastRecievedShorthandedRoundBonus = 0x568; // int32_t + constexpr std::ptrdiff_t m_nShorthandedRoundBonusStartRound = 0x56C; // int32_t + constexpr std::ptrdiff_t m_bSurrendered = 0x570; // bool + constexpr std::ptrdiff_t m_szTeamMatchStat = 0x571; // char[512] + constexpr std::ptrdiff_t m_numMapVictories = 0x774; // int32_t + constexpr std::ptrdiff_t m_scoreFirstHalf = 0x778; // int32_t + constexpr std::ptrdiff_t m_scoreSecondHalf = 0x77C; // int32_t + constexpr std::ptrdiff_t m_scoreOvertime = 0x780; // int32_t + constexpr std::ptrdiff_t m_szClanTeamname = 0x784; // char[129] + constexpr std::ptrdiff_t m_iClanID = 0x808; // uint32_t + constexpr std::ptrdiff_t m_szTeamFlagImage = 0x80C; // char[8] + constexpr std::ptrdiff_t m_szTeamLogoImage = 0x814; // char[8] + constexpr std::ptrdiff_t m_flNextResourceTime = 0x81C; // float + constexpr std::ptrdiff_t m_iLastUpdateSentAt = 0x820; // int32_t +} + +namespace CCSWeaponBase { // CBasePlayerWeapon + constexpr std::ptrdiff_t m_bRemoveable = 0xC88; // bool + constexpr std::ptrdiff_t m_flFireSequenceStartTime = 0xC8C; // float + constexpr std::ptrdiff_t m_nFireSequenceStartTimeChange = 0xC90; // int32_t + constexpr std::ptrdiff_t m_nFireSequenceStartTimeAck = 0xC94; // int32_t + constexpr std::ptrdiff_t m_bPlayerFireEventIsPrimary = 0xC98; // bool + constexpr std::ptrdiff_t m_seqIdle = 0xC9C; // HSequence + constexpr std::ptrdiff_t m_seqFirePrimary = 0xCA0; // HSequence + constexpr std::ptrdiff_t m_seqFireSecondary = 0xCA4; // HSequence + constexpr std::ptrdiff_t m_thirdPersonFireSequences = 0xCA8; // CUtlVector + constexpr std::ptrdiff_t m_hCurrentThirdPersonSequence = 0xCC0; // HSequence + constexpr std::ptrdiff_t m_nSilencerBoneIndex = 0xCC4; // int32_t + constexpr std::ptrdiff_t m_thirdPersonSequences = 0xCC8; // HSequence[6] + constexpr std::ptrdiff_t m_bPlayerAmmoStockOnPickup = 0xCE8; // bool + constexpr std::ptrdiff_t m_bRequireUseToTouch = 0xCE9; // bool + constexpr std::ptrdiff_t m_iState = 0xCEC; // CSWeaponState_t + constexpr std::ptrdiff_t m_flLastTimeInAir = 0xCF0; // GameTime_t + constexpr std::ptrdiff_t m_flLastDeployTime = 0xCF4; // GameTime_t + constexpr std::ptrdiff_t m_nViewModelIndex = 0xCF8; // uint32_t + constexpr std::ptrdiff_t m_bReloadsWithClips = 0xCFC; // bool + constexpr std::ptrdiff_t m_flTimeWeaponIdle = 0xD18; // GameTime_t + constexpr std::ptrdiff_t m_bFireOnEmpty = 0xD1C; // bool + constexpr std::ptrdiff_t m_OnPlayerPickup = 0xD20; // CEntityIOOutput + constexpr std::ptrdiff_t m_weaponMode = 0xD48; // CSWeaponMode + constexpr std::ptrdiff_t m_flTurningInaccuracyDelta = 0xD4C; // float + constexpr std::ptrdiff_t m_vecTurningInaccuracyEyeDirLast = 0xD50; // Vector + constexpr std::ptrdiff_t m_flTurningInaccuracy = 0xD5C; // float + constexpr std::ptrdiff_t m_fAccuracyPenalty = 0xD60; // float + constexpr std::ptrdiff_t m_flLastAccuracyUpdateTime = 0xD64; // GameTime_t + constexpr std::ptrdiff_t m_fAccuracySmoothedForZoom = 0xD68; // float + constexpr std::ptrdiff_t m_fScopeZoomEndTime = 0xD6C; // GameTime_t + constexpr std::ptrdiff_t m_iRecoilIndex = 0xD70; // int32_t + constexpr std::ptrdiff_t m_flRecoilIndex = 0xD74; // float + constexpr std::ptrdiff_t m_bBurstMode = 0xD78; // bool + constexpr std::ptrdiff_t m_flPostponeFireReadyTime = 0xD7C; // GameTime_t + constexpr std::ptrdiff_t m_bInReload = 0xD80; // bool + constexpr std::ptrdiff_t m_bReloadVisuallyComplete = 0xD81; // bool + constexpr std::ptrdiff_t m_flDroppedAtTime = 0xD84; // GameTime_t + constexpr std::ptrdiff_t m_bIsHauledBack = 0xD88; // bool + constexpr std::ptrdiff_t m_bSilencerOn = 0xD89; // bool + constexpr std::ptrdiff_t m_flTimeSilencerSwitchComplete = 0xD8C; // GameTime_t + constexpr std::ptrdiff_t m_iOriginalTeamNumber = 0xD90; // int32_t + constexpr std::ptrdiff_t m_flNextAttackRenderTimeOffset = 0xD94; // float + constexpr std::ptrdiff_t m_bCanBePickedUp = 0xDA8; // bool + constexpr std::ptrdiff_t m_bUseCanOverrideNextOwnerTouchTime = 0xDA9; // bool + constexpr std::ptrdiff_t m_nextOwnerTouchTime = 0xDAC; // GameTime_t + constexpr std::ptrdiff_t m_nextPrevOwnerTouchTime = 0xDB0; // GameTime_t + constexpr std::ptrdiff_t m_hPrevOwner = 0xDB4; // CHandle + constexpr std::ptrdiff_t m_nDropTick = 0xDB8; // GameTick_t + constexpr std::ptrdiff_t m_donated = 0xDDC; // bool + constexpr std::ptrdiff_t m_fLastShotTime = 0xDE0; // GameTime_t + constexpr std::ptrdiff_t m_bWasOwnedByCT = 0xDE4; // bool + constexpr std::ptrdiff_t m_bWasOwnedByTerrorist = 0xDE5; // bool + constexpr std::ptrdiff_t m_bFiredOutOfAmmoEvent = 0xDE6; // bool + constexpr std::ptrdiff_t m_numRemoveUnownedWeaponThink = 0xDE8; // int32_t + constexpr std::ptrdiff_t m_IronSightController = 0xDF0; // CIronSightController + constexpr std::ptrdiff_t m_iIronSightMode = 0xE08; // int32_t + constexpr std::ptrdiff_t m_flLastLOSTraceFailureTime = 0xE0C; // GameTime_t + constexpr std::ptrdiff_t m_iNumEmptyAttacks = 0xE10; // int32_t +} + +namespace CCSWeaponBaseGun { // CCSWeaponBase + constexpr std::ptrdiff_t m_zoomLevel = 0xE18; // int32_t + constexpr std::ptrdiff_t m_iBurstShotsRemaining = 0xE1C; // int32_t + constexpr std::ptrdiff_t m_silencedModelIndex = 0xE28; // int32_t + constexpr std::ptrdiff_t m_inPrecache = 0xE2C; // bool + constexpr std::ptrdiff_t m_bNeedsBoltAction = 0xE2D; // bool + constexpr std::ptrdiff_t m_bSkillReloadAvailable = 0xE2E; // bool + constexpr std::ptrdiff_t m_bSkillReloadLiftedReloadKey = 0xE2F; // bool + constexpr std::ptrdiff_t m_bSkillBoltInterruptAvailable = 0xE30; // bool + constexpr std::ptrdiff_t m_bSkillBoltLiftedFireKey = 0xE31; // bool +} + +namespace CCSWeaponBaseVData { // CBasePlayerWeaponVData + constexpr std::ptrdiff_t m_WeaponType = 0x240; // CSWeaponType + constexpr std::ptrdiff_t m_WeaponCategory = 0x244; // CSWeaponCategory + constexpr std::ptrdiff_t m_szViewModel = 0x248; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szPlayerModel = 0x328; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szWorldDroppedModel = 0x408; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szAimsightLensMaskModel = 0x4E8; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMagazineModel = 0x5C8; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szHeatEffect = 0x6A8; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szEjectBrassEffect = 0x788; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMuzzleFlashParticleAlt = 0x868; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMuzzleFlashThirdPersonParticle = 0x948; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szMuzzleFlashThirdPersonParticleAlt = 0xA28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_szTracerParticle = 0xB08; // CResourceNameTyped> + constexpr std::ptrdiff_t m_GearSlot = 0xBE8; // gear_slot_t + constexpr std::ptrdiff_t m_GearSlotPosition = 0xBEC; // int32_t + constexpr std::ptrdiff_t m_DefaultLoadoutSlot = 0xBF0; // loadout_slot_t + constexpr std::ptrdiff_t m_sWrongTeamMsg = 0xBF8; // CUtlString + constexpr std::ptrdiff_t m_nPrice = 0xC00; // int32_t + constexpr std::ptrdiff_t m_nKillAward = 0xC04; // int32_t + constexpr std::ptrdiff_t m_nPrimaryReserveAmmoMax = 0xC08; // int32_t + constexpr std::ptrdiff_t m_nSecondaryReserveAmmoMax = 0xC0C; // int32_t + constexpr std::ptrdiff_t m_bMeleeWeapon = 0xC10; // bool + constexpr std::ptrdiff_t m_bHasBurstMode = 0xC11; // bool + constexpr std::ptrdiff_t m_bIsRevolver = 0xC12; // bool + constexpr std::ptrdiff_t m_bCannotShootUnderwater = 0xC13; // bool + constexpr std::ptrdiff_t m_szName = 0xC18; // CUtlString + constexpr std::ptrdiff_t m_szAnimExtension = 0xC20; // CUtlString + constexpr std::ptrdiff_t m_eSilencerType = 0xC28; // CSWeaponSilencerType + constexpr std::ptrdiff_t m_nCrosshairMinDistance = 0xC2C; // int32_t + constexpr std::ptrdiff_t m_nCrosshairDeltaDistance = 0xC30; // int32_t + constexpr std::ptrdiff_t m_flCycleTime = 0xC34; // CFiringModeFloat + constexpr std::ptrdiff_t m_flMaxSpeed = 0xC3C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flSpread = 0xC44; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyCrouch = 0xC4C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyStand = 0xC54; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyJump = 0xC5C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyLand = 0xC64; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyLadder = 0xC6C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyFire = 0xC74; // CFiringModeFloat + constexpr std::ptrdiff_t m_flInaccuracyMove = 0xC7C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilAngle = 0xC84; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilAngleVariance = 0xC8C; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilMagnitude = 0xC94; // CFiringModeFloat + constexpr std::ptrdiff_t m_flRecoilMagnitudeVariance = 0xC9C; // CFiringModeFloat + constexpr std::ptrdiff_t m_nTracerFrequency = 0xCA4; // CFiringModeInt + constexpr std::ptrdiff_t m_flInaccuracyJumpInitial = 0xCAC; // float + constexpr std::ptrdiff_t m_flInaccuracyJumpApex = 0xCB0; // float + constexpr std::ptrdiff_t m_flInaccuracyReload = 0xCB4; // float + constexpr std::ptrdiff_t m_nRecoilSeed = 0xCB8; // int32_t + constexpr std::ptrdiff_t m_nSpreadSeed = 0xCBC; // int32_t + constexpr std::ptrdiff_t m_flTimeToIdleAfterFire = 0xCC0; // float + constexpr std::ptrdiff_t m_flIdleInterval = 0xCC4; // float + constexpr std::ptrdiff_t m_flAttackMovespeedFactor = 0xCC8; // float + constexpr std::ptrdiff_t m_flHeatPerShot = 0xCCC; // float + constexpr std::ptrdiff_t m_flInaccuracyPitchShift = 0xCD0; // float + constexpr std::ptrdiff_t m_flInaccuracyAltSoundThreshold = 0xCD4; // float + constexpr std::ptrdiff_t m_flBotAudibleRange = 0xCD8; // float + constexpr std::ptrdiff_t m_szUseRadioSubtitle = 0xCE0; // CUtlString + constexpr std::ptrdiff_t m_bUnzoomsAfterShot = 0xCE8; // bool + constexpr std::ptrdiff_t m_bHideViewModelWhenZoomed = 0xCE9; // bool + constexpr std::ptrdiff_t m_nZoomLevels = 0xCEC; // int32_t + constexpr std::ptrdiff_t m_nZoomFOV1 = 0xCF0; // int32_t + constexpr std::ptrdiff_t m_nZoomFOV2 = 0xCF4; // int32_t + constexpr std::ptrdiff_t m_flZoomTime0 = 0xCF8; // float + constexpr std::ptrdiff_t m_flZoomTime1 = 0xCFC; // float + constexpr std::ptrdiff_t m_flZoomTime2 = 0xD00; // float + constexpr std::ptrdiff_t m_flIronSightPullUpSpeed = 0xD04; // float + constexpr std::ptrdiff_t m_flIronSightPutDownSpeed = 0xD08; // float + constexpr std::ptrdiff_t m_flIronSightFOV = 0xD0C; // float + constexpr std::ptrdiff_t m_flIronSightPivotForward = 0xD10; // float + constexpr std::ptrdiff_t m_flIronSightLooseness = 0xD14; // float + constexpr std::ptrdiff_t m_angPivotAngle = 0xD18; // QAngle + constexpr std::ptrdiff_t m_vecIronSightEyePos = 0xD24; // Vector + constexpr std::ptrdiff_t m_nDamage = 0xD30; // int32_t + constexpr std::ptrdiff_t m_flHeadshotMultiplier = 0xD34; // float + constexpr std::ptrdiff_t m_flArmorRatio = 0xD38; // float + constexpr std::ptrdiff_t m_flPenetration = 0xD3C; // float + constexpr std::ptrdiff_t m_flRange = 0xD40; // float + constexpr std::ptrdiff_t m_flRangeModifier = 0xD44; // float + constexpr std::ptrdiff_t m_flFlinchVelocityModifierLarge = 0xD48; // float + constexpr std::ptrdiff_t m_flFlinchVelocityModifierSmall = 0xD4C; // float + constexpr std::ptrdiff_t m_flRecoveryTimeCrouch = 0xD50; // float + constexpr std::ptrdiff_t m_flRecoveryTimeStand = 0xD54; // float + constexpr std::ptrdiff_t m_flRecoveryTimeCrouchFinal = 0xD58; // float + constexpr std::ptrdiff_t m_flRecoveryTimeStandFinal = 0xD5C; // float + constexpr std::ptrdiff_t m_nRecoveryTransitionStartBullet = 0xD60; // int32_t + constexpr std::ptrdiff_t m_nRecoveryTransitionEndBullet = 0xD64; // int32_t + constexpr std::ptrdiff_t m_flThrowVelocity = 0xD68; // float + constexpr std::ptrdiff_t m_vSmokeColor = 0xD6C; // Vector + constexpr std::ptrdiff_t m_szAnimClass = 0xD78; // CUtlString +} + +namespace CChangeLevel { // CBaseTrigger + constexpr std::ptrdiff_t m_sMapName = 0x8A8; // CUtlString + constexpr std::ptrdiff_t m_sLandmarkName = 0x8B0; // CUtlString + constexpr std::ptrdiff_t m_OnChangeLevel = 0x8B8; // CEntityIOOutput + constexpr std::ptrdiff_t m_bTouched = 0x8E0; // bool + constexpr std::ptrdiff_t m_bNoTouch = 0x8E1; // bool + constexpr std::ptrdiff_t m_bNewChapter = 0x8E2; // bool + constexpr std::ptrdiff_t m_bOnChangeLevelFired = 0x8E3; // bool +} + +namespace CChicken { // CDynamicProp + constexpr std::ptrdiff_t m_AttributeManager = 0xB28; // CAttributeContainer + constexpr std::ptrdiff_t m_OriginalOwnerXuidLow = 0xDF0; // uint32_t + constexpr std::ptrdiff_t m_OriginalOwnerXuidHigh = 0xDF4; // uint32_t + constexpr std::ptrdiff_t m_updateTimer = 0xDF8; // CountdownTimer + constexpr std::ptrdiff_t m_stuckAnchor = 0xE10; // Vector + constexpr std::ptrdiff_t m_stuckTimer = 0xE20; // CountdownTimer + constexpr std::ptrdiff_t m_collisionStuckTimer = 0xE38; // CountdownTimer + constexpr std::ptrdiff_t m_isOnGround = 0xE50; // bool + constexpr std::ptrdiff_t m_vFallVelocity = 0xE54; // Vector + constexpr std::ptrdiff_t m_activity = 0xE60; // ChickenActivity + constexpr std::ptrdiff_t m_activityTimer = 0xE68; // CountdownTimer + constexpr std::ptrdiff_t m_turnRate = 0xE80; // float + constexpr std::ptrdiff_t m_fleeFrom = 0xE84; // CHandle + constexpr std::ptrdiff_t m_moveRateThrottleTimer = 0xE88; // CountdownTimer + constexpr std::ptrdiff_t m_startleTimer = 0xEA0; // CountdownTimer + constexpr std::ptrdiff_t m_vocalizeTimer = 0xEB8; // CountdownTimer + constexpr std::ptrdiff_t m_flWhenZombified = 0xED0; // GameTime_t + constexpr std::ptrdiff_t m_jumpedThisFrame = 0xED4; // bool + constexpr std::ptrdiff_t m_leader = 0xED8; // CHandle + constexpr std::ptrdiff_t m_reuseTimer = 0xEE0; // CountdownTimer + constexpr std::ptrdiff_t m_hasBeenUsed = 0xEF8; // bool + constexpr std::ptrdiff_t m_jumpTimer = 0xF00; // CountdownTimer + constexpr std::ptrdiff_t m_flLastJumpTime = 0xF18; // float + constexpr std::ptrdiff_t m_bInJump = 0xF1C; // bool + constexpr std::ptrdiff_t m_isWaitingForLeader = 0xF1D; // bool + constexpr std::ptrdiff_t m_repathTimer = 0x2F28; // CountdownTimer + constexpr std::ptrdiff_t m_inhibitDoorTimer = 0x2F40; // CountdownTimer + constexpr std::ptrdiff_t m_inhibitObstacleAvoidanceTimer = 0x2FD0; // CountdownTimer + constexpr std::ptrdiff_t m_vecPathGoal = 0x2FF0; // Vector + constexpr std::ptrdiff_t m_flActiveFollowStartTime = 0x2FFC; // GameTime_t + constexpr std::ptrdiff_t m_followMinuteTimer = 0x3000; // CountdownTimer + constexpr std::ptrdiff_t m_vecLastEggPoopPosition = 0x3018; // Vector + constexpr std::ptrdiff_t m_vecEggsPooped = 0x3028; // CUtlVector> + constexpr std::ptrdiff_t m_BlockDirectionTimer = 0x3048; // CountdownTimer +} + +namespace CCollisionProperty { + constexpr std::ptrdiff_t m_collisionAttribute = 0x10; // VPhysicsCollisionAttribute_t + constexpr std::ptrdiff_t m_vecMins = 0x40; // Vector + constexpr std::ptrdiff_t m_vecMaxs = 0x4C; // Vector + constexpr std::ptrdiff_t m_usSolidFlags = 0x5A; // uint8_t + constexpr std::ptrdiff_t m_nSolidType = 0x5B; // SolidType_t + constexpr std::ptrdiff_t m_triggerBloat = 0x5C; // uint8_t + constexpr std::ptrdiff_t m_nSurroundType = 0x5D; // SurroundingBoundsType_t + constexpr std::ptrdiff_t m_CollisionGroup = 0x5E; // uint8_t + constexpr std::ptrdiff_t m_nEnablePhysics = 0x5F; // uint8_t + constexpr std::ptrdiff_t m_flBoundingRadius = 0x60; // float + constexpr std::ptrdiff_t m_vecSpecifiedSurroundingMins = 0x64; // Vector + constexpr std::ptrdiff_t m_vecSpecifiedSurroundingMaxs = 0x70; // Vector + constexpr std::ptrdiff_t m_vecSurroundingMaxs = 0x7C; // Vector + constexpr std::ptrdiff_t m_vecSurroundingMins = 0x88; // Vector + constexpr std::ptrdiff_t m_vCapsuleCenter1 = 0x94; // Vector + constexpr std::ptrdiff_t m_vCapsuleCenter2 = 0xA0; // Vector + constexpr std::ptrdiff_t m_flCapsuleRadius = 0xAC; // float +} + +namespace CColorCorrection { // CBaseEntity + constexpr std::ptrdiff_t m_flFadeInDuration = 0x4B0; // float + constexpr std::ptrdiff_t m_flFadeOutDuration = 0x4B4; // float + constexpr std::ptrdiff_t m_flStartFadeInWeight = 0x4B8; // float + constexpr std::ptrdiff_t m_flStartFadeOutWeight = 0x4BC; // float + constexpr std::ptrdiff_t m_flTimeStartFadeIn = 0x4C0; // GameTime_t + constexpr std::ptrdiff_t m_flTimeStartFadeOut = 0x4C4; // GameTime_t + constexpr std::ptrdiff_t m_flMaxWeight = 0x4C8; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x4CC; // bool + constexpr std::ptrdiff_t m_bEnabled = 0x4CD; // bool + constexpr std::ptrdiff_t m_bMaster = 0x4CE; // bool + constexpr std::ptrdiff_t m_bClientSide = 0x4CF; // bool + constexpr std::ptrdiff_t m_bExclusive = 0x4D0; // bool + constexpr std::ptrdiff_t m_MinFalloff = 0x4D4; // float + constexpr std::ptrdiff_t m_MaxFalloff = 0x4D8; // float + constexpr std::ptrdiff_t m_flCurWeight = 0x4DC; // float + constexpr std::ptrdiff_t m_netlookupFilename = 0x4E0; // char[512] + constexpr std::ptrdiff_t m_lookupFilename = 0x6E0; // CUtlSymbolLarge +} + +namespace CColorCorrectionVolume { // CBaseTrigger + constexpr std::ptrdiff_t m_bEnabled = 0x8A8; // bool + constexpr std::ptrdiff_t m_MaxWeight = 0x8AC; // float + constexpr std::ptrdiff_t m_FadeDuration = 0x8B0; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x8B4; // bool + constexpr std::ptrdiff_t m_Weight = 0x8B8; // float + constexpr std::ptrdiff_t m_lookupFilename = 0x8BC; // char[512] + constexpr std::ptrdiff_t m_LastEnterWeight = 0xABC; // float + constexpr std::ptrdiff_t m_LastEnterTime = 0xAC0; // GameTime_t + constexpr std::ptrdiff_t m_LastExitWeight = 0xAC4; // float + constexpr std::ptrdiff_t m_LastExitTime = 0xAC8; // GameTime_t +} + +namespace CCommentaryAuto { // CBaseEntity + constexpr std::ptrdiff_t m_OnCommentaryNewGame = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnCommentaryMidGame = 0x4D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnCommentaryMultiplayerSpawn = 0x500; // CEntityIOOutput +} + +namespace CCommentarySystem { + constexpr std::ptrdiff_t m_bCommentaryConvarsChanging = 0x11; // bool + constexpr std::ptrdiff_t m_bCommentaryEnabledMidGame = 0x12; // bool + constexpr std::ptrdiff_t m_flNextTeleportTime = 0x14; // GameTime_t + constexpr std::ptrdiff_t m_iTeleportStage = 0x18; // int32_t + constexpr std::ptrdiff_t m_bCheatState = 0x1C; // bool + constexpr std::ptrdiff_t m_bIsFirstSpawnGroupToLoad = 0x1D; // bool + constexpr std::ptrdiff_t m_hCurrentNode = 0x38; // CHandle + constexpr std::ptrdiff_t m_hActiveCommentaryNode = 0x3C; // CHandle + constexpr std::ptrdiff_t m_hLastCommentaryNode = 0x40; // CHandle + constexpr std::ptrdiff_t m_vecNodes = 0x48; // CUtlVector> +} + +namespace CCommentaryViewPosition { // CSprite +} + +namespace CConstantForceController { + constexpr std::ptrdiff_t m_linear = 0xC; // Vector + constexpr std::ptrdiff_t m_angular = 0x18; // RotationVector + constexpr std::ptrdiff_t m_linearSave = 0x24; // Vector + constexpr std::ptrdiff_t m_angularSave = 0x30; // RotationVector +} + +namespace CConstraintAnchor { // CBaseAnimGraph + constexpr std::ptrdiff_t m_massScale = 0x890; // float +} + +namespace CCoopBonusCoin { // CDynamicProp +} + +namespace CCopyRecipientFilter { + constexpr std::ptrdiff_t m_Flags = 0x8; // int32_t + constexpr std::ptrdiff_t m_Recipients = 0x10; // CUtlVector +} + +namespace CCredits { // CPointEntity + constexpr std::ptrdiff_t m_OnCreditsDone = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_bRolledOutroCredits = 0x4D8; // bool + constexpr std::ptrdiff_t m_flLogoLength = 0x4DC; // float +} + +namespace CDEagle { // CCSWeaponBaseGun +} + +namespace CDamageRecord { + constexpr std::ptrdiff_t m_PlayerDamager = 0x28; // CHandle + constexpr std::ptrdiff_t m_PlayerRecipient = 0x2C; // CHandle + constexpr std::ptrdiff_t m_hPlayerControllerDamager = 0x30; // CHandle + constexpr std::ptrdiff_t m_hPlayerControllerRecipient = 0x34; // CHandle + constexpr std::ptrdiff_t m_szPlayerDamagerName = 0x38; // CUtlString + constexpr std::ptrdiff_t m_szPlayerRecipientName = 0x40; // CUtlString + constexpr std::ptrdiff_t m_DamagerXuid = 0x48; // uint64_t + constexpr std::ptrdiff_t m_RecipientXuid = 0x50; // uint64_t + constexpr std::ptrdiff_t m_iDamage = 0x58; // int32_t + constexpr std::ptrdiff_t m_iActualHealthRemoved = 0x5C; // int32_t + constexpr std::ptrdiff_t m_iNumHits = 0x60; // int32_t + constexpr std::ptrdiff_t m_iLastBulletUpdate = 0x64; // int32_t + constexpr std::ptrdiff_t m_bIsOtherEnemy = 0x68; // bool + constexpr std::ptrdiff_t m_killType = 0x69; // EKillTypes_t +} + +namespace CDebugHistory { // CBaseEntity + constexpr std::ptrdiff_t m_nNpcEvents = 0x44F0; // int32_t +} + +namespace CDecoyGrenade { // CBaseCSGrenade +} + +namespace CDecoyProjectile { // CBaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_nDecoyShotTick = 0xA38; // int32_t + constexpr std::ptrdiff_t m_shotsRemaining = 0xA3C; // int32_t + constexpr std::ptrdiff_t m_fExpireTime = 0xA40; // GameTime_t + constexpr std::ptrdiff_t m_decoyWeaponDefIndex = 0xA50; // uint16_t +} + +namespace CDynamicLight { // CBaseModelEntity + constexpr std::ptrdiff_t m_ActualFlags = 0x700; // uint8_t + constexpr std::ptrdiff_t m_Flags = 0x701; // uint8_t + constexpr std::ptrdiff_t m_LightStyle = 0x702; // uint8_t + constexpr std::ptrdiff_t m_On = 0x703; // bool + constexpr std::ptrdiff_t m_Radius = 0x704; // float + constexpr std::ptrdiff_t m_Exponent = 0x708; // int32_t + constexpr std::ptrdiff_t m_InnerAngle = 0x70C; // float + constexpr std::ptrdiff_t m_OuterAngle = 0x710; // float + constexpr std::ptrdiff_t m_SpotRadius = 0x714; // float +} + +namespace CDynamicProp { // CBreakableProp + constexpr std::ptrdiff_t m_bCreateNavObstacle = 0xA10; // bool + constexpr std::ptrdiff_t m_bUseHitboxesForRenderBox = 0xA11; // bool + constexpr std::ptrdiff_t m_bUseAnimGraph = 0xA12; // bool + constexpr std::ptrdiff_t m_pOutputAnimBegun = 0xA18; // CEntityIOOutput + constexpr std::ptrdiff_t m_pOutputAnimOver = 0xA40; // CEntityIOOutput + constexpr std::ptrdiff_t m_pOutputAnimLoopCycleOver = 0xA68; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAnimReachedStart = 0xA90; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAnimReachedEnd = 0xAB8; // CEntityIOOutput + constexpr std::ptrdiff_t m_iszDefaultAnim = 0xAE0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nDefaultAnimLoopMode = 0xAE8; // AnimLoopMode_t + constexpr std::ptrdiff_t m_bAnimateOnServer = 0xAEC; // bool + constexpr std::ptrdiff_t m_bRandomizeCycle = 0xAED; // bool + constexpr std::ptrdiff_t m_bStartDisabled = 0xAEE; // bool + constexpr std::ptrdiff_t m_bScriptedMovement = 0xAEF; // bool + constexpr std::ptrdiff_t m_bFiredStartEndOutput = 0xAF0; // bool + constexpr std::ptrdiff_t m_bForceNpcExclude = 0xAF1; // bool + constexpr std::ptrdiff_t m_bCreateNonSolid = 0xAF2; // bool + constexpr std::ptrdiff_t m_bIsOverrideProp = 0xAF3; // bool + constexpr std::ptrdiff_t m_iInitialGlowState = 0xAF4; // int32_t + constexpr std::ptrdiff_t m_nGlowRange = 0xAF8; // int32_t + constexpr std::ptrdiff_t m_nGlowRangeMin = 0xAFC; // int32_t + constexpr std::ptrdiff_t m_glowColor = 0xB00; // Color + constexpr std::ptrdiff_t m_nGlowTeam = 0xB04; // int32_t +} + +namespace CDynamicPropAlias_cable_dynamic { // CDynamicProp +} + +namespace CDynamicPropAlias_dynamic_prop { // CDynamicProp +} + +namespace CDynamicPropAlias_prop_dynamic_override { // CDynamicProp +} + +namespace CEconEntity { // CBaseFlex + constexpr std::ptrdiff_t m_AttributeManager = 0x930; // CAttributeContainer + constexpr std::ptrdiff_t m_OriginalOwnerXuidLow = 0xBF8; // uint32_t + constexpr std::ptrdiff_t m_OriginalOwnerXuidHigh = 0xBFC; // uint32_t + constexpr std::ptrdiff_t m_nFallbackPaintKit = 0xC00; // int32_t + constexpr std::ptrdiff_t m_nFallbackSeed = 0xC04; // int32_t + constexpr std::ptrdiff_t m_flFallbackWear = 0xC08; // float + constexpr std::ptrdiff_t m_nFallbackStatTrak = 0xC0C; // int32_t + constexpr std::ptrdiff_t m_hOldProvidee = 0xC10; // CHandle + constexpr std::ptrdiff_t m_iOldOwnerClass = 0xC14; // int32_t +} + +namespace CEconItemAttribute { + constexpr std::ptrdiff_t m_iAttributeDefinitionIndex = 0x30; // uint16_t + constexpr std::ptrdiff_t m_flValue = 0x34; // float + constexpr std::ptrdiff_t m_flInitialValue = 0x38; // float + constexpr std::ptrdiff_t m_nRefundableCurrency = 0x3C; // int32_t + constexpr std::ptrdiff_t m_bSetBonus = 0x40; // bool +} + +namespace CEconItemView { // IEconItemInterface + constexpr std::ptrdiff_t m_iItemDefinitionIndex = 0x38; // uint16_t + constexpr std::ptrdiff_t m_iEntityQuality = 0x3C; // int32_t + constexpr std::ptrdiff_t m_iEntityLevel = 0x40; // uint32_t + constexpr std::ptrdiff_t m_iItemID = 0x48; // uint64_t + constexpr std::ptrdiff_t m_iItemIDHigh = 0x50; // uint32_t + constexpr std::ptrdiff_t m_iItemIDLow = 0x54; // uint32_t + constexpr std::ptrdiff_t m_iAccountID = 0x58; // uint32_t + constexpr std::ptrdiff_t m_iInventoryPosition = 0x5C; // uint32_t + constexpr std::ptrdiff_t m_bInitialized = 0x68; // bool + constexpr std::ptrdiff_t m_AttributeList = 0x70; // CAttributeList + constexpr std::ptrdiff_t m_NetworkedDynamicAttributes = 0xD0; // CAttributeList + constexpr std::ptrdiff_t m_szCustomName = 0x130; // char[161] + constexpr std::ptrdiff_t m_szCustomNameOverride = 0x1D1; // char[161] +} + +namespace CEconWearable { // CEconEntity + constexpr std::ptrdiff_t m_nForceSkin = 0xC18; // int32_t + constexpr std::ptrdiff_t m_bAlwaysAllow = 0xC1C; // bool +} + +namespace CEffectData { + constexpr std::ptrdiff_t m_vOrigin = 0x8; // Vector + constexpr std::ptrdiff_t m_vStart = 0x14; // Vector + constexpr std::ptrdiff_t m_vNormal = 0x20; // Vector + constexpr std::ptrdiff_t m_vAngles = 0x2C; // QAngle + constexpr std::ptrdiff_t m_hEntity = 0x38; // CEntityHandle + constexpr std::ptrdiff_t m_hOtherEntity = 0x3C; // CEntityHandle + constexpr std::ptrdiff_t m_flScale = 0x40; // float + constexpr std::ptrdiff_t m_flMagnitude = 0x44; // float + constexpr std::ptrdiff_t m_flRadius = 0x48; // float + constexpr std::ptrdiff_t m_nSurfaceProp = 0x4C; // CUtlStringToken + constexpr std::ptrdiff_t m_nEffectIndex = 0x50; // CWeakHandle + constexpr std::ptrdiff_t m_nDamageType = 0x58; // uint32_t + constexpr std::ptrdiff_t m_nPenetrate = 0x5C; // uint8_t + constexpr std::ptrdiff_t m_nMaterial = 0x5E; // uint16_t + constexpr std::ptrdiff_t m_nHitBox = 0x60; // uint16_t + constexpr std::ptrdiff_t m_nColor = 0x62; // uint8_t + constexpr std::ptrdiff_t m_fFlags = 0x63; // uint8_t + constexpr std::ptrdiff_t m_nAttachmentIndex = 0x64; // AttachmentHandle_t + constexpr std::ptrdiff_t m_nAttachmentName = 0x68; // CUtlStringToken + constexpr std::ptrdiff_t m_iEffectName = 0x6C; // uint16_t + constexpr std::ptrdiff_t m_nExplosionType = 0x6E; // uint8_t +} + +namespace CEnableMotionFixup { // CBaseEntity +} + +namespace CEntityBlocker { // CBaseModelEntity +} + +namespace CEntityComponent { +} + +namespace CEntityDissolve { // CBaseModelEntity + constexpr std::ptrdiff_t m_flFadeInStart = 0x700; // float + constexpr std::ptrdiff_t m_flFadeInLength = 0x704; // float + constexpr std::ptrdiff_t m_flFadeOutModelStart = 0x708; // float + constexpr std::ptrdiff_t m_flFadeOutModelLength = 0x70C; // float + constexpr std::ptrdiff_t m_flFadeOutStart = 0x710; // float + constexpr std::ptrdiff_t m_flFadeOutLength = 0x714; // float + constexpr std::ptrdiff_t m_flStartTime = 0x718; // GameTime_t + constexpr std::ptrdiff_t m_nDissolveType = 0x71C; // EntityDisolveType_t + constexpr std::ptrdiff_t m_vDissolverOrigin = 0x720; // Vector + constexpr std::ptrdiff_t m_nMagnitude = 0x72C; // uint32_t +} + +namespace CEntityFlame { // CBaseEntity + constexpr std::ptrdiff_t m_hEntAttached = 0x4B0; // CHandle + constexpr std::ptrdiff_t m_bCheapEffect = 0x4B4; // bool + constexpr std::ptrdiff_t m_flSize = 0x4B8; // float + constexpr std::ptrdiff_t m_bUseHitboxes = 0x4BC; // bool + constexpr std::ptrdiff_t m_iNumHitboxFires = 0x4C0; // int32_t + constexpr std::ptrdiff_t m_flHitboxFireScale = 0x4C4; // float + constexpr std::ptrdiff_t m_flLifetime = 0x4C8; // GameTime_t + constexpr std::ptrdiff_t m_hAttacker = 0x4CC; // CHandle + constexpr std::ptrdiff_t m_iDangerSound = 0x4D0; // int32_t + constexpr std::ptrdiff_t m_flDirectDamagePerSecond = 0x4D4; // float + constexpr std::ptrdiff_t m_iCustomDamageType = 0x4D8; // int32_t +} + +namespace CEntityIdentity { + constexpr std::ptrdiff_t m_nameStringableIndex = 0x14; // int32_t + constexpr std::ptrdiff_t m_name = 0x18; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_designerName = 0x20; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flags = 0x30; // uint32_t + constexpr std::ptrdiff_t m_worldGroupId = 0x38; // WorldGroupId_t + constexpr std::ptrdiff_t m_fDataObjectTypes = 0x3C; // uint32_t + constexpr std::ptrdiff_t m_PathIndex = 0x40; // ChangeAccessorFieldPathIndex_t + constexpr std::ptrdiff_t m_pPrev = 0x58; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNext = 0x60; // CEntityIdentity* + constexpr std::ptrdiff_t m_pPrevByClass = 0x68; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNextByClass = 0x70; // CEntityIdentity* +} + +namespace CEntityInstance { + constexpr std::ptrdiff_t m_iszPrivateVScripts = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pEntity = 0x10; // CEntityIdentity* + constexpr std::ptrdiff_t m_CScriptComponent = 0x28; // CScriptComponent* +} + +namespace CEntitySubclassVDataBase { +} + +namespace CEnvBeam { // CBeam + constexpr std::ptrdiff_t m_active = 0x7A0; // int32_t + constexpr std::ptrdiff_t m_spriteTexture = 0x7A8; // CStrongHandle + constexpr std::ptrdiff_t m_iszStartEntity = 0x7B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszEndEntity = 0x7B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_life = 0x7C0; // float + constexpr std::ptrdiff_t m_boltWidth = 0x7C4; // float + constexpr std::ptrdiff_t m_noiseAmplitude = 0x7C8; // float + constexpr std::ptrdiff_t m_speed = 0x7CC; // int32_t + constexpr std::ptrdiff_t m_restrike = 0x7D0; // float + constexpr std::ptrdiff_t m_iszSpriteName = 0x7D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_frameStart = 0x7E0; // int32_t + constexpr std::ptrdiff_t m_vEndPointWorld = 0x7E4; // Vector + constexpr std::ptrdiff_t m_vEndPointRelative = 0x7F0; // Vector + constexpr std::ptrdiff_t m_radius = 0x7FC; // float + constexpr std::ptrdiff_t m_TouchType = 0x800; // Touch_t + constexpr std::ptrdiff_t m_iFilterName = 0x808; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFilter = 0x810; // CHandle + constexpr std::ptrdiff_t m_iszDecal = 0x818; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_OnTouchedByEntity = 0x820; // CEntityIOOutput +} + +namespace CEnvBeverage { // CBaseEntity + constexpr std::ptrdiff_t m_CanInDispenser = 0x4B0; // bool + constexpr std::ptrdiff_t m_nBeverageType = 0x4B4; // int32_t +} + +namespace CEnvCombinedLightProbeVolume { // CBaseEntity + constexpr std::ptrdiff_t m_Color = 0x1508; // Color + constexpr std::ptrdiff_t m_flBrightness = 0x150C; // float + constexpr std::ptrdiff_t m_hCubemapTexture = 0x1510; // CStrongHandle + constexpr std::ptrdiff_t m_bCustomCubemapTexture = 0x1518; // bool + constexpr std::ptrdiff_t m_hLightProbeTexture = 0x1520; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightIndicesTexture = 0x1528; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightScalarsTexture = 0x1530; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightShadowsTexture = 0x1538; // CStrongHandle + constexpr std::ptrdiff_t m_vBoxMins = 0x1540; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x154C; // Vector + constexpr std::ptrdiff_t m_bMoveable = 0x1558; // bool + constexpr std::ptrdiff_t m_nHandshake = 0x155C; // int32_t + constexpr std::ptrdiff_t m_nEnvCubeMapArrayIndex = 0x1560; // int32_t + constexpr std::ptrdiff_t m_nPriority = 0x1564; // int32_t + constexpr std::ptrdiff_t m_bStartDisabled = 0x1568; // bool + constexpr std::ptrdiff_t m_flEdgeFadeDist = 0x156C; // float + constexpr std::ptrdiff_t m_vEdgeFadeDists = 0x1570; // Vector + constexpr std::ptrdiff_t m_nLightProbeSizeX = 0x157C; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeY = 0x1580; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeZ = 0x1584; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasX = 0x1588; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasY = 0x158C; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasZ = 0x1590; // int32_t + constexpr std::ptrdiff_t m_bEnabled = 0x15A9; // bool +} + +namespace CEnvCubemap { // CBaseEntity + constexpr std::ptrdiff_t m_hCubemapTexture = 0x530; // CStrongHandle + constexpr std::ptrdiff_t m_bCustomCubemapTexture = 0x538; // bool + constexpr std::ptrdiff_t m_flInfluenceRadius = 0x53C; // float + constexpr std::ptrdiff_t m_vBoxProjectMins = 0x540; // Vector + constexpr std::ptrdiff_t m_vBoxProjectMaxs = 0x54C; // Vector + constexpr std::ptrdiff_t m_bMoveable = 0x558; // bool + constexpr std::ptrdiff_t m_nHandshake = 0x55C; // int32_t + constexpr std::ptrdiff_t m_nEnvCubeMapArrayIndex = 0x560; // int32_t + constexpr std::ptrdiff_t m_nPriority = 0x564; // int32_t + constexpr std::ptrdiff_t m_flEdgeFadeDist = 0x568; // float + constexpr std::ptrdiff_t m_vEdgeFadeDists = 0x56C; // Vector + constexpr std::ptrdiff_t m_flDiffuseScale = 0x578; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x57C; // bool + constexpr std::ptrdiff_t m_bDefaultEnvMap = 0x57D; // bool + constexpr std::ptrdiff_t m_bDefaultSpecEnvMap = 0x57E; // bool + constexpr std::ptrdiff_t m_bIndoorCubeMap = 0x57F; // bool + constexpr std::ptrdiff_t m_bCopyDiffuseFromDefaultCubemap = 0x580; // bool + constexpr std::ptrdiff_t m_bEnabled = 0x590; // bool +} + +namespace CEnvCubemapBox { // CEnvCubemap +} + +namespace CEnvCubemapFog { // CBaseEntity + constexpr std::ptrdiff_t m_flEndDistance = 0x4B0; // float + constexpr std::ptrdiff_t m_flStartDistance = 0x4B4; // float + constexpr std::ptrdiff_t m_flFogFalloffExponent = 0x4B8; // float + constexpr std::ptrdiff_t m_bHeightFogEnabled = 0x4BC; // bool + constexpr std::ptrdiff_t m_flFogHeightWidth = 0x4C0; // float + constexpr std::ptrdiff_t m_flFogHeightEnd = 0x4C4; // float + constexpr std::ptrdiff_t m_flFogHeightStart = 0x4C8; // float + constexpr std::ptrdiff_t m_flFogHeightExponent = 0x4CC; // float + constexpr std::ptrdiff_t m_flLODBias = 0x4D0; // float + constexpr std::ptrdiff_t m_bActive = 0x4D4; // bool + constexpr std::ptrdiff_t m_bStartDisabled = 0x4D5; // bool + constexpr std::ptrdiff_t m_flFogMaxOpacity = 0x4D8; // float + constexpr std::ptrdiff_t m_nCubemapSourceType = 0x4DC; // int32_t + constexpr std::ptrdiff_t m_hSkyMaterial = 0x4E0; // CStrongHandle + constexpr std::ptrdiff_t m_iszSkyEntity = 0x4E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFogCubemapTexture = 0x4F0; // CStrongHandle + constexpr std::ptrdiff_t m_bHasHeightFogEnd = 0x4F8; // bool + constexpr std::ptrdiff_t m_bFirstTime = 0x4F9; // bool +} + +namespace CEnvDecal { // CBaseModelEntity + constexpr std::ptrdiff_t m_hDecalMaterial = 0x700; // CStrongHandle + constexpr std::ptrdiff_t m_flWidth = 0x708; // float + constexpr std::ptrdiff_t m_flHeight = 0x70C; // float + constexpr std::ptrdiff_t m_flDepth = 0x710; // float + constexpr std::ptrdiff_t m_nRenderOrder = 0x714; // uint32_t + constexpr std::ptrdiff_t m_bProjectOnWorld = 0x718; // bool + constexpr std::ptrdiff_t m_bProjectOnCharacters = 0x719; // bool + constexpr std::ptrdiff_t m_bProjectOnWater = 0x71A; // bool + constexpr std::ptrdiff_t m_flDepthSortBias = 0x71C; // float +} + +namespace CEnvDetailController { // CBaseEntity + constexpr std::ptrdiff_t m_flFadeStartDist = 0x4B0; // float + constexpr std::ptrdiff_t m_flFadeEndDist = 0x4B4; // float +} + +namespace CEnvEntityIgniter { // CBaseEntity + constexpr std::ptrdiff_t m_flLifetime = 0x4B0; // float +} + +namespace CEnvEntityMaker { // CPointEntity + constexpr std::ptrdiff_t m_vecEntityMins = 0x4B0; // Vector + constexpr std::ptrdiff_t m_vecEntityMaxs = 0x4BC; // Vector + constexpr std::ptrdiff_t m_hCurrentInstance = 0x4C8; // CHandle + constexpr std::ptrdiff_t m_hCurrentBlocker = 0x4CC; // CHandle + constexpr std::ptrdiff_t m_vecBlockerOrigin = 0x4D0; // Vector + constexpr std::ptrdiff_t m_angPostSpawnDirection = 0x4DC; // QAngle + constexpr std::ptrdiff_t m_flPostSpawnDirectionVariance = 0x4E8; // float + constexpr std::ptrdiff_t m_flPostSpawnSpeed = 0x4EC; // float + constexpr std::ptrdiff_t m_bPostSpawnUseAngles = 0x4F0; // bool + constexpr std::ptrdiff_t m_iszTemplate = 0x4F8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pOutputOnSpawned = 0x500; // CEntityIOOutput + constexpr std::ptrdiff_t m_pOutputOnFailedSpawn = 0x528; // CEntityIOOutput +} + +namespace CEnvExplosion { // CModelPointEntity + constexpr std::ptrdiff_t m_iMagnitude = 0x700; // int32_t + constexpr std::ptrdiff_t m_flPlayerDamage = 0x704; // float + constexpr std::ptrdiff_t m_iRadiusOverride = 0x708; // int32_t + constexpr std::ptrdiff_t m_flInnerRadius = 0x70C; // float + constexpr std::ptrdiff_t m_spriteScale = 0x710; // int32_t + constexpr std::ptrdiff_t m_flDamageForce = 0x714; // float + constexpr std::ptrdiff_t m_hInflictor = 0x718; // CHandle + constexpr std::ptrdiff_t m_iCustomDamageType = 0x71C; // int32_t + constexpr std::ptrdiff_t m_iszExplosionType = 0x728; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszCustomEffectName = 0x730; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszCustomSoundName = 0x738; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iClassIgnore = 0x740; // Class_T + constexpr std::ptrdiff_t m_iClassIgnore2 = 0x744; // Class_T + constexpr std::ptrdiff_t m_iszEntityIgnoreName = 0x748; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hEntityIgnore = 0x750; // CHandle +} + +namespace CEnvFade { // CLogicalEntity + constexpr std::ptrdiff_t m_fadeColor = 0x4B0; // Color + constexpr std::ptrdiff_t m_Duration = 0x4B4; // float + constexpr std::ptrdiff_t m_HoldDuration = 0x4B8; // float + constexpr std::ptrdiff_t m_OnBeginFade = 0x4C0; // CEntityIOOutput +} + +namespace CEnvFireSensor { // CBaseEntity + constexpr std::ptrdiff_t m_bEnabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_bHeatAtLevel = 0x4B1; // bool + constexpr std::ptrdiff_t m_radius = 0x4B4; // float + constexpr std::ptrdiff_t m_targetLevel = 0x4B8; // float + constexpr std::ptrdiff_t m_targetTime = 0x4BC; // float + constexpr std::ptrdiff_t m_levelTime = 0x4C0; // float + constexpr std::ptrdiff_t m_OnHeatLevelStart = 0x4C8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnHeatLevelEnd = 0x4F0; // CEntityIOOutput +} + +namespace CEnvFireSource { // CBaseEntity + constexpr std::ptrdiff_t m_bEnabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_radius = 0x4B4; // float + constexpr std::ptrdiff_t m_damage = 0x4B8; // float +} + +namespace CEnvFunnel { // CBaseEntity +} + +namespace CEnvGlobal { // CLogicalEntity + constexpr std::ptrdiff_t m_outCounter = 0x4B0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_globalstate = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_triggermode = 0x4E0; // int32_t + constexpr std::ptrdiff_t m_initialstate = 0x4E4; // int32_t + constexpr std::ptrdiff_t m_counter = 0x4E8; // int32_t +} + +namespace CEnvHudHint { // CPointEntity + constexpr std::ptrdiff_t m_iszMessage = 0x4B0; // CUtlSymbolLarge +} + +namespace CEnvInstructorHint { // CPointEntity + constexpr std::ptrdiff_t m_iszName = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszReplace_Key = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszHintTargetEntity = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iTimeout = 0x4C8; // int32_t + constexpr std::ptrdiff_t m_iDisplayLimit = 0x4CC; // int32_t + constexpr std::ptrdiff_t m_iszIcon_Onscreen = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszIcon_Offscreen = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszCaption = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszActivatorCaption = 0x4E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Color = 0x4F0; // Color + constexpr std::ptrdiff_t m_fIconOffset = 0x4F4; // float + constexpr std::ptrdiff_t m_fRange = 0x4F8; // float + constexpr std::ptrdiff_t m_iPulseOption = 0x4FC; // uint8_t + constexpr std::ptrdiff_t m_iAlphaOption = 0x4FD; // uint8_t + constexpr std::ptrdiff_t m_iShakeOption = 0x4FE; // uint8_t + constexpr std::ptrdiff_t m_bStatic = 0x4FF; // bool + constexpr std::ptrdiff_t m_bNoOffscreen = 0x500; // bool + constexpr std::ptrdiff_t m_bForceCaption = 0x501; // bool + constexpr std::ptrdiff_t m_iInstanceType = 0x504; // int32_t + constexpr std::ptrdiff_t m_bSuppressRest = 0x508; // bool + constexpr std::ptrdiff_t m_iszBinding = 0x510; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bAllowNoDrawTarget = 0x518; // bool + constexpr std::ptrdiff_t m_bAutoStart = 0x519; // bool + constexpr std::ptrdiff_t m_bLocalPlayerOnly = 0x51A; // bool +} + +namespace CEnvInstructorVRHint { // CPointEntity + constexpr std::ptrdiff_t m_iszName = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszHintTargetEntity = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iTimeout = 0x4C0; // int32_t + constexpr std::ptrdiff_t m_iszCaption = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszStartSound = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iLayoutFileType = 0x4D8; // int32_t + constexpr std::ptrdiff_t m_iszCustomLayoutFile = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iAttachType = 0x4E8; // int32_t + constexpr std::ptrdiff_t m_flHeightOffset = 0x4EC; // float +} + +namespace CEnvLaser { // CBeam + constexpr std::ptrdiff_t m_iszLaserTarget = 0x7A0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pSprite = 0x7A8; // CSprite* + constexpr std::ptrdiff_t m_iszSpriteName = 0x7B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_firePosition = 0x7B8; // Vector + constexpr std::ptrdiff_t m_flStartFrame = 0x7C4; // float +} + +namespace CEnvLightProbeVolume { // CBaseEntity + constexpr std::ptrdiff_t m_hLightProbeTexture = 0x1488; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightIndicesTexture = 0x1490; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightScalarsTexture = 0x1498; // CStrongHandle + constexpr std::ptrdiff_t m_hLightProbeDirectLightShadowsTexture = 0x14A0; // CStrongHandle + constexpr std::ptrdiff_t m_vBoxMins = 0x14A8; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x14B4; // Vector + constexpr std::ptrdiff_t m_bMoveable = 0x14C0; // bool + constexpr std::ptrdiff_t m_nHandshake = 0x14C4; // int32_t + constexpr std::ptrdiff_t m_nPriority = 0x14C8; // int32_t + constexpr std::ptrdiff_t m_bStartDisabled = 0x14CC; // bool + constexpr std::ptrdiff_t m_nLightProbeSizeX = 0x14D0; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeY = 0x14D4; // int32_t + constexpr std::ptrdiff_t m_nLightProbeSizeZ = 0x14D8; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasX = 0x14DC; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasY = 0x14E0; // int32_t + constexpr std::ptrdiff_t m_nLightProbeAtlasZ = 0x14E4; // int32_t + constexpr std::ptrdiff_t m_bEnabled = 0x14F1; // bool +} + +namespace CEnvMicrophone { // CPointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_hMeasureTarget = 0x4B4; // CHandle + constexpr std::ptrdiff_t m_nSoundMask = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_flSensitivity = 0x4BC; // float + constexpr std::ptrdiff_t m_flSmoothFactor = 0x4C0; // float + constexpr std::ptrdiff_t m_flMaxRange = 0x4C4; // float + constexpr std::ptrdiff_t m_iszSpeakerName = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hSpeaker = 0x4D0; // CHandle + constexpr std::ptrdiff_t m_bAvoidFeedback = 0x4D4; // bool + constexpr std::ptrdiff_t m_iSpeakerDSPPreset = 0x4D8; // int32_t + constexpr std::ptrdiff_t m_iszListenFilter = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hListenFilter = 0x4E8; // CHandle + constexpr std::ptrdiff_t m_SoundLevel = 0x4F0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnRoutedSound = 0x518; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnHeardSound = 0x540; // CEntityIOOutput + constexpr std::ptrdiff_t m_szLastSound = 0x568; // char[256] + constexpr std::ptrdiff_t m_iLastRoutedFrame = 0x668; // int32_t +} + +namespace CEnvMuzzleFlash { // CPointEntity + constexpr std::ptrdiff_t m_flScale = 0x4B0; // float + constexpr std::ptrdiff_t m_iszParentAttachment = 0x4B8; // CUtlSymbolLarge +} + +namespace CEnvParticleGlow { // CParticleSystem + constexpr std::ptrdiff_t m_flAlphaScale = 0xC78; // float + constexpr std::ptrdiff_t m_flRadiusScale = 0xC7C; // float + constexpr std::ptrdiff_t m_flSelfIllumScale = 0xC80; // float + constexpr std::ptrdiff_t m_ColorTint = 0xC84; // Color + constexpr std::ptrdiff_t m_hTextureOverride = 0xC88; // CStrongHandle +} + +namespace CEnvProjectedTexture { // CModelPointEntity + constexpr std::ptrdiff_t m_hTargetEntity = 0x700; // CHandle + constexpr std::ptrdiff_t m_bState = 0x704; // bool + constexpr std::ptrdiff_t m_bAlwaysUpdate = 0x705; // bool + constexpr std::ptrdiff_t m_flLightFOV = 0x708; // float + constexpr std::ptrdiff_t m_bEnableShadows = 0x70C; // bool + constexpr std::ptrdiff_t m_bSimpleProjection = 0x70D; // bool + constexpr std::ptrdiff_t m_bLightOnlyTarget = 0x70E; // bool + constexpr std::ptrdiff_t m_bLightWorld = 0x70F; // bool + constexpr std::ptrdiff_t m_bCameraSpace = 0x710; // bool + constexpr std::ptrdiff_t m_flBrightnessScale = 0x714; // float + constexpr std::ptrdiff_t m_LightColor = 0x718; // Color + constexpr std::ptrdiff_t m_flIntensity = 0x71C; // float + constexpr std::ptrdiff_t m_flLinearAttenuation = 0x720; // float + constexpr std::ptrdiff_t m_flQuadraticAttenuation = 0x724; // float + constexpr std::ptrdiff_t m_bVolumetric = 0x728; // bool + constexpr std::ptrdiff_t m_flNoiseStrength = 0x72C; // float + constexpr std::ptrdiff_t m_flFlashlightTime = 0x730; // float + constexpr std::ptrdiff_t m_nNumPlanes = 0x734; // uint32_t + constexpr std::ptrdiff_t m_flPlaneOffset = 0x738; // float + constexpr std::ptrdiff_t m_flVolumetricIntensity = 0x73C; // float + constexpr std::ptrdiff_t m_flColorTransitionTime = 0x740; // float + constexpr std::ptrdiff_t m_flAmbient = 0x744; // float + constexpr std::ptrdiff_t m_SpotlightTextureName = 0x748; // char[512] + constexpr std::ptrdiff_t m_nSpotlightTextureFrame = 0x948; // int32_t + constexpr std::ptrdiff_t m_nShadowQuality = 0x94C; // uint32_t + constexpr std::ptrdiff_t m_flNearZ = 0x950; // float + constexpr std::ptrdiff_t m_flFarZ = 0x954; // float + constexpr std::ptrdiff_t m_flProjectionSize = 0x958; // float + constexpr std::ptrdiff_t m_flRotation = 0x95C; // float + constexpr std::ptrdiff_t m_bFlipHorizontal = 0x960; // bool +} + +namespace CEnvScreenOverlay { // CPointEntity + constexpr std::ptrdiff_t m_iszOverlayNames = 0x4B0; // CUtlSymbolLarge[10] + constexpr std::ptrdiff_t m_flOverlayTimes = 0x500; // float[10] + constexpr std::ptrdiff_t m_flStartTime = 0x528; // GameTime_t + constexpr std::ptrdiff_t m_iDesiredOverlay = 0x52C; // int32_t + constexpr std::ptrdiff_t m_bIsActive = 0x530; // bool +} + +namespace CEnvShake { // CPointEntity + constexpr std::ptrdiff_t m_limitToEntity = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Amplitude = 0x4B8; // float + constexpr std::ptrdiff_t m_Frequency = 0x4BC; // float + constexpr std::ptrdiff_t m_Duration = 0x4C0; // float + constexpr std::ptrdiff_t m_Radius = 0x4C4; // float + constexpr std::ptrdiff_t m_stopTime = 0x4C8; // GameTime_t + constexpr std::ptrdiff_t m_nextShake = 0x4CC; // GameTime_t + constexpr std::ptrdiff_t m_currentAmp = 0x4D0; // float + constexpr std::ptrdiff_t m_maxForce = 0x4D4; // Vector + constexpr std::ptrdiff_t m_shakeCallback = 0x4E8; // CPhysicsShake +} + +namespace CEnvSky { // CBaseModelEntity + constexpr std::ptrdiff_t m_hSkyMaterial = 0x700; // CStrongHandle + constexpr std::ptrdiff_t m_hSkyMaterialLightingOnly = 0x708; // CStrongHandle + constexpr std::ptrdiff_t m_bStartDisabled = 0x710; // bool + constexpr std::ptrdiff_t m_vTintColor = 0x711; // Color + constexpr std::ptrdiff_t m_vTintColorLightingOnly = 0x715; // Color + constexpr std::ptrdiff_t m_flBrightnessScale = 0x71C; // float + constexpr std::ptrdiff_t m_nFogType = 0x720; // int32_t + constexpr std::ptrdiff_t m_flFogMinStart = 0x724; // float + constexpr std::ptrdiff_t m_flFogMinEnd = 0x728; // float + constexpr std::ptrdiff_t m_flFogMaxStart = 0x72C; // float + constexpr std::ptrdiff_t m_flFogMaxEnd = 0x730; // float + constexpr std::ptrdiff_t m_bEnabled = 0x734; // bool +} + +namespace CEnvSoundscape { // CServerOnlyEntity + constexpr std::ptrdiff_t m_OnPlay = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_flRadius = 0x4D8; // float + constexpr std::ptrdiff_t m_soundscapeName = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_soundEventName = 0x4E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bOverrideWithEvent = 0x4F0; // bool + constexpr std::ptrdiff_t m_soundscapeIndex = 0x4F4; // int32_t + constexpr std::ptrdiff_t m_soundscapeEntityListId = 0x4F8; // int32_t + constexpr std::ptrdiff_t m_soundEventHash = 0x4FC; // uint32_t + constexpr std::ptrdiff_t m_positionNames = 0x500; // CUtlSymbolLarge[8] + constexpr std::ptrdiff_t m_hProxySoundscape = 0x540; // CHandle + constexpr std::ptrdiff_t m_bDisabled = 0x544; // bool +} + +namespace CEnvSoundscapeAlias_snd_soundscape { // CEnvSoundscape +} + +namespace CEnvSoundscapeProxy { // CEnvSoundscape + constexpr std::ptrdiff_t m_MainSoundscapeName = 0x548; // CUtlSymbolLarge +} + +namespace CEnvSoundscapeProxyAlias_snd_soundscape_proxy { // CEnvSoundscapeProxy +} + +namespace CEnvSoundscapeTriggerable { // CEnvSoundscape +} + +namespace CEnvSoundscapeTriggerableAlias_snd_soundscape_triggerable { // CEnvSoundscapeTriggerable +} + +namespace CEnvSpark { // CPointEntity + constexpr std::ptrdiff_t m_flDelay = 0x4B0; // float + constexpr std::ptrdiff_t m_nMagnitude = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_nTrailLength = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_nType = 0x4BC; // int32_t + constexpr std::ptrdiff_t m_OnSpark = 0x4C0; // CEntityIOOutput +} + +namespace CEnvSplash { // CPointEntity + constexpr std::ptrdiff_t m_flScale = 0x4B0; // float +} + +namespace CEnvTilt { // CPointEntity + constexpr std::ptrdiff_t m_Duration = 0x4B0; // float + constexpr std::ptrdiff_t m_Radius = 0x4B4; // float + constexpr std::ptrdiff_t m_TiltTime = 0x4B8; // float + constexpr std::ptrdiff_t m_stopTime = 0x4BC; // GameTime_t +} + +namespace CEnvTracer { // CPointEntity + constexpr std::ptrdiff_t m_vecEnd = 0x4B0; // Vector + constexpr std::ptrdiff_t m_flDelay = 0x4BC; // float +} + +namespace CEnvViewPunch { // CPointEntity + constexpr std::ptrdiff_t m_flRadius = 0x4B0; // float + constexpr std::ptrdiff_t m_angViewPunch = 0x4B4; // QAngle +} + +namespace CEnvVolumetricFogController { // CBaseEntity + constexpr std::ptrdiff_t m_flScattering = 0x4B0; // float + constexpr std::ptrdiff_t m_flAnisotropy = 0x4B4; // float + constexpr std::ptrdiff_t m_flFadeSpeed = 0x4B8; // float + constexpr std::ptrdiff_t m_flDrawDistance = 0x4BC; // float + constexpr std::ptrdiff_t m_flFadeInStart = 0x4C0; // float + constexpr std::ptrdiff_t m_flFadeInEnd = 0x4C4; // float + constexpr std::ptrdiff_t m_flIndirectStrength = 0x4C8; // float + constexpr std::ptrdiff_t m_nIndirectTextureDimX = 0x4CC; // int32_t + constexpr std::ptrdiff_t m_nIndirectTextureDimY = 0x4D0; // int32_t + constexpr std::ptrdiff_t m_nIndirectTextureDimZ = 0x4D4; // int32_t + constexpr std::ptrdiff_t m_vBoxMins = 0x4D8; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x4E4; // Vector + constexpr std::ptrdiff_t m_bActive = 0x4F0; // bool + constexpr std::ptrdiff_t m_flStartAnisoTime = 0x4F4; // GameTime_t + constexpr std::ptrdiff_t m_flStartScatterTime = 0x4F8; // GameTime_t + constexpr std::ptrdiff_t m_flStartDrawDistanceTime = 0x4FC; // GameTime_t + constexpr std::ptrdiff_t m_flStartAnisotropy = 0x500; // float + constexpr std::ptrdiff_t m_flStartScattering = 0x504; // float + constexpr std::ptrdiff_t m_flStartDrawDistance = 0x508; // float + constexpr std::ptrdiff_t m_flDefaultAnisotropy = 0x50C; // float + constexpr std::ptrdiff_t m_flDefaultScattering = 0x510; // float + constexpr std::ptrdiff_t m_flDefaultDrawDistance = 0x514; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x518; // bool + constexpr std::ptrdiff_t m_bEnableIndirect = 0x519; // bool + constexpr std::ptrdiff_t m_bIsMaster = 0x51A; // bool + constexpr std::ptrdiff_t m_hFogIndirectTexture = 0x520; // CStrongHandle + constexpr std::ptrdiff_t m_nForceRefreshCount = 0x528; // int32_t + constexpr std::ptrdiff_t m_bFirstTime = 0x52C; // bool +} + +namespace CEnvVolumetricFogVolume { // CBaseEntity + constexpr std::ptrdiff_t m_bActive = 0x4B0; // bool + constexpr std::ptrdiff_t m_vBoxMins = 0x4B4; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x4C0; // Vector + constexpr std::ptrdiff_t m_bStartDisabled = 0x4CC; // bool + constexpr std::ptrdiff_t m_flStrength = 0x4D0; // float + constexpr std::ptrdiff_t m_nFalloffShape = 0x4D4; // int32_t + constexpr std::ptrdiff_t m_flFalloffExponent = 0x4D8; // float +} + +namespace CEnvWind { // CBaseEntity + constexpr std::ptrdiff_t m_EnvWindShared = 0x4B0; // CEnvWindShared +} + +namespace CEnvWindShared { + constexpr std::ptrdiff_t m_flStartTime = 0x8; // GameTime_t + constexpr std::ptrdiff_t m_iWindSeed = 0xC; // uint32_t + constexpr std::ptrdiff_t m_iMinWind = 0x10; // uint16_t + constexpr std::ptrdiff_t m_iMaxWind = 0x12; // uint16_t + constexpr std::ptrdiff_t m_windRadius = 0x14; // int32_t + constexpr std::ptrdiff_t m_iMinGust = 0x18; // uint16_t + constexpr std::ptrdiff_t m_iMaxGust = 0x1A; // uint16_t + constexpr std::ptrdiff_t m_flMinGustDelay = 0x1C; // float + constexpr std::ptrdiff_t m_flMaxGustDelay = 0x20; // float + constexpr std::ptrdiff_t m_flGustDuration = 0x24; // float + constexpr std::ptrdiff_t m_iGustDirChange = 0x28; // uint16_t + constexpr std::ptrdiff_t m_location = 0x2C; // Vector + constexpr std::ptrdiff_t m_iszGustSound = 0x38; // int32_t + constexpr std::ptrdiff_t m_iWindDir = 0x3C; // int32_t + constexpr std::ptrdiff_t m_flWindSpeed = 0x40; // float + constexpr std::ptrdiff_t m_currentWindVector = 0x44; // Vector + constexpr std::ptrdiff_t m_CurrentSwayVector = 0x50; // Vector + constexpr std::ptrdiff_t m_PrevSwayVector = 0x5C; // Vector + constexpr std::ptrdiff_t m_iInitialWindDir = 0x68; // uint16_t + constexpr std::ptrdiff_t m_flInitialWindSpeed = 0x6C; // float + constexpr std::ptrdiff_t m_OnGustStart = 0x70; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnGustEnd = 0x98; // CEntityIOOutput + constexpr std::ptrdiff_t m_flVariationTime = 0xC0; // GameTime_t + constexpr std::ptrdiff_t m_flSwayTime = 0xC4; // GameTime_t + constexpr std::ptrdiff_t m_flSimTime = 0xC8; // GameTime_t + constexpr std::ptrdiff_t m_flSwitchTime = 0xCC; // GameTime_t + constexpr std::ptrdiff_t m_flAveWindSpeed = 0xD0; // float + constexpr std::ptrdiff_t m_bGusting = 0xD4; // bool + constexpr std::ptrdiff_t m_flWindAngleVariation = 0xD8; // float + constexpr std::ptrdiff_t m_flWindSpeedVariation = 0xDC; // float + constexpr std::ptrdiff_t m_iEntIndex = 0xE0; // CEntityIndex +} + +namespace CEnvWindShared_WindAveEvent_t { + constexpr std::ptrdiff_t m_flStartWindSpeed = 0x0; // float + constexpr std::ptrdiff_t m_flAveWindSpeed = 0x4; // float +} + +namespace CEnvWindShared_WindVariationEvent_t { + constexpr std::ptrdiff_t m_flWindAngleVariation = 0x0; // float + constexpr std::ptrdiff_t m_flWindSpeedVariation = 0x4; // float +} + +namespace CFilterAttributeInt { // CBaseFilter + constexpr std::ptrdiff_t m_sAttributeName = 0x508; // CUtlStringToken +} + +namespace CFilterClass { // CBaseFilter + constexpr std::ptrdiff_t m_iFilterClass = 0x508; // CUtlSymbolLarge +} + +namespace CFilterContext { // CBaseFilter + constexpr std::ptrdiff_t m_iFilterContext = 0x508; // CUtlSymbolLarge +} + +namespace CFilterEnemy { // CBaseFilter + constexpr std::ptrdiff_t m_iszEnemyName = 0x508; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flRadius = 0x510; // float + constexpr std::ptrdiff_t m_flOuterRadius = 0x514; // float + constexpr std::ptrdiff_t m_nMaxSquadmatesPerEnemy = 0x518; // int32_t + constexpr std::ptrdiff_t m_iszPlayerName = 0x520; // CUtlSymbolLarge +} + +namespace CFilterLOS { // CBaseFilter +} + +namespace CFilterMassGreater { // CBaseFilter + constexpr std::ptrdiff_t m_fFilterMass = 0x508; // float +} + +namespace CFilterModel { // CBaseFilter + constexpr std::ptrdiff_t m_iFilterModel = 0x508; // CUtlSymbolLarge +} + +namespace CFilterMultiple { // CBaseFilter + constexpr std::ptrdiff_t m_nFilterType = 0x508; // filter_t + constexpr std::ptrdiff_t m_iFilterName = 0x510; // CUtlSymbolLarge[10] + constexpr std::ptrdiff_t m_hFilter = 0x560; // CHandle[10] + constexpr std::ptrdiff_t m_nFilterCount = 0x588; // int32_t +} + +namespace CFilterName { // CBaseFilter + constexpr std::ptrdiff_t m_iFilterName = 0x508; // CUtlSymbolLarge +} + +namespace CFilterProximity { // CBaseFilter + constexpr std::ptrdiff_t m_flRadius = 0x508; // float +} + +namespace CFire { // CBaseModelEntity + constexpr std::ptrdiff_t m_hEffect = 0x700; // CHandle + constexpr std::ptrdiff_t m_hOwner = 0x704; // CHandle + constexpr std::ptrdiff_t m_nFireType = 0x708; // int32_t + constexpr std::ptrdiff_t m_flFuel = 0x70C; // float + constexpr std::ptrdiff_t m_flDamageTime = 0x710; // GameTime_t + constexpr std::ptrdiff_t m_lastDamage = 0x714; // GameTime_t + constexpr std::ptrdiff_t m_flFireSize = 0x718; // float + constexpr std::ptrdiff_t m_flLastNavUpdateTime = 0x71C; // GameTime_t + constexpr std::ptrdiff_t m_flHeatLevel = 0x720; // float + constexpr std::ptrdiff_t m_flHeatAbsorb = 0x724; // float + constexpr std::ptrdiff_t m_flDamageScale = 0x728; // float + constexpr std::ptrdiff_t m_flMaxHeat = 0x72C; // float + constexpr std::ptrdiff_t m_flLastHeatLevel = 0x730; // float + constexpr std::ptrdiff_t m_flAttackTime = 0x734; // float + constexpr std::ptrdiff_t m_bEnabled = 0x738; // bool + constexpr std::ptrdiff_t m_bStartDisabled = 0x739; // bool + constexpr std::ptrdiff_t m_bDidActivate = 0x73A; // bool + constexpr std::ptrdiff_t m_OnIgnited = 0x740; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnExtinguished = 0x768; // CEntityIOOutput +} + +namespace CFireCrackerBlast { // CInferno +} + +namespace CFireSmoke { // CBaseFire + constexpr std::ptrdiff_t m_nFlameModelIndex = 0x4C0; // int32_t + constexpr std::ptrdiff_t m_nFlameFromAboveModelIndex = 0x4C4; // int32_t +} + +namespace CFiringModeFloat { + constexpr std::ptrdiff_t m_flValues = 0x0; // float[2] +} + +namespace CFiringModeInt { + constexpr std::ptrdiff_t m_nValues = 0x0; // int32_t[2] +} + +namespace CFish { // CBaseAnimGraph + constexpr std::ptrdiff_t m_pool = 0x890; // CHandle + constexpr std::ptrdiff_t m_id = 0x894; // uint32_t + constexpr std::ptrdiff_t m_x = 0x898; // float + constexpr std::ptrdiff_t m_y = 0x89C; // float + constexpr std::ptrdiff_t m_z = 0x8A0; // float + constexpr std::ptrdiff_t m_angle = 0x8A4; // float + constexpr std::ptrdiff_t m_angleChange = 0x8A8; // float + constexpr std::ptrdiff_t m_forward = 0x8AC; // Vector + constexpr std::ptrdiff_t m_perp = 0x8B8; // Vector + constexpr std::ptrdiff_t m_poolOrigin = 0x8C4; // Vector + constexpr std::ptrdiff_t m_waterLevel = 0x8D0; // float + constexpr std::ptrdiff_t m_speed = 0x8D4; // float + constexpr std::ptrdiff_t m_desiredSpeed = 0x8D8; // float + constexpr std::ptrdiff_t m_calmSpeed = 0x8DC; // float + constexpr std::ptrdiff_t m_panicSpeed = 0x8E0; // float + constexpr std::ptrdiff_t m_avoidRange = 0x8E4; // float + constexpr std::ptrdiff_t m_turnTimer = 0x8E8; // CountdownTimer + constexpr std::ptrdiff_t m_turnClockwise = 0x900; // bool + constexpr std::ptrdiff_t m_goTimer = 0x908; // CountdownTimer + constexpr std::ptrdiff_t m_moveTimer = 0x920; // CountdownTimer + constexpr std::ptrdiff_t m_panicTimer = 0x938; // CountdownTimer + constexpr std::ptrdiff_t m_disperseTimer = 0x950; // CountdownTimer + constexpr std::ptrdiff_t m_proximityTimer = 0x968; // CountdownTimer + constexpr std::ptrdiff_t m_visible = 0x980; // CUtlVector +} + +namespace CFishPool { // CBaseEntity + constexpr std::ptrdiff_t m_fishCount = 0x4C0; // int32_t + constexpr std::ptrdiff_t m_maxRange = 0x4C4; // float + constexpr std::ptrdiff_t m_swimDepth = 0x4C8; // float + constexpr std::ptrdiff_t m_waterLevel = 0x4CC; // float + constexpr std::ptrdiff_t m_isDormant = 0x4D0; // bool + constexpr std::ptrdiff_t m_fishes = 0x4D8; // CUtlVector> + constexpr std::ptrdiff_t m_visTimer = 0x4F0; // CountdownTimer +} + +namespace CFists { // CCSWeaponBase + constexpr std::ptrdiff_t m_bPlayingUninterruptableAct = 0xE18; // bool + constexpr std::ptrdiff_t m_nUninterruptableActivity = 0xE1C; // PlayerAnimEvent_t + constexpr std::ptrdiff_t m_bRestorePrevWep = 0xE20; // bool + constexpr std::ptrdiff_t m_hWeaponBeforePrevious = 0xE24; // CHandle + constexpr std::ptrdiff_t m_hWeaponPrevious = 0xE28; // CHandle + constexpr std::ptrdiff_t m_bDelayedHardPunchIncoming = 0xE2C; // bool + constexpr std::ptrdiff_t m_bDestroyAfterTaunt = 0xE2D; // bool +} + +namespace CFlashbang { // CBaseCSGrenade +} + +namespace CFlashbangProjectile { // CBaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_flTimeToDetonate = 0xA30; // float + constexpr std::ptrdiff_t m_numOpponentsHit = 0xA34; // uint8_t + constexpr std::ptrdiff_t m_numTeammatesHit = 0xA35; // uint8_t +} + +namespace CFogController { // CBaseEntity + constexpr std::ptrdiff_t m_fog = 0x4B0; // fogparams_t + constexpr std::ptrdiff_t m_bUseAngles = 0x518; // bool + constexpr std::ptrdiff_t m_iChangedVariables = 0x51C; // int32_t +} + +namespace CFogTrigger { // CBaseTrigger + constexpr std::ptrdiff_t m_fog = 0x8A8; // fogparams_t +} + +namespace CFogVolume { // CServerOnlyModelEntity + constexpr std::ptrdiff_t m_fogName = 0x700; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_postProcessName = 0x708; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_colorCorrectionName = 0x710; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bDisabled = 0x720; // bool + constexpr std::ptrdiff_t m_bInFogVolumesList = 0x721; // bool +} + +namespace CFootstepControl { // CBaseTrigger + constexpr std::ptrdiff_t m_source = 0x8A8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_destination = 0x8B0; // CUtlSymbolLarge +} + +namespace CFootstepTableHandle { +} + +namespace CFuncBrush { // CBaseModelEntity + constexpr std::ptrdiff_t m_iSolidity = 0x700; // BrushSolidities_e + constexpr std::ptrdiff_t m_iDisabled = 0x704; // int32_t + constexpr std::ptrdiff_t m_bSolidBsp = 0x708; // bool + constexpr std::ptrdiff_t m_iszExcludedClass = 0x710; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bInvertExclusion = 0x718; // bool + constexpr std::ptrdiff_t m_bScriptedMovement = 0x719; // bool +} + +namespace CFuncConveyor { // CBaseModelEntity + constexpr std::ptrdiff_t m_szConveyorModels = 0x700; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flTransitionDurationSeconds = 0x708; // float + constexpr std::ptrdiff_t m_angMoveEntitySpace = 0x70C; // QAngle + constexpr std::ptrdiff_t m_vecMoveDirEntitySpace = 0x718; // Vector + constexpr std::ptrdiff_t m_flTargetSpeed = 0x724; // float + constexpr std::ptrdiff_t m_nTransitionStartTick = 0x728; // GameTick_t + constexpr std::ptrdiff_t m_nTransitionDurationTicks = 0x72C; // int32_t + constexpr std::ptrdiff_t m_flTransitionStartSpeed = 0x730; // float + constexpr std::ptrdiff_t m_hConveyorModels = 0x738; // CNetworkUtlVectorBase> +} + +namespace CFuncElectrifiedVolume { // CFuncBrush + constexpr std::ptrdiff_t m_EffectName = 0x720; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_EffectInterpenetrateName = 0x728; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_EffectZapName = 0x730; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszEffectSource = 0x738; // CUtlSymbolLarge +} + +namespace CFuncIllusionary { // CBaseModelEntity +} + +namespace CFuncInteractionLayerClip { // CBaseModelEntity + constexpr std::ptrdiff_t m_bDisabled = 0x700; // bool + constexpr std::ptrdiff_t m_iszInteractsAs = 0x708; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszInteractsWith = 0x710; // CUtlSymbolLarge +} + +namespace CFuncLadder { // CBaseModelEntity + constexpr std::ptrdiff_t m_vecLadderDir = 0x700; // Vector + constexpr std::ptrdiff_t m_Dismounts = 0x710; // CUtlVector> + constexpr std::ptrdiff_t m_vecLocalTop = 0x728; // Vector + constexpr std::ptrdiff_t m_vecPlayerMountPositionTop = 0x734; // Vector + constexpr std::ptrdiff_t m_vecPlayerMountPositionBottom = 0x740; // Vector + constexpr std::ptrdiff_t m_flAutoRideSpeed = 0x74C; // float + constexpr std::ptrdiff_t m_bDisabled = 0x750; // bool + constexpr std::ptrdiff_t m_bFakeLadder = 0x751; // bool + constexpr std::ptrdiff_t m_bHasSlack = 0x752; // bool + constexpr std::ptrdiff_t m_surfacePropName = 0x758; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_OnPlayerGotOnLadder = 0x760; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPlayerGotOffLadder = 0x788; // CEntityIOOutput +} + +namespace CFuncLadderAlias_func_useableladder { // CFuncLadder +} + +namespace CFuncMonitor { // CFuncBrush + constexpr std::ptrdiff_t m_targetCamera = 0x720; // CUtlString + constexpr std::ptrdiff_t m_nResolutionEnum = 0x728; // int32_t + constexpr std::ptrdiff_t m_bRenderShadows = 0x72C; // bool + constexpr std::ptrdiff_t m_bUseUniqueColorTarget = 0x72D; // bool + constexpr std::ptrdiff_t m_brushModelName = 0x730; // CUtlString + constexpr std::ptrdiff_t m_hTargetCamera = 0x738; // CHandle + constexpr std::ptrdiff_t m_bEnabled = 0x73C; // bool + constexpr std::ptrdiff_t m_bDraw3DSkybox = 0x73D; // bool + constexpr std::ptrdiff_t m_bStartEnabled = 0x73E; // bool +} + +namespace CFuncMoveLinear { // CBaseToggle + constexpr std::ptrdiff_t m_authoredPosition = 0x780; // MoveLinearAuthoredPos_t + constexpr std::ptrdiff_t m_angMoveEntitySpace = 0x784; // QAngle + constexpr std::ptrdiff_t m_vecMoveDirParentSpace = 0x790; // Vector + constexpr std::ptrdiff_t m_soundStart = 0x7A0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_soundStop = 0x7A8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_currentSound = 0x7B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flBlockDamage = 0x7B8; // float + constexpr std::ptrdiff_t m_flStartPosition = 0x7BC; // float + constexpr std::ptrdiff_t m_flMoveDistance = 0x7C0; // float + constexpr std::ptrdiff_t m_OnFullyOpen = 0x7D0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFullyClosed = 0x7F8; // CEntityIOOutput + constexpr std::ptrdiff_t m_bCreateMovableNavMesh = 0x820; // bool + constexpr std::ptrdiff_t m_bCreateNavObstacle = 0x821; // bool +} + +namespace CFuncMoveLinearAlias_momentary_door { // CFuncMoveLinear +} + +namespace CFuncNavBlocker { // CBaseModelEntity + constexpr std::ptrdiff_t m_bDisabled = 0x700; // bool + constexpr std::ptrdiff_t m_nBlockedTeamNumber = 0x704; // int32_t +} + +namespace CFuncNavObstruction { // CBaseModelEntity + constexpr std::ptrdiff_t m_bDisabled = 0x708; // bool +} + +namespace CFuncPlat { // CBasePlatTrain + constexpr std::ptrdiff_t m_sNoise = 0x7A8; // CUtlSymbolLarge +} + +namespace CFuncPlatRot { // CFuncPlat + constexpr std::ptrdiff_t m_end = 0x7B0; // QAngle + constexpr std::ptrdiff_t m_start = 0x7BC; // QAngle +} + +namespace CFuncPropRespawnZone { // CBaseEntity +} + +namespace CFuncRotating { // CBaseModelEntity + constexpr std::ptrdiff_t m_vecMoveAng = 0x700; // QAngle + constexpr std::ptrdiff_t m_flFanFriction = 0x70C; // float + constexpr std::ptrdiff_t m_flAttenuation = 0x710; // float + constexpr std::ptrdiff_t m_flVolume = 0x714; // float + constexpr std::ptrdiff_t m_flTargetSpeed = 0x718; // float + constexpr std::ptrdiff_t m_flMaxSpeed = 0x71C; // float + constexpr std::ptrdiff_t m_flBlockDamage = 0x720; // float + constexpr std::ptrdiff_t m_flTimeScale = 0x724; // float + constexpr std::ptrdiff_t m_NoiseRunning = 0x728; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bReversed = 0x730; // bool + constexpr std::ptrdiff_t m_angStart = 0x73C; // QAngle + constexpr std::ptrdiff_t m_bStopAtStartPos = 0x748; // bool + constexpr std::ptrdiff_t m_vecClientOrigin = 0x74C; // Vector + constexpr std::ptrdiff_t m_vecClientAngles = 0x758; // QAngle +} + +namespace CFuncShatterglass { // CBaseModelEntity + constexpr std::ptrdiff_t m_hGlassMaterialDamaged = 0x700; // CStrongHandle + constexpr std::ptrdiff_t m_hGlassMaterialUndamaged = 0x708; // CStrongHandle + constexpr std::ptrdiff_t m_hConcreteMaterialEdgeFace = 0x710; // CStrongHandle + constexpr std::ptrdiff_t m_hConcreteMaterialEdgeCaps = 0x718; // CStrongHandle + constexpr std::ptrdiff_t m_hConcreteMaterialEdgeFins = 0x720; // CStrongHandle + constexpr std::ptrdiff_t m_matPanelTransform = 0x728; // matrix3x4_t + constexpr std::ptrdiff_t m_matPanelTransformWsTemp = 0x758; // matrix3x4_t + constexpr std::ptrdiff_t m_vecShatterGlassShards = 0x788; // CUtlVector + constexpr std::ptrdiff_t m_PanelSize = 0x7A0; // Vector2D + constexpr std::ptrdiff_t m_vecPanelNormalWs = 0x7A8; // Vector + constexpr std::ptrdiff_t m_nNumShardsEverCreated = 0x7B4; // int32_t + constexpr std::ptrdiff_t m_flLastShatterSoundEmitTime = 0x7B8; // GameTime_t + constexpr std::ptrdiff_t m_flLastCleanupTime = 0x7BC; // GameTime_t + constexpr std::ptrdiff_t m_flInitAtTime = 0x7C0; // GameTime_t + constexpr std::ptrdiff_t m_flGlassThickness = 0x7C4; // float + constexpr std::ptrdiff_t m_flSpawnInvulnerability = 0x7C8; // float + constexpr std::ptrdiff_t m_bBreakSilent = 0x7CC; // bool + constexpr std::ptrdiff_t m_bBreakShardless = 0x7CD; // bool + constexpr std::ptrdiff_t m_bBroken = 0x7CE; // bool + constexpr std::ptrdiff_t m_bHasRateLimitedShards = 0x7CF; // bool + constexpr std::ptrdiff_t m_bGlassNavIgnore = 0x7D0; // bool + constexpr std::ptrdiff_t m_bGlassInFrame = 0x7D1; // bool + constexpr std::ptrdiff_t m_bStartBroken = 0x7D2; // bool + constexpr std::ptrdiff_t m_iInitialDamageType = 0x7D3; // uint8_t + constexpr std::ptrdiff_t m_szDamagePositioningEntityName01 = 0x7D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_szDamagePositioningEntityName02 = 0x7E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_szDamagePositioningEntityName03 = 0x7E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_szDamagePositioningEntityName04 = 0x7F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_vInitialDamagePositions = 0x7F8; // CUtlVector + constexpr std::ptrdiff_t m_vExtraDamagePositions = 0x810; // CUtlVector + constexpr std::ptrdiff_t m_OnBroken = 0x828; // CEntityIOOutput + constexpr std::ptrdiff_t m_iSurfaceType = 0x851; // uint8_t +} + +namespace CFuncTankTrain { // CFuncTrackTrain + constexpr std::ptrdiff_t m_OnDeath = 0x850; // CEntityIOOutput +} + +namespace CFuncTimescale { // CBaseEntity + constexpr std::ptrdiff_t m_flDesiredTimescale = 0x4B0; // float + constexpr std::ptrdiff_t m_flAcceleration = 0x4B4; // float + constexpr std::ptrdiff_t m_flMinBlendRate = 0x4B8; // float + constexpr std::ptrdiff_t m_flBlendDeltaMultiplier = 0x4BC; // float + constexpr std::ptrdiff_t m_isStarted = 0x4C0; // bool +} + +namespace CFuncTrackAuto { // CFuncTrackChange +} + +namespace CFuncTrackChange { // CFuncPlatRot + constexpr std::ptrdiff_t m_trackTop = 0x7C8; // CPathTrack* + constexpr std::ptrdiff_t m_trackBottom = 0x7D0; // CPathTrack* + constexpr std::ptrdiff_t m_train = 0x7D8; // CFuncTrackTrain* + constexpr std::ptrdiff_t m_trackTopName = 0x7E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_trackBottomName = 0x7E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_trainName = 0x7F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_code = 0x7F8; // TRAIN_CODE + constexpr std::ptrdiff_t m_targetState = 0x7FC; // int32_t + constexpr std::ptrdiff_t m_use = 0x800; // int32_t +} + +namespace CFuncTrackTrain { // CBaseModelEntity + constexpr std::ptrdiff_t m_ppath = 0x700; // CHandle + constexpr std::ptrdiff_t m_length = 0x704; // float + constexpr std::ptrdiff_t m_vPosPrev = 0x708; // Vector + constexpr std::ptrdiff_t m_angPrev = 0x714; // QAngle + constexpr std::ptrdiff_t m_controlMins = 0x720; // Vector + constexpr std::ptrdiff_t m_controlMaxs = 0x72C; // Vector + constexpr std::ptrdiff_t m_lastBlockPos = 0x738; // Vector + constexpr std::ptrdiff_t m_lastBlockTick = 0x744; // int32_t + constexpr std::ptrdiff_t m_flVolume = 0x748; // float + constexpr std::ptrdiff_t m_flBank = 0x74C; // float + constexpr std::ptrdiff_t m_oldSpeed = 0x750; // float + constexpr std::ptrdiff_t m_flBlockDamage = 0x754; // float + constexpr std::ptrdiff_t m_height = 0x758; // float + constexpr std::ptrdiff_t m_maxSpeed = 0x75C; // float + constexpr std::ptrdiff_t m_dir = 0x760; // float + constexpr std::ptrdiff_t m_iszSoundMove = 0x768; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSoundMovePing = 0x770; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSoundStart = 0x778; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSoundStop = 0x780; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_strPathTarget = 0x788; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flMoveSoundMinDuration = 0x790; // float + constexpr std::ptrdiff_t m_flMoveSoundMaxDuration = 0x794; // float + constexpr std::ptrdiff_t m_flNextMoveSoundTime = 0x798; // GameTime_t + constexpr std::ptrdiff_t m_flMoveSoundMinPitch = 0x79C; // float + constexpr std::ptrdiff_t m_flMoveSoundMaxPitch = 0x7A0; // float + constexpr std::ptrdiff_t m_eOrientationType = 0x7A4; // TrainOrientationType_t + constexpr std::ptrdiff_t m_eVelocityType = 0x7A8; // TrainVelocityType_t + constexpr std::ptrdiff_t m_OnStart = 0x7B8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnNext = 0x7E0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnArrivedAtDestinationNode = 0x808; // CEntityIOOutput + constexpr std::ptrdiff_t m_bManualSpeedChanges = 0x830; // bool + constexpr std::ptrdiff_t m_flDesiredSpeed = 0x834; // float + constexpr std::ptrdiff_t m_flSpeedChangeTime = 0x838; // GameTime_t + constexpr std::ptrdiff_t m_flAccelSpeed = 0x83C; // float + constexpr std::ptrdiff_t m_flDecelSpeed = 0x840; // float + constexpr std::ptrdiff_t m_bAccelToSpeed = 0x844; // bool + constexpr std::ptrdiff_t m_flTimeScale = 0x848; // float + constexpr std::ptrdiff_t m_flNextMPSoundTime = 0x84C; // GameTime_t +} + +namespace CFuncTrain { // CBasePlatTrain + constexpr std::ptrdiff_t m_hCurrentTarget = 0x7A8; // CHandle + constexpr std::ptrdiff_t m_activated = 0x7AC; // bool + constexpr std::ptrdiff_t m_hEnemy = 0x7B0; // CHandle + constexpr std::ptrdiff_t m_flBlockDamage = 0x7B4; // float + constexpr std::ptrdiff_t m_flNextBlockTime = 0x7B8; // GameTime_t + constexpr std::ptrdiff_t m_iszLastTarget = 0x7C0; // CUtlSymbolLarge +} + +namespace CFuncTrainControls { // CBaseModelEntity +} + +namespace CFuncVPhysicsClip { // CBaseModelEntity + constexpr std::ptrdiff_t m_bDisabled = 0x700; // bool +} + +namespace CFuncVehicleClip { // CBaseModelEntity +} + +namespace CFuncWall { // CBaseModelEntity + constexpr std::ptrdiff_t m_nState = 0x700; // int32_t +} + +namespace CFuncWallToggle { // CFuncWall +} + +namespace CFuncWater { // CBaseModelEntity + constexpr std::ptrdiff_t m_BuoyancyHelper = 0x700; // CBuoyancyHelper +} + +namespace CGameChoreoServices { // IChoreoServices + constexpr std::ptrdiff_t m_hOwner = 0x8; // CHandle + constexpr std::ptrdiff_t m_hScriptedSequence = 0xC; // CHandle + constexpr std::ptrdiff_t m_scriptState = 0x10; // IChoreoServices::ScriptState_t + constexpr std::ptrdiff_t m_choreoState = 0x14; // IChoreoServices::ChoreoState_t + constexpr std::ptrdiff_t m_flTimeStartedState = 0x18; // GameTime_t +} + +namespace CGameEnd { // CRulePointEntity +} + +namespace CGameGibManager { // CBaseEntity + constexpr std::ptrdiff_t m_bAllowNewGibs = 0x4D0; // bool + constexpr std::ptrdiff_t m_iCurrentMaxPieces = 0x4D4; // int32_t + constexpr std::ptrdiff_t m_iMaxPieces = 0x4D8; // int32_t + constexpr std::ptrdiff_t m_iLastFrame = 0x4DC; // int32_t +} + +namespace CGameMoney { // CRulePointEntity + constexpr std::ptrdiff_t m_OnMoneySpent = 0x710; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMoneySpentFail = 0x738; // CEntityIOOutput + constexpr std::ptrdiff_t m_nMoney = 0x760; // int32_t + constexpr std::ptrdiff_t m_strAwardText = 0x768; // CUtlString +} + +namespace CGamePlayerEquip { // CRulePointEntity +} + +namespace CGamePlayerZone { // CRuleBrushEntity + constexpr std::ptrdiff_t m_OnPlayerInZone = 0x708; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPlayerOutZone = 0x730; // CEntityIOOutput + constexpr std::ptrdiff_t m_PlayersInCount = 0x758; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_PlayersOutCount = 0x780; // CEntityOutputTemplate +} + +namespace CGameRules { + constexpr std::ptrdiff_t m_szQuestName = 0x8; // char[128] + constexpr std::ptrdiff_t m_nQuestPhase = 0x88; // int32_t +} + +namespace CGameRulesProxy { // CBaseEntity +} + +namespace CGameSceneNode { + constexpr std::ptrdiff_t m_nodeToWorld = 0x10; // CTransform + constexpr std::ptrdiff_t m_pOwner = 0x30; // CEntityInstance* + constexpr std::ptrdiff_t m_pParent = 0x38; // CGameSceneNode* + constexpr std::ptrdiff_t m_pChild = 0x40; // CGameSceneNode* + constexpr std::ptrdiff_t m_pNextSibling = 0x48; // CGameSceneNode* + constexpr std::ptrdiff_t m_hParent = 0x70; // CGameSceneNodeHandle + constexpr std::ptrdiff_t m_vecOrigin = 0x80; // CNetworkOriginCellCoordQuantizedVector + constexpr std::ptrdiff_t m_angRotation = 0xB8; // QAngle + constexpr std::ptrdiff_t m_flScale = 0xC4; // float + constexpr std::ptrdiff_t m_vecAbsOrigin = 0xC8; // Vector + constexpr std::ptrdiff_t m_angAbsRotation = 0xD4; // QAngle + constexpr std::ptrdiff_t m_flAbsScale = 0xE0; // float + constexpr std::ptrdiff_t m_nParentAttachmentOrBone = 0xE4; // int16_t + constexpr std::ptrdiff_t m_bDebugAbsOriginChanges = 0xE6; // bool + constexpr std::ptrdiff_t m_bDormant = 0xE7; // bool + constexpr std::ptrdiff_t m_bForceParentToBeNetworked = 0xE8; // bool + constexpr std::ptrdiff_t m_bDirtyHierarchy = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bDirtyBoneMergeInfo = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNetworkedPositionChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNetworkedAnglesChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNetworkedScaleChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bWillBeCallingPostDataUpdate = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bNotifyBoneTransformsChanged = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bBoneMergeFlex = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_nLatchAbsOrigin = 0x0; // bitfield:2 + constexpr std::ptrdiff_t m_bDirtyBoneMergeBoneToRoot = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_nHierarchicalDepth = 0xEB; // uint8_t + constexpr std::ptrdiff_t m_nHierarchyType = 0xEC; // uint8_t + constexpr std::ptrdiff_t m_nDoNotSetAnimTimeInInvalidatePhysicsCount = 0xED; // uint8_t + constexpr std::ptrdiff_t m_name = 0xF0; // CUtlStringToken + constexpr std::ptrdiff_t m_hierarchyAttachName = 0x130; // CUtlStringToken + constexpr std::ptrdiff_t m_flZOffset = 0x134; // float + constexpr std::ptrdiff_t m_vRenderOrigin = 0x138; // Vector +} + +namespace CGameSceneNodeHandle { + constexpr std::ptrdiff_t m_hOwner = 0x8; // CEntityHandle + constexpr std::ptrdiff_t m_name = 0xC; // CUtlStringToken +} + +namespace CGameScriptedMoveData { + constexpr std::ptrdiff_t m_vDest = 0x0; // Vector + constexpr std::ptrdiff_t m_vSrc = 0xC; // Vector + constexpr std::ptrdiff_t m_angSrc = 0x18; // QAngle + constexpr std::ptrdiff_t m_angDst = 0x24; // QAngle + constexpr std::ptrdiff_t m_angCurrent = 0x30; // QAngle + constexpr std::ptrdiff_t m_flAngRate = 0x3C; // float + constexpr std::ptrdiff_t m_flDuration = 0x40; // float + constexpr std::ptrdiff_t m_flStartTime = 0x44; // GameTime_t + constexpr std::ptrdiff_t m_nPrevMoveType = 0x48; // MoveType_t + constexpr std::ptrdiff_t m_bActive = 0x49; // bool + constexpr std::ptrdiff_t m_bTeleportOnEnd = 0x4A; // bool + constexpr std::ptrdiff_t m_bEndOnDestinationReached = 0x4B; // bool + constexpr std::ptrdiff_t m_bIgnoreRotation = 0x4C; // bool + constexpr std::ptrdiff_t m_nType = 0x50; // ScriptedMoveType_t + constexpr std::ptrdiff_t m_bSuccess = 0x54; // bool + constexpr std::ptrdiff_t m_nForcedCrouchState = 0x58; // ForcedCrouchState_t + constexpr std::ptrdiff_t m_bIgnoreCollisions = 0x5C; // bool +} + +namespace CGameText { // CRulePointEntity + constexpr std::ptrdiff_t m_iszMessage = 0x710; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_textParms = 0x718; // hudtextparms_t +} + +namespace CGenericConstraint { // CPhysConstraint + constexpr std::ptrdiff_t m_nLinearMotionX = 0x510; // JointMotion_t + constexpr std::ptrdiff_t m_nLinearMotionY = 0x514; // JointMotion_t + constexpr std::ptrdiff_t m_nLinearMotionZ = 0x518; // JointMotion_t + constexpr std::ptrdiff_t m_flLinearFrequencyX = 0x51C; // float + constexpr std::ptrdiff_t m_flLinearFrequencyY = 0x520; // float + constexpr std::ptrdiff_t m_flLinearFrequencyZ = 0x524; // float + constexpr std::ptrdiff_t m_flLinearDampingRatioX = 0x528; // float + constexpr std::ptrdiff_t m_flLinearDampingRatioY = 0x52C; // float + constexpr std::ptrdiff_t m_flLinearDampingRatioZ = 0x530; // float + constexpr std::ptrdiff_t m_flMaxLinearImpulseX = 0x534; // float + constexpr std::ptrdiff_t m_flMaxLinearImpulseY = 0x538; // float + constexpr std::ptrdiff_t m_flMaxLinearImpulseZ = 0x53C; // float + constexpr std::ptrdiff_t m_flBreakAfterTimeX = 0x540; // float + constexpr std::ptrdiff_t m_flBreakAfterTimeY = 0x544; // float + constexpr std::ptrdiff_t m_flBreakAfterTimeZ = 0x548; // float + constexpr std::ptrdiff_t m_flBreakAfterTimeStartTimeX = 0x54C; // GameTime_t + constexpr std::ptrdiff_t m_flBreakAfterTimeStartTimeY = 0x550; // GameTime_t + constexpr std::ptrdiff_t m_flBreakAfterTimeStartTimeZ = 0x554; // GameTime_t + constexpr std::ptrdiff_t m_flBreakAfterTimeThresholdX = 0x558; // float + constexpr std::ptrdiff_t m_flBreakAfterTimeThresholdY = 0x55C; // float + constexpr std::ptrdiff_t m_flBreakAfterTimeThresholdZ = 0x560; // float + constexpr std::ptrdiff_t m_flNotifyForceX = 0x564; // float + constexpr std::ptrdiff_t m_flNotifyForceY = 0x568; // float + constexpr std::ptrdiff_t m_flNotifyForceZ = 0x56C; // float + constexpr std::ptrdiff_t m_flNotifyForceMinTimeX = 0x570; // float + constexpr std::ptrdiff_t m_flNotifyForceMinTimeY = 0x574; // float + constexpr std::ptrdiff_t m_flNotifyForceMinTimeZ = 0x578; // float + constexpr std::ptrdiff_t m_flNotifyForceLastTimeX = 0x57C; // GameTime_t + constexpr std::ptrdiff_t m_flNotifyForceLastTimeY = 0x580; // GameTime_t + constexpr std::ptrdiff_t m_flNotifyForceLastTimeZ = 0x584; // GameTime_t + constexpr std::ptrdiff_t m_bAxisNotifiedX = 0x588; // bool + constexpr std::ptrdiff_t m_bAxisNotifiedY = 0x589; // bool + constexpr std::ptrdiff_t m_bAxisNotifiedZ = 0x58A; // bool + constexpr std::ptrdiff_t m_nAngularMotionX = 0x58C; // JointMotion_t + constexpr std::ptrdiff_t m_nAngularMotionY = 0x590; // JointMotion_t + constexpr std::ptrdiff_t m_nAngularMotionZ = 0x594; // JointMotion_t + constexpr std::ptrdiff_t m_flAngularFrequencyX = 0x598; // float + constexpr std::ptrdiff_t m_flAngularFrequencyY = 0x59C; // float + constexpr std::ptrdiff_t m_flAngularFrequencyZ = 0x5A0; // float + constexpr std::ptrdiff_t m_flAngularDampingRatioX = 0x5A4; // float + constexpr std::ptrdiff_t m_flAngularDampingRatioY = 0x5A8; // float + constexpr std::ptrdiff_t m_flAngularDampingRatioZ = 0x5AC; // float + constexpr std::ptrdiff_t m_flMaxAngularImpulseX = 0x5B0; // float + constexpr std::ptrdiff_t m_flMaxAngularImpulseY = 0x5B4; // float + constexpr std::ptrdiff_t m_flMaxAngularImpulseZ = 0x5B8; // float + constexpr std::ptrdiff_t m_NotifyForceReachedX = 0x5C0; // CEntityIOOutput + constexpr std::ptrdiff_t m_NotifyForceReachedY = 0x5E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_NotifyForceReachedZ = 0x610; // CEntityIOOutput +} + +namespace CGlowProperty { + constexpr std::ptrdiff_t m_fGlowColor = 0x8; // Vector + constexpr std::ptrdiff_t m_iGlowType = 0x30; // int32_t + constexpr std::ptrdiff_t m_iGlowTeam = 0x34; // int32_t + constexpr std::ptrdiff_t m_nGlowRange = 0x38; // int32_t + constexpr std::ptrdiff_t m_nGlowRangeMin = 0x3C; // int32_t + constexpr std::ptrdiff_t m_glowColorOverride = 0x40; // Color + constexpr std::ptrdiff_t m_bFlashing = 0x44; // bool + constexpr std::ptrdiff_t m_flGlowTime = 0x48; // float + constexpr std::ptrdiff_t m_flGlowStartTime = 0x4C; // float + constexpr std::ptrdiff_t m_bEligibleForScreenHighlight = 0x50; // bool + constexpr std::ptrdiff_t m_bGlowing = 0x51; // bool +} + +namespace CGradientFog { // CBaseEntity + constexpr std::ptrdiff_t m_hGradientFogTexture = 0x4B0; // CStrongHandle + constexpr std::ptrdiff_t m_flFogStartDistance = 0x4B8; // float + constexpr std::ptrdiff_t m_flFogEndDistance = 0x4BC; // float + constexpr std::ptrdiff_t m_bHeightFogEnabled = 0x4C0; // bool + constexpr std::ptrdiff_t m_flFogStartHeight = 0x4C4; // float + constexpr std::ptrdiff_t m_flFogEndHeight = 0x4C8; // float + constexpr std::ptrdiff_t m_flFarZ = 0x4CC; // float + constexpr std::ptrdiff_t m_flFogMaxOpacity = 0x4D0; // float + constexpr std::ptrdiff_t m_flFogFalloffExponent = 0x4D4; // float + constexpr std::ptrdiff_t m_flFogVerticalExponent = 0x4D8; // float + constexpr std::ptrdiff_t m_fogColor = 0x4DC; // Color + constexpr std::ptrdiff_t m_flFogStrength = 0x4E0; // float + constexpr std::ptrdiff_t m_flFadeTime = 0x4E4; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x4E8; // bool + constexpr std::ptrdiff_t m_bIsEnabled = 0x4E9; // bool + constexpr std::ptrdiff_t m_bGradientFogNeedsTextures = 0x4EA; // bool +} + +namespace CGunTarget { // CBaseToggle + constexpr std::ptrdiff_t m_on = 0x780; // bool + constexpr std::ptrdiff_t m_hTargetEnt = 0x784; // CHandle + constexpr std::ptrdiff_t m_OnDeath = 0x788; // CEntityIOOutput +} + +namespace CHEGrenade { // CBaseCSGrenade +} + +namespace CHEGrenadeProjectile { // CBaseCSGrenadeProjectile +} + +namespace CHandleDummy { // CBaseEntity +} + +namespace CHandleTest { // CBaseEntity + constexpr std::ptrdiff_t m_Handle = 0x4B0; // CHandle + constexpr std::ptrdiff_t m_bSendHandle = 0x4B4; // bool +} + +namespace CHintMessage { + constexpr std::ptrdiff_t m_hintString = 0x8; // char* + constexpr std::ptrdiff_t m_args = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_duration = 0x28; // float +} + +namespace CHintMessageQueue { + constexpr std::ptrdiff_t m_tmMessageEnd = 0x8; // float + constexpr std::ptrdiff_t m_messages = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_pPlayerController = 0x28; // CBasePlayerController* +} + +namespace CHitboxComponent { // CEntityComponent + constexpr std::ptrdiff_t m_bvDisabledHitGroups = 0x24; // uint32_t[1] +} + +namespace CHostage { // CHostageExpresserShim + constexpr std::ptrdiff_t m_OnHostageBeginGrab = 0x9E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFirstPickedUp = 0xA10; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnDroppedNotRescued = 0xA38; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnRescued = 0xA60; // CEntityIOOutput + constexpr std::ptrdiff_t m_entitySpottedState = 0xA88; // EntitySpottedState_t + constexpr std::ptrdiff_t m_nSpotRules = 0xAA0; // int32_t + constexpr std::ptrdiff_t m_uiHostageSpawnExclusionGroupMask = 0xAA4; // uint32_t + constexpr std::ptrdiff_t m_nHostageSpawnRandomFactor = 0xAA8; // uint32_t + constexpr std::ptrdiff_t m_bRemove = 0xAAC; // bool + constexpr std::ptrdiff_t m_vel = 0xAB0; // Vector + constexpr std::ptrdiff_t m_isRescued = 0xABC; // bool + constexpr std::ptrdiff_t m_jumpedThisFrame = 0xABD; // bool + constexpr std::ptrdiff_t m_nHostageState = 0xAC0; // int32_t + constexpr std::ptrdiff_t m_leader = 0xAC4; // CHandle + constexpr std::ptrdiff_t m_lastLeader = 0xAC8; // CHandle + constexpr std::ptrdiff_t m_reuseTimer = 0xAD0; // CountdownTimer + constexpr std::ptrdiff_t m_hasBeenUsed = 0xAE8; // bool + constexpr std::ptrdiff_t m_accel = 0xAEC; // Vector + constexpr std::ptrdiff_t m_isRunning = 0xAF8; // bool + constexpr std::ptrdiff_t m_isCrouching = 0xAF9; // bool + constexpr std::ptrdiff_t m_jumpTimer = 0xB00; // CountdownTimer + constexpr std::ptrdiff_t m_isWaitingForLeader = 0xB18; // bool + constexpr std::ptrdiff_t m_repathTimer = 0x2B28; // CountdownTimer + constexpr std::ptrdiff_t m_inhibitDoorTimer = 0x2B40; // CountdownTimer + constexpr std::ptrdiff_t m_inhibitObstacleAvoidanceTimer = 0x2BD0; // CountdownTimer + constexpr std::ptrdiff_t m_wiggleTimer = 0x2BF0; // CountdownTimer + constexpr std::ptrdiff_t m_isAdjusted = 0x2C0C; // bool + constexpr std::ptrdiff_t m_bHandsHaveBeenCut = 0x2C0D; // bool + constexpr std::ptrdiff_t m_hHostageGrabber = 0x2C10; // CHandle + constexpr std::ptrdiff_t m_fLastGrabTime = 0x2C14; // GameTime_t + constexpr std::ptrdiff_t m_vecPositionWhenStartedDroppingToGround = 0x2C18; // Vector + constexpr std::ptrdiff_t m_vecGrabbedPos = 0x2C24; // Vector + constexpr std::ptrdiff_t m_flRescueStartTime = 0x2C30; // GameTime_t + constexpr std::ptrdiff_t m_flGrabSuccessTime = 0x2C34; // GameTime_t + constexpr std::ptrdiff_t m_flDropStartTime = 0x2C38; // GameTime_t + constexpr std::ptrdiff_t m_nApproachRewardPayouts = 0x2C3C; // int32_t + constexpr std::ptrdiff_t m_nPickupEventCount = 0x2C40; // int32_t + constexpr std::ptrdiff_t m_vecSpawnGroundPos = 0x2C44; // Vector +} + +namespace CHostageAlias_info_hostage_spawn { // CHostage +} + +namespace CHostageCarriableProp { // CBaseAnimGraph +} + +namespace CHostageExpresserShim { // CBaseCombatCharacter + constexpr std::ptrdiff_t m_pExpresser = 0x9D0; // CAI_Expresser* +} + +namespace CHostageRescueZone { // CHostageRescueZoneShim +} + +namespace CHostageRescueZoneShim { // CBaseTrigger +} + +namespace CInButtonState { + constexpr std::ptrdiff_t m_pButtonStates = 0x8; // uint64_t[3] +} + +namespace CIncendiaryGrenade { // CMolotovGrenade +} + +namespace CInferno { // CBaseModelEntity + constexpr std::ptrdiff_t m_firePositions = 0x710; // Vector[64] + constexpr std::ptrdiff_t m_fireParentPositions = 0xA10; // Vector[64] + constexpr std::ptrdiff_t m_bFireIsBurning = 0xD10; // bool[64] + constexpr std::ptrdiff_t m_BurnNormal = 0xD50; // Vector[64] + constexpr std::ptrdiff_t m_fireCount = 0x1050; // int32_t + constexpr std::ptrdiff_t m_nInfernoType = 0x1054; // int32_t + constexpr std::ptrdiff_t m_nFireEffectTickBegin = 0x1058; // int32_t + constexpr std::ptrdiff_t m_nFireLifetime = 0x105C; // float + constexpr std::ptrdiff_t m_bInPostEffectTime = 0x1060; // bool + constexpr std::ptrdiff_t m_nFiresExtinguishCount = 0x1064; // int32_t + constexpr std::ptrdiff_t m_bWasCreatedInSmoke = 0x1068; // bool + constexpr std::ptrdiff_t m_extent = 0x1270; // Extent + constexpr std::ptrdiff_t m_damageTimer = 0x1288; // CountdownTimer + constexpr std::ptrdiff_t m_damageRampTimer = 0x12A0; // CountdownTimer + constexpr std::ptrdiff_t m_splashVelocity = 0x12B8; // Vector + constexpr std::ptrdiff_t m_InitialSplashVelocity = 0x12C4; // Vector + constexpr std::ptrdiff_t m_startPos = 0x12D0; // Vector + constexpr std::ptrdiff_t m_vecOriginalSpawnLocation = 0x12DC; // Vector + constexpr std::ptrdiff_t m_activeTimer = 0x12E8; // IntervalTimer + constexpr std::ptrdiff_t m_fireSpawnOffset = 0x12F8; // int32_t + constexpr std::ptrdiff_t m_nMaxFlames = 0x12FC; // int32_t + constexpr std::ptrdiff_t m_BookkeepingTimer = 0x1300; // CountdownTimer + constexpr std::ptrdiff_t m_NextSpreadTimer = 0x1318; // CountdownTimer + constexpr std::ptrdiff_t m_nSourceItemDefIndex = 0x1330; // uint16_t +} + +namespace CInfoData { // CServerOnlyEntity +} + +namespace CInfoDeathmatchSpawn { // SpawnPoint +} + +namespace CInfoDynamicShadowHint { // CPointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_flRange = 0x4B4; // float + constexpr std::ptrdiff_t m_nImportance = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_nLightChoice = 0x4BC; // int32_t + constexpr std::ptrdiff_t m_hLight = 0x4C0; // CHandle +} + +namespace CInfoDynamicShadowHintBox { // CInfoDynamicShadowHint + constexpr std::ptrdiff_t m_vBoxMins = 0x4C8; // Vector + constexpr std::ptrdiff_t m_vBoxMaxs = 0x4D4; // Vector +} + +namespace CInfoEnemyTerroristSpawn { // SpawnPointCoopEnemy +} + +namespace CInfoGameEventProxy { // CPointEntity + constexpr std::ptrdiff_t m_iszEventName = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flRange = 0x4B8; // float +} + +namespace CInfoInstructorHintBombTargetA { // CPointEntity +} + +namespace CInfoInstructorHintBombTargetB { // CPointEntity +} + +namespace CInfoInstructorHintHostageRescueZone { // CPointEntity +} + +namespace CInfoInstructorHintTarget { // CPointEntity +} + +namespace CInfoLadderDismount { // CBaseEntity +} + +namespace CInfoLandmark { // CPointEntity +} + +namespace CInfoOffscreenPanoramaTexture { // CPointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_nResolutionX = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_nResolutionY = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_szLayoutFileName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_RenderAttrName = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_TargetEntities = 0x4D0; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_nTargetChangeCount = 0x4E8; // int32_t + constexpr std::ptrdiff_t m_vecCSSClasses = 0x4F0; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_szTargetsName = 0x508; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_AdditionalTargetEntities = 0x510; // CUtlVector> +} + +namespace CInfoParticleTarget { // CPointEntity +} + +namespace CInfoPlayerCounterterrorist { // SpawnPoint +} + +namespace CInfoPlayerStart { // CPointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool +} + +namespace CInfoPlayerTerrorist { // SpawnPoint +} + +namespace CInfoSpawnGroupLandmark { // CPointEntity +} + +namespace CInfoSpawnGroupLoadUnload { // CLogicalEntity + constexpr std::ptrdiff_t m_OnSpawnGroupLoadStarted = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnSpawnGroupLoadFinished = 0x4D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnSpawnGroupUnloadStarted = 0x500; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnSpawnGroupUnloadFinished = 0x528; // CEntityIOOutput + constexpr std::ptrdiff_t m_iszSpawnGroupName = 0x550; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSpawnGroupFilterName = 0x558; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszLandmarkName = 0x560; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sFixedSpawnGroupName = 0x568; // CUtlString + constexpr std::ptrdiff_t m_flTimeoutInterval = 0x570; // float + constexpr std::ptrdiff_t m_bStreamingStarted = 0x574; // bool + constexpr std::ptrdiff_t m_bUnloadingStarted = 0x575; // bool +} + +namespace CInfoTarget { // CPointEntity +} + +namespace CInfoTargetServerOnly { // CServerOnlyPointEntity +} + +namespace CInfoTeleportDestination { // CPointEntity +} + +namespace CInfoVisibilityBox { // CBaseEntity + constexpr std::ptrdiff_t m_nMode = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_vBoxSize = 0x4B8; // Vector + constexpr std::ptrdiff_t m_bEnabled = 0x4C4; // bool +} + +namespace CInfoWorldLayer { // CBaseEntity + constexpr std::ptrdiff_t m_pOutputOnEntitiesSpawned = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_worldName = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_layerName = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bWorldLayerVisible = 0x4E8; // bool + constexpr std::ptrdiff_t m_bEntitiesSpawned = 0x4E9; // bool + constexpr std::ptrdiff_t m_bCreateAsChildSpawnGroup = 0x4EA; // bool + constexpr std::ptrdiff_t m_hLayerSpawnGroup = 0x4EC; // uint32_t +} + +namespace CInstancedSceneEntity { // CSceneEntity + constexpr std::ptrdiff_t m_hOwner = 0xA08; // CHandle + constexpr std::ptrdiff_t m_bHadOwner = 0xA0C; // bool + constexpr std::ptrdiff_t m_flPostSpeakDelay = 0xA10; // float + constexpr std::ptrdiff_t m_flPreDelay = 0xA14; // float + constexpr std::ptrdiff_t m_bIsBackground = 0xA18; // bool +} + +namespace CInstructorEventEntity { // CPointEntity + constexpr std::ptrdiff_t m_iszName = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszHintTargetEntity = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hTargetPlayer = 0x4C0; // CHandle +} + +namespace CIronSightController { + constexpr std::ptrdiff_t m_bIronSightAvailable = 0x8; // bool + constexpr std::ptrdiff_t m_flIronSightAmount = 0xC; // float + constexpr std::ptrdiff_t m_flIronSightAmountGained = 0x10; // float + constexpr std::ptrdiff_t m_flIronSightAmountBiased = 0x14; // float +} + +namespace CItem { // CBaseAnimGraph + constexpr std::ptrdiff_t m_OnPlayerTouch = 0x898; // CEntityIOOutput + constexpr std::ptrdiff_t m_bActivateWhenAtRest = 0x8C0; // bool + constexpr std::ptrdiff_t m_OnCacheInteraction = 0x8C8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPlayerPickup = 0x8F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnGlovePulled = 0x918; // CEntityIOOutput + constexpr std::ptrdiff_t m_vOriginalSpawnOrigin = 0x940; // Vector + constexpr std::ptrdiff_t m_vOriginalSpawnAngles = 0x94C; // QAngle + constexpr std::ptrdiff_t m_bPhysStartAsleep = 0x958; // bool +} + +namespace CItemAssaultSuit { // CItem +} + +namespace CItemDefuser { // CItem + constexpr std::ptrdiff_t m_entitySpottedState = 0x968; // EntitySpottedState_t + constexpr std::ptrdiff_t m_nSpotRules = 0x980; // int32_t +} + +namespace CItemDefuserAlias_item_defuser { // CItemDefuser +} + +namespace CItemDogtags { // CItem + constexpr std::ptrdiff_t m_OwningPlayer = 0x968; // CHandle + constexpr std::ptrdiff_t m_KillingPlayer = 0x96C; // CHandle +} + +namespace CItemGeneric { // CItem + constexpr std::ptrdiff_t m_bHasTriggerRadius = 0x970; // bool + constexpr std::ptrdiff_t m_bHasPickupRadius = 0x971; // bool + constexpr std::ptrdiff_t m_flPickupRadiusSqr = 0x974; // float + constexpr std::ptrdiff_t m_flTriggerRadiusSqr = 0x978; // float + constexpr std::ptrdiff_t m_flLastPickupCheck = 0x97C; // GameTime_t + constexpr std::ptrdiff_t m_bPlayerCounterListenerAdded = 0x980; // bool + constexpr std::ptrdiff_t m_bPlayerInTriggerRadius = 0x981; // bool + constexpr std::ptrdiff_t m_hSpawnParticleEffect = 0x988; // CStrongHandle + constexpr std::ptrdiff_t m_pAmbientSoundEffect = 0x990; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bAutoStartAmbientSound = 0x998; // bool + constexpr std::ptrdiff_t m_pSpawnScriptFunction = 0x9A0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hPickupParticleEffect = 0x9A8; // CStrongHandle + constexpr std::ptrdiff_t m_pPickupSoundEffect = 0x9B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pPickupScriptFunction = 0x9B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hTimeoutParticleEffect = 0x9C0; // CStrongHandle + constexpr std::ptrdiff_t m_pTimeoutSoundEffect = 0x9C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pTimeoutScriptFunction = 0x9D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pPickupFilterName = 0x9D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hPickupFilter = 0x9E0; // CHandle + constexpr std::ptrdiff_t m_OnPickup = 0x9E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTimeout = 0xA10; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTriggerStartTouch = 0xA38; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTriggerTouch = 0xA60; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTriggerEndTouch = 0xA88; // CEntityIOOutput + constexpr std::ptrdiff_t m_pAllowPickupScriptFunction = 0xAB0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flPickupRadius = 0xAB8; // float + constexpr std::ptrdiff_t m_flTriggerRadius = 0xABC; // float + constexpr std::ptrdiff_t m_pTriggerSoundEffect = 0xAC0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bGlowWhenInTrigger = 0xAC8; // bool + constexpr std::ptrdiff_t m_glowColor = 0xAC9; // Color + constexpr std::ptrdiff_t m_bUseable = 0xACD; // bool + constexpr std::ptrdiff_t m_hTriggerHelper = 0xAD0; // CHandle +} + +namespace CItemGenericTriggerHelper { // CBaseModelEntity + constexpr std::ptrdiff_t m_hParentItem = 0x700; // CHandle +} + +namespace CItemHeavyAssaultSuit { // CItemAssaultSuit +} + +namespace CItemKevlar { // CItem +} + +namespace CItemSoda { // CBaseAnimGraph +} + +namespace CItem_Healthshot { // CWeaponBaseItem +} + +namespace CKeepUpright { // CPointEntity + constexpr std::ptrdiff_t m_worldGoalAxis = 0x4B8; // Vector + constexpr std::ptrdiff_t m_localTestAxis = 0x4C4; // Vector + constexpr std::ptrdiff_t m_nameAttach = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_attachedObject = 0x4E0; // CHandle + constexpr std::ptrdiff_t m_angularLimit = 0x4E4; // float + constexpr std::ptrdiff_t m_bActive = 0x4E8; // bool + constexpr std::ptrdiff_t m_bDampAllRotation = 0x4E9; // bool +} + +namespace CKnife { // CCSWeaponBase + constexpr std::ptrdiff_t m_bFirstAttack = 0xE18; // bool +} + +namespace CLightComponent { // CEntityComponent + constexpr std::ptrdiff_t __m_pChainEntity = 0x48; // CNetworkVarChainer + constexpr std::ptrdiff_t m_Color = 0x85; // Color + constexpr std::ptrdiff_t m_SecondaryColor = 0x89; // Color + constexpr std::ptrdiff_t m_flBrightness = 0x90; // float + constexpr std::ptrdiff_t m_flBrightnessScale = 0x94; // float + constexpr std::ptrdiff_t m_flBrightnessMult = 0x98; // float + constexpr std::ptrdiff_t m_flRange = 0x9C; // float + constexpr std::ptrdiff_t m_flFalloff = 0xA0; // float + constexpr std::ptrdiff_t m_flAttenuation0 = 0xA4; // float + constexpr std::ptrdiff_t m_flAttenuation1 = 0xA8; // float + constexpr std::ptrdiff_t m_flAttenuation2 = 0xAC; // float + constexpr std::ptrdiff_t m_flTheta = 0xB0; // float + constexpr std::ptrdiff_t m_flPhi = 0xB4; // float + constexpr std::ptrdiff_t m_hLightCookie = 0xB8; // CStrongHandle + constexpr std::ptrdiff_t m_nCascades = 0xC0; // int32_t + constexpr std::ptrdiff_t m_nCastShadows = 0xC4; // int32_t + constexpr std::ptrdiff_t m_nShadowWidth = 0xC8; // int32_t + constexpr std::ptrdiff_t m_nShadowHeight = 0xCC; // int32_t + constexpr std::ptrdiff_t m_bRenderDiffuse = 0xD0; // bool + constexpr std::ptrdiff_t m_nRenderSpecular = 0xD4; // int32_t + constexpr std::ptrdiff_t m_bRenderTransmissive = 0xD8; // bool + constexpr std::ptrdiff_t m_flOrthoLightWidth = 0xDC; // float + constexpr std::ptrdiff_t m_flOrthoLightHeight = 0xE0; // float + constexpr std::ptrdiff_t m_nStyle = 0xE4; // int32_t + constexpr std::ptrdiff_t m_Pattern = 0xE8; // CUtlString + constexpr std::ptrdiff_t m_nCascadeRenderStaticObjects = 0xF0; // int32_t + constexpr std::ptrdiff_t m_flShadowCascadeCrossFade = 0xF4; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistanceFade = 0xF8; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance0 = 0xFC; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance1 = 0x100; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance2 = 0x104; // float + constexpr std::ptrdiff_t m_flShadowCascadeDistance3 = 0x108; // float + constexpr std::ptrdiff_t m_nShadowCascadeResolution0 = 0x10C; // int32_t + constexpr std::ptrdiff_t m_nShadowCascadeResolution1 = 0x110; // int32_t + constexpr std::ptrdiff_t m_nShadowCascadeResolution2 = 0x114; // int32_t + constexpr std::ptrdiff_t m_nShadowCascadeResolution3 = 0x118; // int32_t + constexpr std::ptrdiff_t m_bUsesBakedShadowing = 0x11C; // bool + constexpr std::ptrdiff_t m_nShadowPriority = 0x120; // int32_t + constexpr std::ptrdiff_t m_nBakedShadowIndex = 0x124; // int32_t + constexpr std::ptrdiff_t m_bRenderToCubemaps = 0x128; // bool + constexpr std::ptrdiff_t m_nDirectLight = 0x12C; // int32_t + constexpr std::ptrdiff_t m_nIndirectLight = 0x130; // int32_t + constexpr std::ptrdiff_t m_flFadeMinDist = 0x134; // float + constexpr std::ptrdiff_t m_flFadeMaxDist = 0x138; // float + constexpr std::ptrdiff_t m_flShadowFadeMinDist = 0x13C; // float + constexpr std::ptrdiff_t m_flShadowFadeMaxDist = 0x140; // float + constexpr std::ptrdiff_t m_bEnabled = 0x144; // bool + constexpr std::ptrdiff_t m_bFlicker = 0x145; // bool + constexpr std::ptrdiff_t m_bPrecomputedFieldsValid = 0x146; // bool + constexpr std::ptrdiff_t m_vPrecomputedBoundsMins = 0x148; // Vector + constexpr std::ptrdiff_t m_vPrecomputedBoundsMaxs = 0x154; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBOrigin = 0x160; // Vector + constexpr std::ptrdiff_t m_vPrecomputedOBBAngles = 0x16C; // QAngle + constexpr std::ptrdiff_t m_vPrecomputedOBBExtent = 0x178; // Vector + constexpr std::ptrdiff_t m_flPrecomputedMaxRange = 0x184; // float + constexpr std::ptrdiff_t m_nFogLightingMode = 0x188; // int32_t + constexpr std::ptrdiff_t m_flFogContributionStength = 0x18C; // float + constexpr std::ptrdiff_t m_flNearClipPlane = 0x190; // float + constexpr std::ptrdiff_t m_SkyColor = 0x194; // Color + constexpr std::ptrdiff_t m_flSkyIntensity = 0x198; // float + constexpr std::ptrdiff_t m_SkyAmbientBounce = 0x19C; // Color + constexpr std::ptrdiff_t m_bUseSecondaryColor = 0x1A0; // bool + constexpr std::ptrdiff_t m_bMixedShadows = 0x1A1; // bool + constexpr std::ptrdiff_t m_flLightStyleStartTime = 0x1A4; // GameTime_t + constexpr std::ptrdiff_t m_flCapsuleLength = 0x1A8; // float + constexpr std::ptrdiff_t m_flMinRoughness = 0x1AC; // float + constexpr std::ptrdiff_t m_bPvsModifyEntity = 0x1C0; // bool +} + +namespace CLightDirectionalEntity { // CLightEntity +} + +namespace CLightEntity { // CBaseModelEntity + constexpr std::ptrdiff_t m_CLightComponent = 0x700; // CLightComponent* +} + +namespace CLightEnvironmentEntity { // CLightDirectionalEntity +} + +namespace CLightGlow { // CBaseModelEntity + constexpr std::ptrdiff_t m_nHorizontalSize = 0x700; // uint32_t + constexpr std::ptrdiff_t m_nVerticalSize = 0x704; // uint32_t + constexpr std::ptrdiff_t m_nMinDist = 0x708; // uint32_t + constexpr std::ptrdiff_t m_nMaxDist = 0x70C; // uint32_t + constexpr std::ptrdiff_t m_nOuterMaxDist = 0x710; // uint32_t + constexpr std::ptrdiff_t m_flGlowProxySize = 0x714; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0x718; // float +} + +namespace CLightOrthoEntity { // CLightEntity +} + +namespace CLightSpotEntity { // CLightEntity +} + +namespace CLogicAchievement { // CLogicalEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_iszAchievementEventID = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_OnFired = 0x4C0; // CEntityIOOutput +} + +namespace CLogicActiveAutosave { // CLogicAutosave + constexpr std::ptrdiff_t m_TriggerHitPoints = 0x4C0; // int32_t + constexpr std::ptrdiff_t m_flTimeToTrigger = 0x4C4; // float + constexpr std::ptrdiff_t m_flStartTime = 0x4C8; // GameTime_t + constexpr std::ptrdiff_t m_flDangerousTime = 0x4CC; // float +} + +namespace CLogicAuto { // CBaseEntity + constexpr std::ptrdiff_t m_OnMapSpawn = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnDemoMapSpawn = 0x4D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnNewGame = 0x500; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnLoadGame = 0x528; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMapTransition = 0x550; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnBackgroundMap = 0x578; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMultiNewMap = 0x5A0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMultiNewRound = 0x5C8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnVREnabled = 0x5F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnVRNotEnabled = 0x618; // CEntityIOOutput + constexpr std::ptrdiff_t m_globalstate = 0x640; // CUtlSymbolLarge +} + +namespace CLogicAutosave { // CLogicalEntity + constexpr std::ptrdiff_t m_bForceNewLevelUnit = 0x4B0; // bool + constexpr std::ptrdiff_t m_minHitPoints = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_minHitPointsToCommit = 0x4B8; // int32_t +} + +namespace CLogicBranch { // CLogicalEntity + constexpr std::ptrdiff_t m_bInValue = 0x4B0; // bool + constexpr std::ptrdiff_t m_Listeners = 0x4B8; // CUtlVector> + constexpr std::ptrdiff_t m_OnTrue = 0x4D0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFalse = 0x4F8; // CEntityIOOutput +} + +namespace CLogicBranchList { // CLogicalEntity + constexpr std::ptrdiff_t m_nLogicBranchNames = 0x4B0; // CUtlSymbolLarge[16] + constexpr std::ptrdiff_t m_LogicBranchList = 0x530; // CUtlVector> + constexpr std::ptrdiff_t m_eLastState = 0x548; // CLogicBranchList::LogicBranchListenerLastState_t + constexpr std::ptrdiff_t m_OnAllTrue = 0x550; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAllFalse = 0x578; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMixed = 0x5A0; // CEntityIOOutput +} + +namespace CLogicCase { // CLogicalEntity + constexpr std::ptrdiff_t m_nCase = 0x4B0; // CUtlSymbolLarge[32] + constexpr std::ptrdiff_t m_nShuffleCases = 0x5B0; // int32_t + constexpr std::ptrdiff_t m_nLastShuffleCase = 0x5B4; // int32_t + constexpr std::ptrdiff_t m_uchShuffleCaseMap = 0x5B8; // uint8_t[32] + constexpr std::ptrdiff_t m_OnCase = 0x5D8; // CEntityIOOutput[32] + constexpr std::ptrdiff_t m_OnDefault = 0xAD8; // CEntityOutputTemplate> +} + +namespace CLogicCollisionPair { // CLogicalEntity + constexpr std::ptrdiff_t m_nameAttach1 = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nameAttach2 = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_disabled = 0x4C0; // bool + constexpr std::ptrdiff_t m_succeeded = 0x4C1; // bool +} + +namespace CLogicCompare { // CLogicalEntity + constexpr std::ptrdiff_t m_flInValue = 0x4B0; // float + constexpr std::ptrdiff_t m_flCompareValue = 0x4B4; // float + constexpr std::ptrdiff_t m_OnLessThan = 0x4B8; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnEqualTo = 0x4E0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnNotEqualTo = 0x508; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnGreaterThan = 0x530; // CEntityOutputTemplate +} + +namespace CLogicDistanceAutosave { // CLogicalEntity + constexpr std::ptrdiff_t m_iszTargetEntity = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flDistanceToPlayer = 0x4B8; // float + constexpr std::ptrdiff_t m_bForceNewLevelUnit = 0x4BC; // bool + constexpr std::ptrdiff_t m_bCheckCough = 0x4BD; // bool + constexpr std::ptrdiff_t m_bThinkDangerous = 0x4BE; // bool + constexpr std::ptrdiff_t m_flDangerousTime = 0x4C0; // float +} + +namespace CLogicDistanceCheck { // CLogicalEntity + constexpr std::ptrdiff_t m_iszEntityA = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszEntityB = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flZone1Distance = 0x4C0; // float + constexpr std::ptrdiff_t m_flZone2Distance = 0x4C4; // float + constexpr std::ptrdiff_t m_InZone1 = 0x4C8; // CEntityIOOutput + constexpr std::ptrdiff_t m_InZone2 = 0x4F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_InZone3 = 0x518; // CEntityIOOutput +} + +namespace CLogicGameEvent { // CLogicalEntity + constexpr std::ptrdiff_t m_iszEventName = 0x4B0; // CUtlSymbolLarge +} + +namespace CLogicGameEventListener { // CLogicalEntity + constexpr std::ptrdiff_t m_OnEventFired = 0x4C0; // CEntityIOOutput + constexpr std::ptrdiff_t m_iszGameEventName = 0x4E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszGameEventItem = 0x4F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bEnabled = 0x4F8; // bool + constexpr std::ptrdiff_t m_bStartDisabled = 0x4F9; // bool +} + +namespace CLogicLineToEntity { // CLogicalEntity + constexpr std::ptrdiff_t m_Line = 0x4B0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_SourceName = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_StartEntity = 0x4E0; // CHandle + constexpr std::ptrdiff_t m_EndEntity = 0x4E4; // CHandle +} + +namespace CLogicMeasureMovement { // CLogicalEntity + constexpr std::ptrdiff_t m_strMeasureTarget = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_strMeasureReference = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_strTargetReference = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hMeasureTarget = 0x4C8; // CHandle + constexpr std::ptrdiff_t m_hMeasureReference = 0x4CC; // CHandle + constexpr std::ptrdiff_t m_hTarget = 0x4D0; // CHandle + constexpr std::ptrdiff_t m_hTargetReference = 0x4D4; // CHandle + constexpr std::ptrdiff_t m_flScale = 0x4D8; // float + constexpr std::ptrdiff_t m_nMeasureType = 0x4DC; // int32_t +} + +namespace CLogicNPCCounter { // CBaseEntity + constexpr std::ptrdiff_t m_OnMinCountAll = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMaxCountAll = 0x4D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFactorAll = 0x500; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMinPlayerDistAll = 0x528; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMinCount_1 = 0x550; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMaxCount_1 = 0x578; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFactor_1 = 0x5A0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMinPlayerDist_1 = 0x5C8; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMinCount_2 = 0x5F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMaxCount_2 = 0x618; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFactor_2 = 0x640; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMinPlayerDist_2 = 0x668; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMinCount_3 = 0x690; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMaxCount_3 = 0x6B8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFactor_3 = 0x6E0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMinPlayerDist_3 = 0x708; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_hSource = 0x730; // CEntityHandle + constexpr std::ptrdiff_t m_iszSourceEntityName = 0x738; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flDistanceMax = 0x740; // float + constexpr std::ptrdiff_t m_bDisabled = 0x744; // bool + constexpr std::ptrdiff_t m_nMinCountAll = 0x748; // int32_t + constexpr std::ptrdiff_t m_nMaxCountAll = 0x74C; // int32_t + constexpr std::ptrdiff_t m_nMinFactorAll = 0x750; // int32_t + constexpr std::ptrdiff_t m_nMaxFactorAll = 0x754; // int32_t + constexpr std::ptrdiff_t m_iszNPCClassname_1 = 0x760; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nNPCState_1 = 0x768; // int32_t + constexpr std::ptrdiff_t m_bInvertState_1 = 0x76C; // bool + constexpr std::ptrdiff_t m_nMinCount_1 = 0x770; // int32_t + constexpr std::ptrdiff_t m_nMaxCount_1 = 0x774; // int32_t + constexpr std::ptrdiff_t m_nMinFactor_1 = 0x778; // int32_t + constexpr std::ptrdiff_t m_nMaxFactor_1 = 0x77C; // int32_t + constexpr std::ptrdiff_t m_flDefaultDist_1 = 0x784; // float + constexpr std::ptrdiff_t m_iszNPCClassname_2 = 0x788; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nNPCState_2 = 0x790; // int32_t + constexpr std::ptrdiff_t m_bInvertState_2 = 0x794; // bool + constexpr std::ptrdiff_t m_nMinCount_2 = 0x798; // int32_t + constexpr std::ptrdiff_t m_nMaxCount_2 = 0x79C; // int32_t + constexpr std::ptrdiff_t m_nMinFactor_2 = 0x7A0; // int32_t + constexpr std::ptrdiff_t m_nMaxFactor_2 = 0x7A4; // int32_t + constexpr std::ptrdiff_t m_flDefaultDist_2 = 0x7AC; // float + constexpr std::ptrdiff_t m_iszNPCClassname_3 = 0x7B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nNPCState_3 = 0x7B8; // int32_t + constexpr std::ptrdiff_t m_bInvertState_3 = 0x7BC; // bool + constexpr std::ptrdiff_t m_nMinCount_3 = 0x7C0; // int32_t + constexpr std::ptrdiff_t m_nMaxCount_3 = 0x7C4; // int32_t + constexpr std::ptrdiff_t m_nMinFactor_3 = 0x7C8; // int32_t + constexpr std::ptrdiff_t m_nMaxFactor_3 = 0x7CC; // int32_t + constexpr std::ptrdiff_t m_flDefaultDist_3 = 0x7D4; // float +} + +namespace CLogicNPCCounterAABB { // CLogicNPCCounter + constexpr std::ptrdiff_t m_vDistanceOuterMins = 0x7F0; // Vector + constexpr std::ptrdiff_t m_vDistanceOuterMaxs = 0x7FC; // Vector + constexpr std::ptrdiff_t m_vOuterMins = 0x808; // Vector + constexpr std::ptrdiff_t m_vOuterMaxs = 0x814; // Vector +} + +namespace CLogicNPCCounterOBB { // CLogicNPCCounterAABB +} + +namespace CLogicNavigation { // CLogicalEntity + constexpr std::ptrdiff_t m_isOn = 0x4B8; // bool + constexpr std::ptrdiff_t m_navProperty = 0x4BC; // navproperties_t +} + +namespace CLogicPlayerProxy { // CLogicalEntity + constexpr std::ptrdiff_t m_hPlayer = 0x4B0; // CHandle + constexpr std::ptrdiff_t m_PlayerHasAmmo = 0x4B8; // CEntityIOOutput + constexpr std::ptrdiff_t m_PlayerHasNoAmmo = 0x4E0; // CEntityIOOutput + constexpr std::ptrdiff_t m_PlayerDied = 0x508; // CEntityIOOutput + constexpr std::ptrdiff_t m_RequestedPlayerHealth = 0x530; // CEntityOutputTemplate +} + +namespace CLogicProximity { // CPointEntity +} + +namespace CLogicRelay { // CLogicalEntity + constexpr std::ptrdiff_t m_OnTrigger = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnSpawn = 0x4D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_bDisabled = 0x500; // bool + constexpr std::ptrdiff_t m_bWaitForRefire = 0x501; // bool + constexpr std::ptrdiff_t m_bTriggerOnce = 0x502; // bool + constexpr std::ptrdiff_t m_bFastRetrigger = 0x503; // bool + constexpr std::ptrdiff_t m_bPassthoughCaller = 0x504; // bool +} + +namespace CLogicScript { // CPointEntity +} + +namespace CLogicalEntity { // CServerOnlyEntity +} + +namespace CMapInfo { // CPointEntity + constexpr std::ptrdiff_t m_iBuyingStatus = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_flBombRadius = 0x4B4; // float + constexpr std::ptrdiff_t m_iPetPopulation = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_bUseNormalSpawnsForDM = 0x4BC; // bool + constexpr std::ptrdiff_t m_bDisableAutoGeneratedDMSpawns = 0x4BD; // bool + constexpr std::ptrdiff_t m_flBotMaxVisionDistance = 0x4C0; // float + constexpr std::ptrdiff_t m_iHostageCount = 0x4C4; // int32_t + constexpr std::ptrdiff_t m_bFadePlayerVisibilityFarZ = 0x4C8; // bool +} + +namespace CMapVetoPickController { // CBaseEntity + constexpr std::ptrdiff_t m_bPlayedIntroVcd = 0x4B0; // bool + constexpr std::ptrdiff_t m_bNeedToPlayFiveSecondsRemaining = 0x4B1; // bool + constexpr std::ptrdiff_t m_dblPreMatchDraftSequenceTime = 0x4D0; // double + constexpr std::ptrdiff_t m_bPreMatchDraftStateChanged = 0x4D8; // bool + constexpr std::ptrdiff_t m_nDraftType = 0x4DC; // int32_t + constexpr std::ptrdiff_t m_nTeamWinningCoinToss = 0x4E0; // int32_t + constexpr std::ptrdiff_t m_nTeamWithFirstChoice = 0x4E4; // int32_t[64] + constexpr std::ptrdiff_t m_nVoteMapIdsList = 0x5E4; // int32_t[7] + constexpr std::ptrdiff_t m_nAccountIDs = 0x600; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId0 = 0x700; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId1 = 0x800; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId2 = 0x900; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId3 = 0xA00; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId4 = 0xB00; // int32_t[64] + constexpr std::ptrdiff_t m_nMapId5 = 0xC00; // int32_t[64] + constexpr std::ptrdiff_t m_nStartingSide0 = 0xD00; // int32_t[64] + constexpr std::ptrdiff_t m_nCurrentPhase = 0xE00; // int32_t + constexpr std::ptrdiff_t m_nPhaseStartTick = 0xE04; // int32_t + constexpr std::ptrdiff_t m_nPhaseDurationTicks = 0xE08; // int32_t + constexpr std::ptrdiff_t m_OnMapVetoed = 0xE10; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnMapPicked = 0xE38; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnSidesPicked = 0xE60; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnNewPhaseStarted = 0xE88; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnLevelTransition = 0xEB0; // CEntityOutputTemplate +} + +namespace CMarkupVolume { // CBaseModelEntity + constexpr std::ptrdiff_t m_bEnabled = 0x700; // bool +} + +namespace CMarkupVolumeTagged { // CMarkupVolume + constexpr std::ptrdiff_t m_bIsGroup = 0x738; // bool + constexpr std::ptrdiff_t m_bGroupByPrefab = 0x739; // bool + constexpr std::ptrdiff_t m_bGroupByVolume = 0x73A; // bool + constexpr std::ptrdiff_t m_bGroupOtherGroups = 0x73B; // bool + constexpr std::ptrdiff_t m_bIsInGroup = 0x73C; // bool +} + +namespace CMarkupVolumeTagged_Nav { // CMarkupVolumeTagged +} + +namespace CMarkupVolumeTagged_NavGame { // CMarkupVolumeWithRef + constexpr std::ptrdiff_t m_bFloodFillAttribute = 0x758; // bool +} + +namespace CMarkupVolumeWithRef { // CMarkupVolumeTagged + constexpr std::ptrdiff_t m_bUseRef = 0x740; // bool + constexpr std::ptrdiff_t m_vRefPos = 0x744; // Vector + constexpr std::ptrdiff_t m_flRefDot = 0x750; // float +} + +namespace CMathColorBlend { // CLogicalEntity + constexpr std::ptrdiff_t m_flInMin = 0x4B0; // float + constexpr std::ptrdiff_t m_flInMax = 0x4B4; // float + constexpr std::ptrdiff_t m_OutColor1 = 0x4B8; // Color + constexpr std::ptrdiff_t m_OutColor2 = 0x4BC; // Color + constexpr std::ptrdiff_t m_OutValue = 0x4C0; // CEntityOutputTemplate +} + +namespace CMathCounter { // CLogicalEntity + constexpr std::ptrdiff_t m_flMin = 0x4B0; // float + constexpr std::ptrdiff_t m_flMax = 0x4B4; // float + constexpr std::ptrdiff_t m_bHitMin = 0x4B8; // bool + constexpr std::ptrdiff_t m_bHitMax = 0x4B9; // bool + constexpr std::ptrdiff_t m_bDisabled = 0x4BA; // bool + constexpr std::ptrdiff_t m_OutValue = 0x4C0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnGetValue = 0x4E8; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnHitMin = 0x510; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnHitMax = 0x538; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnChangedFromMin = 0x560; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnChangedFromMax = 0x588; // CEntityIOOutput +} + +namespace CMathRemap { // CLogicalEntity + constexpr std::ptrdiff_t m_flInMin = 0x4B0; // float + constexpr std::ptrdiff_t m_flInMax = 0x4B4; // float + constexpr std::ptrdiff_t m_flOut1 = 0x4B8; // float + constexpr std::ptrdiff_t m_flOut2 = 0x4BC; // float + constexpr std::ptrdiff_t m_flOldInValue = 0x4C0; // float + constexpr std::ptrdiff_t m_bEnabled = 0x4C4; // bool + constexpr std::ptrdiff_t m_OutValue = 0x4C8; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnRoseAboveMin = 0x4F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnRoseAboveMax = 0x518; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFellBelowMin = 0x540; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFellBelowMax = 0x568; // CEntityIOOutput +} + +namespace CMelee { // CCSWeaponBase + constexpr std::ptrdiff_t m_flThrowAt = 0xE18; // GameTime_t + constexpr std::ptrdiff_t m_hThrower = 0xE1C; // CHandle + constexpr std::ptrdiff_t m_bDidThrowDamage = 0xE20; // bool +} + +namespace CMessage { // CPointEntity + constexpr std::ptrdiff_t m_iszMessage = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_MessageVolume = 0x4B8; // float + constexpr std::ptrdiff_t m_MessageAttenuation = 0x4BC; // int32_t + constexpr std::ptrdiff_t m_Radius = 0x4C0; // float + constexpr std::ptrdiff_t m_sNoise = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_OnShowMessage = 0x4D0; // CEntityIOOutput +} + +namespace CMessageEntity { // CPointEntity + constexpr std::ptrdiff_t m_radius = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_messageText = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_drawText = 0x4C0; // bool + constexpr std::ptrdiff_t m_bDeveloperOnly = 0x4C1; // bool + constexpr std::ptrdiff_t m_bEnabled = 0x4C2; // bool +} + +namespace CModelPointEntity { // CBaseModelEntity +} + +namespace CModelState { + constexpr std::ptrdiff_t m_hModel = 0xA0; // CStrongHandle + constexpr std::ptrdiff_t m_ModelName = 0xA8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bClientClothCreationSuppressed = 0xE8; // bool + constexpr std::ptrdiff_t m_MeshGroupMask = 0x180; // uint64_t + constexpr std::ptrdiff_t m_nIdealMotionType = 0x222; // int8_t + constexpr std::ptrdiff_t m_nForceLOD = 0x223; // int8_t + constexpr std::ptrdiff_t m_nClothUpdateFlags = 0x224; // int8_t +} + +namespace CMolotovGrenade { // CBaseCSGrenade +} + +namespace CMolotovProjectile { // CBaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_bIsIncGrenade = 0xA30; // bool + constexpr std::ptrdiff_t m_bDetonated = 0xA3C; // bool + constexpr std::ptrdiff_t m_stillTimer = 0xA40; // IntervalTimer + constexpr std::ptrdiff_t m_bHasBouncedOffPlayer = 0xB20; // bool +} + +namespace CMomentaryRotButton { // CRotButton + constexpr std::ptrdiff_t m_Position = 0x8C8; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnUnpressed = 0x8F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFullyOpen = 0x918; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnFullyClosed = 0x940; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnReachedPosition = 0x968; // CEntityIOOutput + constexpr std::ptrdiff_t m_lastUsed = 0x990; // int32_t + constexpr std::ptrdiff_t m_start = 0x994; // QAngle + constexpr std::ptrdiff_t m_end = 0x9A0; // QAngle + constexpr std::ptrdiff_t m_IdealYaw = 0x9AC; // float + constexpr std::ptrdiff_t m_sNoise = 0x9B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bUpdateTarget = 0x9B8; // bool + constexpr std::ptrdiff_t m_direction = 0x9BC; // int32_t + constexpr std::ptrdiff_t m_returnSpeed = 0x9C0; // float + constexpr std::ptrdiff_t m_flStartPosition = 0x9C4; // float +} + +namespace CMotorController { + constexpr std::ptrdiff_t m_speed = 0x8; // float + constexpr std::ptrdiff_t m_maxTorque = 0xC; // float + constexpr std::ptrdiff_t m_axis = 0x10; // Vector + constexpr std::ptrdiff_t m_inertiaFactor = 0x1C; // float +} + +namespace CMultiLightProxy { // CLogicalEntity + constexpr std::ptrdiff_t m_iszLightNameFilter = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszLightClassFilter = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flLightRadiusFilter = 0x4C0; // float + constexpr std::ptrdiff_t m_flBrightnessDelta = 0x4C4; // float + constexpr std::ptrdiff_t m_bPerformScreenFade = 0x4C8; // bool + constexpr std::ptrdiff_t m_flTargetBrightnessMultiplier = 0x4CC; // float + constexpr std::ptrdiff_t m_flCurrentBrightnessMultiplier = 0x4D0; // float + constexpr std::ptrdiff_t m_vecLights = 0x4D8; // CUtlVector> +} + +namespace CMultiSource { // CLogicalEntity + constexpr std::ptrdiff_t m_rgEntities = 0x4B0; // CHandle[32] + constexpr std::ptrdiff_t m_rgTriggered = 0x530; // int32_t[32] + constexpr std::ptrdiff_t m_OnTrigger = 0x5B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_iTotal = 0x5D8; // int32_t + constexpr std::ptrdiff_t m_globalstate = 0x5E0; // CUtlSymbolLarge +} + +namespace CMultiplayRules { // CGameRules +} + +namespace CMultiplayer_Expresser { // CAI_ExpresserWithFollowup + constexpr std::ptrdiff_t m_bAllowMultipleScenes = 0x70; // bool +} + +namespace CNavHullPresetVData { + constexpr std::ptrdiff_t m_vecNavHulls = 0x0; // CUtlVector +} + +namespace CNavHullVData { + constexpr std::ptrdiff_t m_bAgentEnabled = 0x0; // bool + constexpr std::ptrdiff_t m_agentRadius = 0x4; // float + constexpr std::ptrdiff_t m_agentHeight = 0x8; // float + constexpr std::ptrdiff_t m_agentShortHeightEnabled = 0xC; // bool + constexpr std::ptrdiff_t m_agentShortHeight = 0x10; // float + constexpr std::ptrdiff_t m_agentMaxClimb = 0x14; // float + constexpr std::ptrdiff_t m_agentMaxSlope = 0x18; // int32_t + constexpr std::ptrdiff_t m_agentMaxJumpDownDist = 0x1C; // float + constexpr std::ptrdiff_t m_agentMaxJumpHorizDistBase = 0x20; // float + constexpr std::ptrdiff_t m_agentMaxJumpUpDist = 0x24; // float + constexpr std::ptrdiff_t m_agentBorderErosion = 0x28; // int32_t +} + +namespace CNavLinkAnimgraphVar { + constexpr std::ptrdiff_t m_strAnimgraphVar = 0x0; // CUtlString + constexpr std::ptrdiff_t m_unAlignmentDegrees = 0x8; // uint32_t +} + +namespace CNavLinkAreaEntity { // CPointEntity + constexpr std::ptrdiff_t m_flWidth = 0x4B0; // float + constexpr std::ptrdiff_t m_vLocatorOffset = 0x4B4; // Vector + constexpr std::ptrdiff_t m_qLocatorAnglesOffset = 0x4C0; // QAngle + constexpr std::ptrdiff_t m_strMovementForward = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_strMovementReverse = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nNavLinkIdForward = 0x4E0; // int32_t + constexpr std::ptrdiff_t m_nNavLinkIdReverse = 0x4E4; // int32_t + constexpr std::ptrdiff_t m_bEnabled = 0x4E8; // bool + constexpr std::ptrdiff_t m_strFilterName = 0x4F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFilter = 0x4F8; // CHandle + constexpr std::ptrdiff_t m_OnNavLinkStart = 0x500; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnNavLinkFinish = 0x528; // CEntityIOOutput + constexpr std::ptrdiff_t m_bIsTerminus = 0x550; // bool +} + +namespace CNavLinkMovementVData { + constexpr std::ptrdiff_t m_bIsInterpolated = 0x0; // bool + constexpr std::ptrdiff_t m_unRecommendedDistance = 0x4; // uint32_t + constexpr std::ptrdiff_t m_vecAnimgraphVars = 0x8; // CUtlVector +} + +namespace CNavSpaceInfo { // CPointEntity + constexpr std::ptrdiff_t m_bCreateFlightSpace = 0x4B0; // bool +} + +namespace CNavVolume { +} + +namespace CNavVolumeAll { // CNavVolumeVector +} + +namespace CNavVolumeBreadthFirstSearch { // CNavVolumeCalculatedVector + constexpr std::ptrdiff_t m_vStartPos = 0xA0; // Vector + constexpr std::ptrdiff_t m_flSearchDist = 0xAC; // float +} + +namespace CNavVolumeCalculatedVector { // CNavVolume +} + +namespace CNavVolumeMarkupVolume { // CNavVolume +} + +namespace CNavVolumeSphere { // CNavVolume + constexpr std::ptrdiff_t m_vCenter = 0x70; // Vector + constexpr std::ptrdiff_t m_flRadius = 0x7C; // float +} + +namespace CNavVolumeSphericalShell { // CNavVolumeSphere + constexpr std::ptrdiff_t m_flRadiusInner = 0x80; // float +} + +namespace CNavVolumeVector { // CNavVolume + constexpr std::ptrdiff_t m_bHasBeenPreFiltered = 0x78; // bool +} + +namespace CNavWalkable { // CPointEntity +} + +namespace CNetworkOriginCellCoordQuantizedVector { + constexpr std::ptrdiff_t m_cellX = 0x10; // uint16_t + constexpr std::ptrdiff_t m_cellY = 0x12; // uint16_t + constexpr std::ptrdiff_t m_cellZ = 0x14; // uint16_t + constexpr std::ptrdiff_t m_nOutsideWorld = 0x16; // uint16_t + constexpr std::ptrdiff_t m_vecX = 0x18; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecY = 0x20; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecZ = 0x28; // CNetworkedQuantizedFloat +} + +namespace CNetworkOriginQuantizedVector { + constexpr std::ptrdiff_t m_vecX = 0x10; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecY = 0x18; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecZ = 0x20; // CNetworkedQuantizedFloat +} + +namespace CNetworkTransmitComponent { + constexpr std::ptrdiff_t m_nTransmitStateOwnedCounter = 0x16C; // uint8_t +} + +namespace CNetworkVelocityVector { + constexpr std::ptrdiff_t m_vecX = 0x10; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecY = 0x18; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecZ = 0x20; // CNetworkedQuantizedFloat +} + +namespace CNetworkViewOffsetVector { + constexpr std::ptrdiff_t m_vecX = 0x10; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecY = 0x18; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_vecZ = 0x20; // CNetworkedQuantizedFloat +} + +namespace CNetworkedSequenceOperation { + constexpr std::ptrdiff_t m_hSequence = 0x8; // HSequence + constexpr std::ptrdiff_t m_flPrevCycle = 0xC; // float + constexpr std::ptrdiff_t m_flCycle = 0x10; // float + constexpr std::ptrdiff_t m_flWeight = 0x14; // CNetworkedQuantizedFloat + constexpr std::ptrdiff_t m_bSequenceChangeNetworked = 0x1C; // bool + constexpr std::ptrdiff_t m_bDiscontinuity = 0x1D; // bool + constexpr std::ptrdiff_t m_flPrevCycleFromDiscontinuity = 0x20; // float + constexpr std::ptrdiff_t m_flPrevCycleForAnimEventDetection = 0x24; // float +} + +namespace CNullEntity { // CBaseEntity +} + +namespace COmniLight { // CBarnLight + constexpr std::ptrdiff_t m_flInnerAngle = 0x928; // float + constexpr std::ptrdiff_t m_flOuterAngle = 0x92C; // float + constexpr std::ptrdiff_t m_bShowLight = 0x930; // bool +} + +namespace COrnamentProp { // CDynamicProp + constexpr std::ptrdiff_t m_initialOwner = 0xB08; // CUtlSymbolLarge +} + +namespace CParticleSystem { // CBaseModelEntity + constexpr std::ptrdiff_t m_szSnapshotFileName = 0x700; // char[512] + constexpr std::ptrdiff_t m_bActive = 0x900; // bool + constexpr std::ptrdiff_t m_bFrozen = 0x901; // bool + constexpr std::ptrdiff_t m_flFreezeTransitionDuration = 0x904; // float + constexpr std::ptrdiff_t m_nStopType = 0x908; // int32_t + constexpr std::ptrdiff_t m_bAnimateDuringGameplayPause = 0x90C; // bool + constexpr std::ptrdiff_t m_iEffectIndex = 0x910; // CStrongHandle + constexpr std::ptrdiff_t m_flStartTime = 0x918; // GameTime_t + constexpr std::ptrdiff_t m_flPreSimTime = 0x91C; // float + constexpr std::ptrdiff_t m_vServerControlPoints = 0x920; // Vector[4] + constexpr std::ptrdiff_t m_iServerControlPointAssignments = 0x950; // uint8_t[4] + constexpr std::ptrdiff_t m_hControlPointEnts = 0x954; // CHandle[64] + constexpr std::ptrdiff_t m_bNoSave = 0xA54; // bool + constexpr std::ptrdiff_t m_bNoFreeze = 0xA55; // bool + constexpr std::ptrdiff_t m_bNoRamp = 0xA56; // bool + constexpr std::ptrdiff_t m_bStartActive = 0xA57; // bool + constexpr std::ptrdiff_t m_iszEffectName = 0xA58; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszControlPointNames = 0xA60; // CUtlSymbolLarge[64] + constexpr std::ptrdiff_t m_nDataCP = 0xC60; // int32_t + constexpr std::ptrdiff_t m_vecDataCPValue = 0xC64; // Vector + constexpr std::ptrdiff_t m_nTintCP = 0xC70; // int32_t + constexpr std::ptrdiff_t m_clrTint = 0xC74; // Color +} + +namespace CPathCorner { // CPointEntity + constexpr std::ptrdiff_t m_flWait = 0x4B0; // float + constexpr std::ptrdiff_t m_flRadius = 0x4B4; // float + constexpr std::ptrdiff_t m_OnPass = 0x4B8; // CEntityIOOutput +} + +namespace CPathCornerCrash { // CPathCorner +} + +namespace CPathKeyFrame { // CLogicalEntity + constexpr std::ptrdiff_t m_Origin = 0x4B0; // Vector + constexpr std::ptrdiff_t m_Angles = 0x4BC; // QAngle + constexpr std::ptrdiff_t m_qAngle = 0x4D0; // Quaternion + constexpr std::ptrdiff_t m_iNextKey = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flNextTime = 0x4E8; // float + constexpr std::ptrdiff_t m_pNextKey = 0x4F0; // CPathKeyFrame* + constexpr std::ptrdiff_t m_pPrevKey = 0x4F8; // CPathKeyFrame* + constexpr std::ptrdiff_t m_flSpeed = 0x500; // float +} + +namespace CPathParticleRope { // CBaseEntity + constexpr std::ptrdiff_t m_bStartActive = 0x4B0; // bool + constexpr std::ptrdiff_t m_flMaxSimulationTime = 0x4B4; // float + constexpr std::ptrdiff_t m_iszEffectName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_PathNodes_Name = 0x4C0; // CUtlVector + constexpr std::ptrdiff_t m_flParticleSpacing = 0x4D8; // float + constexpr std::ptrdiff_t m_flSlack = 0x4DC; // float + constexpr std::ptrdiff_t m_flRadius = 0x4E0; // float + constexpr std::ptrdiff_t m_ColorTint = 0x4E4; // Color + constexpr std::ptrdiff_t m_nEffectState = 0x4E8; // int32_t + constexpr std::ptrdiff_t m_iEffectIndex = 0x4F0; // CStrongHandle + constexpr std::ptrdiff_t m_PathNodes_Position = 0x4F8; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_TangentIn = 0x510; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_TangentOut = 0x528; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_Color = 0x540; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_PinEnabled = 0x558; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_PathNodes_RadiusScale = 0x570; // CNetworkUtlVectorBase +} + +namespace CPathParticleRopeAlias_path_particle_rope_clientside { // CPathParticleRope +} + +namespace CPathTrack { // CPointEntity + constexpr std::ptrdiff_t m_pnext = 0x4B0; // CPathTrack* + constexpr std::ptrdiff_t m_pprevious = 0x4B8; // CPathTrack* + constexpr std::ptrdiff_t m_paltpath = 0x4C0; // CPathTrack* + constexpr std::ptrdiff_t m_flRadius = 0x4C8; // float + constexpr std::ptrdiff_t m_length = 0x4CC; // float + constexpr std::ptrdiff_t m_altName = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nIterVal = 0x4D8; // int32_t + constexpr std::ptrdiff_t m_eOrientationType = 0x4DC; // TrackOrientationType_t + constexpr std::ptrdiff_t m_OnPass = 0x4E0; // CEntityIOOutput +} + +namespace CPhysBallSocket { // CPhysConstraint + constexpr std::ptrdiff_t m_flFriction = 0x508; // float + constexpr std::ptrdiff_t m_bEnableSwingLimit = 0x50C; // bool + constexpr std::ptrdiff_t m_flSwingLimit = 0x510; // float + constexpr std::ptrdiff_t m_bEnableTwistLimit = 0x514; // bool + constexpr std::ptrdiff_t m_flMinTwistAngle = 0x518; // float + constexpr std::ptrdiff_t m_flMaxTwistAngle = 0x51C; // float +} + +namespace CPhysBox { // CBreakable + constexpr std::ptrdiff_t m_damageType = 0x7C0; // int32_t + constexpr std::ptrdiff_t m_massScale = 0x7C4; // float + constexpr std::ptrdiff_t m_damageToEnableMotion = 0x7C8; // int32_t + constexpr std::ptrdiff_t m_flForceToEnableMotion = 0x7CC; // float + constexpr std::ptrdiff_t m_angPreferredCarryAngles = 0x7D0; // QAngle + constexpr std::ptrdiff_t m_bNotSolidToWorld = 0x7DC; // bool + constexpr std::ptrdiff_t m_bEnableUseOutput = 0x7DD; // bool + constexpr std::ptrdiff_t m_iExploitableByPlayer = 0x7E0; // int32_t + constexpr std::ptrdiff_t m_flTouchOutputPerEntityDelay = 0x7E4; // float + constexpr std::ptrdiff_t m_OnDamaged = 0x7E8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAwakened = 0x810; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMotionEnabled = 0x838; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPlayerUse = 0x860; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnStartTouch = 0x888; // CEntityIOOutput + constexpr std::ptrdiff_t m_hCarryingPlayer = 0x8B0; // CHandle +} + +namespace CPhysConstraint { // CLogicalEntity + constexpr std::ptrdiff_t m_nameAttach1 = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nameAttach2 = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_breakSound = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_forceLimit = 0x4D0; // float + constexpr std::ptrdiff_t m_torqueLimit = 0x4D4; // float + constexpr std::ptrdiff_t m_teleportTick = 0x4D8; // uint32_t + constexpr std::ptrdiff_t m_minTeleportDistance = 0x4DC; // float + constexpr std::ptrdiff_t m_OnBreak = 0x4E0; // CEntityIOOutput +} + +namespace CPhysExplosion { // CPointEntity + constexpr std::ptrdiff_t m_bExplodeOnSpawn = 0x4B0; // bool + constexpr std::ptrdiff_t m_flMagnitude = 0x4B4; // float + constexpr std::ptrdiff_t m_flDamage = 0x4B8; // float + constexpr std::ptrdiff_t m_radius = 0x4BC; // float + constexpr std::ptrdiff_t m_targetEntityName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flInnerRadius = 0x4C8; // float + constexpr std::ptrdiff_t m_flPushScale = 0x4CC; // float + constexpr std::ptrdiff_t m_bConvertToDebrisWhenPossible = 0x4D0; // bool + constexpr std::ptrdiff_t m_OnPushedPlayer = 0x4D8; // CEntityIOOutput +} + +namespace CPhysFixed { // CPhysConstraint + constexpr std::ptrdiff_t m_flLinearFrequency = 0x508; // float + constexpr std::ptrdiff_t m_flLinearDampingRatio = 0x50C; // float + constexpr std::ptrdiff_t m_flAngularFrequency = 0x510; // float + constexpr std::ptrdiff_t m_flAngularDampingRatio = 0x514; // float + constexpr std::ptrdiff_t m_bEnableLinearConstraint = 0x518; // bool + constexpr std::ptrdiff_t m_bEnableAngularConstraint = 0x519; // bool +} + +namespace CPhysForce { // CPointEntity + constexpr std::ptrdiff_t m_nameAttach = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_force = 0x4C0; // float + constexpr std::ptrdiff_t m_forceTime = 0x4C4; // float + constexpr std::ptrdiff_t m_attachedObject = 0x4C8; // CHandle + constexpr std::ptrdiff_t m_wasRestored = 0x4CC; // bool + constexpr std::ptrdiff_t m_integrator = 0x4D0; // CConstantForceController +} + +namespace CPhysHinge { // CPhysConstraint + constexpr std::ptrdiff_t m_soundInfo = 0x510; // ConstraintSoundInfo + constexpr std::ptrdiff_t m_NotifyMinLimitReached = 0x598; // CEntityIOOutput + constexpr std::ptrdiff_t m_NotifyMaxLimitReached = 0x5C0; // CEntityIOOutput + constexpr std::ptrdiff_t m_bAtMinLimit = 0x5E8; // bool + constexpr std::ptrdiff_t m_bAtMaxLimit = 0x5E9; // bool + constexpr std::ptrdiff_t m_hinge = 0x5EC; // constraint_hingeparams_t + constexpr std::ptrdiff_t m_hingeFriction = 0x62C; // float + constexpr std::ptrdiff_t m_systemLoadScale = 0x630; // float + constexpr std::ptrdiff_t m_bIsAxisLocal = 0x634; // bool + constexpr std::ptrdiff_t m_flMinRotation = 0x638; // float + constexpr std::ptrdiff_t m_flMaxRotation = 0x63C; // float + constexpr std::ptrdiff_t m_flInitialRotation = 0x640; // float + constexpr std::ptrdiff_t m_flMotorFrequency = 0x644; // float + constexpr std::ptrdiff_t m_flMotorDampingRatio = 0x648; // float + constexpr std::ptrdiff_t m_flAngleSpeed = 0x64C; // float + constexpr std::ptrdiff_t m_flAngleSpeedThreshold = 0x650; // float + constexpr std::ptrdiff_t m_OnStartMoving = 0x658; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnStopMoving = 0x680; // CEntityIOOutput +} + +namespace CPhysHingeAlias_phys_hinge_local { // CPhysHinge +} + +namespace CPhysImpact { // CPointEntity + constexpr std::ptrdiff_t m_damage = 0x4B0; // float + constexpr std::ptrdiff_t m_distance = 0x4B4; // float + constexpr std::ptrdiff_t m_directionEntityName = 0x4B8; // CUtlSymbolLarge +} + +namespace CPhysLength { // CPhysConstraint + constexpr std::ptrdiff_t m_offset = 0x508; // Vector[2] + constexpr std::ptrdiff_t m_vecAttach = 0x520; // Vector + constexpr std::ptrdiff_t m_addLength = 0x52C; // float + constexpr std::ptrdiff_t m_minLength = 0x530; // float + constexpr std::ptrdiff_t m_totalLength = 0x534; // float + constexpr std::ptrdiff_t m_bEnableCollision = 0x538; // bool +} + +namespace CPhysMagnet { // CBaseAnimGraph + constexpr std::ptrdiff_t m_OnMagnetAttach = 0x890; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnMagnetDetach = 0x8B8; // CEntityIOOutput + constexpr std::ptrdiff_t m_massScale = 0x8E0; // float + constexpr std::ptrdiff_t m_forceLimit = 0x8E4; // float + constexpr std::ptrdiff_t m_torqueLimit = 0x8E8; // float + constexpr std::ptrdiff_t m_MagnettedEntities = 0x8F0; // CUtlVector + constexpr std::ptrdiff_t m_bActive = 0x908; // bool + constexpr std::ptrdiff_t m_bHasHitSomething = 0x909; // bool + constexpr std::ptrdiff_t m_flTotalMass = 0x90C; // float + constexpr std::ptrdiff_t m_flRadius = 0x910; // float + constexpr std::ptrdiff_t m_flNextSuckTime = 0x914; // GameTime_t + constexpr std::ptrdiff_t m_iMaxObjectsAttached = 0x918; // int32_t +} + +namespace CPhysMotor { // CLogicalEntity + constexpr std::ptrdiff_t m_nameAttach = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hAttachedObject = 0x4B8; // CHandle + constexpr std::ptrdiff_t m_spinUp = 0x4BC; // float + constexpr std::ptrdiff_t m_additionalAcceleration = 0x4C0; // float + constexpr std::ptrdiff_t m_angularAcceleration = 0x4C4; // float + constexpr std::ptrdiff_t m_lastTime = 0x4C8; // GameTime_t + constexpr std::ptrdiff_t m_motor = 0x4E0; // CMotorController +} + +namespace CPhysPulley { // CPhysConstraint + constexpr std::ptrdiff_t m_position2 = 0x508; // Vector + constexpr std::ptrdiff_t m_offset = 0x514; // Vector[2] + constexpr std::ptrdiff_t m_addLength = 0x52C; // float + constexpr std::ptrdiff_t m_gearRatio = 0x530; // float +} + +namespace CPhysSlideConstraint { // CPhysConstraint + constexpr std::ptrdiff_t m_axisEnd = 0x510; // Vector + constexpr std::ptrdiff_t m_slideFriction = 0x51C; // float + constexpr std::ptrdiff_t m_systemLoadScale = 0x520; // float + constexpr std::ptrdiff_t m_initialOffset = 0x524; // float + constexpr std::ptrdiff_t m_bEnableLinearConstraint = 0x528; // bool + constexpr std::ptrdiff_t m_bEnableAngularConstraint = 0x529; // bool + constexpr std::ptrdiff_t m_flMotorFrequency = 0x52C; // float + constexpr std::ptrdiff_t m_flMotorDampingRatio = 0x530; // float + constexpr std::ptrdiff_t m_bUseEntityPivot = 0x534; // bool + constexpr std::ptrdiff_t m_soundInfo = 0x538; // ConstraintSoundInfo +} + +namespace CPhysThruster { // CPhysForce + constexpr std::ptrdiff_t m_localOrigin = 0x510; // Vector +} + +namespace CPhysTorque { // CPhysForce + constexpr std::ptrdiff_t m_axis = 0x510; // Vector +} + +namespace CPhysWheelConstraint { // CPhysConstraint + constexpr std::ptrdiff_t m_flSuspensionFrequency = 0x508; // float + constexpr std::ptrdiff_t m_flSuspensionDampingRatio = 0x50C; // float + constexpr std::ptrdiff_t m_flSuspensionHeightOffset = 0x510; // float + constexpr std::ptrdiff_t m_bEnableSuspensionLimit = 0x514; // bool + constexpr std::ptrdiff_t m_flMinSuspensionOffset = 0x518; // float + constexpr std::ptrdiff_t m_flMaxSuspensionOffset = 0x51C; // float + constexpr std::ptrdiff_t m_bEnableSteeringLimit = 0x520; // bool + constexpr std::ptrdiff_t m_flMinSteeringAngle = 0x524; // float + constexpr std::ptrdiff_t m_flMaxSteeringAngle = 0x528; // float + constexpr std::ptrdiff_t m_flSteeringAxisFriction = 0x52C; // float + constexpr std::ptrdiff_t m_flSpinAxisFriction = 0x530; // float +} + +namespace CPhysicalButton { // CBaseButton +} + +namespace CPhysicsEntitySolver { // CLogicalEntity + constexpr std::ptrdiff_t m_hMovingEntity = 0x4B8; // CHandle + constexpr std::ptrdiff_t m_hPhysicsBlocker = 0x4BC; // CHandle + constexpr std::ptrdiff_t m_separationDuration = 0x4C0; // float + constexpr std::ptrdiff_t m_cancelTime = 0x4C4; // GameTime_t +} + +namespace CPhysicsProp { // CBreakableProp + constexpr std::ptrdiff_t m_MotionEnabled = 0xA10; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAwakened = 0xA38; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAwake = 0xA60; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnAsleep = 0xA88; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPlayerUse = 0xAB0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPlayerPickup = 0xAD8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnOutOfWorld = 0xB00; // CEntityIOOutput + constexpr std::ptrdiff_t m_massScale = 0xB28; // float + constexpr std::ptrdiff_t m_inertiaScale = 0xB2C; // float + constexpr std::ptrdiff_t m_buoyancyScale = 0xB30; // float + constexpr std::ptrdiff_t m_damageType = 0xB34; // int32_t + constexpr std::ptrdiff_t m_damageToEnableMotion = 0xB38; // int32_t + constexpr std::ptrdiff_t m_flForceToEnableMotion = 0xB3C; // float + constexpr std::ptrdiff_t m_bThrownByPlayer = 0xB40; // bool + constexpr std::ptrdiff_t m_bDroppedByPlayer = 0xB41; // bool + constexpr std::ptrdiff_t m_bTouchedByPlayer = 0xB42; // bool + constexpr std::ptrdiff_t m_bFirstCollisionAfterLaunch = 0xB43; // bool + constexpr std::ptrdiff_t m_iExploitableByPlayer = 0xB44; // int32_t + constexpr std::ptrdiff_t m_bHasBeenAwakened = 0xB48; // bool + constexpr std::ptrdiff_t m_bIsOverrideProp = 0xB49; // bool + constexpr std::ptrdiff_t m_fNextCheckDisableMotionContactsTime = 0xB4C; // GameTime_t + constexpr std::ptrdiff_t m_iInitialGlowState = 0xB50; // int32_t + constexpr std::ptrdiff_t m_nGlowRange = 0xB54; // int32_t + constexpr std::ptrdiff_t m_nGlowRangeMin = 0xB58; // int32_t + constexpr std::ptrdiff_t m_glowColor = 0xB5C; // Color + constexpr std::ptrdiff_t m_bForceNavIgnore = 0xB60; // bool + constexpr std::ptrdiff_t m_bNoNavmeshBlocker = 0xB61; // bool + constexpr std::ptrdiff_t m_bForceNpcExclude = 0xB62; // bool + constexpr std::ptrdiff_t m_bShouldAutoConvertBackFromDebris = 0xB63; // bool + constexpr std::ptrdiff_t m_bMuteImpactEffects = 0xB64; // bool + constexpr std::ptrdiff_t m_bAcceptDamageFromHeldObjects = 0xB6C; // bool + constexpr std::ptrdiff_t m_bEnableUseOutput = 0xB6D; // bool + constexpr std::ptrdiff_t m_bAwake = 0xB6E; // bool + constexpr std::ptrdiff_t m_nCollisionGroupOverride = 0xB70; // int32_t +} + +namespace CPhysicsPropMultiplayer { // CPhysicsProp +} + +namespace CPhysicsPropOverride { // CPhysicsProp +} + +namespace CPhysicsPropRespawnable { // CPhysicsProp + constexpr std::ptrdiff_t m_vOriginalSpawnOrigin = 0xB78; // Vector + constexpr std::ptrdiff_t m_vOriginalSpawnAngles = 0xB84; // QAngle + constexpr std::ptrdiff_t m_vOriginalMins = 0xB90; // Vector + constexpr std::ptrdiff_t m_vOriginalMaxs = 0xB9C; // Vector + constexpr std::ptrdiff_t m_flRespawnDuration = 0xBA8; // float +} + +namespace CPhysicsShake { + constexpr std::ptrdiff_t m_force = 0x8; // Vector +} + +namespace CPhysicsSpring { // CBaseEntity + constexpr std::ptrdiff_t m_flFrequency = 0x4B8; // float + constexpr std::ptrdiff_t m_flDampingRatio = 0x4BC; // float + constexpr std::ptrdiff_t m_flRestLength = 0x4C0; // float + constexpr std::ptrdiff_t m_nameAttachStart = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nameAttachEnd = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_start = 0x4D8; // Vector + constexpr std::ptrdiff_t m_end = 0x4E4; // Vector + constexpr std::ptrdiff_t m_teleportTick = 0x4F0; // uint32_t +} + +namespace CPhysicsWire { // CBaseEntity + constexpr std::ptrdiff_t m_nDensity = 0x4B0; // int32_t +} + +namespace CPlantedC4 { // CBaseAnimGraph + constexpr std::ptrdiff_t m_bBombTicking = 0x890; // bool + constexpr std::ptrdiff_t m_flC4Blow = 0x894; // GameTime_t + constexpr std::ptrdiff_t m_nBombSite = 0x898; // int32_t + constexpr std::ptrdiff_t m_nSourceSoundscapeHash = 0x89C; // int32_t + constexpr std::ptrdiff_t m_OnBombDefused = 0x8A0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnBombBeginDefuse = 0x8C8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnBombDefuseAborted = 0x8F0; // CEntityIOOutput + constexpr std::ptrdiff_t m_bCannotBeDefused = 0x918; // bool + constexpr std::ptrdiff_t m_entitySpottedState = 0x920; // EntitySpottedState_t + constexpr std::ptrdiff_t m_nSpotRules = 0x938; // int32_t + constexpr std::ptrdiff_t m_bTrainingPlacedByPlayer = 0x93C; // bool + constexpr std::ptrdiff_t m_bHasExploded = 0x93D; // bool + constexpr std::ptrdiff_t m_flTimerLength = 0x940; // float + constexpr std::ptrdiff_t m_bBeingDefused = 0x944; // bool + constexpr std::ptrdiff_t m_fLastDefuseTime = 0x94C; // GameTime_t + constexpr std::ptrdiff_t m_flDefuseLength = 0x954; // float + constexpr std::ptrdiff_t m_flDefuseCountDown = 0x958; // GameTime_t + constexpr std::ptrdiff_t m_bBombDefused = 0x95C; // bool + constexpr std::ptrdiff_t m_hBombDefuser = 0x960; // CHandle + constexpr std::ptrdiff_t m_hControlPanel = 0x964; // CHandle + constexpr std::ptrdiff_t m_iProgressBarTime = 0x968; // int32_t + constexpr std::ptrdiff_t m_bVoiceAlertFired = 0x96C; // bool + constexpr std::ptrdiff_t m_bVoiceAlertPlayed = 0x96D; // bool[4] + constexpr std::ptrdiff_t m_flNextBotBeepTime = 0x974; // GameTime_t + constexpr std::ptrdiff_t m_bPlantedAfterPickup = 0x97C; // bool + constexpr std::ptrdiff_t m_angCatchUpToPlayerEye = 0x980; // QAngle + constexpr std::ptrdiff_t m_flLastSpinDetectionTime = 0x98C; // GameTime_t +} + +namespace CPlatTrigger { // CBaseModelEntity + constexpr std::ptrdiff_t m_pPlatform = 0x700; // CHandle +} + +namespace CPlayerControllerComponent { + constexpr std::ptrdiff_t __m_pChainEntity = 0x8; // CNetworkVarChainer +} + +namespace CPlayerPawnComponent { + constexpr std::ptrdiff_t __m_pChainEntity = 0x8; // CNetworkVarChainer +} + +namespace CPlayerPing { // CBaseEntity + constexpr std::ptrdiff_t m_hPlayer = 0x4B8; // CHandle + constexpr std::ptrdiff_t m_hPingedEntity = 0x4BC; // CHandle + constexpr std::ptrdiff_t m_iType = 0x4C0; // int32_t + constexpr std::ptrdiff_t m_bUrgent = 0x4C4; // bool + constexpr std::ptrdiff_t m_szPlaceName = 0x4C5; // char[18] +} + +namespace CPlayerSprayDecal { // CModelPointEntity + constexpr std::ptrdiff_t m_nUniqueID = 0x700; // int32_t + constexpr std::ptrdiff_t m_unAccountID = 0x704; // uint32_t + constexpr std::ptrdiff_t m_unTraceID = 0x708; // uint32_t + constexpr std::ptrdiff_t m_rtGcTime = 0x70C; // uint32_t + constexpr std::ptrdiff_t m_vecEndPos = 0x710; // Vector + constexpr std::ptrdiff_t m_vecStart = 0x71C; // Vector + constexpr std::ptrdiff_t m_vecLeft = 0x728; // Vector + constexpr std::ptrdiff_t m_vecNormal = 0x734; // Vector + constexpr std::ptrdiff_t m_nPlayer = 0x740; // int32_t + constexpr std::ptrdiff_t m_nEntity = 0x744; // int32_t + constexpr std::ptrdiff_t m_nHitbox = 0x748; // int32_t + constexpr std::ptrdiff_t m_flCreationTime = 0x74C; // float + constexpr std::ptrdiff_t m_nTintID = 0x750; // int32_t + constexpr std::ptrdiff_t m_nVersion = 0x754; // uint8_t + constexpr std::ptrdiff_t m_ubSignature = 0x755; // uint8_t[128] +} + +namespace CPlayerVisibility { // CBaseEntity + constexpr std::ptrdiff_t m_flVisibilityStrength = 0x4B0; // float + constexpr std::ptrdiff_t m_flFogDistanceMultiplier = 0x4B4; // float + constexpr std::ptrdiff_t m_flFogMaxDensityMultiplier = 0x4B8; // float + constexpr std::ptrdiff_t m_flFadeTime = 0x4BC; // float + constexpr std::ptrdiff_t m_bStartDisabled = 0x4C0; // bool + constexpr std::ptrdiff_t m_bIsEnabled = 0x4C1; // bool +} + +namespace CPlayer_AutoaimServices { // CPlayerPawnComponent +} + +namespace CPlayer_CameraServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_vecCsViewPunchAngle = 0x40; // QAngle + constexpr std::ptrdiff_t m_nCsViewPunchAngleTick = 0x4C; // GameTick_t + constexpr std::ptrdiff_t m_flCsViewPunchAngleTickRatio = 0x50; // float + constexpr std::ptrdiff_t m_PlayerFog = 0x58; // fogplayerparams_t + constexpr std::ptrdiff_t m_hColorCorrectionCtrl = 0x98; // CHandle + constexpr std::ptrdiff_t m_hViewEntity = 0x9C; // CHandle + constexpr std::ptrdiff_t m_hTonemapController = 0xA0; // CHandle + constexpr std::ptrdiff_t m_audio = 0xA8; // audioparams_t + constexpr std::ptrdiff_t m_PostProcessingVolumes = 0x120; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_flOldPlayerZ = 0x138; // float + constexpr std::ptrdiff_t m_flOldPlayerViewOffsetZ = 0x13C; // float + constexpr std::ptrdiff_t m_hTriggerSoundscapeList = 0x158; // CUtlVector> +} + +namespace CPlayer_FlashlightServices { // CPlayerPawnComponent +} + +namespace CPlayer_ItemServices { // CPlayerPawnComponent +} + +namespace CPlayer_MovementServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_nImpulse = 0x40; // int32_t + constexpr std::ptrdiff_t m_nButtons = 0x48; // CInButtonState + constexpr std::ptrdiff_t m_nQueuedButtonDownMask = 0x68; // uint64_t + constexpr std::ptrdiff_t m_nQueuedButtonChangeMask = 0x70; // uint64_t + constexpr std::ptrdiff_t m_nButtonDoublePressed = 0x78; // uint64_t + constexpr std::ptrdiff_t m_pButtonPressedCmdNumber = 0x80; // uint32_t[64] + constexpr std::ptrdiff_t m_nLastCommandNumberProcessed = 0x180; // uint32_t + constexpr std::ptrdiff_t m_nToggleButtonDownMask = 0x188; // uint64_t + constexpr std::ptrdiff_t m_flMaxspeed = 0x190; // float + constexpr std::ptrdiff_t m_arrForceSubtickMoveWhen = 0x194; // float[4] + constexpr std::ptrdiff_t m_flForwardMove = 0x1A4; // float + constexpr std::ptrdiff_t m_flLeftMove = 0x1A8; // float + constexpr std::ptrdiff_t m_flUpMove = 0x1AC; // float + constexpr std::ptrdiff_t m_vecLastMovementImpulses = 0x1B0; // Vector + constexpr std::ptrdiff_t m_vecOldViewAngles = 0x1BC; // QAngle +} + +namespace CPlayer_MovementServices_Humanoid { // CPlayer_MovementServices + constexpr std::ptrdiff_t m_flStepSoundTime = 0x1D0; // float + constexpr std::ptrdiff_t m_flFallVelocity = 0x1D4; // float + constexpr std::ptrdiff_t m_bInCrouch = 0x1D8; // bool + constexpr std::ptrdiff_t m_nCrouchState = 0x1DC; // uint32_t + constexpr std::ptrdiff_t m_flCrouchTransitionStartTime = 0x1E0; // GameTime_t + constexpr std::ptrdiff_t m_bDucked = 0x1E4; // bool + constexpr std::ptrdiff_t m_bDucking = 0x1E5; // bool + constexpr std::ptrdiff_t m_bInDuckJump = 0x1E6; // bool + constexpr std::ptrdiff_t m_groundNormal = 0x1E8; // Vector + constexpr std::ptrdiff_t m_flSurfaceFriction = 0x1F4; // float + constexpr std::ptrdiff_t m_surfaceProps = 0x1F8; // CUtlStringToken + constexpr std::ptrdiff_t m_nStepside = 0x208; // int32_t + constexpr std::ptrdiff_t m_iTargetVolume = 0x20C; // int32_t + constexpr std::ptrdiff_t m_vecSmoothedVelocity = 0x210; // Vector +} + +namespace CPlayer_ObserverServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_iObserverMode = 0x40; // uint8_t + constexpr std::ptrdiff_t m_hObserverTarget = 0x44; // CHandle + constexpr std::ptrdiff_t m_iObserverLastMode = 0x48; // ObserverMode_t + constexpr std::ptrdiff_t m_bForcedObserverMode = 0x4C; // bool +} + +namespace CPlayer_UseServices { // CPlayerPawnComponent +} + +namespace CPlayer_ViewModelServices { // CPlayerPawnComponent +} + +namespace CPlayer_WaterServices { // CPlayerPawnComponent +} + +namespace CPlayer_WeaponServices { // CPlayerPawnComponent + constexpr std::ptrdiff_t m_bAllowSwitchToNoWeapon = 0x40; // bool + constexpr std::ptrdiff_t m_hMyWeapons = 0x48; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_hActiveWeapon = 0x60; // CHandle + constexpr std::ptrdiff_t m_hLastWeapon = 0x64; // CHandle + constexpr std::ptrdiff_t m_iAmmo = 0x68; // uint16_t[32] + constexpr std::ptrdiff_t m_bPreventWeaponPickup = 0xA8; // bool +} + +namespace CPointAngleSensor { // CPointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_nLookAtName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hTargetEntity = 0x4C0; // CHandle + constexpr std::ptrdiff_t m_hLookAtEntity = 0x4C4; // CHandle + constexpr std::ptrdiff_t m_flDuration = 0x4C8; // float + constexpr std::ptrdiff_t m_flDotTolerance = 0x4CC; // float + constexpr std::ptrdiff_t m_flFacingTime = 0x4D0; // GameTime_t + constexpr std::ptrdiff_t m_bFired = 0x4D4; // bool + constexpr std::ptrdiff_t m_OnFacingLookat = 0x4D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnNotFacingLookat = 0x500; // CEntityIOOutput + constexpr std::ptrdiff_t m_TargetDir = 0x528; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_FacingPercentage = 0x550; // CEntityOutputTemplate +} + +namespace CPointAngularVelocitySensor { // CPointEntity + constexpr std::ptrdiff_t m_hTargetEntity = 0x4B0; // CHandle + constexpr std::ptrdiff_t m_flThreshold = 0x4B4; // float + constexpr std::ptrdiff_t m_nLastCompareResult = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_nLastFireResult = 0x4BC; // int32_t + constexpr std::ptrdiff_t m_flFireTime = 0x4C0; // GameTime_t + constexpr std::ptrdiff_t m_flFireInterval = 0x4C4; // float + constexpr std::ptrdiff_t m_flLastAngVelocity = 0x4C8; // float + constexpr std::ptrdiff_t m_lastOrientation = 0x4CC; // QAngle + constexpr std::ptrdiff_t m_vecAxis = 0x4D8; // Vector + constexpr std::ptrdiff_t m_bUseHelper = 0x4E4; // bool + constexpr std::ptrdiff_t m_AngularVelocity = 0x4E8; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnLessThan = 0x510; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnLessThanOrEqualTo = 0x538; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnGreaterThan = 0x560; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnGreaterThanOrEqualTo = 0x588; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnEqualTo = 0x5B0; // CEntityIOOutput +} + +namespace CPointBroadcastClientCommand { // CPointEntity +} + +namespace CPointCamera { // CBaseEntity + constexpr std::ptrdiff_t m_FOV = 0x4B0; // float + constexpr std::ptrdiff_t m_Resolution = 0x4B4; // float + constexpr std::ptrdiff_t m_bFogEnable = 0x4B8; // bool + constexpr std::ptrdiff_t m_FogColor = 0x4B9; // Color + constexpr std::ptrdiff_t m_flFogStart = 0x4C0; // float + constexpr std::ptrdiff_t m_flFogEnd = 0x4C4; // float + constexpr std::ptrdiff_t m_flFogMaxDensity = 0x4C8; // float + constexpr std::ptrdiff_t m_bActive = 0x4CC; // bool + constexpr std::ptrdiff_t m_bUseScreenAspectRatio = 0x4CD; // bool + constexpr std::ptrdiff_t m_flAspectRatio = 0x4D0; // float + constexpr std::ptrdiff_t m_bNoSky = 0x4D4; // bool + constexpr std::ptrdiff_t m_fBrightness = 0x4D8; // float + constexpr std::ptrdiff_t m_flZFar = 0x4DC; // float + constexpr std::ptrdiff_t m_flZNear = 0x4E0; // float + constexpr std::ptrdiff_t m_bCanHLTVUse = 0x4E4; // bool + constexpr std::ptrdiff_t m_bDofEnabled = 0x4E5; // bool + constexpr std::ptrdiff_t m_flDofNearBlurry = 0x4E8; // float + constexpr std::ptrdiff_t m_flDofNearCrisp = 0x4EC; // float + constexpr std::ptrdiff_t m_flDofFarCrisp = 0x4F0; // float + constexpr std::ptrdiff_t m_flDofFarBlurry = 0x4F4; // float + constexpr std::ptrdiff_t m_flDofTiltToGround = 0x4F8; // float + constexpr std::ptrdiff_t m_TargetFOV = 0x4FC; // float + constexpr std::ptrdiff_t m_DegreesPerSecond = 0x500; // float + constexpr std::ptrdiff_t m_bIsOn = 0x504; // bool + constexpr std::ptrdiff_t m_pNext = 0x508; // CPointCamera* +} + +namespace CPointCameraVFOV { // CPointCamera + constexpr std::ptrdiff_t m_flVerticalFOV = 0x510; // float +} + +namespace CPointClientCommand { // CPointEntity +} + +namespace CPointClientUIDialog { // CBaseClientUIEntity + constexpr std::ptrdiff_t m_hActivator = 0x8B0; // CHandle + constexpr std::ptrdiff_t m_bStartEnabled = 0x8B4; // bool +} + +namespace CPointClientUIWorldPanel { // CBaseClientUIEntity + constexpr std::ptrdiff_t m_bIgnoreInput = 0x8B0; // bool + constexpr std::ptrdiff_t m_bLit = 0x8B1; // bool + constexpr std::ptrdiff_t m_bFollowPlayerAcrossTeleport = 0x8B2; // bool + constexpr std::ptrdiff_t m_flWidth = 0x8B4; // float + constexpr std::ptrdiff_t m_flHeight = 0x8B8; // float + constexpr std::ptrdiff_t m_flDPI = 0x8BC; // float + constexpr std::ptrdiff_t m_flInteractDistance = 0x8C0; // float + constexpr std::ptrdiff_t m_flDepthOffset = 0x8C4; // float + constexpr std::ptrdiff_t m_unOwnerContext = 0x8C8; // uint32_t + constexpr std::ptrdiff_t m_unHorizontalAlign = 0x8CC; // uint32_t + constexpr std::ptrdiff_t m_unVerticalAlign = 0x8D0; // uint32_t + constexpr std::ptrdiff_t m_unOrientation = 0x8D4; // uint32_t + constexpr std::ptrdiff_t m_bAllowInteractionFromAllSceneWorlds = 0x8D8; // bool + constexpr std::ptrdiff_t m_vecCSSClasses = 0x8E0; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_bOpaque = 0x8F8; // bool + constexpr std::ptrdiff_t m_bNoDepth = 0x8F9; // bool + constexpr std::ptrdiff_t m_bRenderBackface = 0x8FA; // bool + constexpr std::ptrdiff_t m_bUseOffScreenIndicator = 0x8FB; // bool + constexpr std::ptrdiff_t m_bExcludeFromSaveGames = 0x8FC; // bool + constexpr std::ptrdiff_t m_bGrabbable = 0x8FD; // bool + constexpr std::ptrdiff_t m_bOnlyRenderToTexture = 0x8FE; // bool + constexpr std::ptrdiff_t m_bDisableMipGen = 0x8FF; // bool + constexpr std::ptrdiff_t m_nExplicitImageLayout = 0x900; // int32_t +} + +namespace CPointClientUIWorldTextPanel { // CPointClientUIWorldPanel + constexpr std::ptrdiff_t m_messageText = 0x908; // char[512] +} + +namespace CPointCommentaryNode { // CBaseAnimGraph + constexpr std::ptrdiff_t m_iszPreCommands = 0x890; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszPostCommands = 0x898; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszCommentaryFile = 0x8A0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszViewTarget = 0x8A8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hViewTarget = 0x8B0; // CHandle + constexpr std::ptrdiff_t m_hViewTargetAngles = 0x8B4; // CHandle + constexpr std::ptrdiff_t m_iszViewPosition = 0x8B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hViewPosition = 0x8C0; // CHandle + constexpr std::ptrdiff_t m_hViewPositionMover = 0x8C4; // CHandle + constexpr std::ptrdiff_t m_bPreventMovement = 0x8C8; // bool + constexpr std::ptrdiff_t m_bUnderCrosshair = 0x8C9; // bool + constexpr std::ptrdiff_t m_bUnstoppable = 0x8CA; // bool + constexpr std::ptrdiff_t m_flFinishedTime = 0x8CC; // GameTime_t + constexpr std::ptrdiff_t m_vecFinishOrigin = 0x8D0; // Vector + constexpr std::ptrdiff_t m_vecOriginalAngles = 0x8DC; // QAngle + constexpr std::ptrdiff_t m_vecFinishAngles = 0x8E8; // QAngle + constexpr std::ptrdiff_t m_bPreventChangesWhileMoving = 0x8F4; // bool + constexpr std::ptrdiff_t m_bDisabled = 0x8F5; // bool + constexpr std::ptrdiff_t m_vecTeleportOrigin = 0x8F8; // Vector + constexpr std::ptrdiff_t m_flAbortedPlaybackAt = 0x904; // GameTime_t + constexpr std::ptrdiff_t m_pOnCommentaryStarted = 0x908; // CEntityIOOutput + constexpr std::ptrdiff_t m_pOnCommentaryStopped = 0x930; // CEntityIOOutput + constexpr std::ptrdiff_t m_bActive = 0x958; // bool + constexpr std::ptrdiff_t m_flStartTime = 0x95C; // GameTime_t + constexpr std::ptrdiff_t m_flStartTimeInCommentary = 0x960; // float + constexpr std::ptrdiff_t m_iszTitle = 0x968; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSpeakers = 0x970; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iNodeNumber = 0x978; // int32_t + constexpr std::ptrdiff_t m_iNodeNumberMax = 0x97C; // int32_t + constexpr std::ptrdiff_t m_bListenedTo = 0x980; // bool +} + +namespace CPointEntity { // CBaseEntity +} + +namespace CPointEntityFinder { // CBaseEntity + constexpr std::ptrdiff_t m_hEntity = 0x4B0; // CHandle + constexpr std::ptrdiff_t m_iFilterName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFilter = 0x4C0; // CHandle + constexpr std::ptrdiff_t m_iRefName = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hReference = 0x4D0; // CHandle + constexpr std::ptrdiff_t m_FindMethod = 0x4D4; // EntFinderMethod_t + constexpr std::ptrdiff_t m_OnFoundEntity = 0x4D8; // CEntityIOOutput +} + +namespace CPointGamestatsCounter { // CPointEntity + constexpr std::ptrdiff_t m_strStatisticName = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bDisabled = 0x4B8; // bool +} + +namespace CPointGiveAmmo { // CPointEntity + constexpr std::ptrdiff_t m_pActivator = 0x4B0; // CHandle +} + +namespace CPointHurt { // CPointEntity + constexpr std::ptrdiff_t m_nDamage = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_bitsDamageType = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_flRadius = 0x4B8; // float + constexpr std::ptrdiff_t m_flDelay = 0x4BC; // float + constexpr std::ptrdiff_t m_strTarget = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pActivator = 0x4C8; // CHandle +} + +namespace CPointPrefab { // CServerOnlyPointEntity + constexpr std::ptrdiff_t m_targetMapName = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_forceWorldGroupID = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_associatedRelayTargetName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_fixupNames = 0x4C8; // bool + constexpr std::ptrdiff_t m_bLoadDynamic = 0x4C9; // bool + constexpr std::ptrdiff_t m_associatedRelayEntity = 0x4CC; // CHandle +} + +namespace CPointProximitySensor { // CPointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_hTargetEntity = 0x4B4; // CHandle + constexpr std::ptrdiff_t m_Distance = 0x4B8; // CEntityOutputTemplate +} + +namespace CPointPulse { // CBaseEntity + constexpr std::ptrdiff_t m_sNameFixupStaticPrefix = 0x5C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sNameFixupParent = 0x5D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_sNameFixupLocal = 0x5D8; // CUtlSymbolLarge +} + +namespace CPointPush { // CPointEntity + constexpr std::ptrdiff_t m_bEnabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_flMagnitude = 0x4B4; // float + constexpr std::ptrdiff_t m_flRadius = 0x4B8; // float + constexpr std::ptrdiff_t m_flInnerRadius = 0x4BC; // float + constexpr std::ptrdiff_t m_flConeOfInfluence = 0x4C0; // float + constexpr std::ptrdiff_t m_iszFilterName = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFilter = 0x4D0; // CHandle +} + +namespace CPointScript { // CBaseEntity +} + +namespace CPointServerCommand { // CPointEntity +} + +namespace CPointTeleport { // CServerOnlyPointEntity + constexpr std::ptrdiff_t m_vSaveOrigin = 0x4B0; // Vector + constexpr std::ptrdiff_t m_vSaveAngles = 0x4BC; // QAngle + constexpr std::ptrdiff_t m_bTeleportParentedEntities = 0x4C8; // bool + constexpr std::ptrdiff_t m_bTeleportUseCurrentAngle = 0x4C9; // bool +} + +namespace CPointTemplate { // CLogicalEntity + constexpr std::ptrdiff_t m_iszWorldName = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSource2EntityLumpName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszEntityFilterName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flTimeoutInterval = 0x4C8; // float + constexpr std::ptrdiff_t m_bAsynchronouslySpawnEntities = 0x4CC; // bool + constexpr std::ptrdiff_t m_pOutputOnSpawned = 0x4D0; // CEntityIOOutput + constexpr std::ptrdiff_t m_clientOnlyEntityBehavior = 0x4F8; // PointTemplateClientOnlyEntityBehavior_t + constexpr std::ptrdiff_t m_ownerSpawnGroupType = 0x4FC; // PointTemplateOwnerSpawnGroupType_t + constexpr std::ptrdiff_t m_createdSpawnGroupHandles = 0x500; // CUtlVector + constexpr std::ptrdiff_t m_SpawnedEntityHandles = 0x518; // CUtlVector + constexpr std::ptrdiff_t m_ScriptSpawnCallback = 0x530; // HSCRIPT + constexpr std::ptrdiff_t m_ScriptCallbackScope = 0x538; // HSCRIPT +} + +namespace CPointValueRemapper { // CBaseEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_bUpdateOnClient = 0x4B1; // bool + constexpr std::ptrdiff_t m_nInputType = 0x4B4; // ValueRemapperInputType_t + constexpr std::ptrdiff_t m_iszRemapLineStartName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszRemapLineEndName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hRemapLineStart = 0x4C8; // CHandle + constexpr std::ptrdiff_t m_hRemapLineEnd = 0x4CC; // CHandle + constexpr std::ptrdiff_t m_flMaximumChangePerSecond = 0x4D0; // float + constexpr std::ptrdiff_t m_flDisengageDistance = 0x4D4; // float + constexpr std::ptrdiff_t m_flEngageDistance = 0x4D8; // float + constexpr std::ptrdiff_t m_bRequiresUseKey = 0x4DC; // bool + constexpr std::ptrdiff_t m_nOutputType = 0x4E0; // ValueRemapperOutputType_t + constexpr std::ptrdiff_t m_iszOutputEntityName = 0x4E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOutputEntity2Name = 0x4F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOutputEntity3Name = 0x4F8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOutputEntity4Name = 0x500; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hOutputEntities = 0x508; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_nHapticsType = 0x520; // ValueRemapperHapticsType_t + constexpr std::ptrdiff_t m_nMomentumType = 0x524; // ValueRemapperMomentumType_t + constexpr std::ptrdiff_t m_flMomentumModifier = 0x528; // float + constexpr std::ptrdiff_t m_flSnapValue = 0x52C; // float + constexpr std::ptrdiff_t m_flCurrentMomentum = 0x530; // float + constexpr std::ptrdiff_t m_nRatchetType = 0x534; // ValueRemapperRatchetType_t + constexpr std::ptrdiff_t m_flRatchetOffset = 0x538; // float + constexpr std::ptrdiff_t m_flInputOffset = 0x53C; // float + constexpr std::ptrdiff_t m_bEngaged = 0x540; // bool + constexpr std::ptrdiff_t m_bFirstUpdate = 0x541; // bool + constexpr std::ptrdiff_t m_flPreviousValue = 0x544; // float + constexpr std::ptrdiff_t m_flPreviousUpdateTickTime = 0x548; // GameTime_t + constexpr std::ptrdiff_t m_vecPreviousTestPoint = 0x54C; // Vector + constexpr std::ptrdiff_t m_hUsingPlayer = 0x558; // CHandle + constexpr std::ptrdiff_t m_flCustomOutputValue = 0x55C; // float + constexpr std::ptrdiff_t m_iszSoundEngage = 0x560; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSoundDisengage = 0x568; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSoundReachedValueZero = 0x570; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSoundReachedValueOne = 0x578; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSoundMovingLoop = 0x580; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Position = 0x590; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_PositionDelta = 0x5B8; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_OnReachedValueZero = 0x5E0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnReachedValueOne = 0x608; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnReachedValueCustom = 0x630; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnEngage = 0x658; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnDisengage = 0x680; // CEntityIOOutput +} + +namespace CPointVelocitySensor { // CPointEntity + constexpr std::ptrdiff_t m_hTargetEntity = 0x4B0; // CHandle + constexpr std::ptrdiff_t m_vecAxis = 0x4B4; // Vector + constexpr std::ptrdiff_t m_bEnabled = 0x4C0; // bool + constexpr std::ptrdiff_t m_fPrevVelocity = 0x4C4; // float + constexpr std::ptrdiff_t m_flAvgInterval = 0x4C8; // float + constexpr std::ptrdiff_t m_Velocity = 0x4D0; // CEntityOutputTemplate +} + +namespace CPointWorldText { // CModelPointEntity + constexpr std::ptrdiff_t m_messageText = 0x700; // char[512] + constexpr std::ptrdiff_t m_FontName = 0x900; // char[64] + constexpr std::ptrdiff_t m_bEnabled = 0x940; // bool + constexpr std::ptrdiff_t m_bFullbright = 0x941; // bool + constexpr std::ptrdiff_t m_flWorldUnitsPerPx = 0x944; // float + constexpr std::ptrdiff_t m_flFontSize = 0x948; // float + constexpr std::ptrdiff_t m_flDepthOffset = 0x94C; // float + constexpr std::ptrdiff_t m_Color = 0x950; // Color + constexpr std::ptrdiff_t m_nJustifyHorizontal = 0x954; // PointWorldTextJustifyHorizontal_t + constexpr std::ptrdiff_t m_nJustifyVertical = 0x958; // PointWorldTextJustifyVertical_t + constexpr std::ptrdiff_t m_nReorientMode = 0x95C; // PointWorldTextReorientMode_t +} + +namespace CPostProcessingVolume { // CBaseTrigger + constexpr std::ptrdiff_t m_hPostSettings = 0x8B8; // CStrongHandle + constexpr std::ptrdiff_t m_flFadeDuration = 0x8C0; // float + constexpr std::ptrdiff_t m_flMinLogExposure = 0x8C4; // float + constexpr std::ptrdiff_t m_flMaxLogExposure = 0x8C8; // float + constexpr std::ptrdiff_t m_flMinExposure = 0x8CC; // float + constexpr std::ptrdiff_t m_flMaxExposure = 0x8D0; // float + constexpr std::ptrdiff_t m_flExposureCompensation = 0x8D4; // float + constexpr std::ptrdiff_t m_flExposureFadeSpeedUp = 0x8D8; // float + constexpr std::ptrdiff_t m_flExposureFadeSpeedDown = 0x8DC; // float + constexpr std::ptrdiff_t m_flTonemapEVSmoothingRange = 0x8E0; // float + constexpr std::ptrdiff_t m_bMaster = 0x8E4; // bool + constexpr std::ptrdiff_t m_bExposureControl = 0x8E5; // bool + constexpr std::ptrdiff_t m_flRate = 0x8E8; // float + constexpr std::ptrdiff_t m_flTonemapPercentTarget = 0x8EC; // float + constexpr std::ptrdiff_t m_flTonemapPercentBrightPixels = 0x8F0; // float + constexpr std::ptrdiff_t m_flTonemapMinAvgLum = 0x8F4; // float +} + +namespace CPrecipitation { // CBaseTrigger +} + +namespace CPrecipitationBlocker { // CBaseModelEntity +} + +namespace CPrecipitationVData { // CEntitySubclassVDataBase + constexpr std::ptrdiff_t m_szParticlePrecipitationEffect = 0x28; // CResourceNameTyped> + constexpr std::ptrdiff_t m_flInnerDistance = 0x108; // float + constexpr std::ptrdiff_t m_nAttachType = 0x10C; // ParticleAttachment_t + constexpr std::ptrdiff_t m_bBatchSameVolumeType = 0x110; // bool + constexpr std::ptrdiff_t m_nRTEnvCP = 0x114; // int32_t + constexpr std::ptrdiff_t m_nRTEnvCPComponent = 0x118; // int32_t + constexpr std::ptrdiff_t m_szModifier = 0x120; // CUtlString +} + +namespace CPredictedViewModel { // CBaseViewModel +} + +namespace CProjectedDecal { // CPointEntity + constexpr std::ptrdiff_t m_nTexture = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_flDistance = 0x4B4; // float +} + +namespace CPropDoorRotating { // CBasePropDoor + constexpr std::ptrdiff_t m_vecAxis = 0xD98; // Vector + constexpr std::ptrdiff_t m_flDistance = 0xDA4; // float + constexpr std::ptrdiff_t m_eSpawnPosition = 0xDA8; // PropDoorRotatingSpawnPos_t + constexpr std::ptrdiff_t m_eOpenDirection = 0xDAC; // PropDoorRotatingOpenDirection_e + constexpr std::ptrdiff_t m_eCurrentOpenDirection = 0xDB0; // PropDoorRotatingOpenDirection_e + constexpr std::ptrdiff_t m_flAjarAngle = 0xDB4; // float + constexpr std::ptrdiff_t m_angRotationAjarDeprecated = 0xDB8; // QAngle + constexpr std::ptrdiff_t m_angRotationClosed = 0xDC4; // QAngle + constexpr std::ptrdiff_t m_angRotationOpenForward = 0xDD0; // QAngle + constexpr std::ptrdiff_t m_angRotationOpenBack = 0xDDC; // QAngle + constexpr std::ptrdiff_t m_angGoal = 0xDE8; // QAngle + constexpr std::ptrdiff_t m_vecForwardBoundsMin = 0xDF4; // Vector + constexpr std::ptrdiff_t m_vecForwardBoundsMax = 0xE00; // Vector + constexpr std::ptrdiff_t m_vecBackBoundsMin = 0xE0C; // Vector + constexpr std::ptrdiff_t m_vecBackBoundsMax = 0xE18; // Vector + constexpr std::ptrdiff_t m_bAjarDoorShouldntAlwaysOpen = 0xE24; // bool + constexpr std::ptrdiff_t m_hEntityBlocker = 0xE28; // CHandle +} + +namespace CPropDoorRotatingBreakable { // CPropDoorRotating + constexpr std::ptrdiff_t m_bBreakable = 0xE30; // bool + constexpr std::ptrdiff_t m_isAbleToCloseAreaPortals = 0xE31; // bool + constexpr std::ptrdiff_t m_currentDamageState = 0xE34; // int32_t + constexpr std::ptrdiff_t m_damageStates = 0xE38; // CUtlVector +} + +namespace CPulseCell_Inflow_GameEvent { // CPulseCell_Inflow_BaseEntrypoint + constexpr std::ptrdiff_t m_EventName = 0x70; // CBufferString +} + +namespace CPulseCell_Outflow_PlayVCD { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_vcdFilename = 0x48; // CUtlString + constexpr std::ptrdiff_t m_OnFinished = 0x50; // CPulse_OutflowConnection + constexpr std::ptrdiff_t m_Triggers = 0x60; // CUtlVector +} + +namespace CPulseCell_SoundEventStart { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Type = 0x48; // SoundEventStartType_t +} + +namespace CPulseCell_Step_EntFire { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_Input = 0x48; // CUtlString +} + +namespace CPulseCell_Step_SetAnimGraphParam { // CPulseCell_BaseFlow + constexpr std::ptrdiff_t m_ParamName = 0x48; // CUtlString +} + +namespace CPulseCell_Value_FindEntByName { // CPulseCell_BaseValue + constexpr std::ptrdiff_t m_EntityType = 0x48; // CUtlString +} + +namespace CPulseGraphInstance_ServerPointEntity { // CBasePulseGraphInstance +} + +namespace CPulseServerFuncs { +} + +namespace CPulseServerFuncs_Sounds { +} + +namespace CPushable { // CBreakable +} + +namespace CRR_Response { + constexpr std::ptrdiff_t m_Type = 0x0; // uint8_t + constexpr std::ptrdiff_t m_szResponseName = 0x1; // char[192] + constexpr std::ptrdiff_t m_szMatchingRule = 0xC1; // char[128] + constexpr std::ptrdiff_t m_Params = 0x148; // ResponseParams + constexpr std::ptrdiff_t m_fMatchScore = 0x168; // float + constexpr std::ptrdiff_t m_szSpeakerContext = 0x170; // char* + constexpr std::ptrdiff_t m_szWorldContext = 0x178; // char* + constexpr std::ptrdiff_t m_Followup = 0x180; // ResponseFollowup + constexpr std::ptrdiff_t m_pchCriteriaNames = 0x1B8; // CUtlVector + constexpr std::ptrdiff_t m_pchCriteriaValues = 0x1D0; // CUtlVector +} + +namespace CRagdollConstraint { // CPhysConstraint + constexpr std::ptrdiff_t m_xmin = 0x508; // float + constexpr std::ptrdiff_t m_xmax = 0x50C; // float + constexpr std::ptrdiff_t m_ymin = 0x510; // float + constexpr std::ptrdiff_t m_ymax = 0x514; // float + constexpr std::ptrdiff_t m_zmin = 0x518; // float + constexpr std::ptrdiff_t m_zmax = 0x51C; // float + constexpr std::ptrdiff_t m_xfriction = 0x520; // float + constexpr std::ptrdiff_t m_yfriction = 0x524; // float + constexpr std::ptrdiff_t m_zfriction = 0x528; // float +} + +namespace CRagdollMagnet { // CPointEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_radius = 0x4B4; // float + constexpr std::ptrdiff_t m_force = 0x4B8; // float + constexpr std::ptrdiff_t m_axis = 0x4BC; // Vector +} + +namespace CRagdollManager { // CBaseEntity + constexpr std::ptrdiff_t m_iCurrentMaxRagdollCount = 0x4B0; // int8_t + constexpr std::ptrdiff_t m_iMaxRagdollCount = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_bSaveImportant = 0x4B8; // bool +} + +namespace CRagdollProp { // CBaseAnimGraph + constexpr std::ptrdiff_t m_ragdoll = 0x898; // ragdoll_t + constexpr std::ptrdiff_t m_bStartDisabled = 0x8D0; // bool + constexpr std::ptrdiff_t m_ragPos = 0x8D8; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_ragAngles = 0x8F0; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_hRagdollSource = 0x908; // CHandle + constexpr std::ptrdiff_t m_lastUpdateTickCount = 0x90C; // uint32_t + constexpr std::ptrdiff_t m_allAsleep = 0x910; // bool + constexpr std::ptrdiff_t m_bFirstCollisionAfterLaunch = 0x911; // bool + constexpr std::ptrdiff_t m_hDamageEntity = 0x914; // CHandle + constexpr std::ptrdiff_t m_hKiller = 0x918; // CHandle + constexpr std::ptrdiff_t m_hPhysicsAttacker = 0x91C; // CHandle + constexpr std::ptrdiff_t m_flLastPhysicsInfluenceTime = 0x920; // GameTime_t + constexpr std::ptrdiff_t m_flFadeOutStartTime = 0x924; // GameTime_t + constexpr std::ptrdiff_t m_flFadeTime = 0x928; // float + constexpr std::ptrdiff_t m_vecLastOrigin = 0x92C; // Vector + constexpr std::ptrdiff_t m_flAwakeTime = 0x938; // GameTime_t + constexpr std::ptrdiff_t m_flLastOriginChangeTime = 0x93C; // GameTime_t + constexpr std::ptrdiff_t m_nBloodColor = 0x940; // int32_t + constexpr std::ptrdiff_t m_strOriginClassName = 0x948; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_strSourceClassName = 0x950; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bHasBeenPhysgunned = 0x958; // bool + constexpr std::ptrdiff_t m_bShouldTeleportPhysics = 0x959; // bool + constexpr std::ptrdiff_t m_flBlendWeight = 0x95C; // float + constexpr std::ptrdiff_t m_flDefaultFadeScale = 0x960; // float + constexpr std::ptrdiff_t m_ragdollMins = 0x968; // CUtlVector + constexpr std::ptrdiff_t m_ragdollMaxs = 0x980; // CUtlVector + constexpr std::ptrdiff_t m_bShouldDeleteActivationRecord = 0x998; // bool + constexpr std::ptrdiff_t m_bValidatePoweredRagdollPose = 0x9F8; // bool +} + +namespace CRagdollPropAlias_physics_prop_ragdoll { // CRagdollProp +} + +namespace CRagdollPropAttached { // CRagdollProp + constexpr std::ptrdiff_t m_boneIndexAttached = 0xA38; // uint32_t + constexpr std::ptrdiff_t m_ragdollAttachedObjectIndex = 0xA3C; // uint32_t + constexpr std::ptrdiff_t m_attachmentPointBoneSpace = 0xA40; // Vector + constexpr std::ptrdiff_t m_attachmentPointRagdollSpace = 0xA4C; // Vector + constexpr std::ptrdiff_t m_bShouldDetach = 0xA58; // bool + constexpr std::ptrdiff_t m_bShouldDeleteAttachedActivationRecord = 0xA68; // bool +} + +namespace CRandSimTimer { // CSimpleSimTimer + constexpr std::ptrdiff_t m_minInterval = 0x8; // float + constexpr std::ptrdiff_t m_maxInterval = 0xC; // float +} + +namespace CRandStopwatch { // CStopwatchBase + constexpr std::ptrdiff_t m_minInterval = 0xC; // float + constexpr std::ptrdiff_t m_maxInterval = 0x10; // float +} + +namespace CRangeFloat { + constexpr std::ptrdiff_t m_pValue = 0x0; // float[2] +} + +namespace CRangeInt { + constexpr std::ptrdiff_t m_pValue = 0x0; // int32_t[2] +} + +namespace CRectLight { // CBarnLight + constexpr std::ptrdiff_t m_bShowLight = 0x928; // bool +} + +namespace CRemapFloat { + constexpr std::ptrdiff_t m_pValue = 0x0; // float[4] +} + +namespace CRenderComponent { // CEntityComponent + constexpr std::ptrdiff_t __m_pChainEntity = 0x10; // CNetworkVarChainer + constexpr std::ptrdiff_t m_bIsRenderingWithViewModels = 0x50; // bool + constexpr std::ptrdiff_t m_nSplitscreenFlags = 0x54; // uint32_t + constexpr std::ptrdiff_t m_bEnableRendering = 0x60; // bool + constexpr std::ptrdiff_t m_bInterpolationReadyToDraw = 0xB0; // bool +} + +namespace CResponseCriteriaSet { + constexpr std::ptrdiff_t m_nNumPrefixedContexts = 0x28; // int32_t + constexpr std::ptrdiff_t m_bOverrideOnAppend = 0x2C; // bool +} + +namespace CResponseQueue { + constexpr std::ptrdiff_t m_ExpresserTargets = 0x50; // CUtlVector +} + +namespace CResponseQueue_CDeferredResponse { + constexpr std::ptrdiff_t m_contexts = 0x10; // CResponseCriteriaSet + constexpr std::ptrdiff_t m_fDispatchTime = 0x40; // float + constexpr std::ptrdiff_t m_hIssuer = 0x44; // CHandle + constexpr std::ptrdiff_t m_response = 0x50; // CRR_Response + constexpr std::ptrdiff_t m_bResponseValid = 0x238; // bool +} + +namespace CRetakeGameRules { + constexpr std::ptrdiff_t m_nMatchSeed = 0xF8; // int32_t + constexpr std::ptrdiff_t m_bBlockersPresent = 0xFC; // bool + constexpr std::ptrdiff_t m_bRoundInProgress = 0xFD; // bool + constexpr std::ptrdiff_t m_iFirstSecondHalfRound = 0x100; // int32_t + constexpr std::ptrdiff_t m_iBombSite = 0x104; // int32_t +} + +namespace CRevertSaved { // CModelPointEntity + constexpr std::ptrdiff_t m_loadTime = 0x700; // float + constexpr std::ptrdiff_t m_Duration = 0x704; // float + constexpr std::ptrdiff_t m_HoldTime = 0x708; // float +} + +namespace CRopeKeyframe { // CBaseModelEntity + constexpr std::ptrdiff_t m_RopeFlags = 0x708; // uint16_t + constexpr std::ptrdiff_t m_iNextLinkName = 0x710; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_Slack = 0x718; // int16_t + constexpr std::ptrdiff_t m_Width = 0x71C; // float + constexpr std::ptrdiff_t m_TextureScale = 0x720; // float + constexpr std::ptrdiff_t m_nSegments = 0x724; // uint8_t + constexpr std::ptrdiff_t m_bConstrainBetweenEndpoints = 0x725; // bool + constexpr std::ptrdiff_t m_strRopeMaterialModel = 0x728; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iRopeMaterialModelIndex = 0x730; // CStrongHandle + constexpr std::ptrdiff_t m_Subdiv = 0x738; // uint8_t + constexpr std::ptrdiff_t m_nChangeCount = 0x739; // uint8_t + constexpr std::ptrdiff_t m_RopeLength = 0x73A; // int16_t + constexpr std::ptrdiff_t m_fLockedPoints = 0x73C; // uint8_t + constexpr std::ptrdiff_t m_bCreatedFromMapFile = 0x73D; // bool + constexpr std::ptrdiff_t m_flScrollSpeed = 0x740; // float + constexpr std::ptrdiff_t m_bStartPointValid = 0x744; // bool + constexpr std::ptrdiff_t m_bEndPointValid = 0x745; // bool + constexpr std::ptrdiff_t m_hStartPoint = 0x748; // CHandle + constexpr std::ptrdiff_t m_hEndPoint = 0x74C; // CHandle + constexpr std::ptrdiff_t m_iStartAttachment = 0x750; // AttachmentHandle_t + constexpr std::ptrdiff_t m_iEndAttachment = 0x751; // AttachmentHandle_t +} + +namespace CRopeKeyframeAlias_move_rope { // CRopeKeyframe +} + +namespace CRotButton { // CBaseButton +} + +namespace CRotDoor { // CBaseDoor + constexpr std::ptrdiff_t m_bSolidBsp = 0x988; // bool +} + +namespace CRuleBrushEntity { // CRuleEntity +} + +namespace CRuleEntity { // CBaseModelEntity + constexpr std::ptrdiff_t m_iszMaster = 0x700; // CUtlSymbolLarge +} + +namespace CRulePointEntity { // CRuleEntity + constexpr std::ptrdiff_t m_Score = 0x708; // int32_t +} + +namespace CSAdditionalMatchStats_t { // CSAdditionalPerRoundStats_t + constexpr std::ptrdiff_t m_numRoundsSurvived = 0x14; // int32_t + constexpr std::ptrdiff_t m_maxNumRoundsSurvived = 0x18; // int32_t + constexpr std::ptrdiff_t m_numRoundsSurvivedTotal = 0x1C; // int32_t + constexpr std::ptrdiff_t m_iRoundsWonWithoutPurchase = 0x20; // int32_t + constexpr std::ptrdiff_t m_iRoundsWonWithoutPurchaseTotal = 0x24; // int32_t + constexpr std::ptrdiff_t m_numFirstKills = 0x28; // int32_t + constexpr std::ptrdiff_t m_numClutchKills = 0x2C; // int32_t + constexpr std::ptrdiff_t m_numPistolKills = 0x30; // int32_t + constexpr std::ptrdiff_t m_numSniperKills = 0x34; // int32_t + constexpr std::ptrdiff_t m_iNumSuicides = 0x38; // int32_t + constexpr std::ptrdiff_t m_iNumTeamKills = 0x3C; // int32_t + constexpr std::ptrdiff_t m_iTeamDamage = 0x40; // int32_t +} + +namespace CSAdditionalPerRoundStats_t { + constexpr std::ptrdiff_t m_numChickensKilled = 0x0; // int32_t + constexpr std::ptrdiff_t m_killsWhileBlind = 0x4; // int32_t + constexpr std::ptrdiff_t m_bombCarrierkills = 0x8; // int32_t + constexpr std::ptrdiff_t m_iBurnDamageInflicted = 0xC; // int32_t + constexpr std::ptrdiff_t m_iDinks = 0x10; // int32_t +} + +namespace CSMatchStats_t { // CSPerRoundStats_t + constexpr std::ptrdiff_t m_iEnemy5Ks = 0x68; // int32_t + constexpr std::ptrdiff_t m_iEnemy4Ks = 0x6C; // int32_t + constexpr std::ptrdiff_t m_iEnemy3Ks = 0x70; // int32_t + constexpr std::ptrdiff_t m_iEnemy2Ks = 0x74; // int32_t + constexpr std::ptrdiff_t m_iUtility_Count = 0x78; // int32_t + constexpr std::ptrdiff_t m_iUtility_Successes = 0x7C; // int32_t + constexpr std::ptrdiff_t m_iUtility_Enemies = 0x80; // int32_t + constexpr std::ptrdiff_t m_iFlash_Count = 0x84; // int32_t + constexpr std::ptrdiff_t m_iFlash_Successes = 0x88; // int32_t + constexpr std::ptrdiff_t m_nHealthPointsRemovedTotal = 0x8C; // int32_t + constexpr std::ptrdiff_t m_nHealthPointsDealtTotal = 0x90; // int32_t + constexpr std::ptrdiff_t m_nShotsFiredTotal = 0x94; // int32_t + constexpr std::ptrdiff_t m_nShotsOnTargetTotal = 0x98; // int32_t + constexpr std::ptrdiff_t m_i1v1Count = 0x9C; // int32_t + constexpr std::ptrdiff_t m_i1v1Wins = 0xA0; // int32_t + constexpr std::ptrdiff_t m_i1v2Count = 0xA4; // int32_t + constexpr std::ptrdiff_t m_i1v2Wins = 0xA8; // int32_t + constexpr std::ptrdiff_t m_iEntryCount = 0xAC; // int32_t + constexpr std::ptrdiff_t m_iEntryWins = 0xB0; // int32_t +} + +namespace CSPerRoundStats_t { + constexpr std::ptrdiff_t m_iKills = 0x30; // int32_t + constexpr std::ptrdiff_t m_iDeaths = 0x34; // int32_t + constexpr std::ptrdiff_t m_iAssists = 0x38; // int32_t + constexpr std::ptrdiff_t m_iDamage = 0x3C; // int32_t + constexpr std::ptrdiff_t m_iEquipmentValue = 0x40; // int32_t + constexpr std::ptrdiff_t m_iMoneySaved = 0x44; // int32_t + constexpr std::ptrdiff_t m_iKillReward = 0x48; // int32_t + constexpr std::ptrdiff_t m_iLiveTime = 0x4C; // int32_t + constexpr std::ptrdiff_t m_iHeadShotKills = 0x50; // int32_t + constexpr std::ptrdiff_t m_iObjective = 0x54; // int32_t + constexpr std::ptrdiff_t m_iCashEarned = 0x58; // int32_t + constexpr std::ptrdiff_t m_iUtilityDamage = 0x5C; // int32_t + constexpr std::ptrdiff_t m_iEnemiesFlashed = 0x60; // int32_t +} + +namespace CSceneEntity { // CPointEntity + constexpr std::ptrdiff_t m_iszSceneFile = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszResumeSceneFile = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget1 = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget2 = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget3 = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget4 = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget5 = 0x4E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget6 = 0x4F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget7 = 0x4F8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTarget8 = 0x500; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hTarget1 = 0x508; // CHandle + constexpr std::ptrdiff_t m_hTarget2 = 0x50C; // CHandle + constexpr std::ptrdiff_t m_hTarget3 = 0x510; // CHandle + constexpr std::ptrdiff_t m_hTarget4 = 0x514; // CHandle + constexpr std::ptrdiff_t m_hTarget5 = 0x518; // CHandle + constexpr std::ptrdiff_t m_hTarget6 = 0x51C; // CHandle + constexpr std::ptrdiff_t m_hTarget7 = 0x520; // CHandle + constexpr std::ptrdiff_t m_hTarget8 = 0x524; // CHandle + constexpr std::ptrdiff_t m_bIsPlayingBack = 0x528; // bool + constexpr std::ptrdiff_t m_bPaused = 0x529; // bool + constexpr std::ptrdiff_t m_bMultiplayer = 0x52A; // bool + constexpr std::ptrdiff_t m_bAutogenerated = 0x52B; // bool + constexpr std::ptrdiff_t m_flForceClientTime = 0x52C; // float + constexpr std::ptrdiff_t m_flCurrentTime = 0x530; // float + constexpr std::ptrdiff_t m_flFrameTime = 0x534; // float + constexpr std::ptrdiff_t m_bCancelAtNextInterrupt = 0x538; // bool + constexpr std::ptrdiff_t m_fPitch = 0x53C; // float + constexpr std::ptrdiff_t m_bAutomated = 0x540; // bool + constexpr std::ptrdiff_t m_nAutomatedAction = 0x544; // int32_t + constexpr std::ptrdiff_t m_flAutomationDelay = 0x548; // float + constexpr std::ptrdiff_t m_flAutomationTime = 0x54C; // float + constexpr std::ptrdiff_t m_hWaitingForThisResumeScene = 0x550; // CHandle + constexpr std::ptrdiff_t m_bWaitingForResumeScene = 0x554; // bool + constexpr std::ptrdiff_t m_bPausedViaInput = 0x555; // bool + constexpr std::ptrdiff_t m_bPauseAtNextInterrupt = 0x556; // bool + constexpr std::ptrdiff_t m_bWaitingForActor = 0x557; // bool + constexpr std::ptrdiff_t m_bWaitingForInterrupt = 0x558; // bool + constexpr std::ptrdiff_t m_bInterruptedActorsScenes = 0x559; // bool + constexpr std::ptrdiff_t m_bBreakOnNonIdle = 0x55A; // bool + constexpr std::ptrdiff_t m_hActorList = 0x560; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_hRemoveActorList = 0x578; // CUtlVector> + constexpr std::ptrdiff_t m_nSceneFlushCounter = 0x5A0; // int32_t + constexpr std::ptrdiff_t m_nSceneStringIndex = 0x5A4; // uint16_t + constexpr std::ptrdiff_t m_OnStart = 0x5A8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnCompletion = 0x5D0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnCanceled = 0x5F8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPaused = 0x620; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnResumed = 0x648; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTrigger = 0x670; // CEntityIOOutput[16] + constexpr std::ptrdiff_t m_hInterruptScene = 0x980; // CHandle + constexpr std::ptrdiff_t m_nInterruptCount = 0x984; // int32_t + constexpr std::ptrdiff_t m_bSceneMissing = 0x988; // bool + constexpr std::ptrdiff_t m_bInterrupted = 0x989; // bool + constexpr std::ptrdiff_t m_bCompletedEarly = 0x98A; // bool + constexpr std::ptrdiff_t m_bInterruptSceneFinished = 0x98B; // bool + constexpr std::ptrdiff_t m_bRestoring = 0x98C; // bool + constexpr std::ptrdiff_t m_hNotifySceneCompletion = 0x990; // CUtlVector> + constexpr std::ptrdiff_t m_hListManagers = 0x9A8; // CUtlVector> + constexpr std::ptrdiff_t m_iszSoundName = 0x9E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hActor = 0x9F0; // CHandle + constexpr std::ptrdiff_t m_hActivator = 0x9F4; // CHandle + constexpr std::ptrdiff_t m_BusyActor = 0x9F8; // int32_t + constexpr std::ptrdiff_t m_iPlayerDeathBehavior = 0x9FC; // SceneOnPlayerDeath_t +} + +namespace CSceneEntityAlias_logic_choreographed_scene { // CSceneEntity +} + +namespace CSceneEventInfo { + constexpr std::ptrdiff_t m_iLayer = 0x0; // int32_t + constexpr std::ptrdiff_t m_iPriority = 0x4; // int32_t + constexpr std::ptrdiff_t m_hSequence = 0x8; // HSequence + constexpr std::ptrdiff_t m_flWeight = 0xC; // float + constexpr std::ptrdiff_t m_bIsMoving = 0x10; // bool + constexpr std::ptrdiff_t m_bHasArrived = 0x11; // bool + constexpr std::ptrdiff_t m_flInitialYaw = 0x14; // float + constexpr std::ptrdiff_t m_flTargetYaw = 0x18; // float + constexpr std::ptrdiff_t m_flFacingYaw = 0x1C; // float + constexpr std::ptrdiff_t m_nType = 0x20; // int32_t + constexpr std::ptrdiff_t m_flNext = 0x24; // GameTime_t + constexpr std::ptrdiff_t m_bIsGesture = 0x28; // bool + constexpr std::ptrdiff_t m_bShouldRemove = 0x29; // bool + constexpr std::ptrdiff_t m_hTarget = 0x54; // CHandle + constexpr std::ptrdiff_t m_nSceneEventId = 0x58; // uint32_t + constexpr std::ptrdiff_t m_bClientSide = 0x5C; // bool + constexpr std::ptrdiff_t m_bStarted = 0x5D; // bool +} + +namespace CSceneListManager { // CLogicalEntity + constexpr std::ptrdiff_t m_hListManagers = 0x4B0; // CUtlVector> + constexpr std::ptrdiff_t m_iszScenes = 0x4C8; // CUtlSymbolLarge[16] + constexpr std::ptrdiff_t m_hScenes = 0x548; // CHandle[16] +} + +namespace CScriptComponent { // CEntityComponent + constexpr std::ptrdiff_t m_scriptClassName = 0x30; // CUtlSymbolLarge +} + +namespace CScriptItem { // CItem + constexpr std::ptrdiff_t m_OnPlayerPickup = 0x968; // CEntityIOOutput + constexpr std::ptrdiff_t m_MoveTypeOverride = 0x990; // MoveType_t +} + +namespace CScriptNavBlocker { // CFuncNavBlocker + constexpr std::ptrdiff_t m_vExtent = 0x710; // Vector +} + +namespace CScriptTriggerHurt { // CTriggerHurt + constexpr std::ptrdiff_t m_vExtent = 0x948; // Vector +} + +namespace CScriptTriggerMultiple { // CTriggerMultiple + constexpr std::ptrdiff_t m_vExtent = 0x8D0; // Vector +} + +namespace CScriptTriggerOnce { // CTriggerOnce + constexpr std::ptrdiff_t m_vExtent = 0x8D0; // Vector +} + +namespace CScriptTriggerPush { // CTriggerPush + constexpr std::ptrdiff_t m_vExtent = 0x8D0; // Vector +} + +namespace CScriptUniformRandomStream { + constexpr std::ptrdiff_t m_hScriptScope = 0x8; // HSCRIPT + constexpr std::ptrdiff_t m_nInitialSeed = 0x9C; // int32_t +} + +namespace CScriptedSequence { // CBaseEntity + constexpr std::ptrdiff_t m_iszEntry = 0x4B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszPreIdle = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszPlay = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszPostIdle = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszModifierToAddOnPlay = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszNextScript = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszEntity = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSyncGroup = 0x4E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nMoveTo = 0x4F0; // ScriptedMoveTo_t + constexpr std::ptrdiff_t m_bIsPlayingPreIdle = 0x4F4; // bool + constexpr std::ptrdiff_t m_bIsPlayingEntry = 0x4F5; // bool + constexpr std::ptrdiff_t m_bIsPlayingAction = 0x4F6; // bool + constexpr std::ptrdiff_t m_bIsPlayingPostIdle = 0x4F7; // bool + constexpr std::ptrdiff_t m_bLoopPreIdleSequence = 0x4F8; // bool + constexpr std::ptrdiff_t m_bLoopActionSequence = 0x4F9; // bool + constexpr std::ptrdiff_t m_bLoopPostIdleSequence = 0x4FA; // bool + constexpr std::ptrdiff_t m_bSynchPostIdles = 0x4FB; // bool + constexpr std::ptrdiff_t m_bIgnoreGravity = 0x4FC; // bool + constexpr std::ptrdiff_t m_bDisableNPCCollisions = 0x4FD; // bool + constexpr std::ptrdiff_t m_bKeepAnimgraphLockedPost = 0x4FE; // bool + constexpr std::ptrdiff_t m_bDontAddModifiers = 0x4FF; // bool + constexpr std::ptrdiff_t m_flRadius = 0x500; // float + constexpr std::ptrdiff_t m_flRepeat = 0x504; // float + constexpr std::ptrdiff_t m_flPlayAnimFadeInTime = 0x508; // float + constexpr std::ptrdiff_t m_flMoveInterpTime = 0x50C; // float + constexpr std::ptrdiff_t m_flAngRate = 0x510; // float + constexpr std::ptrdiff_t m_iDelay = 0x514; // int32_t + constexpr std::ptrdiff_t m_startTime = 0x518; // GameTime_t + constexpr std::ptrdiff_t m_bWaitForBeginSequence = 0x51C; // bool + constexpr std::ptrdiff_t m_saved_effects = 0x520; // int32_t + constexpr std::ptrdiff_t m_savedFlags = 0x524; // int32_t + constexpr std::ptrdiff_t m_savedCollisionGroup = 0x528; // int32_t + constexpr std::ptrdiff_t m_interruptable = 0x52C; // bool + constexpr std::ptrdiff_t m_sequenceStarted = 0x52D; // bool + constexpr std::ptrdiff_t m_bPrevAnimatedEveryTick = 0x52E; // bool + constexpr std::ptrdiff_t m_bForcedAnimatedEveryTick = 0x52F; // bool + constexpr std::ptrdiff_t m_bPositionRelativeToOtherEntity = 0x530; // bool + constexpr std::ptrdiff_t m_hTargetEnt = 0x534; // CHandle + constexpr std::ptrdiff_t m_hNextCine = 0x538; // CHandle + constexpr std::ptrdiff_t m_bThinking = 0x53C; // bool + constexpr std::ptrdiff_t m_bInitiatedSelfDelete = 0x53D; // bool + constexpr std::ptrdiff_t m_bIsTeleportingDueToMoveTo = 0x53E; // bool + constexpr std::ptrdiff_t m_bAllowCustomInterruptConditions = 0x53F; // bool + constexpr std::ptrdiff_t m_hLastFoundEntity = 0x540; // CHandle + constexpr std::ptrdiff_t m_hForcedTarget = 0x544; // CHandle + constexpr std::ptrdiff_t m_bDontCancelOtherSequences = 0x548; // bool + constexpr std::ptrdiff_t m_bForceSynch = 0x549; // bool + constexpr std::ptrdiff_t m_bTargetWasAsleep = 0x54A; // bool + constexpr std::ptrdiff_t m_bPreventUpdateYawOnFinish = 0x54B; // bool + constexpr std::ptrdiff_t m_bEnsureOnNavmeshOnFinish = 0x54C; // bool + constexpr std::ptrdiff_t m_onDeathBehavior = 0x550; // ScriptedOnDeath_t + constexpr std::ptrdiff_t m_ConflictResponse = 0x554; // ScriptedConflictResponse_t + constexpr std::ptrdiff_t m_OnBeginSequence = 0x558; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnActionStartOrLoop = 0x580; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnEndSequence = 0x5A8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnPostIdleEndSequence = 0x5D0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnCancelSequence = 0x5F8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnCancelFailedSequence = 0x620; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnScriptEvent = 0x648; // CEntityIOOutput[8] + constexpr std::ptrdiff_t m_matOtherToMain = 0x790; // CTransform + constexpr std::ptrdiff_t m_hInteractionMainEntity = 0x7B0; // CHandle + constexpr std::ptrdiff_t m_iPlayerDeathBehavior = 0x7B4; // int32_t +} + +namespace CSensorGrenade { // CBaseCSGrenade +} + +namespace CSensorGrenadeProjectile { // CBaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_fExpireTime = 0xA30; // GameTime_t + constexpr std::ptrdiff_t m_fNextDetectPlayerSound = 0xA34; // GameTime_t + constexpr std::ptrdiff_t m_hDisplayGrenade = 0xA38; // CHandle +} + +namespace CServerOnlyEntity { // CBaseEntity +} + +namespace CServerOnlyModelEntity { // CBaseModelEntity +} + +namespace CServerOnlyPointEntity { // CServerOnlyEntity +} + +namespace CServerRagdollTrigger { // CBaseTrigger +} + +namespace CShatterGlassShard { + constexpr std::ptrdiff_t m_hShardHandle = 0x8; // uint32_t + constexpr std::ptrdiff_t m_vecPanelVertices = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_vLocalPanelSpaceOrigin = 0x28; // Vector2D + constexpr std::ptrdiff_t m_hModel = 0x30; // CStrongHandle + constexpr std::ptrdiff_t m_hPhysicsEntity = 0x38; // CHandle + constexpr std::ptrdiff_t m_hParentPanel = 0x3C; // CHandle + constexpr std::ptrdiff_t m_hParentShard = 0x40; // uint32_t + constexpr std::ptrdiff_t m_ShatterStressType = 0x44; // ShatterGlassStressType + constexpr std::ptrdiff_t m_vecStressVelocity = 0x48; // Vector + constexpr std::ptrdiff_t m_bCreatedModel = 0x54; // bool + constexpr std::ptrdiff_t m_flLongestEdge = 0x58; // float + constexpr std::ptrdiff_t m_flShortestEdge = 0x5C; // float + constexpr std::ptrdiff_t m_flLongestAcross = 0x60; // float + constexpr std::ptrdiff_t m_flShortestAcross = 0x64; // float + constexpr std::ptrdiff_t m_flSumOfAllEdges = 0x68; // float + constexpr std::ptrdiff_t m_flArea = 0x6C; // float + constexpr std::ptrdiff_t m_nOnFrameEdge = 0x70; // OnFrame + constexpr std::ptrdiff_t m_nParentPanelsNthShard = 0x74; // int32_t + constexpr std::ptrdiff_t m_nSubShardGeneration = 0x78; // int32_t + constexpr std::ptrdiff_t m_vecAverageVertPosition = 0x7C; // Vector2D + constexpr std::ptrdiff_t m_bAverageVertPositionIsValid = 0x84; // bool + constexpr std::ptrdiff_t m_vecPanelSpaceStressPositionA = 0x88; // Vector2D + constexpr std::ptrdiff_t m_vecPanelSpaceStressPositionB = 0x90; // Vector2D + constexpr std::ptrdiff_t m_bStressPositionAIsValid = 0x98; // bool + constexpr std::ptrdiff_t m_bStressPositionBIsValid = 0x99; // bool + constexpr std::ptrdiff_t m_bFlaggedForRemoval = 0x9A; // bool + constexpr std::ptrdiff_t m_flPhysicsEntitySpawnedAtTime = 0x9C; // GameTime_t + constexpr std::ptrdiff_t m_bShatterRateLimited = 0xA0; // bool + constexpr std::ptrdiff_t m_hEntityHittingMe = 0xA4; // CHandle + constexpr std::ptrdiff_t m_vecNeighbors = 0xA8; // CUtlVector +} + +namespace CShatterGlassShardPhysics { // CPhysicsProp + constexpr std::ptrdiff_t m_bDebris = 0xB78; // bool + constexpr std::ptrdiff_t m_hParentShard = 0xB7C; // uint32_t + constexpr std::ptrdiff_t m_ShardDesc = 0xB80; // shard_model_desc_t +} + +namespace CShower { // CModelPointEntity +} + +namespace CSimTimer { // CSimpleSimTimer + constexpr std::ptrdiff_t m_interval = 0x8; // float +} + +namespace CSimpleMarkupVolumeTagged { // CMarkupVolumeTagged +} + +namespace CSimpleSimTimer { + constexpr std::ptrdiff_t m_next = 0x0; // GameTime_t + constexpr std::ptrdiff_t m_nWorldGroupId = 0x4; // WorldGroupId_t +} + +namespace CSimpleStopwatch { // CStopwatchBase +} + +namespace CSingleplayRules { // CGameRules + constexpr std::ptrdiff_t m_bSinglePlayerGameEnding = 0x90; // bool +} + +namespace CSkeletonAnimationController { // ISkeletonAnimationController + constexpr std::ptrdiff_t m_pSkeletonInstance = 0x8; // CSkeletonInstance* +} + +namespace CSkeletonInstance { // CGameSceneNode + constexpr std::ptrdiff_t m_modelState = 0x160; // CModelState + constexpr std::ptrdiff_t m_bIsAnimationEnabled = 0x390; // bool + constexpr std::ptrdiff_t m_bUseParentRenderBounds = 0x391; // bool + constexpr std::ptrdiff_t m_bDisableSolidCollisionsForHierarchy = 0x392; // bool + constexpr std::ptrdiff_t m_bDirtyMotionType = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_bIsGeneratingLatchedParentSpaceState = 0x0; // bitfield:1 + constexpr std::ptrdiff_t m_materialGroup = 0x394; // CUtlStringToken + constexpr std::ptrdiff_t m_nHitboxSet = 0x398; // uint8_t +} + +namespace CSkillDamage { + constexpr std::ptrdiff_t m_flDamage = 0x0; // CSkillFloat + constexpr std::ptrdiff_t m_flPhysicsForceDamage = 0x10; // float +} + +namespace CSkillFloat { + constexpr std::ptrdiff_t m_pValue = 0x0; // float[4] +} + +namespace CSkillInt { + constexpr std::ptrdiff_t m_pValue = 0x0; // int32_t[4] +} + +namespace CSkyCamera { // CBaseEntity + constexpr std::ptrdiff_t m_skyboxData = 0x4B0; // sky3dparams_t + constexpr std::ptrdiff_t m_skyboxSlotToken = 0x540; // CUtlStringToken + constexpr std::ptrdiff_t m_bUseAngles = 0x544; // bool + constexpr std::ptrdiff_t m_pNext = 0x548; // CSkyCamera* +} + +namespace CSkyboxReference { // CBaseEntity + constexpr std::ptrdiff_t m_worldGroupId = 0x4B0; // WorldGroupId_t + constexpr std::ptrdiff_t m_hSkyCamera = 0x4B4; // CHandle +} + +namespace CSmokeGrenade { // CBaseCSGrenade +} + +namespace CSmokeGrenadeProjectile { // CBaseCSGrenadeProjectile + constexpr std::ptrdiff_t m_nSmokeEffectTickBegin = 0xA48; // int32_t + constexpr std::ptrdiff_t m_bDidSmokeEffect = 0xA4C; // bool + constexpr std::ptrdiff_t m_nRandomSeed = 0xA50; // int32_t + constexpr std::ptrdiff_t m_vSmokeColor = 0xA54; // Vector + constexpr std::ptrdiff_t m_vSmokeDetonationPos = 0xA60; // Vector + constexpr std::ptrdiff_t m_VoxelFrameData = 0xA70; // CUtlVector + constexpr std::ptrdiff_t m_flLastBounce = 0xA88; // GameTime_t + constexpr std::ptrdiff_t m_fllastSimulationTime = 0xA8C; // GameTime_t +} + +namespace CSmoothFunc { + constexpr std::ptrdiff_t m_flSmoothAmplitude = 0x8; // float + constexpr std::ptrdiff_t m_flSmoothBias = 0xC; // float + constexpr std::ptrdiff_t m_flSmoothDuration = 0x10; // float + constexpr std::ptrdiff_t m_flSmoothRemainingTime = 0x14; // float + constexpr std::ptrdiff_t m_nSmoothDir = 0x18; // int32_t +} + +namespace CSound { + constexpr std::ptrdiff_t m_hOwner = 0x0; // CHandle + constexpr std::ptrdiff_t m_hTarget = 0x4; // CHandle + constexpr std::ptrdiff_t m_iVolume = 0x8; // int32_t + constexpr std::ptrdiff_t m_flOcclusionScale = 0xC; // float + constexpr std::ptrdiff_t m_iType = 0x10; // int32_t + constexpr std::ptrdiff_t m_iNextAudible = 0x14; // int32_t + constexpr std::ptrdiff_t m_flExpireTime = 0x18; // GameTime_t + constexpr std::ptrdiff_t m_iNext = 0x1C; // int16_t + constexpr std::ptrdiff_t m_bNoExpirationTime = 0x1E; // bool + constexpr std::ptrdiff_t m_ownerChannelIndex = 0x20; // int32_t + constexpr std::ptrdiff_t m_vecOrigin = 0x24; // Vector + constexpr std::ptrdiff_t m_bHasOwner = 0x30; // bool +} + +namespace CSoundAreaEntityBase { // CBaseEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_iszSoundAreaType = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_vPos = 0x4C0; // Vector +} + +namespace CSoundAreaEntityOrientedBox { // CSoundAreaEntityBase + constexpr std::ptrdiff_t m_vMin = 0x4D0; // Vector + constexpr std::ptrdiff_t m_vMax = 0x4DC; // Vector +} + +namespace CSoundAreaEntitySphere { // CSoundAreaEntityBase + constexpr std::ptrdiff_t m_flRadius = 0x4D0; // float +} + +namespace CSoundEnt { // CPointEntity + constexpr std::ptrdiff_t m_iFreeSound = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_iActiveSound = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_cLastActiveSounds = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_SoundPool = 0x4BC; // CSound[128] +} + +namespace CSoundEnvelope { + constexpr std::ptrdiff_t m_current = 0x0; // float + constexpr std::ptrdiff_t m_target = 0x4; // float + constexpr std::ptrdiff_t m_rate = 0x8; // float + constexpr std::ptrdiff_t m_forceupdate = 0xC; // bool +} + +namespace CSoundEventAABBEntity { // CSoundEventEntity + constexpr std::ptrdiff_t m_vMins = 0x558; // Vector + constexpr std::ptrdiff_t m_vMaxs = 0x564; // Vector +} + +namespace CSoundEventEntity { // CBaseEntity + constexpr std::ptrdiff_t m_bStartOnSpawn = 0x4B0; // bool + constexpr std::ptrdiff_t m_bToLocalPlayer = 0x4B1; // bool + constexpr std::ptrdiff_t m_bStopOnNew = 0x4B2; // bool + constexpr std::ptrdiff_t m_bSaveRestore = 0x4B3; // bool + constexpr std::ptrdiff_t m_bSavedIsPlaying = 0x4B4; // bool + constexpr std::ptrdiff_t m_flSavedElapsedTime = 0x4B8; // float + constexpr std::ptrdiff_t m_iszSourceEntityName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszAttachmentName = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_onGUIDChanged = 0x4D0; // CEntityOutputTemplate + constexpr std::ptrdiff_t m_onSoundFinished = 0x4F8; // CEntityIOOutput + constexpr std::ptrdiff_t m_iszSoundName = 0x540; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hSource = 0x550; // CEntityHandle +} + +namespace CSoundEventEntityAlias_snd_event_point { // CSoundEventEntity +} + +namespace CSoundEventOBBEntity { // CSoundEventEntity + constexpr std::ptrdiff_t m_vMins = 0x558; // Vector + constexpr std::ptrdiff_t m_vMaxs = 0x564; // Vector +} + +namespace CSoundEventParameter { // CBaseEntity + constexpr std::ptrdiff_t m_iszParamName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flFloatValue = 0x4C0; // float +} + +namespace CSoundEventPathCornerEntity { // CSoundEventEntity + constexpr std::ptrdiff_t m_iszPathCorner = 0x558; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iCountMax = 0x560; // int32_t + constexpr std::ptrdiff_t m_flDistanceMax = 0x564; // float + constexpr std::ptrdiff_t m_flDistMaxSqr = 0x568; // float + constexpr std::ptrdiff_t m_flDotProductMax = 0x56C; // float + constexpr std::ptrdiff_t bPlaying = 0x570; // bool +} + +namespace CSoundOpvarSetAABBEntity { // CSoundOpvarSetPointEntity + constexpr std::ptrdiff_t m_vDistanceInnerMins = 0x648; // Vector + constexpr std::ptrdiff_t m_vDistanceInnerMaxs = 0x654; // Vector + constexpr std::ptrdiff_t m_vDistanceOuterMins = 0x660; // Vector + constexpr std::ptrdiff_t m_vDistanceOuterMaxs = 0x66C; // Vector + constexpr std::ptrdiff_t m_nAABBDirection = 0x678; // int32_t + constexpr std::ptrdiff_t m_vInnerMins = 0x67C; // Vector + constexpr std::ptrdiff_t m_vInnerMaxs = 0x688; // Vector + constexpr std::ptrdiff_t m_vOuterMins = 0x694; // Vector + constexpr std::ptrdiff_t m_vOuterMaxs = 0x6A0; // Vector +} + +namespace CSoundOpvarSetEntity { // CBaseEntity + constexpr std::ptrdiff_t m_iszStackName = 0x4B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOperatorName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOpvarName = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nOpvarType = 0x4D0; // int32_t + constexpr std::ptrdiff_t m_nOpvarIndex = 0x4D4; // int32_t + constexpr std::ptrdiff_t m_flOpvarValue = 0x4D8; // float + constexpr std::ptrdiff_t m_OpvarValueString = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bSetOnSpawn = 0x4E8; // bool +} + +namespace CSoundOpvarSetOBBEntity { // CSoundOpvarSetAABBEntity +} + +namespace CSoundOpvarSetOBBWindEntity { // CSoundOpvarSetPointBase + constexpr std::ptrdiff_t m_vMins = 0x548; // Vector + constexpr std::ptrdiff_t m_vMaxs = 0x554; // Vector + constexpr std::ptrdiff_t m_vDistanceMins = 0x560; // Vector + constexpr std::ptrdiff_t m_vDistanceMaxs = 0x56C; // Vector + constexpr std::ptrdiff_t m_flWindMin = 0x578; // float + constexpr std::ptrdiff_t m_flWindMax = 0x57C; // float + constexpr std::ptrdiff_t m_flWindMapMin = 0x580; // float + constexpr std::ptrdiff_t m_flWindMapMax = 0x584; // float +} + +namespace CSoundOpvarSetPathCornerEntity { // CSoundOpvarSetPointEntity + constexpr std::ptrdiff_t m_flDistMinSqr = 0x660; // float + constexpr std::ptrdiff_t m_flDistMaxSqr = 0x664; // float + constexpr std::ptrdiff_t m_iszPathCornerEntityName = 0x668; // CUtlSymbolLarge +} + +namespace CSoundOpvarSetPointBase { // CBaseEntity + constexpr std::ptrdiff_t m_bDisabled = 0x4B0; // bool + constexpr std::ptrdiff_t m_hSource = 0x4B4; // CEntityHandle + constexpr std::ptrdiff_t m_iszSourceEntityName = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_vLastPosition = 0x518; // Vector + constexpr std::ptrdiff_t m_iszStackName = 0x528; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOperatorName = 0x530; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszOpvarName = 0x538; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iOpvarIndex = 0x540; // int32_t + constexpr std::ptrdiff_t m_bUseAutoCompare = 0x544; // bool +} + +namespace CSoundOpvarSetPointEntity { // CSoundOpvarSetPointBase + constexpr std::ptrdiff_t m_OnEnter = 0x548; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnExit = 0x570; // CEntityIOOutput + constexpr std::ptrdiff_t m_bAutoDisable = 0x598; // bool + constexpr std::ptrdiff_t m_flDistanceMin = 0x5DC; // float + constexpr std::ptrdiff_t m_flDistanceMax = 0x5E0; // float + constexpr std::ptrdiff_t m_flDistanceMapMin = 0x5E4; // float + constexpr std::ptrdiff_t m_flDistanceMapMax = 0x5E8; // float + constexpr std::ptrdiff_t m_flOcclusionRadius = 0x5EC; // float + constexpr std::ptrdiff_t m_flOcclusionMin = 0x5F0; // float + constexpr std::ptrdiff_t m_flOcclusionMax = 0x5F4; // float + constexpr std::ptrdiff_t m_flValSetOnDisable = 0x5F8; // float + constexpr std::ptrdiff_t m_bSetValueOnDisable = 0x5FC; // bool + constexpr std::ptrdiff_t m_nSimulationMode = 0x600; // int32_t + constexpr std::ptrdiff_t m_nVisibilitySamples = 0x604; // int32_t + constexpr std::ptrdiff_t m_vDynamicProxyPoint = 0x608; // Vector + constexpr std::ptrdiff_t m_flDynamicMaximumOcclusion = 0x614; // float + constexpr std::ptrdiff_t m_hDynamicEntity = 0x618; // CEntityHandle + constexpr std::ptrdiff_t m_iszDynamicEntityName = 0x620; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flPathingDistanceNormFactor = 0x628; // float + constexpr std::ptrdiff_t m_vPathingSourcePos = 0x62C; // Vector + constexpr std::ptrdiff_t m_vPathingListenerPos = 0x638; // Vector + constexpr std::ptrdiff_t m_nPathingSourceIndex = 0x644; // int32_t +} + +namespace CSoundPatch { + constexpr std::ptrdiff_t m_pitch = 0x8; // CSoundEnvelope + constexpr std::ptrdiff_t m_volume = 0x18; // CSoundEnvelope + constexpr std::ptrdiff_t m_shutdownTime = 0x30; // float + constexpr std::ptrdiff_t m_flLastTime = 0x34; // float + constexpr std::ptrdiff_t m_iszSoundScriptName = 0x38; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hEnt = 0x40; // CHandle + constexpr std::ptrdiff_t m_soundEntityIndex = 0x44; // CEntityIndex + constexpr std::ptrdiff_t m_soundOrigin = 0x48; // Vector + constexpr std::ptrdiff_t m_isPlaying = 0x54; // int32_t + constexpr std::ptrdiff_t m_Filter = 0x58; // CCopyRecipientFilter + constexpr std::ptrdiff_t m_flCloseCaptionDuration = 0x80; // float + constexpr std::ptrdiff_t m_bUpdatedSoundOrigin = 0x84; // bool + constexpr std::ptrdiff_t m_iszClassName = 0x88; // CUtlSymbolLarge +} + +namespace CSoundStackSave { // CLogicalEntity + constexpr std::ptrdiff_t m_iszStackName = 0x4B0; // CUtlSymbolLarge +} + +namespace CSplineConstraint { // CPhysConstraint +} + +namespace CSpotlightEnd { // CBaseModelEntity + constexpr std::ptrdiff_t m_flLightScale = 0x700; // float + constexpr std::ptrdiff_t m_Radius = 0x704; // float + constexpr std::ptrdiff_t m_vSpotlightDir = 0x708; // Vector + constexpr std::ptrdiff_t m_vSpotlightOrg = 0x714; // Vector +} + +namespace CSprite { // CBaseModelEntity + constexpr std::ptrdiff_t m_hSpriteMaterial = 0x700; // CStrongHandle + constexpr std::ptrdiff_t m_hAttachedToEntity = 0x708; // CHandle + constexpr std::ptrdiff_t m_nAttachment = 0x70C; // AttachmentHandle_t + constexpr std::ptrdiff_t m_flSpriteFramerate = 0x710; // float + constexpr std::ptrdiff_t m_flFrame = 0x714; // float + constexpr std::ptrdiff_t m_flDieTime = 0x718; // GameTime_t + constexpr std::ptrdiff_t m_nBrightness = 0x728; // uint32_t + constexpr std::ptrdiff_t m_flBrightnessDuration = 0x72C; // float + constexpr std::ptrdiff_t m_flSpriteScale = 0x730; // float + constexpr std::ptrdiff_t m_flScaleDuration = 0x734; // float + constexpr std::ptrdiff_t m_bWorldSpaceScale = 0x738; // bool + constexpr std::ptrdiff_t m_flGlowProxySize = 0x73C; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0x740; // float + constexpr std::ptrdiff_t m_flLastTime = 0x744; // GameTime_t + constexpr std::ptrdiff_t m_flMaxFrame = 0x748; // float + constexpr std::ptrdiff_t m_flStartScale = 0x74C; // float + constexpr std::ptrdiff_t m_flDestScale = 0x750; // float + constexpr std::ptrdiff_t m_flScaleTimeStart = 0x754; // GameTime_t + constexpr std::ptrdiff_t m_nStartBrightness = 0x758; // int32_t + constexpr std::ptrdiff_t m_nDestBrightness = 0x75C; // int32_t + constexpr std::ptrdiff_t m_flBrightnessTimeStart = 0x760; // GameTime_t + constexpr std::ptrdiff_t m_nSpriteWidth = 0x764; // int32_t + constexpr std::ptrdiff_t m_nSpriteHeight = 0x768; // int32_t +} + +namespace CSpriteAlias_env_glow { // CSprite +} + +namespace CSpriteOriented { // CSprite +} + +namespace CStopwatch { // CStopwatchBase + constexpr std::ptrdiff_t m_interval = 0xC; // float +} + +namespace CStopwatchBase { // CSimpleSimTimer + constexpr std::ptrdiff_t m_fIsRunning = 0x8; // bool +} + +namespace CSun { // CBaseModelEntity + constexpr std::ptrdiff_t m_vDirection = 0x700; // Vector + constexpr std::ptrdiff_t m_clrOverlay = 0x70C; // Color + constexpr std::ptrdiff_t m_iszEffectName = 0x710; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszSSEffectName = 0x718; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bOn = 0x720; // bool + constexpr std::ptrdiff_t m_bmaxColor = 0x721; // bool + constexpr std::ptrdiff_t m_flSize = 0x724; // float + constexpr std::ptrdiff_t m_flRotation = 0x728; // float + constexpr std::ptrdiff_t m_flHazeScale = 0x72C; // float + constexpr std::ptrdiff_t m_flAlphaHaze = 0x730; // float + constexpr std::ptrdiff_t m_flAlphaHdr = 0x734; // float + constexpr std::ptrdiff_t m_flAlphaScale = 0x738; // float + constexpr std::ptrdiff_t m_flHDRColorScale = 0x73C; // float + constexpr std::ptrdiff_t m_flFarZScale = 0x740; // float +} + +namespace CTablet { // CCSWeaponBase +} + +namespace CTakeDamageInfo { + constexpr std::ptrdiff_t m_vecDamageForce = 0x8; // Vector + constexpr std::ptrdiff_t m_vecDamagePosition = 0x14; // Vector + constexpr std::ptrdiff_t m_vecReportedPosition = 0x20; // Vector + constexpr std::ptrdiff_t m_vecDamageDirection = 0x2C; // Vector + constexpr std::ptrdiff_t m_hInflictor = 0x38; // CHandle + constexpr std::ptrdiff_t m_hAttacker = 0x3C; // CHandle + constexpr std::ptrdiff_t m_hAbility = 0x40; // CHandle + constexpr std::ptrdiff_t m_flDamage = 0x44; // float + constexpr std::ptrdiff_t m_bitsDamageType = 0x48; // int32_t + constexpr std::ptrdiff_t m_iDamageCustom = 0x4C; // int32_t + constexpr std::ptrdiff_t m_iAmmoType = 0x50; // AmmoIndex_t + constexpr std::ptrdiff_t m_flOriginalDamage = 0x60; // float + constexpr std::ptrdiff_t m_bShouldBleed = 0x64; // bool + constexpr std::ptrdiff_t m_bShouldSpark = 0x65; // bool + constexpr std::ptrdiff_t m_nDamageFlags = 0x70; // TakeDamageFlags_t + constexpr std::ptrdiff_t m_nNumObjectsPenetrated = 0x74; // int32_t + constexpr std::ptrdiff_t m_hScriptInstance = 0x78; // HSCRIPT + constexpr std::ptrdiff_t m_bInTakeDamageFlow = 0x94; // bool +} + +namespace CTakeDamageResult { + constexpr std::ptrdiff_t m_nHealthLost = 0x0; // int32_t + constexpr std::ptrdiff_t m_nDamageTaken = 0x4; // int32_t +} + +namespace CTakeDamageSummaryScopeGuard { + constexpr std::ptrdiff_t m_vecSummaries = 0x8; // CUtlVector +} + +namespace CTankTargetChange { // CPointEntity + constexpr std::ptrdiff_t m_newTarget = 0x4B0; // CVariantBase + constexpr std::ptrdiff_t m_newTargetName = 0x4C0; // CUtlSymbolLarge +} + +namespace CTankTrainAI { // CPointEntity + constexpr std::ptrdiff_t m_hTrain = 0x4B0; // CHandle + constexpr std::ptrdiff_t m_hTargetEntity = 0x4B4; // CHandle + constexpr std::ptrdiff_t m_soundPlaying = 0x4B8; // int32_t + constexpr std::ptrdiff_t m_startSoundName = 0x4D0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_engineSoundName = 0x4D8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_movementSoundName = 0x4E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_targetEntityName = 0x4E8; // CUtlSymbolLarge +} + +namespace CTeam { // CBaseEntity + constexpr std::ptrdiff_t m_aPlayerControllers = 0x4B0; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_aPlayers = 0x4C8; // CNetworkUtlVectorBase> + constexpr std::ptrdiff_t m_iScore = 0x4E0; // int32_t + constexpr std::ptrdiff_t m_szTeamname = 0x4E4; // char[129] +} + +namespace CTeamplayRules { // CMultiplayRules +} + +namespace CTestEffect { // CBaseEntity + constexpr std::ptrdiff_t m_iLoop = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_iBeam = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_pBeam = 0x4B8; // CBeam*[24] + constexpr std::ptrdiff_t m_flBeamTime = 0x578; // GameTime_t[24] + constexpr std::ptrdiff_t m_flStartTime = 0x5D8; // GameTime_t +} + +namespace CTextureBasedAnimatable { // CBaseModelEntity + constexpr std::ptrdiff_t m_bLoop = 0x700; // bool + constexpr std::ptrdiff_t m_flFPS = 0x704; // float + constexpr std::ptrdiff_t m_hPositionKeys = 0x708; // CStrongHandle + constexpr std::ptrdiff_t m_hRotationKeys = 0x710; // CStrongHandle + constexpr std::ptrdiff_t m_vAnimationBoundsMin = 0x718; // Vector + constexpr std::ptrdiff_t m_vAnimationBoundsMax = 0x724; // Vector + constexpr std::ptrdiff_t m_flStartTime = 0x730; // float + constexpr std::ptrdiff_t m_flStartFrame = 0x734; // float +} + +namespace CTimeline { // IntervalTimer + constexpr std::ptrdiff_t m_flValues = 0x10; // float[64] + constexpr std::ptrdiff_t m_nValueCounts = 0x110; // int32_t[64] + constexpr std::ptrdiff_t m_nBucketCount = 0x210; // int32_t + constexpr std::ptrdiff_t m_flInterval = 0x214; // float + constexpr std::ptrdiff_t m_flFinalValue = 0x218; // float + constexpr std::ptrdiff_t m_nCompressionType = 0x21C; // TimelineCompression_t + constexpr std::ptrdiff_t m_bStopped = 0x220; // bool +} + +namespace CTimerEntity { // CLogicalEntity + constexpr std::ptrdiff_t m_OnTimer = 0x4B0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTimerHigh = 0x4D8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnTimerLow = 0x500; // CEntityIOOutput + constexpr std::ptrdiff_t m_iDisabled = 0x528; // int32_t + constexpr std::ptrdiff_t m_flInitialDelay = 0x52C; // float + constexpr std::ptrdiff_t m_flRefireTime = 0x530; // float + constexpr std::ptrdiff_t m_bUpDownState = 0x534; // bool + constexpr std::ptrdiff_t m_iUseRandomTime = 0x538; // int32_t + constexpr std::ptrdiff_t m_bPauseAfterFiring = 0x53C; // bool + constexpr std::ptrdiff_t m_flLowerRandomBound = 0x540; // float + constexpr std::ptrdiff_t m_flUpperRandomBound = 0x544; // float + constexpr std::ptrdiff_t m_flRemainingTime = 0x548; // float + constexpr std::ptrdiff_t m_bPaused = 0x54C; // bool +} + +namespace CTonemapController2 { // CBaseEntity + constexpr std::ptrdiff_t m_flAutoExposureMin = 0x4B0; // float + constexpr std::ptrdiff_t m_flAutoExposureMax = 0x4B4; // float + constexpr std::ptrdiff_t m_flTonemapPercentTarget = 0x4B8; // float + constexpr std::ptrdiff_t m_flTonemapPercentBrightPixels = 0x4BC; // float + constexpr std::ptrdiff_t m_flTonemapMinAvgLum = 0x4C0; // float + constexpr std::ptrdiff_t m_flExposureAdaptationSpeedUp = 0x4C4; // float + constexpr std::ptrdiff_t m_flExposureAdaptationSpeedDown = 0x4C8; // float + constexpr std::ptrdiff_t m_flTonemapEVSmoothingRange = 0x4CC; // float +} + +namespace CTonemapController2Alias_env_tonemap_controller2 { // CTonemapController2 +} + +namespace CTonemapTrigger { // CBaseTrigger + constexpr std::ptrdiff_t m_tonemapControllerName = 0x8A8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hTonemapController = 0x8B0; // CEntityHandle +} + +namespace CTouchExpansionComponent { // CEntityComponent +} + +namespace CTriggerActiveWeaponDetect { // CBaseTrigger + constexpr std::ptrdiff_t m_OnTouchedActiveWeapon = 0x8A8; // CEntityIOOutput + constexpr std::ptrdiff_t m_iszWeaponClassName = 0x8D0; // CUtlSymbolLarge +} + +namespace CTriggerBombReset { // CBaseTrigger +} + +namespace CTriggerBrush { // CBaseModelEntity + constexpr std::ptrdiff_t m_OnStartTouch = 0x700; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnEndTouch = 0x728; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnUse = 0x750; // CEntityIOOutput + constexpr std::ptrdiff_t m_iInputFilter = 0x778; // int32_t + constexpr std::ptrdiff_t m_iDontMessageParent = 0x77C; // int32_t +} + +namespace CTriggerBuoyancy { // CBaseTrigger + constexpr std::ptrdiff_t m_BuoyancyHelper = 0x8A8; // CBuoyancyHelper + constexpr std::ptrdiff_t m_flFluidDensity = 0x8C8; // float +} + +namespace CTriggerCallback { // CBaseTrigger +} + +namespace CTriggerDetectBulletFire { // CBaseTrigger + constexpr std::ptrdiff_t m_bPlayerFireOnly = 0x8A8; // bool + constexpr std::ptrdiff_t m_OnDetectedBulletFire = 0x8B0; // CEntityIOOutput +} + +namespace CTriggerDetectExplosion { // CBaseTrigger + constexpr std::ptrdiff_t m_OnDetectedExplosion = 0x8E0; // CEntityIOOutput +} + +namespace CTriggerFan { // CBaseTrigger + constexpr std::ptrdiff_t m_vFanOrigin = 0x8A8; // Vector + constexpr std::ptrdiff_t m_vFanEnd = 0x8B4; // Vector + constexpr std::ptrdiff_t m_vNoise = 0x8C0; // Vector + constexpr std::ptrdiff_t m_flForce = 0x8CC; // float + constexpr std::ptrdiff_t m_flPlayerForce = 0x8D0; // float + constexpr std::ptrdiff_t m_flRampTime = 0x8D4; // float + constexpr std::ptrdiff_t m_bFalloff = 0x8D8; // bool + constexpr std::ptrdiff_t m_bPushPlayer = 0x8D9; // bool + constexpr std::ptrdiff_t m_bRampDown = 0x8DA; // bool + constexpr std::ptrdiff_t m_bAddNoise = 0x8DB; // bool + constexpr std::ptrdiff_t m_RampTimer = 0x8E0; // CountdownTimer +} + +namespace CTriggerGameEvent { // CBaseTrigger + constexpr std::ptrdiff_t m_strStartTouchEventName = 0x8A8; // CUtlString + constexpr std::ptrdiff_t m_strEndTouchEventName = 0x8B0; // CUtlString + constexpr std::ptrdiff_t m_strTriggerID = 0x8B8; // CUtlString +} + +namespace CTriggerGravity { // CBaseTrigger +} + +namespace CTriggerHurt { // CBaseTrigger + constexpr std::ptrdiff_t m_flOriginalDamage = 0x8A8; // float + constexpr std::ptrdiff_t m_flDamage = 0x8AC; // float + constexpr std::ptrdiff_t m_flDamageCap = 0x8B0; // float + constexpr std::ptrdiff_t m_flLastDmgTime = 0x8B4; // GameTime_t + constexpr std::ptrdiff_t m_flForgivenessDelay = 0x8B8; // float + constexpr std::ptrdiff_t m_bitsDamageInflict = 0x8BC; // int32_t + constexpr std::ptrdiff_t m_damageModel = 0x8C0; // int32_t + constexpr std::ptrdiff_t m_bNoDmgForce = 0x8C4; // bool + constexpr std::ptrdiff_t m_vDamageForce = 0x8C8; // Vector + constexpr std::ptrdiff_t m_thinkAlways = 0x8D4; // bool + constexpr std::ptrdiff_t m_hurtThinkPeriod = 0x8D8; // float + constexpr std::ptrdiff_t m_OnHurt = 0x8E0; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnHurtPlayer = 0x908; // CEntityIOOutput + constexpr std::ptrdiff_t m_hurtEntities = 0x930; // CUtlVector> +} + +namespace CTriggerHurtGhost { // CTriggerHurt +} + +namespace CTriggerImpact { // CTriggerMultiple + constexpr std::ptrdiff_t m_flMagnitude = 0x8D0; // float + constexpr std::ptrdiff_t m_flNoise = 0x8D4; // float + constexpr std::ptrdiff_t m_flViewkick = 0x8D8; // float + constexpr std::ptrdiff_t m_pOutputForce = 0x8E0; // CEntityOutputTemplate +} + +namespace CTriggerLerpObject { // CBaseTrigger + constexpr std::ptrdiff_t m_iszLerpTarget = 0x8A8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hLerpTarget = 0x8B0; // CHandle + constexpr std::ptrdiff_t m_iszLerpTargetAttachment = 0x8B8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hLerpTargetAttachment = 0x8C0; // AttachmentHandle_t + constexpr std::ptrdiff_t m_flLerpDuration = 0x8C4; // float + constexpr std::ptrdiff_t m_bLerpRestoreMoveType = 0x8C8; // bool + constexpr std::ptrdiff_t m_bSingleLerpObject = 0x8C9; // bool + constexpr std::ptrdiff_t m_vecLerpingObjects = 0x8D0; // CUtlVector + constexpr std::ptrdiff_t m_iszLerpEffect = 0x8E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszLerpSound = 0x8F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_OnLerpStarted = 0x8F8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnLerpFinished = 0x920; // CEntityIOOutput +} + +namespace CTriggerLook { // CTriggerOnce + constexpr std::ptrdiff_t m_hLookTarget = 0x8D0; // CHandle + constexpr std::ptrdiff_t m_flFieldOfView = 0x8D4; // float + constexpr std::ptrdiff_t m_flLookTime = 0x8D8; // float + constexpr std::ptrdiff_t m_flLookTimeTotal = 0x8DC; // float + constexpr std::ptrdiff_t m_flLookTimeLast = 0x8E0; // GameTime_t + constexpr std::ptrdiff_t m_flTimeoutDuration = 0x8E4; // float + constexpr std::ptrdiff_t m_bTimeoutFired = 0x8E8; // bool + constexpr std::ptrdiff_t m_bIsLooking = 0x8E9; // bool + constexpr std::ptrdiff_t m_b2DFOV = 0x8EA; // bool + constexpr std::ptrdiff_t m_bUseVelocity = 0x8EB; // bool + constexpr std::ptrdiff_t m_hActivator = 0x8EC; // CHandle + constexpr std::ptrdiff_t m_bTestOcclusion = 0x8F0; // bool + constexpr std::ptrdiff_t m_OnTimeout = 0x8F8; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnStartLook = 0x920; // CEntityIOOutput + constexpr std::ptrdiff_t m_OnEndLook = 0x948; // CEntityIOOutput +} + +namespace CTriggerMultiple { // CBaseTrigger + constexpr std::ptrdiff_t m_OnTrigger = 0x8A8; // CEntityIOOutput +} + +namespace CTriggerOnce { // CTriggerMultiple +} + +namespace CTriggerPhysics { // CBaseTrigger + constexpr std::ptrdiff_t m_gravityScale = 0x8B8; // float + constexpr std::ptrdiff_t m_linearLimit = 0x8BC; // float + constexpr std::ptrdiff_t m_linearDamping = 0x8C0; // float + constexpr std::ptrdiff_t m_angularLimit = 0x8C4; // float + constexpr std::ptrdiff_t m_angularDamping = 0x8C8; // float + constexpr std::ptrdiff_t m_linearForce = 0x8CC; // float + constexpr std::ptrdiff_t m_flFrequency = 0x8D0; // float + constexpr std::ptrdiff_t m_flDampingRatio = 0x8D4; // float + constexpr std::ptrdiff_t m_vecLinearForcePointAt = 0x8D8; // Vector + constexpr std::ptrdiff_t m_bCollapseToForcePoint = 0x8E4; // bool + constexpr std::ptrdiff_t m_vecLinearForcePointAtWorld = 0x8E8; // Vector + constexpr std::ptrdiff_t m_vecLinearForceDirection = 0x8F4; // Vector + constexpr std::ptrdiff_t m_bConvertToDebrisWhenPossible = 0x900; // bool +} + +namespace CTriggerProximity { // CBaseTrigger + constexpr std::ptrdiff_t m_hMeasureTarget = 0x8A8; // CHandle + constexpr std::ptrdiff_t m_iszMeasureTarget = 0x8B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_fRadius = 0x8B8; // float + constexpr std::ptrdiff_t m_nTouchers = 0x8BC; // int32_t + constexpr std::ptrdiff_t m_NearestEntityDistance = 0x8C0; // CEntityOutputTemplate +} + +namespace CTriggerPush { // CBaseTrigger + constexpr std::ptrdiff_t m_angPushEntitySpace = 0x8A8; // QAngle + constexpr std::ptrdiff_t m_vecPushDirEntitySpace = 0x8B4; // Vector + constexpr std::ptrdiff_t m_bTriggerOnStartTouch = 0x8C0; // bool + constexpr std::ptrdiff_t m_flAlternateTicksFix = 0x8C4; // float + constexpr std::ptrdiff_t m_flPushSpeed = 0x8C8; // float +} + +namespace CTriggerRemove { // CBaseTrigger + constexpr std::ptrdiff_t m_OnRemove = 0x8A8; // CEntityIOOutput +} + +namespace CTriggerSave { // CBaseTrigger + constexpr std::ptrdiff_t m_bForceNewLevelUnit = 0x8A8; // bool + constexpr std::ptrdiff_t m_fDangerousTimer = 0x8AC; // float + constexpr std::ptrdiff_t m_minHitPoints = 0x8B0; // int32_t +} + +namespace CTriggerSndSosOpvar { // CBaseTrigger + constexpr std::ptrdiff_t m_hTouchingPlayers = 0x8A8; // CUtlVector> + constexpr std::ptrdiff_t m_flPosition = 0x8C0; // Vector + constexpr std::ptrdiff_t m_flCenterSize = 0x8CC; // float + constexpr std::ptrdiff_t m_flMinVal = 0x8D0; // float + constexpr std::ptrdiff_t m_flMaxVal = 0x8D4; // float + constexpr std::ptrdiff_t m_flWait = 0x8D8; // float + constexpr std::ptrdiff_t m_opvarName = 0x8E0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_stackName = 0x8E8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_operatorName = 0x8F0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bVolIs2D = 0x8F8; // bool + constexpr std::ptrdiff_t m_opvarNameChar = 0x8F9; // char[256] + constexpr std::ptrdiff_t m_stackNameChar = 0x9F9; // char[256] + constexpr std::ptrdiff_t m_operatorNameChar = 0xAF9; // char[256] + constexpr std::ptrdiff_t m_VecNormPos = 0xBFC; // Vector + constexpr std::ptrdiff_t m_flNormCenterSize = 0xC08; // float +} + +namespace CTriggerSoundscape { // CBaseTrigger + constexpr std::ptrdiff_t m_hSoundscape = 0x8A8; // CHandle + constexpr std::ptrdiff_t m_SoundscapeName = 0x8B0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_spectators = 0x8B8; // CUtlVector> +} + +namespace CTriggerTeleport { // CBaseTrigger + constexpr std::ptrdiff_t m_iLandmark = 0x8A8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_bUseLandmarkAngles = 0x8B0; // bool + constexpr std::ptrdiff_t m_bMirrorPlayer = 0x8B1; // bool +} + +namespace CTriggerToggleSave { // CBaseTrigger + constexpr std::ptrdiff_t m_bDisabled = 0x8A8; // bool +} + +namespace CTriggerTripWire { // CBaseTrigger +} + +namespace CTriggerVolume { // CBaseModelEntity + constexpr std::ptrdiff_t m_iFilterName = 0x700; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_hFilter = 0x708; // CHandle +} + +namespace CTripWireFire { // CBaseCSGrenade +} + +namespace CTripWireFireProjectile { // CBaseGrenade +} + +namespace CVoteController { // CBaseEntity + constexpr std::ptrdiff_t m_iActiveIssueIndex = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_iOnlyTeamToVote = 0x4B4; // int32_t + constexpr std::ptrdiff_t m_nVoteOptionCount = 0x4B8; // int32_t[5] + constexpr std::ptrdiff_t m_nPotentialVotes = 0x4CC; // int32_t + constexpr std::ptrdiff_t m_bIsYesNoVote = 0x4D0; // bool + constexpr std::ptrdiff_t m_acceptingVotesTimer = 0x4D8; // CountdownTimer + constexpr std::ptrdiff_t m_executeCommandTimer = 0x4F0; // CountdownTimer + constexpr std::ptrdiff_t m_resetVoteTimer = 0x508; // CountdownTimer + constexpr std::ptrdiff_t m_nVotesCast = 0x520; // int32_t[64] + constexpr std::ptrdiff_t m_playerHoldingVote = 0x620; // CPlayerSlot + constexpr std::ptrdiff_t m_playerOverrideForVote = 0x624; // CPlayerSlot + constexpr std::ptrdiff_t m_nHighestCountIndex = 0x628; // int32_t + constexpr std::ptrdiff_t m_potentialIssues = 0x630; // CUtlVector + constexpr std::ptrdiff_t m_VoteOptions = 0x648; // CUtlVector +} + +namespace CWaterBullet { // CBaseAnimGraph +} + +namespace CWeaponAWP { // CCSWeaponBaseGun +} + +namespace CWeaponAug { // CCSWeaponBaseGun +} + +namespace CWeaponBaseItem { // CCSWeaponBase + constexpr std::ptrdiff_t m_SequenceCompleteTimer = 0xE18; // CountdownTimer + constexpr std::ptrdiff_t m_bRedraw = 0xE30; // bool +} + +namespace CWeaponBizon { // CCSWeaponBaseGun +} + +namespace CWeaponCZ75a { // CCSWeaponBaseGun +} + +namespace CWeaponElite { // CCSWeaponBaseGun +} + +namespace CWeaponFamas { // CCSWeaponBaseGun +} + +namespace CWeaponFiveSeven { // CCSWeaponBaseGun +} + +namespace CWeaponG3SG1 { // CCSWeaponBaseGun +} + +namespace CWeaponGalilAR { // CCSWeaponBaseGun +} + +namespace CWeaponGlock { // CCSWeaponBaseGun +} + +namespace CWeaponHKP2000 { // CCSWeaponBaseGun +} + +namespace CWeaponM249 { // CCSWeaponBaseGun +} + +namespace CWeaponM4A1 { // CCSWeaponBaseGun +} + +namespace CWeaponM4A1Silencer { // CCSWeaponBaseGun +} + +namespace CWeaponMAC10 { // CCSWeaponBaseGun +} + +namespace CWeaponMP5SD { // CCSWeaponBaseGun +} + +namespace CWeaponMP7 { // CCSWeaponBaseGun +} + +namespace CWeaponMP9 { // CCSWeaponBaseGun +} + +namespace CWeaponMag7 { // CCSWeaponBaseGun +} + +namespace CWeaponNOVA { // CCSWeaponBase +} + +namespace CWeaponNegev { // CCSWeaponBaseGun +} + +namespace CWeaponP250 { // CCSWeaponBaseGun +} + +namespace CWeaponP90 { // CCSWeaponBaseGun +} + +namespace CWeaponRevolver { // CCSWeaponBaseGun +} + +namespace CWeaponSCAR20 { // CCSWeaponBaseGun +} + +namespace CWeaponSG556 { // CCSWeaponBaseGun +} + +namespace CWeaponSSG08 { // CCSWeaponBaseGun +} + +namespace CWeaponSawedoff { // CCSWeaponBase +} + +namespace CWeaponShield { // CCSWeaponBaseGun + constexpr std::ptrdiff_t m_flBulletDamageAbsorbed = 0xE38; // float + constexpr std::ptrdiff_t m_flLastBulletHitSoundTime = 0xE3C; // GameTime_t + constexpr std::ptrdiff_t m_flDisplayHealth = 0xE40; // float +} + +namespace CWeaponTaser { // CCSWeaponBaseGun + constexpr std::ptrdiff_t m_fFireTime = 0xE38; // GameTime_t +} + +namespace CWeaponTec9 { // CCSWeaponBaseGun +} + +namespace CWeaponUMP45 { // CCSWeaponBaseGun +} + +namespace CWeaponUSPSilencer { // CCSWeaponBaseGun +} + +namespace CWeaponXM1014 { // CCSWeaponBase +} + +namespace CWeaponZoneRepulsor { // CCSWeaponBaseGun +} + +namespace CWorld { // CBaseModelEntity +} + +namespace CommandToolCommand_t { + constexpr std::ptrdiff_t m_bEnabled = 0x0; // bool + constexpr std::ptrdiff_t m_bOpened = 0x1; // bool + constexpr std::ptrdiff_t m_InternalId = 0x4; // uint32_t + constexpr std::ptrdiff_t m_ShortName = 0x8; // CUtlString + constexpr std::ptrdiff_t m_ExecMode = 0x10; // CommandExecMode_t + constexpr std::ptrdiff_t m_SpawnGroup = 0x18; // CUtlString + constexpr std::ptrdiff_t m_PeriodicExecDelay = 0x20; // float + constexpr std::ptrdiff_t m_SpecType = 0x24; // CommandEntitySpecType_t + constexpr std::ptrdiff_t m_EntitySpec = 0x28; // CUtlString + constexpr std::ptrdiff_t m_Commands = 0x30; // CUtlString + constexpr std::ptrdiff_t m_SetDebugBits = 0x38; // DebugOverlayBits_t + constexpr std::ptrdiff_t m_ClearDebugBits = 0x40; // DebugOverlayBits_t +} + +namespace ConceptHistory_t { + constexpr std::ptrdiff_t timeSpoken = 0x0; // float + constexpr std::ptrdiff_t m_response = 0x8; // CRR_Response +} + +namespace ConstraintSoundInfo { + constexpr std::ptrdiff_t m_vSampler = 0x8; // VelocitySampler + constexpr std::ptrdiff_t m_soundProfile = 0x20; // SimpleConstraintSoundProfile + constexpr std::ptrdiff_t m_forwardAxis = 0x40; // Vector + constexpr std::ptrdiff_t m_iszTravelSoundFwd = 0x50; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszTravelSoundBack = 0x58; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszReversalSounds = 0x68; // CUtlSymbolLarge[3] + constexpr std::ptrdiff_t m_bPlayTravelSound = 0x80; // bool + constexpr std::ptrdiff_t m_bPlayReversalSound = 0x81; // bool +} + +namespace CountdownTimer { + constexpr std::ptrdiff_t m_duration = 0x8; // float + constexpr std::ptrdiff_t m_timestamp = 0xC; // GameTime_t + constexpr std::ptrdiff_t m_timescale = 0x10; // float + constexpr std::ptrdiff_t m_nWorldGroupId = 0x14; // WorldGroupId_t +} + +namespace EngineCountdownTimer { + constexpr std::ptrdiff_t m_duration = 0x8; // float + constexpr std::ptrdiff_t m_timestamp = 0xC; // float + constexpr std::ptrdiff_t m_timescale = 0x10; // float +} + +namespace EntityRenderAttribute_t { + constexpr std::ptrdiff_t m_ID = 0x30; // CUtlStringToken + constexpr std::ptrdiff_t m_Values = 0x34; // Vector4D +} + +namespace EntitySpottedState_t { + constexpr std::ptrdiff_t m_bSpotted = 0x8; // bool + constexpr std::ptrdiff_t m_bSpottedByMask = 0xC; // uint32_t[2] +} + +namespace Extent { + constexpr std::ptrdiff_t lo = 0x0; // Vector + constexpr std::ptrdiff_t hi = 0xC; // Vector +} + +namespace FilterDamageType { // CBaseFilter + constexpr std::ptrdiff_t m_iDamageType = 0x508; // int32_t +} + +namespace FilterHealth { // CBaseFilter + constexpr std::ptrdiff_t m_bAdrenalineActive = 0x508; // bool + constexpr std::ptrdiff_t m_iHealthMin = 0x50C; // int32_t + constexpr std::ptrdiff_t m_iHealthMax = 0x510; // int32_t +} + +namespace FilterTeam { // CBaseFilter + constexpr std::ptrdiff_t m_iFilterTeam = 0x508; // int32_t +} + +namespace GameAmmoTypeInfo_t { // AmmoTypeInfo_t + constexpr std::ptrdiff_t m_nBuySize = 0x38; // int32_t + constexpr std::ptrdiff_t m_nCost = 0x3C; // int32_t +} + +namespace GameTick_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace GameTime_t { + constexpr std::ptrdiff_t m_Value = 0x0; // float +} + +namespace HullFlags_t { + constexpr std::ptrdiff_t m_bHull_Human = 0x0; // bool + constexpr std::ptrdiff_t m_bHull_SmallCentered = 0x1; // bool + constexpr std::ptrdiff_t m_bHull_WideHuman = 0x2; // bool + constexpr std::ptrdiff_t m_bHull_Tiny = 0x3; // bool + constexpr std::ptrdiff_t m_bHull_Medium = 0x4; // bool + constexpr std::ptrdiff_t m_bHull_TinyCentered = 0x5; // bool + constexpr std::ptrdiff_t m_bHull_Large = 0x6; // bool + constexpr std::ptrdiff_t m_bHull_LargeCentered = 0x7; // bool + constexpr std::ptrdiff_t m_bHull_MediumTall = 0x8; // bool + constexpr std::ptrdiff_t m_bHull_Small = 0x9; // bool +} + +namespace IChoreoServices { +} + +namespace IEconItemInterface { +} + +namespace IHasAttributes { +} + +namespace IRagdoll { +} + +namespace ISkeletonAnimationController { +} + +namespace IVehicle { +} + +namespace IntervalTimer { + constexpr std::ptrdiff_t m_timestamp = 0x8; // GameTime_t + constexpr std::ptrdiff_t m_nWorldGroupId = 0xC; // WorldGroupId_t +} + +namespace ModelConfigHandle_t { + constexpr std::ptrdiff_t m_Value = 0x0; // uint32_t +} + +namespace ParticleIndex_t { + constexpr std::ptrdiff_t m_Value = 0x0; // int32_t +} + +namespace PhysicsRagdollPose_t { + constexpr std::ptrdiff_t __m_pChainEntity = 0x8; // CNetworkVarChainer + constexpr std::ptrdiff_t m_Transforms = 0x30; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_hOwner = 0x48; // CHandle +} + +namespace QuestProgress { +} + +namespace RagdollCreationParams_t { + constexpr std::ptrdiff_t m_vForce = 0x0; // Vector + constexpr std::ptrdiff_t m_nForceBone = 0xC; // int32_t +} + +namespace RelationshipOverride_t { // Relationship_t + constexpr std::ptrdiff_t entity = 0x8; // CHandle + constexpr std::ptrdiff_t classType = 0xC; // Class_T +} + +namespace Relationship_t { + constexpr std::ptrdiff_t disposition = 0x0; // Disposition_t + constexpr std::ptrdiff_t priority = 0x4; // int32_t +} + +namespace ResponseContext_t { + constexpr std::ptrdiff_t m_iszName = 0x0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_iszValue = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_fExpirationTime = 0x10; // GameTime_t +} + +namespace ResponseFollowup { + constexpr std::ptrdiff_t followup_concept = 0x0; // char* + constexpr std::ptrdiff_t followup_contexts = 0x8; // char* + constexpr std::ptrdiff_t followup_delay = 0x10; // float + constexpr std::ptrdiff_t followup_target = 0x14; // char* + constexpr std::ptrdiff_t followup_entityiotarget = 0x1C; // char* + constexpr std::ptrdiff_t followup_entityioinput = 0x24; // char* + constexpr std::ptrdiff_t followup_entityiodelay = 0x2C; // float + constexpr std::ptrdiff_t bFired = 0x30; // bool +} + +namespace ResponseParams { + constexpr std::ptrdiff_t odds = 0x10; // int16_t + constexpr std::ptrdiff_t flags = 0x12; // int16_t + constexpr std::ptrdiff_t m_pFollowup = 0x18; // ResponseFollowup* +} + +namespace SellbackPurchaseEntry_t { + constexpr std::ptrdiff_t m_unDefIdx = 0x30; // uint16_t + constexpr std::ptrdiff_t m_nCost = 0x34; // int32_t + constexpr std::ptrdiff_t m_nPrevArmor = 0x38; // int32_t + constexpr std::ptrdiff_t m_bPrevHelmet = 0x3C; // bool + constexpr std::ptrdiff_t m_hItem = 0x40; // CEntityHandle +} + +namespace ServerAuthoritativeWeaponSlot_t { + constexpr std::ptrdiff_t unClass = 0x28; // uint16_t + constexpr std::ptrdiff_t unSlot = 0x2A; // uint16_t + constexpr std::ptrdiff_t unItemDefIdx = 0x2C; // uint16_t +} + +namespace SimpleConstraintSoundProfile { + constexpr std::ptrdiff_t eKeypoints = 0x8; // SimpleConstraintSoundProfile::SimpleConstraintsSoundProfileKeypoints_t + constexpr std::ptrdiff_t m_keyPoints = 0xC; // float[2] + constexpr std::ptrdiff_t m_reversalSoundThresholds = 0x14; // float[3] +} + +namespace SpawnPoint { // CServerOnlyPointEntity + constexpr std::ptrdiff_t m_iPriority = 0x4B0; // int32_t + constexpr std::ptrdiff_t m_bEnabled = 0x4B4; // bool + constexpr std::ptrdiff_t m_nType = 0x4B8; // int32_t +} + +namespace SpawnPointCoopEnemy { // SpawnPoint + constexpr std::ptrdiff_t m_szWeaponsToGive = 0x4C0; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_szPlayerModelToUse = 0x4C8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_nArmorToSpawnWith = 0x4D0; // int32_t + constexpr std::ptrdiff_t m_nDefaultBehavior = 0x4D4; // SpawnPointCoopEnemy::BotDefaultBehavior_t + constexpr std::ptrdiff_t m_nBotDifficulty = 0x4D8; // int32_t + constexpr std::ptrdiff_t m_bIsAgressive = 0x4DC; // bool + constexpr std::ptrdiff_t m_bStartAsleep = 0x4DD; // bool + constexpr std::ptrdiff_t m_flHideRadius = 0x4E0; // float + constexpr std::ptrdiff_t m_szBehaviorTreeFile = 0x4F0; // CUtlSymbolLarge +} + +namespace SummaryTakeDamageInfo_t { + constexpr std::ptrdiff_t nSummarisedCount = 0x0; // int32_t + constexpr std::ptrdiff_t info = 0x8; // CTakeDamageInfo + constexpr std::ptrdiff_t result = 0xA0; // CTakeDamageResult + constexpr std::ptrdiff_t hTarget = 0xA8; // CHandle +} + +namespace VPhysicsCollisionAttribute_t { + constexpr std::ptrdiff_t m_nInteractsAs = 0x8; // uint64_t + constexpr std::ptrdiff_t m_nInteractsWith = 0x10; // uint64_t + constexpr std::ptrdiff_t m_nInteractsExclude = 0x18; // uint64_t + constexpr std::ptrdiff_t m_nEntityId = 0x20; // uint32_t + constexpr std::ptrdiff_t m_nOwnerId = 0x24; // uint32_t + constexpr std::ptrdiff_t m_nHierarchyId = 0x28; // uint16_t + constexpr std::ptrdiff_t m_nCollisionGroup = 0x2A; // uint8_t + constexpr std::ptrdiff_t m_nCollisionFunctionMask = 0x2B; // uint8_t +} + +namespace VelocitySampler { + constexpr std::ptrdiff_t m_prevSample = 0x0; // Vector + constexpr std::ptrdiff_t m_fPrevSampleTime = 0xC; // GameTime_t + constexpr std::ptrdiff_t m_fIdealSampleRate = 0x10; // float +} + +namespace ViewAngleServerChange_t { + constexpr std::ptrdiff_t nType = 0x30; // FixAngleSet_t + constexpr std::ptrdiff_t qAngle = 0x34; // QAngle + constexpr std::ptrdiff_t nIndex = 0x40; // uint32_t +} + +namespace WeaponPurchaseCount_t { + constexpr std::ptrdiff_t m_nItemDefIndex = 0x30; // uint16_t + constexpr std::ptrdiff_t m_nCount = 0x32; // uint16_t +} + +namespace WeaponPurchaseTracker_t { + constexpr std::ptrdiff_t m_weaponPurchases = 0x8; // CUtlVectorEmbeddedNetworkVar +} + +namespace audioparams_t { + constexpr std::ptrdiff_t localSound = 0x8; // Vector[8] + constexpr std::ptrdiff_t soundscapeIndex = 0x68; // int32_t + constexpr std::ptrdiff_t localBits = 0x6C; // uint8_t + constexpr std::ptrdiff_t soundscapeEntityListIndex = 0x70; // int32_t + constexpr std::ptrdiff_t soundEventHash = 0x74; // uint32_t +} + +namespace dynpitchvol_base_t { + constexpr std::ptrdiff_t preset = 0x0; // int32_t + constexpr std::ptrdiff_t pitchrun = 0x4; // int32_t + constexpr std::ptrdiff_t pitchstart = 0x8; // int32_t + constexpr std::ptrdiff_t spinup = 0xC; // int32_t + constexpr std::ptrdiff_t spindown = 0x10; // int32_t + constexpr std::ptrdiff_t volrun = 0x14; // int32_t + constexpr std::ptrdiff_t volstart = 0x18; // int32_t + constexpr std::ptrdiff_t fadein = 0x1C; // int32_t + constexpr std::ptrdiff_t fadeout = 0x20; // int32_t + constexpr std::ptrdiff_t lfotype = 0x24; // int32_t + constexpr std::ptrdiff_t lforate = 0x28; // int32_t + constexpr std::ptrdiff_t lfomodpitch = 0x2C; // int32_t + constexpr std::ptrdiff_t lfomodvol = 0x30; // int32_t + constexpr std::ptrdiff_t cspinup = 0x34; // int32_t + constexpr std::ptrdiff_t cspincount = 0x38; // int32_t + constexpr std::ptrdiff_t pitch = 0x3C; // int32_t + constexpr std::ptrdiff_t spinupsav = 0x40; // int32_t + constexpr std::ptrdiff_t spindownsav = 0x44; // int32_t + constexpr std::ptrdiff_t pitchfrac = 0x48; // int32_t + constexpr std::ptrdiff_t vol = 0x4C; // int32_t + constexpr std::ptrdiff_t fadeinsav = 0x50; // int32_t + constexpr std::ptrdiff_t fadeoutsav = 0x54; // int32_t + constexpr std::ptrdiff_t volfrac = 0x58; // int32_t + constexpr std::ptrdiff_t lfofrac = 0x5C; // int32_t + constexpr std::ptrdiff_t lfomult = 0x60; // int32_t +} + +namespace dynpitchvol_t { // dynpitchvol_base_t +} + +namespace fogparams_t { + constexpr std::ptrdiff_t dirPrimary = 0x8; // Vector + constexpr std::ptrdiff_t colorPrimary = 0x14; // Color + constexpr std::ptrdiff_t colorSecondary = 0x18; // Color + constexpr std::ptrdiff_t colorPrimaryLerpTo = 0x1C; // Color + constexpr std::ptrdiff_t colorSecondaryLerpTo = 0x20; // Color + constexpr std::ptrdiff_t start = 0x24; // float + constexpr std::ptrdiff_t end = 0x28; // float + constexpr std::ptrdiff_t farz = 0x2C; // float + constexpr std::ptrdiff_t maxdensity = 0x30; // float + constexpr std::ptrdiff_t exponent = 0x34; // float + constexpr std::ptrdiff_t HDRColorScale = 0x38; // float + constexpr std::ptrdiff_t skyboxFogFactor = 0x3C; // float + constexpr std::ptrdiff_t skyboxFogFactorLerpTo = 0x40; // float + constexpr std::ptrdiff_t startLerpTo = 0x44; // float + constexpr std::ptrdiff_t endLerpTo = 0x48; // float + constexpr std::ptrdiff_t maxdensityLerpTo = 0x4C; // float + constexpr std::ptrdiff_t lerptime = 0x50; // GameTime_t + constexpr std::ptrdiff_t duration = 0x54; // float + constexpr std::ptrdiff_t blendtobackground = 0x58; // float + constexpr std::ptrdiff_t scattering = 0x5C; // float + constexpr std::ptrdiff_t locallightscale = 0x60; // float + constexpr std::ptrdiff_t enable = 0x64; // bool + constexpr std::ptrdiff_t blend = 0x65; // bool + constexpr std::ptrdiff_t m_bNoReflectionFog = 0x66; // bool + constexpr std::ptrdiff_t m_bPadding = 0x67; // bool +} + +namespace fogplayerparams_t { + constexpr std::ptrdiff_t m_hCtrl = 0x8; // CHandle + constexpr std::ptrdiff_t m_flTransitionTime = 0xC; // float + constexpr std::ptrdiff_t m_OldColor = 0x10; // Color + constexpr std::ptrdiff_t m_flOldStart = 0x14; // float + constexpr std::ptrdiff_t m_flOldEnd = 0x18; // float + constexpr std::ptrdiff_t m_flOldMaxDensity = 0x1C; // float + constexpr std::ptrdiff_t m_flOldHDRColorScale = 0x20; // float + constexpr std::ptrdiff_t m_flOldFarZ = 0x24; // float + constexpr std::ptrdiff_t m_NewColor = 0x28; // Color + constexpr std::ptrdiff_t m_flNewStart = 0x2C; // float + constexpr std::ptrdiff_t m_flNewEnd = 0x30; // float + constexpr std::ptrdiff_t m_flNewMaxDensity = 0x34; // float + constexpr std::ptrdiff_t m_flNewHDRColorScale = 0x38; // float + constexpr std::ptrdiff_t m_flNewFarZ = 0x3C; // float +} + +namespace hudtextparms_t { + constexpr std::ptrdiff_t color1 = 0x0; // Color + constexpr std::ptrdiff_t color2 = 0x4; // Color + constexpr std::ptrdiff_t effect = 0x8; // uint8_t + constexpr std::ptrdiff_t channel = 0x9; // uint8_t + constexpr std::ptrdiff_t x = 0xC; // float + constexpr std::ptrdiff_t y = 0x10; // float +} + +namespace lerpdata_t { + constexpr std::ptrdiff_t m_hEnt = 0x0; // CHandle + constexpr std::ptrdiff_t m_MoveType = 0x4; // MoveType_t + constexpr std::ptrdiff_t m_flStartTime = 0x8; // GameTime_t + constexpr std::ptrdiff_t m_vecStartOrigin = 0xC; // Vector + constexpr std::ptrdiff_t m_qStartRot = 0x20; // Quaternion + constexpr std::ptrdiff_t m_nFXIndex = 0x30; // ParticleIndex_t +} + +namespace locksound_t { + constexpr std::ptrdiff_t sLockedSound = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t sUnlockedSound = 0x10; // CUtlSymbolLarge + constexpr std::ptrdiff_t flwaitSound = 0x18; // GameTime_t +} + +namespace magnetted_objects_t { + constexpr std::ptrdiff_t hEntity = 0x8; // CHandle +} + +namespace ragdoll_t { + constexpr std::ptrdiff_t list = 0x0; // CUtlVector + constexpr std::ptrdiff_t boneIndex = 0x18; // CUtlVector + constexpr std::ptrdiff_t allowStretch = 0x30; // bool + constexpr std::ptrdiff_t unused = 0x31; // bool +} + +namespace ragdollelement_t { + constexpr std::ptrdiff_t originParentSpace = 0x0; // Vector + constexpr std::ptrdiff_t parentIndex = 0x20; // int32_t + constexpr std::ptrdiff_t m_flRadius = 0x24; // float +} + +namespace shard_model_desc_t { + constexpr std::ptrdiff_t m_nModelID = 0x8; // int32_t + constexpr std::ptrdiff_t m_hMaterial = 0x10; // CStrongHandle + constexpr std::ptrdiff_t m_solid = 0x18; // ShardSolid_t + constexpr std::ptrdiff_t m_ShatterPanelMode = 0x19; // ShatterPanelMode + constexpr std::ptrdiff_t m_vecPanelSize = 0x1C; // Vector2D + constexpr std::ptrdiff_t m_vecStressPositionA = 0x24; // Vector2D + constexpr std::ptrdiff_t m_vecStressPositionB = 0x2C; // Vector2D + constexpr std::ptrdiff_t m_vecPanelVertices = 0x38; // CNetworkUtlVectorBase + constexpr std::ptrdiff_t m_flGlassHalfThickness = 0x50; // float + constexpr std::ptrdiff_t m_bHasParent = 0x54; // bool + constexpr std::ptrdiff_t m_bParentFrozen = 0x55; // bool + constexpr std::ptrdiff_t m_SurfacePropStringToken = 0x58; // CUtlStringToken +} + +namespace sky3dparams_t { + constexpr std::ptrdiff_t scale = 0x8; // int16_t + constexpr std::ptrdiff_t origin = 0xC; // Vector + constexpr std::ptrdiff_t bClip3DSkyBoxNearToWorldFar = 0x18; // bool + constexpr std::ptrdiff_t flClip3DSkyBoxNearToWorldFarOffset = 0x1C; // float + constexpr std::ptrdiff_t fog = 0x20; // fogparams_t + constexpr std::ptrdiff_t m_nWorldGroupID = 0x88; // WorldGroupId_t +} + +namespace thinkfunc_t { + constexpr std::ptrdiff_t m_hFn = 0x8; // HSCRIPT + constexpr std::ptrdiff_t m_nContext = 0x10; // CUtlStringToken + constexpr std::ptrdiff_t m_nNextThinkTick = 0x14; // GameTick_t + constexpr std::ptrdiff_t m_nLastThinkTick = 0x18; // GameTick_t +} \ No newline at end of file diff --git a/HPCS2/offset/soundsystem.dll.hpp b/HPCS2/offset/soundsystem.dll.hpp new file mode 100644 index 0000000..e8c8acc --- /dev/null +++ b/HPCS2/offset/soundsystem.dll.hpp @@ -0,0 +1,313 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace CDSPMixgroupModifier { + constexpr std::ptrdiff_t m_mixgroup = 0x0; // CUtlString + constexpr std::ptrdiff_t m_flModifier = 0x8; // float + constexpr std::ptrdiff_t m_flModifierMin = 0xC; // float + constexpr std::ptrdiff_t m_flSourceModifier = 0x10; // float + constexpr std::ptrdiff_t m_flSourceModifierMin = 0x14; // float + constexpr std::ptrdiff_t m_flListenerReverbModifierWhenSourceReverbIsActive = 0x18; // float +} + +namespace CDSPPresetMixgroupModifierTable { + constexpr std::ptrdiff_t m_table = 0x0; // CUtlVector +} + +namespace CDspPresetModifierList { + constexpr std::ptrdiff_t m_dspName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_modifiers = 0x8; // CUtlVector +} + +namespace CSosGroupActionLimitSchema { // CSosGroupActionSchema + constexpr std::ptrdiff_t m_nMaxCount = 0x18; // int32_t + constexpr std::ptrdiff_t m_nStopType = 0x1C; // SosActionStopType_t + constexpr std::ptrdiff_t m_nSortType = 0x20; // SosActionSortType_t +} + +namespace CSosGroupActionSchema { + constexpr std::ptrdiff_t m_name = 0x8; // CUtlString + constexpr std::ptrdiff_t m_actionType = 0x10; // ActionType_t + constexpr std::ptrdiff_t m_actionInstanceType = 0x14; // ActionType_t +} + +namespace CSosGroupActionSetSoundeventParameterSchema { // CSosGroupActionSchema + constexpr std::ptrdiff_t m_nMaxCount = 0x18; // int32_t + constexpr std::ptrdiff_t m_flMinValue = 0x1C; // float + constexpr std::ptrdiff_t m_flMaxValue = 0x20; // float + constexpr std::ptrdiff_t m_opvarName = 0x28; // CUtlString + constexpr std::ptrdiff_t m_nSortType = 0x30; // SosActionSortType_t +} + +namespace CSosGroupActionTimeLimitSchema { // CSosGroupActionSchema + constexpr std::ptrdiff_t m_flMaxDuration = 0x18; // float +} + +namespace CSosGroupBranchPattern { + constexpr std::ptrdiff_t m_bMatchEventName = 0x8; // bool + constexpr std::ptrdiff_t m_bMatchEventSubString = 0x9; // bool + constexpr std::ptrdiff_t m_bMatchEntIndex = 0xA; // bool + constexpr std::ptrdiff_t m_bMatchOpvar = 0xB; // bool +} + +namespace CSosGroupMatchPattern { // CSosGroupBranchPattern + constexpr std::ptrdiff_t m_matchSoundEventName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_matchSoundEventSubString = 0x18; // CUtlString + constexpr std::ptrdiff_t m_flEntIndex = 0x20; // float + constexpr std::ptrdiff_t m_flOpvar = 0x24; // float +} + +namespace CSosSoundEventGroupListSchema { + constexpr std::ptrdiff_t m_groupList = 0x0; // CUtlVector +} + +namespace CSosSoundEventGroupSchema { + constexpr std::ptrdiff_t m_name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nType = 0x8; // SosGroupType_t + constexpr std::ptrdiff_t m_bIsBlocking = 0xC; // bool + constexpr std::ptrdiff_t m_nBlockMaxCount = 0x10; // int32_t + constexpr std::ptrdiff_t m_bInvertMatch = 0x14; // bool + constexpr std::ptrdiff_t m_matchPattern = 0x18; // CSosGroupMatchPattern + constexpr std::ptrdiff_t m_branchPattern = 0x40; // CSosGroupBranchPattern + constexpr std::ptrdiff_t m_vActions = 0xB0; // CSosGroupActionSchema*[4] +} + +namespace CSoundEventMetaData { + constexpr std::ptrdiff_t m_soundEventVMix = 0x0; // CStrongHandle +} + +namespace SelectedEditItemInfo_t { + constexpr std::ptrdiff_t m_EditItems = 0x0; // CUtlVector +} + +namespace SosEditItemInfo_t { + constexpr std::ptrdiff_t itemType = 0x0; // SosEditItemType_t + constexpr std::ptrdiff_t itemName = 0x8; // CUtlString + constexpr std::ptrdiff_t itemTypeName = 0x10; // CUtlString + constexpr std::ptrdiff_t itemKVString = 0x20; // CUtlString + constexpr std::ptrdiff_t itemPos = 0x28; // Vector2D +} + +namespace VMixAutoFilterDesc_t { + constexpr std::ptrdiff_t m_flEnvelopeAmount = 0x0; // float + constexpr std::ptrdiff_t m_flAttackTimeMS = 0x4; // float + constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x8; // float + constexpr std::ptrdiff_t m_filter = 0xC; // VMixFilterDesc_t + constexpr std::ptrdiff_t m_flLFOAmount = 0x1C; // float + constexpr std::ptrdiff_t m_flLFORate = 0x20; // float + constexpr std::ptrdiff_t m_flPhase = 0x24; // float + constexpr std::ptrdiff_t m_nLFOShape = 0x28; // VMixLFOShape_t +} + +namespace VMixBoxverbDesc_t { + constexpr std::ptrdiff_t m_flSizeMax = 0x0; // float + constexpr std::ptrdiff_t m_flSizeMin = 0x4; // float + constexpr std::ptrdiff_t m_flComplexity = 0x8; // float + constexpr std::ptrdiff_t m_flDiffusion = 0xC; // float + constexpr std::ptrdiff_t m_flModDepth = 0x10; // float + constexpr std::ptrdiff_t m_flModRate = 0x14; // float + constexpr std::ptrdiff_t m_bParallel = 0x18; // bool + constexpr std::ptrdiff_t m_filterType = 0x1C; // VMixFilterDesc_t + constexpr std::ptrdiff_t m_flWidth = 0x2C; // float + constexpr std::ptrdiff_t m_flHeight = 0x30; // float + constexpr std::ptrdiff_t m_flDepth = 0x34; // float + constexpr std::ptrdiff_t m_flFeedbackScale = 0x38; // float + constexpr std::ptrdiff_t m_flFeedbackWidth = 0x3C; // float + constexpr std::ptrdiff_t m_flFeedbackHeight = 0x40; // float + constexpr std::ptrdiff_t m_flFeedbackDepth = 0x44; // float + constexpr std::ptrdiff_t m_flOutputGain = 0x48; // float + constexpr std::ptrdiff_t m_flTaps = 0x4C; // float +} + +namespace VMixConvolutionDesc_t { + constexpr std::ptrdiff_t m_fldbGain = 0x0; // float + constexpr std::ptrdiff_t m_flPreDelayMS = 0x4; // float + constexpr std::ptrdiff_t m_flWetMix = 0x8; // float + constexpr std::ptrdiff_t m_fldbLow = 0xC; // float + constexpr std::ptrdiff_t m_fldbMid = 0x10; // float + constexpr std::ptrdiff_t m_fldbHigh = 0x14; // float + constexpr std::ptrdiff_t m_flLowCutoffFreq = 0x18; // float + constexpr std::ptrdiff_t m_flHighCutoffFreq = 0x1C; // float +} + +namespace VMixDelayDesc_t { + constexpr std::ptrdiff_t m_feedbackFilter = 0x0; // VMixFilterDesc_t + constexpr std::ptrdiff_t m_bEnableFilter = 0x10; // bool + constexpr std::ptrdiff_t m_flDelay = 0x14; // float + constexpr std::ptrdiff_t m_flDirectGain = 0x18; // float + constexpr std::ptrdiff_t m_flDelayGain = 0x1C; // float + constexpr std::ptrdiff_t m_flFeedbackGain = 0x20; // float + constexpr std::ptrdiff_t m_flWidth = 0x24; // float +} + +namespace VMixDiffusorDesc_t { + constexpr std::ptrdiff_t m_flSize = 0x0; // float + constexpr std::ptrdiff_t m_flComplexity = 0x4; // float + constexpr std::ptrdiff_t m_flFeedback = 0x8; // float + constexpr std::ptrdiff_t m_flOutputGain = 0xC; // float +} + +namespace VMixDynamics3BandDesc_t { + constexpr std::ptrdiff_t m_fldbGainOutput = 0x0; // float + constexpr std::ptrdiff_t m_flRMSTimeMS = 0x4; // float + constexpr std::ptrdiff_t m_fldbKneeWidth = 0x8; // float + constexpr std::ptrdiff_t m_flDepth = 0xC; // float + constexpr std::ptrdiff_t m_flWetMix = 0x10; // float + constexpr std::ptrdiff_t m_flTimeScale = 0x14; // float + constexpr std::ptrdiff_t m_flLowCutoffFreq = 0x18; // float + constexpr std::ptrdiff_t m_flHighCutoffFreq = 0x1C; // float + constexpr std::ptrdiff_t m_bPeakMode = 0x20; // bool + constexpr std::ptrdiff_t m_bandDesc = 0x24; // VMixDynamicsBand_t[3] +} + +namespace VMixDynamicsBand_t { + constexpr std::ptrdiff_t m_fldbGainInput = 0x0; // float + constexpr std::ptrdiff_t m_fldbGainOutput = 0x4; // float + constexpr std::ptrdiff_t m_fldbThresholdBelow = 0x8; // float + constexpr std::ptrdiff_t m_fldbThresholdAbove = 0xC; // float + constexpr std::ptrdiff_t m_flRatioBelow = 0x10; // float + constexpr std::ptrdiff_t m_flRatioAbove = 0x14; // float + constexpr std::ptrdiff_t m_flAttackTimeMS = 0x18; // float + constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x1C; // float + constexpr std::ptrdiff_t m_bEnable = 0x20; // bool + constexpr std::ptrdiff_t m_bSolo = 0x21; // bool +} + +namespace VMixDynamicsCompressorDesc_t { + constexpr std::ptrdiff_t m_fldbOutputGain = 0x0; // float + constexpr std::ptrdiff_t m_fldbCompressionThreshold = 0x4; // float + constexpr std::ptrdiff_t m_fldbKneeWidth = 0x8; // float + constexpr std::ptrdiff_t m_flCompressionRatio = 0xC; // float + constexpr std::ptrdiff_t m_flAttackTimeMS = 0x10; // float + constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x14; // float + constexpr std::ptrdiff_t m_flRMSTimeMS = 0x18; // float + constexpr std::ptrdiff_t m_flWetMix = 0x1C; // float + constexpr std::ptrdiff_t m_bPeakMode = 0x20; // bool +} + +namespace VMixDynamicsDesc_t { + constexpr std::ptrdiff_t m_fldbGain = 0x0; // float + constexpr std::ptrdiff_t m_fldbNoiseGateThreshold = 0x4; // float + constexpr std::ptrdiff_t m_fldbCompressionThreshold = 0x8; // float + constexpr std::ptrdiff_t m_fldbLimiterThreshold = 0xC; // float + constexpr std::ptrdiff_t m_fldbKneeWidth = 0x10; // float + constexpr std::ptrdiff_t m_flRatio = 0x14; // float + constexpr std::ptrdiff_t m_flLimiterRatio = 0x18; // float + constexpr std::ptrdiff_t m_flAttackTimeMS = 0x1C; // float + constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x20; // float + constexpr std::ptrdiff_t m_flRMSTimeMS = 0x24; // float + constexpr std::ptrdiff_t m_flWetMix = 0x28; // float + constexpr std::ptrdiff_t m_bPeakMode = 0x2C; // bool +} + +namespace VMixEQ8Desc_t { + constexpr std::ptrdiff_t m_stages = 0x0; // VMixFilterDesc_t[8] +} + +namespace VMixEffectChainDesc_t { + constexpr std::ptrdiff_t m_flCrossfadeTime = 0x0; // float +} + +namespace VMixEnvelopeDesc_t { + constexpr std::ptrdiff_t m_flAttackTimeMS = 0x0; // float + constexpr std::ptrdiff_t m_flHoldTimeMS = 0x4; // float + constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x8; // float +} + +namespace VMixFilterDesc_t { + constexpr std::ptrdiff_t m_nFilterType = 0x0; // VMixFilterType_t + constexpr std::ptrdiff_t m_nFilterSlope = 0x2; // VMixFilterSlope_t + constexpr std::ptrdiff_t m_bEnabled = 0x3; // bool + constexpr std::ptrdiff_t m_fldbGain = 0x4; // float + constexpr std::ptrdiff_t m_flCutoffFreq = 0x8; // float + constexpr std::ptrdiff_t m_flQ = 0xC; // float +} + +namespace VMixFreeverbDesc_t { + constexpr std::ptrdiff_t m_flRoomSize = 0x0; // float + constexpr std::ptrdiff_t m_flDamp = 0x4; // float + constexpr std::ptrdiff_t m_flWidth = 0x8; // float + constexpr std::ptrdiff_t m_flLateReflections = 0xC; // float +} + +namespace VMixModDelayDesc_t { + constexpr std::ptrdiff_t m_feedbackFilter = 0x0; // VMixFilterDesc_t + constexpr std::ptrdiff_t m_bPhaseInvert = 0x10; // bool + constexpr std::ptrdiff_t m_flGlideTime = 0x14; // float + constexpr std::ptrdiff_t m_flDelay = 0x18; // float + constexpr std::ptrdiff_t m_flOutputGain = 0x1C; // float + constexpr std::ptrdiff_t m_flFeedbackGain = 0x20; // float + constexpr std::ptrdiff_t m_flModRate = 0x24; // float + constexpr std::ptrdiff_t m_flModDepth = 0x28; // float + constexpr std::ptrdiff_t m_bApplyAntialiasing = 0x2C; // bool +} + +namespace VMixOscDesc_t { + constexpr std::ptrdiff_t oscType = 0x0; // VMixLFOShape_t + constexpr std::ptrdiff_t m_freq = 0x4; // float + constexpr std::ptrdiff_t m_flPhase = 0x8; // float +} + +namespace VMixPannerDesc_t { + constexpr std::ptrdiff_t m_type = 0x0; // VMixPannerType_t + constexpr std::ptrdiff_t m_flStrength = 0x4; // float +} + +namespace VMixPitchShiftDesc_t { + constexpr std::ptrdiff_t m_nGrainSampleCount = 0x0; // int32_t + constexpr std::ptrdiff_t m_flPitchShift = 0x4; // float + constexpr std::ptrdiff_t m_nQuality = 0x8; // int32_t + constexpr std::ptrdiff_t m_nProcType = 0xC; // int32_t +} + +namespace VMixPlateverbDesc_t { + constexpr std::ptrdiff_t m_flPrefilter = 0x0; // float + constexpr std::ptrdiff_t m_flInputDiffusion1 = 0x4; // float + constexpr std::ptrdiff_t m_flInputDiffusion2 = 0x8; // float + constexpr std::ptrdiff_t m_flDecay = 0xC; // float + constexpr std::ptrdiff_t m_flDamp = 0x10; // float + constexpr std::ptrdiff_t m_flFeedbackDiffusion1 = 0x14; // float + constexpr std::ptrdiff_t m_flFeedbackDiffusion2 = 0x18; // float +} + +namespace VMixShaperDesc_t { + constexpr std::ptrdiff_t m_nShape = 0x0; // int32_t + constexpr std::ptrdiff_t m_fldbDrive = 0x4; // float + constexpr std::ptrdiff_t m_fldbOutputGain = 0x8; // float + constexpr std::ptrdiff_t m_flWetMix = 0xC; // float + constexpr std::ptrdiff_t m_nOversampleFactor = 0x10; // int32_t +} + +namespace VMixSubgraphSwitchDesc_t { + constexpr std::ptrdiff_t m_interpolationMode = 0x0; // VMixSubgraphSwitchInterpolationType_t + constexpr std::ptrdiff_t m_bOnlyTailsOnFadeOut = 0x4; // bool + constexpr std::ptrdiff_t m_flInterpolationTime = 0x8; // float +} + +namespace VMixUtilityDesc_t { + constexpr std::ptrdiff_t m_nOp = 0x0; // VMixChannelOperation_t + constexpr std::ptrdiff_t m_flInputPan = 0x4; // float + constexpr std::ptrdiff_t m_flOutputBalance = 0x8; // float + constexpr std::ptrdiff_t m_fldbOutputGain = 0xC; // float + constexpr std::ptrdiff_t m_bBassMono = 0x10; // bool + constexpr std::ptrdiff_t m_flBassFreq = 0x14; // float +} + +namespace VMixVocoderDesc_t { + constexpr std::ptrdiff_t m_nBandCount = 0x0; // int32_t + constexpr std::ptrdiff_t m_flBandwidth = 0x4; // float + constexpr std::ptrdiff_t m_fldBModGain = 0x8; // float + constexpr std::ptrdiff_t m_flFreqRangeStart = 0xC; // float + constexpr std::ptrdiff_t m_flFreqRangeEnd = 0x10; // float + constexpr std::ptrdiff_t m_fldBUnvoicedGain = 0x14; // float + constexpr std::ptrdiff_t m_flAttackTimeMS = 0x18; // float + constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x1C; // float + constexpr std::ptrdiff_t m_nDebugBand = 0x20; // int32_t + constexpr std::ptrdiff_t m_bPeakMode = 0x24; // bool +} \ No newline at end of file diff --git a/HPCS2/offset/vphysics2.dll.hpp b/HPCS2/offset/vphysics2.dll.hpp new file mode 100644 index 0000000..d1bbe40 --- /dev/null +++ b/HPCS2/offset/vphysics2.dll.hpp @@ -0,0 +1,755 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace CFeIndexedJiggleBone { + constexpr std::ptrdiff_t m_nNode = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nJiggleParent = 0x4; // uint32_t + constexpr std::ptrdiff_t m_jiggleBone = 0x8; // CFeJiggleBone +} + +namespace CFeJiggleBone { + constexpr std::ptrdiff_t m_nFlags = 0x0; // uint32_t + constexpr std::ptrdiff_t m_flLength = 0x4; // float + constexpr std::ptrdiff_t m_flTipMass = 0x8; // float + constexpr std::ptrdiff_t m_flYawStiffness = 0xC; // float + constexpr std::ptrdiff_t m_flYawDamping = 0x10; // float + constexpr std::ptrdiff_t m_flPitchStiffness = 0x14; // float + constexpr std::ptrdiff_t m_flPitchDamping = 0x18; // float + constexpr std::ptrdiff_t m_flAlongStiffness = 0x1C; // float + constexpr std::ptrdiff_t m_flAlongDamping = 0x20; // float + constexpr std::ptrdiff_t m_flAngleLimit = 0x24; // float + constexpr std::ptrdiff_t m_flMinYaw = 0x28; // float + constexpr std::ptrdiff_t m_flMaxYaw = 0x2C; // float + constexpr std::ptrdiff_t m_flYawFriction = 0x30; // float + constexpr std::ptrdiff_t m_flYawBounce = 0x34; // float + constexpr std::ptrdiff_t m_flMinPitch = 0x38; // float + constexpr std::ptrdiff_t m_flMaxPitch = 0x3C; // float + constexpr std::ptrdiff_t m_flPitchFriction = 0x40; // float + constexpr std::ptrdiff_t m_flPitchBounce = 0x44; // float + constexpr std::ptrdiff_t m_flBaseMass = 0x48; // float + constexpr std::ptrdiff_t m_flBaseStiffness = 0x4C; // float + constexpr std::ptrdiff_t m_flBaseDamping = 0x50; // float + constexpr std::ptrdiff_t m_flBaseMinLeft = 0x54; // float + constexpr std::ptrdiff_t m_flBaseMaxLeft = 0x58; // float + constexpr std::ptrdiff_t m_flBaseLeftFriction = 0x5C; // float + constexpr std::ptrdiff_t m_flBaseMinUp = 0x60; // float + constexpr std::ptrdiff_t m_flBaseMaxUp = 0x64; // float + constexpr std::ptrdiff_t m_flBaseUpFriction = 0x68; // float + constexpr std::ptrdiff_t m_flBaseMinForward = 0x6C; // float + constexpr std::ptrdiff_t m_flBaseMaxForward = 0x70; // float + constexpr std::ptrdiff_t m_flBaseForwardFriction = 0x74; // float + constexpr std::ptrdiff_t m_flRadius0 = 0x78; // float + constexpr std::ptrdiff_t m_flRadius1 = 0x7C; // float + constexpr std::ptrdiff_t m_vPoint0 = 0x80; // Vector + constexpr std::ptrdiff_t m_vPoint1 = 0x8C; // Vector + constexpr std::ptrdiff_t m_nCollisionMask = 0x98; // uint16_t +} + +namespace CFeMorphLayer { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nNameHash = 0x8; // uint32_t + constexpr std::ptrdiff_t m_Nodes = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_InitPos = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_Gravity = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_GoalStrength = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_GoalDamping = 0x70; // CUtlVector +} + +namespace CFeNamedJiggleBone { + constexpr std::ptrdiff_t m_strParentBone = 0x0; // CUtlString + constexpr std::ptrdiff_t m_transform = 0x10; // CTransform + constexpr std::ptrdiff_t m_nJiggleParent = 0x30; // uint32_t + constexpr std::ptrdiff_t m_jiggleBone = 0x34; // CFeJiggleBone +} + +namespace CFeVertexMapBuildArray { + constexpr std::ptrdiff_t m_Array = 0x0; // CUtlVector +} + +namespace CRegionSVM { + constexpr std::ptrdiff_t m_Planes = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_Nodes = 0x18; // CUtlVector +} + +namespace CastSphereSATParams_t { + constexpr std::ptrdiff_t m_vRayStart = 0x0; // Vector + constexpr std::ptrdiff_t m_vRayDelta = 0xC; // Vector + constexpr std::ptrdiff_t m_flRadius = 0x18; // float + constexpr std::ptrdiff_t m_flMaxFraction = 0x1C; // float + constexpr std::ptrdiff_t m_flScale = 0x20; // float + constexpr std::ptrdiff_t m_pHull = 0x28; // RnHull_t* +} + +namespace CovMatrix3 { + constexpr std::ptrdiff_t m_vDiag = 0x0; // Vector + constexpr std::ptrdiff_t m_flXY = 0xC; // float + constexpr std::ptrdiff_t m_flXZ = 0x10; // float + constexpr std::ptrdiff_t m_flYZ = 0x14; // float +} + +namespace Dop26_t { + constexpr std::ptrdiff_t m_flSupport = 0x0; // float[26] +} + +namespace FeAnimStrayRadius_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[2] + constexpr std::ptrdiff_t flMaxDist = 0x4; // float + constexpr std::ptrdiff_t flRelaxationFactor = 0x8; // float +} + +namespace FeAxialEdgeBend_t { + constexpr std::ptrdiff_t te = 0x0; // float + constexpr std::ptrdiff_t tv = 0x4; // float + constexpr std::ptrdiff_t flDist = 0x8; // float + constexpr std::ptrdiff_t flWeight = 0xC; // float[4] + constexpr std::ptrdiff_t nNode = 0x1C; // uint16_t[6] +} + +namespace FeBandBendLimit_t { + constexpr std::ptrdiff_t flDistMin = 0x0; // float + constexpr std::ptrdiff_t flDistMax = 0x4; // float + constexpr std::ptrdiff_t nNode = 0x8; // uint16_t[6] +} + +namespace FeBoxRigid_t { + constexpr std::ptrdiff_t tmFrame2 = 0x0; // CTransform + constexpr std::ptrdiff_t nNode = 0x20; // uint16_t + constexpr std::ptrdiff_t nCollisionMask = 0x22; // uint16_t + constexpr std::ptrdiff_t vSize = 0x24; // Vector + constexpr std::ptrdiff_t nVertexMapIndex = 0x30; // uint16_t + constexpr std::ptrdiff_t nFlags = 0x32; // uint16_t +} + +namespace FeBuildBoxRigid_t { // FeBoxRigid_t + constexpr std::ptrdiff_t m_nPriority = 0x40; // int32_t + constexpr std::ptrdiff_t m_nVertexMapHash = 0x44; // uint32_t +} + +namespace FeBuildSphereRigid_t { // FeSphereRigid_t + constexpr std::ptrdiff_t m_nPriority = 0x20; // int32_t + constexpr std::ptrdiff_t m_nVertexMapHash = 0x24; // uint32_t +} + +namespace FeBuildTaperedCapsuleRigid_t { // FeTaperedCapsuleRigid_t + constexpr std::ptrdiff_t m_nPriority = 0x30; // int32_t + constexpr std::ptrdiff_t m_nVertexMapHash = 0x34; // uint32_t +} + +namespace FeCollisionPlane_t { + constexpr std::ptrdiff_t nCtrlParent = 0x0; // uint16_t + constexpr std::ptrdiff_t nChildNode = 0x2; // uint16_t + constexpr std::ptrdiff_t m_Plane = 0x4; // RnPlane_t + constexpr std::ptrdiff_t flStrength = 0x14; // float +} + +namespace FeCtrlOffset_t { + constexpr std::ptrdiff_t vOffset = 0x0; // Vector + constexpr std::ptrdiff_t nCtrlParent = 0xC; // uint16_t + constexpr std::ptrdiff_t nCtrlChild = 0xE; // uint16_t +} + +namespace FeCtrlOsOffset_t { + constexpr std::ptrdiff_t nCtrlParent = 0x0; // uint16_t + constexpr std::ptrdiff_t nCtrlChild = 0x2; // uint16_t +} + +namespace FeCtrlSoftOffset_t { + constexpr std::ptrdiff_t nCtrlParent = 0x0; // uint16_t + constexpr std::ptrdiff_t nCtrlChild = 0x2; // uint16_t + constexpr std::ptrdiff_t vOffset = 0x4; // Vector + constexpr std::ptrdiff_t flAlpha = 0x10; // float +} + +namespace FeEdgeDesc_t { + constexpr std::ptrdiff_t nEdge = 0x0; // uint16_t[2] + constexpr std::ptrdiff_t nSide = 0x4; // uint16_t[2][2] + constexpr std::ptrdiff_t nVirtElem = 0xC; // uint16_t[2] +} + +namespace FeEffectDesc_t { + constexpr std::ptrdiff_t sName = 0x0; // CUtlString + constexpr std::ptrdiff_t nNameHash = 0x8; // uint32_t + constexpr std::ptrdiff_t nType = 0xC; // int32_t + constexpr std::ptrdiff_t m_Params = 0x10; // KeyValues3 +} + +namespace FeFitInfluence_t { + constexpr std::ptrdiff_t nVertexNode = 0x0; // uint32_t + constexpr std::ptrdiff_t flWeight = 0x4; // float + constexpr std::ptrdiff_t nMatrixNode = 0x8; // uint32_t +} + +namespace FeFitMatrix_t { + constexpr std::ptrdiff_t bone = 0x0; // CTransform + constexpr std::ptrdiff_t vCenter = 0x20; // Vector + constexpr std::ptrdiff_t nEnd = 0x2C; // uint16_t + constexpr std::ptrdiff_t nNode = 0x2E; // uint16_t + constexpr std::ptrdiff_t nBeginDynamic = 0x30; // uint16_t +} + +namespace FeFitWeight_t { + constexpr std::ptrdiff_t flWeight = 0x0; // float + constexpr std::ptrdiff_t nNode = 0x4; // uint16_t + constexpr std::ptrdiff_t nDummy = 0x6; // uint16_t +} + +namespace FeFollowNode_t { + constexpr std::ptrdiff_t nParentNode = 0x0; // uint16_t + constexpr std::ptrdiff_t nChildNode = 0x2; // uint16_t + constexpr std::ptrdiff_t flWeight = 0x4; // float +} + +namespace FeKelagerBend2_t { + constexpr std::ptrdiff_t flWeight = 0x0; // float[3] + constexpr std::ptrdiff_t flHeight0 = 0xC; // float + constexpr std::ptrdiff_t nNode = 0x10; // uint16_t[3] + constexpr std::ptrdiff_t nReserved = 0x16; // uint16_t +} + +namespace FeMorphLayerDepr_t { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nNameHash = 0x8; // uint32_t + constexpr std::ptrdiff_t m_Nodes = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_InitPos = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_Gravity = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_GoalStrength = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_GoalDamping = 0x70; // CUtlVector + constexpr std::ptrdiff_t m_nFlags = 0x88; // uint32_t +} + +namespace FeNodeBase_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t + constexpr std::ptrdiff_t nDummy = 0x2; // uint16_t[3] + constexpr std::ptrdiff_t nNodeX0 = 0x8; // uint16_t + constexpr std::ptrdiff_t nNodeX1 = 0xA; // uint16_t + constexpr std::ptrdiff_t nNodeY0 = 0xC; // uint16_t + constexpr std::ptrdiff_t nNodeY1 = 0xE; // uint16_t + constexpr std::ptrdiff_t qAdjust = 0x10; // QuaternionStorage +} + +namespace FeNodeIntegrator_t { + constexpr std::ptrdiff_t flPointDamping = 0x0; // float + constexpr std::ptrdiff_t flAnimationForceAttraction = 0x4; // float + constexpr std::ptrdiff_t flAnimationVertexAttraction = 0x8; // float + constexpr std::ptrdiff_t flGravity = 0xC; // float +} + +namespace FeNodeReverseOffset_t { + constexpr std::ptrdiff_t vOffset = 0x0; // Vector + constexpr std::ptrdiff_t nBoneCtrl = 0xC; // uint16_t + constexpr std::ptrdiff_t nTargetNode = 0xE; // uint16_t +} + +namespace FeNodeWindBase_t { + constexpr std::ptrdiff_t nNodeX0 = 0x0; // uint16_t + constexpr std::ptrdiff_t nNodeX1 = 0x2; // uint16_t + constexpr std::ptrdiff_t nNodeY0 = 0x4; // uint16_t + constexpr std::ptrdiff_t nNodeY1 = 0x6; // uint16_t +} + +namespace FeProxyVertexMap_t { + constexpr std::ptrdiff_t m_Name = 0x0; // CUtlString + constexpr std::ptrdiff_t m_flWeight = 0x8; // float +} + +namespace FeQuad_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[4] + constexpr std::ptrdiff_t flSlack = 0x8; // float + constexpr std::ptrdiff_t vShape = 0xC; // Vector4D[4] +} + +namespace FeRigidColliderIndices_t { + constexpr std::ptrdiff_t m_nTaperedCapsuleRigidIndex = 0x0; // uint16_t + constexpr std::ptrdiff_t m_nSphereRigidIndex = 0x2; // uint16_t + constexpr std::ptrdiff_t m_nBoxRigidIndex = 0x4; // uint16_t + constexpr std::ptrdiff_t m_nCollisionPlaneIndex = 0x6; // uint16_t +} + +namespace FeRodConstraint_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[2] + constexpr std::ptrdiff_t flMaxDist = 0x4; // float + constexpr std::ptrdiff_t flMinDist = 0x8; // float + constexpr std::ptrdiff_t flWeight0 = 0xC; // float + constexpr std::ptrdiff_t flRelaxationFactor = 0x10; // float +} + +namespace FeSimdAnimStrayRadius_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[4][2] + constexpr std::ptrdiff_t flMaxDist = 0x10; // fltx4 + constexpr std::ptrdiff_t flRelaxationFactor = 0x20; // fltx4 +} + +namespace FeSimdNodeBase_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[4] + constexpr std::ptrdiff_t nNodeX0 = 0x8; // uint16_t[4] + constexpr std::ptrdiff_t nNodeX1 = 0x10; // uint16_t[4] + constexpr std::ptrdiff_t nNodeY0 = 0x18; // uint16_t[4] + constexpr std::ptrdiff_t nNodeY1 = 0x20; // uint16_t[4] + constexpr std::ptrdiff_t nDummy = 0x28; // uint16_t[4] + constexpr std::ptrdiff_t qAdjust = 0x30; // FourQuaternions +} + +namespace FeSimdQuad_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[4][4] + constexpr std::ptrdiff_t f4Slack = 0x20; // fltx4 + constexpr std::ptrdiff_t vShape = 0x30; // FourVectors[4] + constexpr std::ptrdiff_t f4Weights = 0xF0; // fltx4[4] +} + +namespace FeSimdRodConstraint_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[4][2] + constexpr std::ptrdiff_t f4MaxDist = 0x10; // fltx4 + constexpr std::ptrdiff_t f4MinDist = 0x20; // fltx4 + constexpr std::ptrdiff_t f4Weight0 = 0x30; // fltx4 + constexpr std::ptrdiff_t f4RelaxationFactor = 0x40; // fltx4 +} + +namespace FeSimdSpringIntegrator_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[4][2] + constexpr std::ptrdiff_t flSpringRestLength = 0x10; // fltx4 + constexpr std::ptrdiff_t flSpringConstant = 0x20; // fltx4 + constexpr std::ptrdiff_t flSpringDamping = 0x30; // fltx4 + constexpr std::ptrdiff_t flNodeWeight0 = 0x40; // fltx4 +} + +namespace FeSimdTri_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint32_t[4][3] + constexpr std::ptrdiff_t w1 = 0x30; // fltx4 + constexpr std::ptrdiff_t w2 = 0x40; // fltx4 + constexpr std::ptrdiff_t v1x = 0x50; // fltx4 + constexpr std::ptrdiff_t v2 = 0x60; // FourVectors2D +} + +namespace FeSoftParent_t { + constexpr std::ptrdiff_t nParent = 0x0; // int32_t + constexpr std::ptrdiff_t flAlpha = 0x4; // float +} + +namespace FeSourceEdge_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[2] +} + +namespace FeSphereRigid_t { + constexpr std::ptrdiff_t vSphere = 0x0; // fltx4 + constexpr std::ptrdiff_t nNode = 0x10; // uint16_t + constexpr std::ptrdiff_t nCollisionMask = 0x12; // uint16_t + constexpr std::ptrdiff_t nVertexMapIndex = 0x14; // uint16_t + constexpr std::ptrdiff_t nFlags = 0x16; // uint16_t +} + +namespace FeSpringIntegrator_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[2] + constexpr std::ptrdiff_t flSpringRestLength = 0x4; // float + constexpr std::ptrdiff_t flSpringConstant = 0x8; // float + constexpr std::ptrdiff_t flSpringDamping = 0xC; // float + constexpr std::ptrdiff_t flNodeWeight0 = 0x10; // float +} + +namespace FeStiffHingeBuild_t { + constexpr std::ptrdiff_t flMaxAngle = 0x0; // float + constexpr std::ptrdiff_t flStrength = 0x4; // float + constexpr std::ptrdiff_t flMotionBias = 0x8; // float[3] + constexpr std::ptrdiff_t nNode = 0x14; // uint16_t[3] +} + +namespace FeTaperedCapsuleRigid_t { + constexpr std::ptrdiff_t vSphere = 0x0; // fltx4[2] + constexpr std::ptrdiff_t nNode = 0x20; // uint16_t + constexpr std::ptrdiff_t nCollisionMask = 0x22; // uint16_t + constexpr std::ptrdiff_t nVertexMapIndex = 0x24; // uint16_t + constexpr std::ptrdiff_t nFlags = 0x26; // uint16_t +} + +namespace FeTaperedCapsuleStretch_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[2] + constexpr std::ptrdiff_t nCollisionMask = 0x4; // uint16_t + constexpr std::ptrdiff_t nDummy = 0x6; // uint16_t + constexpr std::ptrdiff_t flRadius = 0x8; // float[2] +} + +namespace FeTreeChildren_t { + constexpr std::ptrdiff_t nChild = 0x0; // uint16_t[2] +} + +namespace FeTri_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t[3] + constexpr std::ptrdiff_t w1 = 0x8; // float + constexpr std::ptrdiff_t w2 = 0xC; // float + constexpr std::ptrdiff_t v1x = 0x10; // float + constexpr std::ptrdiff_t v2 = 0x14; // Vector2D +} + +namespace FeTwistConstraint_t { + constexpr std::ptrdiff_t nNodeOrient = 0x0; // uint16_t + constexpr std::ptrdiff_t nNodeEnd = 0x2; // uint16_t + constexpr std::ptrdiff_t flTwistRelax = 0x4; // float + constexpr std::ptrdiff_t flSwingRelax = 0x8; // float +} + +namespace FeVertexMapBuild_t { + constexpr std::ptrdiff_t m_VertexMapName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_nNameHash = 0x8; // uint32_t + constexpr std::ptrdiff_t m_Color = 0xC; // Color + constexpr std::ptrdiff_t m_flVolumetricSolveStrength = 0x10; // float + constexpr std::ptrdiff_t m_nScaleSourceNode = 0x14; // int32_t + constexpr std::ptrdiff_t m_Weights = 0x18; // CUtlVector +} + +namespace FeVertexMapDesc_t { + constexpr std::ptrdiff_t sName = 0x0; // CUtlString + constexpr std::ptrdiff_t nNameHash = 0x8; // uint32_t + constexpr std::ptrdiff_t nColor = 0xC; // uint32_t + constexpr std::ptrdiff_t nFlags = 0x10; // uint32_t + constexpr std::ptrdiff_t nVertexBase = 0x14; // uint16_t + constexpr std::ptrdiff_t nVertexCount = 0x16; // uint16_t + constexpr std::ptrdiff_t nMapOffset = 0x18; // uint32_t + constexpr std::ptrdiff_t nNodeListOffset = 0x1C; // uint32_t + constexpr std::ptrdiff_t vCenterOfMass = 0x20; // Vector + constexpr std::ptrdiff_t flVolumetricSolveStrength = 0x2C; // float + constexpr std::ptrdiff_t nScaleSourceNode = 0x30; // int16_t + constexpr std::ptrdiff_t nNodeListCount = 0x32; // uint16_t +} + +namespace FeWeightedNode_t { + constexpr std::ptrdiff_t nNode = 0x0; // uint16_t + constexpr std::ptrdiff_t nWeight = 0x2; // uint16_t +} + +namespace FeWorldCollisionParams_t { + constexpr std::ptrdiff_t flWorldFriction = 0x0; // float + constexpr std::ptrdiff_t flGroundFriction = 0x4; // float + constexpr std::ptrdiff_t nListBegin = 0x8; // uint16_t + constexpr std::ptrdiff_t nListEnd = 0xA; // uint16_t +} + +namespace FourCovMatrices3 { + constexpr std::ptrdiff_t m_vDiag = 0x0; // FourVectors + constexpr std::ptrdiff_t m_flXY = 0x30; // fltx4 + constexpr std::ptrdiff_t m_flXZ = 0x40; // fltx4 + constexpr std::ptrdiff_t m_flYZ = 0x50; // fltx4 +} + +namespace FourVectors2D { + constexpr std::ptrdiff_t x = 0x0; // fltx4 + constexpr std::ptrdiff_t y = 0x10; // fltx4 +} + +namespace IPhysicsPlayerController { +} + +namespace OldFeEdge_t { + constexpr std::ptrdiff_t m_flK = 0x0; // float[3] + constexpr std::ptrdiff_t invA = 0xC; // float + constexpr std::ptrdiff_t t = 0x10; // float + constexpr std::ptrdiff_t flThetaRelaxed = 0x14; // float + constexpr std::ptrdiff_t flThetaFactor = 0x18; // float + constexpr std::ptrdiff_t c01 = 0x1C; // float + constexpr std::ptrdiff_t c02 = 0x20; // float + constexpr std::ptrdiff_t c03 = 0x24; // float + constexpr std::ptrdiff_t c04 = 0x28; // float + constexpr std::ptrdiff_t flAxialModelDist = 0x2C; // float + constexpr std::ptrdiff_t flAxialModelWeights = 0x30; // float[4] + constexpr std::ptrdiff_t m_nNode = 0x40; // uint16_t[4] +} + +namespace PhysFeModelDesc_t { + constexpr std::ptrdiff_t m_CtrlHash = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_CtrlName = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_nStaticNodeFlags = 0x30; // uint32_t + constexpr std::ptrdiff_t m_nDynamicNodeFlags = 0x34; // uint32_t + constexpr std::ptrdiff_t m_flLocalForce = 0x38; // float + constexpr std::ptrdiff_t m_flLocalRotation = 0x3C; // float + constexpr std::ptrdiff_t m_nNodeCount = 0x40; // uint16_t + constexpr std::ptrdiff_t m_nStaticNodes = 0x42; // uint16_t + constexpr std::ptrdiff_t m_nRotLockStaticNodes = 0x44; // uint16_t + constexpr std::ptrdiff_t m_nFirstPositionDrivenNode = 0x46; // uint16_t + constexpr std::ptrdiff_t m_nSimdTriCount1 = 0x48; // uint16_t + constexpr std::ptrdiff_t m_nSimdTriCount2 = 0x4A; // uint16_t + constexpr std::ptrdiff_t m_nSimdQuadCount1 = 0x4C; // uint16_t + constexpr std::ptrdiff_t m_nSimdQuadCount2 = 0x4E; // uint16_t + constexpr std::ptrdiff_t m_nQuadCount1 = 0x50; // uint16_t + constexpr std::ptrdiff_t m_nQuadCount2 = 0x52; // uint16_t + constexpr std::ptrdiff_t m_nTreeDepth = 0x54; // uint16_t + constexpr std::ptrdiff_t m_nNodeBaseJiggleboneDependsCount = 0x56; // uint16_t + constexpr std::ptrdiff_t m_nRopeCount = 0x58; // uint16_t + constexpr std::ptrdiff_t m_Ropes = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_NodeBases = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_SimdNodeBases = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_Quads = 0xA8; // CUtlVector + constexpr std::ptrdiff_t m_SimdQuads = 0xC0; // CUtlVector + constexpr std::ptrdiff_t m_SimdTris = 0xD8; // CUtlVector + constexpr std::ptrdiff_t m_SimdRods = 0xF0; // CUtlVector + constexpr std::ptrdiff_t m_InitPose = 0x108; // CUtlVector + constexpr std::ptrdiff_t m_Rods = 0x120; // CUtlVector + constexpr std::ptrdiff_t m_Twists = 0x138; // CUtlVector + constexpr std::ptrdiff_t m_AxialEdges = 0x150; // CUtlVector + constexpr std::ptrdiff_t m_NodeInvMasses = 0x168; // CUtlVector + constexpr std::ptrdiff_t m_CtrlOffsets = 0x180; // CUtlVector + constexpr std::ptrdiff_t m_CtrlOsOffsets = 0x198; // CUtlVector + constexpr std::ptrdiff_t m_FollowNodes = 0x1B0; // CUtlVector + constexpr std::ptrdiff_t m_CollisionPlanes = 0x1C8; // CUtlVector + constexpr std::ptrdiff_t m_NodeIntegrator = 0x1E0; // CUtlVector + constexpr std::ptrdiff_t m_SpringIntegrator = 0x1F8; // CUtlVector + constexpr std::ptrdiff_t m_SimdSpringIntegrator = 0x210; // CUtlVector + constexpr std::ptrdiff_t m_WorldCollisionParams = 0x228; // CUtlVector + constexpr std::ptrdiff_t m_LegacyStretchForce = 0x240; // CUtlVector + constexpr std::ptrdiff_t m_NodeCollisionRadii = 0x258; // CUtlVector + constexpr std::ptrdiff_t m_DynNodeFriction = 0x270; // CUtlVector + constexpr std::ptrdiff_t m_LocalRotation = 0x288; // CUtlVector + constexpr std::ptrdiff_t m_LocalForce = 0x2A0; // CUtlVector + constexpr std::ptrdiff_t m_TaperedCapsuleStretches = 0x2B8; // CUtlVector + constexpr std::ptrdiff_t m_TaperedCapsuleRigids = 0x2D0; // CUtlVector + constexpr std::ptrdiff_t m_SphereRigids = 0x2E8; // CUtlVector + constexpr std::ptrdiff_t m_WorldCollisionNodes = 0x300; // CUtlVector + constexpr std::ptrdiff_t m_TreeParents = 0x318; // CUtlVector + constexpr std::ptrdiff_t m_TreeCollisionMasks = 0x330; // CUtlVector + constexpr std::ptrdiff_t m_TreeChildren = 0x348; // CUtlVector + constexpr std::ptrdiff_t m_FreeNodes = 0x360; // CUtlVector + constexpr std::ptrdiff_t m_FitMatrices = 0x378; // CUtlVector + constexpr std::ptrdiff_t m_FitWeights = 0x390; // CUtlVector + constexpr std::ptrdiff_t m_ReverseOffsets = 0x3A8; // CUtlVector + constexpr std::ptrdiff_t m_AnimStrayRadii = 0x3C0; // CUtlVector + constexpr std::ptrdiff_t m_SimdAnimStrayRadii = 0x3D8; // CUtlVector + constexpr std::ptrdiff_t m_KelagerBends = 0x3F0; // CUtlVector + constexpr std::ptrdiff_t m_CtrlSoftOffsets = 0x408; // CUtlVector + constexpr std::ptrdiff_t m_JiggleBones = 0x420; // CUtlVector + constexpr std::ptrdiff_t m_SourceElems = 0x438; // CUtlVector + constexpr std::ptrdiff_t m_GoalDampedSpringIntegrators = 0x450; // CUtlVector + constexpr std::ptrdiff_t m_Tris = 0x468; // CUtlVector + constexpr std::ptrdiff_t m_nTriCount1 = 0x480; // uint16_t + constexpr std::ptrdiff_t m_nTriCount2 = 0x482; // uint16_t + constexpr std::ptrdiff_t m_nReservedUint8 = 0x484; // uint8_t + constexpr std::ptrdiff_t m_nExtraPressureIterations = 0x485; // uint8_t + constexpr std::ptrdiff_t m_nExtraGoalIterations = 0x486; // uint8_t + constexpr std::ptrdiff_t m_nExtraIterations = 0x487; // uint8_t + constexpr std::ptrdiff_t m_BoxRigids = 0x488; // CUtlVector + constexpr std::ptrdiff_t m_DynNodeVertexSet = 0x4A0; // CUtlVector + constexpr std::ptrdiff_t m_VertexSetNames = 0x4B8; // CUtlVector + constexpr std::ptrdiff_t m_RigidColliderPriorities = 0x4D0; // CUtlVector + constexpr std::ptrdiff_t m_MorphLayers = 0x4E8; // CUtlVector + constexpr std::ptrdiff_t m_MorphSetData = 0x500; // CUtlVector + constexpr std::ptrdiff_t m_VertexMaps = 0x518; // CUtlVector + constexpr std::ptrdiff_t m_VertexMapValues = 0x530; // CUtlVector + constexpr std::ptrdiff_t m_Effects = 0x548; // CUtlVector + constexpr std::ptrdiff_t m_LockToParent = 0x560; // CUtlVector + constexpr std::ptrdiff_t m_LockToGoal = 0x578; // CUtlVector + constexpr std::ptrdiff_t m_DynNodeWindBases = 0x590; // CUtlVector + constexpr std::ptrdiff_t m_flInternalPressure = 0x5A8; // float + constexpr std::ptrdiff_t m_flDefaultTimeDilation = 0x5AC; // float + constexpr std::ptrdiff_t m_flWindage = 0x5B0; // float + constexpr std::ptrdiff_t m_flWindDrag = 0x5B4; // float + constexpr std::ptrdiff_t m_flDefaultSurfaceStretch = 0x5B8; // float + constexpr std::ptrdiff_t m_flDefaultThreadStretch = 0x5BC; // float + constexpr std::ptrdiff_t m_flDefaultGravityScale = 0x5C0; // float + constexpr std::ptrdiff_t m_flDefaultVelAirDrag = 0x5C4; // float + constexpr std::ptrdiff_t m_flDefaultExpAirDrag = 0x5C8; // float + constexpr std::ptrdiff_t m_flDefaultVelQuadAirDrag = 0x5CC; // float + constexpr std::ptrdiff_t m_flDefaultExpQuadAirDrag = 0x5D0; // float + constexpr std::ptrdiff_t m_flRodVelocitySmoothRate = 0x5D4; // float + constexpr std::ptrdiff_t m_flQuadVelocitySmoothRate = 0x5D8; // float + constexpr std::ptrdiff_t m_flAddWorldCollisionRadius = 0x5DC; // float + constexpr std::ptrdiff_t m_flDefaultVolumetricSolveAmount = 0x5E0; // float + constexpr std::ptrdiff_t m_nRodVelocitySmoothIterations = 0x5E4; // uint16_t + constexpr std::ptrdiff_t m_nQuadVelocitySmoothIterations = 0x5E6; // uint16_t +} + +namespace RnBlendVertex_t { + constexpr std::ptrdiff_t m_nWeight0 = 0x0; // uint16_t + constexpr std::ptrdiff_t m_nIndex0 = 0x2; // uint16_t + constexpr std::ptrdiff_t m_nWeight1 = 0x4; // uint16_t + constexpr std::ptrdiff_t m_nIndex1 = 0x6; // uint16_t + constexpr std::ptrdiff_t m_nWeight2 = 0x8; // uint16_t + constexpr std::ptrdiff_t m_nIndex2 = 0xA; // uint16_t + constexpr std::ptrdiff_t m_nFlags = 0xC; // uint16_t + constexpr std::ptrdiff_t m_nTargetIndex = 0xE; // uint16_t +} + +namespace RnBodyDesc_t { + constexpr std::ptrdiff_t m_sDebugName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_vPosition = 0x8; // Vector + constexpr std::ptrdiff_t m_qOrientation = 0x14; // QuaternionStorage + constexpr std::ptrdiff_t m_vLinearVelocity = 0x24; // Vector + constexpr std::ptrdiff_t m_vAngularVelocity = 0x30; // Vector + constexpr std::ptrdiff_t m_vLocalMassCenter = 0x3C; // Vector + constexpr std::ptrdiff_t m_LocalInertiaInv = 0x48; // Vector[3] + constexpr std::ptrdiff_t m_flMassInv = 0x6C; // float + constexpr std::ptrdiff_t m_flGameMass = 0x70; // float + constexpr std::ptrdiff_t m_flInertiaScaleInv = 0x74; // float + constexpr std::ptrdiff_t m_flLinearDamping = 0x78; // float + constexpr std::ptrdiff_t m_flAngularDamping = 0x7C; // float + constexpr std::ptrdiff_t m_flLinearDrag = 0x80; // float + constexpr std::ptrdiff_t m_flAngularDrag = 0x84; // float + constexpr std::ptrdiff_t m_flLinearBuoyancyDrag = 0x88; // float + constexpr std::ptrdiff_t m_flAngularBuoyancyDrag = 0x8C; // float + constexpr std::ptrdiff_t m_vLastAwakeForceAccum = 0x90; // Vector + constexpr std::ptrdiff_t m_vLastAwakeTorqueAccum = 0x9C; // Vector + constexpr std::ptrdiff_t m_flBuoyancyFactor = 0xA8; // float + constexpr std::ptrdiff_t m_flGravityScale = 0xAC; // float + constexpr std::ptrdiff_t m_flTimeScale = 0xB0; // float + constexpr std::ptrdiff_t m_nBodyType = 0xB4; // int32_t + constexpr std::ptrdiff_t m_nGameIndex = 0xB8; // uint32_t + constexpr std::ptrdiff_t m_nGameFlags = 0xBC; // uint32_t + constexpr std::ptrdiff_t m_nMinVelocityIterations = 0xC0; // int8_t + constexpr std::ptrdiff_t m_nMinPositionIterations = 0xC1; // int8_t + constexpr std::ptrdiff_t m_nMassPriority = 0xC2; // int8_t + constexpr std::ptrdiff_t m_bEnabled = 0xC3; // bool + constexpr std::ptrdiff_t m_bSleeping = 0xC4; // bool + constexpr std::ptrdiff_t m_bIsContinuousEnabled = 0xC5; // bool + constexpr std::ptrdiff_t m_bDragEnabled = 0xC6; // bool + constexpr std::ptrdiff_t m_bBuoyancyDragEnabled = 0xC7; // bool + constexpr std::ptrdiff_t m_bGravityDisabled = 0xC8; // bool + constexpr std::ptrdiff_t m_bSpeculativeEnabled = 0xC9; // bool + constexpr std::ptrdiff_t m_bHasShadowController = 0xCA; // bool +} + +namespace RnCapsuleDesc_t { // RnShapeDesc_t + constexpr std::ptrdiff_t m_Capsule = 0x10; // RnCapsule_t +} + +namespace RnCapsule_t { + constexpr std::ptrdiff_t m_vCenter = 0x0; // Vector[2] + constexpr std::ptrdiff_t m_flRadius = 0x18; // float +} + +namespace RnFace_t { + constexpr std::ptrdiff_t m_nEdge = 0x0; // uint8_t +} + +namespace RnHalfEdge_t { + constexpr std::ptrdiff_t m_nNext = 0x0; // uint8_t + constexpr std::ptrdiff_t m_nTwin = 0x1; // uint8_t + constexpr std::ptrdiff_t m_nOrigin = 0x2; // uint8_t + constexpr std::ptrdiff_t m_nFace = 0x3; // uint8_t +} + +namespace RnHullDesc_t { // RnShapeDesc_t + constexpr std::ptrdiff_t m_Hull = 0x10; // RnHull_t +} + +namespace RnHull_t { + constexpr std::ptrdiff_t m_vCentroid = 0x0; // Vector + constexpr std::ptrdiff_t m_flMaxAngularRadius = 0xC; // float + constexpr std::ptrdiff_t m_Bounds = 0x10; // AABB_t + constexpr std::ptrdiff_t m_vOrthographicAreas = 0x28; // Vector + constexpr std::ptrdiff_t m_MassProperties = 0x34; // matrix3x4_t + constexpr std::ptrdiff_t m_flVolume = 0x64; // float + constexpr std::ptrdiff_t m_Vertices = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_VertexPositions = 0x80; // CUtlVector + constexpr std::ptrdiff_t m_Edges = 0x98; // CUtlVector + constexpr std::ptrdiff_t m_Faces = 0xB0; // CUtlVector + constexpr std::ptrdiff_t m_FacePlanes = 0xC8; // CUtlVector + constexpr std::ptrdiff_t m_nFlags = 0xE0; // uint32_t + constexpr std::ptrdiff_t m_pRegionSVM = 0xE8; // CRegionSVM* +} + +namespace RnMeshDesc_t { // RnShapeDesc_t + constexpr std::ptrdiff_t m_Mesh = 0x10; // RnMesh_t +} + +namespace RnMesh_t { + constexpr std::ptrdiff_t m_vMin = 0x0; // Vector + constexpr std::ptrdiff_t m_vMax = 0xC; // Vector + constexpr std::ptrdiff_t m_Nodes = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_Vertices = 0x30; // CUtlVectorSIMDPaddedVector + constexpr std::ptrdiff_t m_Triangles = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_Wings = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_Materials = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_vOrthographicAreas = 0x90; // Vector + constexpr std::ptrdiff_t m_nFlags = 0x9C; // uint32_t + constexpr std::ptrdiff_t m_nDebugFlags = 0xA0; // uint32_t +} + +namespace RnNode_t { + constexpr std::ptrdiff_t m_vMin = 0x0; // Vector + constexpr std::ptrdiff_t m_nChildren = 0xC; // uint32_t + constexpr std::ptrdiff_t m_vMax = 0x10; // Vector + constexpr std::ptrdiff_t m_nTriangleOffset = 0x1C; // uint32_t +} + +namespace RnPlane_t { + constexpr std::ptrdiff_t m_vNormal = 0x0; // Vector + constexpr std::ptrdiff_t m_flOffset = 0xC; // float +} + +namespace RnShapeDesc_t { + constexpr std::ptrdiff_t m_nCollisionAttributeIndex = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nSurfacePropertyIndex = 0x4; // uint32_t + constexpr std::ptrdiff_t m_UserFriendlyName = 0x8; // CUtlString +} + +namespace RnSoftbodyCapsule_t { + constexpr std::ptrdiff_t m_vCenter = 0x0; // Vector[2] + constexpr std::ptrdiff_t m_flRadius = 0x18; // float + constexpr std::ptrdiff_t m_nParticle = 0x1C; // uint16_t[2] +} + +namespace RnSoftbodyParticle_t { + constexpr std::ptrdiff_t m_flMassInv = 0x0; // float +} + +namespace RnSoftbodySpring_t { + constexpr std::ptrdiff_t m_nParticle = 0x0; // uint16_t[2] + constexpr std::ptrdiff_t m_flLength = 0x4; // float +} + +namespace RnSphereDesc_t { // RnShapeDesc_t + constexpr std::ptrdiff_t m_Sphere = 0x10; // RnSphere_t +} + +namespace RnSphere_t { + constexpr std::ptrdiff_t m_vCenter = 0x0; // Vector + constexpr std::ptrdiff_t m_flRadius = 0xC; // float +} + +namespace RnTriangle_t { + constexpr std::ptrdiff_t m_nIndex = 0x0; // int32_t[3] +} + +namespace RnVertex_t { + constexpr std::ptrdiff_t m_nEdge = 0x0; // uint8_t +} + +namespace RnWing_t { + constexpr std::ptrdiff_t m_nIndex = 0x0; // int32_t[3] +} + +namespace VertexPositionColor_t { + constexpr std::ptrdiff_t m_vPosition = 0x0; // Vector +} + +namespace VertexPositionNormal_t { + constexpr std::ptrdiff_t m_vPosition = 0x0; // Vector + constexpr std::ptrdiff_t m_vNormal = 0xC; // Vector +} + +namespace constraint_axislimit_t { + constexpr std::ptrdiff_t flMinRotation = 0x0; // float + constexpr std::ptrdiff_t flMaxRotation = 0x4; // float + constexpr std::ptrdiff_t flMotorTargetAngSpeed = 0x8; // float + constexpr std::ptrdiff_t flMotorMaxTorque = 0xC; // float +} + +namespace constraint_breakableparams_t { + constexpr std::ptrdiff_t strength = 0x0; // float + constexpr std::ptrdiff_t forceLimit = 0x4; // float + constexpr std::ptrdiff_t torqueLimit = 0x8; // float + constexpr std::ptrdiff_t bodyMassScale = 0xC; // float[2] + constexpr std::ptrdiff_t isActive = 0x14; // bool +} + +namespace constraint_hingeparams_t { + constexpr std::ptrdiff_t worldPosition = 0x0; // Vector + constexpr std::ptrdiff_t worldAxisDirection = 0xC; // Vector + constexpr std::ptrdiff_t hingeAxis = 0x18; // constraint_axislimit_t + constexpr std::ptrdiff_t constraint = 0x28; // constraint_breakableparams_t +} + +namespace vphysics_save_cphysicsbody_t { // RnBodyDesc_t + constexpr std::ptrdiff_t m_nOldPointer = 0xD0; // uint64_t +} \ No newline at end of file diff --git a/HPCS2/offset/worldrenderer.dll.hpp b/HPCS2/offset/worldrenderer.dll.hpp new file mode 100644 index 0000000..662af6d --- /dev/null +++ b/HPCS2/offset/worldrenderer.dll.hpp @@ -0,0 +1,233 @@ +/* + * Created using https://github.com/a2x/cs2-dumper + * Sat, 4 Nov 2023 21:18:20 +0000 + */ + +#pragma once + +#include + +namespace AggregateLODSetup_t { + constexpr std::ptrdiff_t m_vLODOrigin = 0x0; // Vector + constexpr std::ptrdiff_t m_fMaxObjectScale = 0xC; // float + constexpr std::ptrdiff_t m_fSwitchDistances = 0x10; // CUtlVectorFixedGrowable +} + +namespace AggregateMeshInfo_t { + constexpr std::ptrdiff_t m_nVisClusterMemberOffset = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nVisClusterMemberCount = 0x4; // uint8_t + constexpr std::ptrdiff_t m_bHasTransform = 0x5; // bool + constexpr std::ptrdiff_t m_nDrawCallIndex = 0x6; // int16_t + constexpr std::ptrdiff_t m_nLODSetupIndex = 0x8; // int16_t + constexpr std::ptrdiff_t m_nLODGroupMask = 0xA; // uint8_t + constexpr std::ptrdiff_t m_vTintColor = 0xB; // Color + constexpr std::ptrdiff_t m_objectFlags = 0x10; // ObjectTypeFlags_t + constexpr std::ptrdiff_t m_nLightProbeVolumePrecomputedHandshake = 0x14; // int32_t +} + +namespace AggregateSceneObject_t { + constexpr std::ptrdiff_t m_allFlags = 0x0; // ObjectTypeFlags_t + constexpr std::ptrdiff_t m_anyFlags = 0x4; // ObjectTypeFlags_t + constexpr std::ptrdiff_t m_nLayer = 0x8; // int16_t + constexpr std::ptrdiff_t m_aggregateMeshes = 0x10; // CUtlVector + constexpr std::ptrdiff_t m_lodSetups = 0x28; // CUtlVector + constexpr std::ptrdiff_t m_visClusterMembership = 0x40; // CUtlVector + constexpr std::ptrdiff_t m_fragmentTransforms = 0x58; // CUtlVector + constexpr std::ptrdiff_t m_renderableModel = 0x70; // CStrongHandle +} + +namespace BakedLightingInfo_t { + constexpr std::ptrdiff_t m_nLightmapVersionNumber = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nLightmapGameVersionNumber = 0x4; // uint32_t + constexpr std::ptrdiff_t m_vLightmapUvScale = 0x8; // Vector2D + constexpr std::ptrdiff_t m_bHasLightmaps = 0x10; // bool + constexpr std::ptrdiff_t m_lightMaps = 0x18; // CUtlVector> +} + +namespace BaseSceneObjectOverride_t { + constexpr std::ptrdiff_t m_nSceneObjectIndex = 0x0; // uint32_t +} + +namespace CEntityComponent { +} + +namespace CEntityIdentity { + constexpr std::ptrdiff_t m_nameStringableIndex = 0x14; // int32_t + constexpr std::ptrdiff_t m_name = 0x18; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_designerName = 0x20; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_flags = 0x30; // uint32_t + constexpr std::ptrdiff_t m_worldGroupId = 0x38; // WorldGroupId_t + constexpr std::ptrdiff_t m_fDataObjectTypes = 0x3C; // uint32_t + constexpr std::ptrdiff_t m_PathIndex = 0x40; // ChangeAccessorFieldPathIndex_t + constexpr std::ptrdiff_t m_pPrev = 0x58; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNext = 0x60; // CEntityIdentity* + constexpr std::ptrdiff_t m_pPrevByClass = 0x68; // CEntityIdentity* + constexpr std::ptrdiff_t m_pNextByClass = 0x70; // CEntityIdentity* +} + +namespace CEntityInstance { + constexpr std::ptrdiff_t m_iszPrivateVScripts = 0x8; // CUtlSymbolLarge + constexpr std::ptrdiff_t m_pEntity = 0x10; // CEntityIdentity* + constexpr std::ptrdiff_t m_CScriptComponent = 0x28; // CScriptComponent* +} + +namespace CScriptComponent { // CEntityComponent + constexpr std::ptrdiff_t m_scriptClassName = 0x30; // CUtlSymbolLarge +} + +namespace CVoxelVisibility { + constexpr std::ptrdiff_t m_nBaseClusterCount = 0x40; // uint32_t + constexpr std::ptrdiff_t m_nPVSBytesPerCluster = 0x44; // uint32_t + constexpr std::ptrdiff_t m_vMinBounds = 0x48; // Vector + constexpr std::ptrdiff_t m_vMaxBounds = 0x54; // Vector + constexpr std::ptrdiff_t m_flGridSize = 0x60; // float + constexpr std::ptrdiff_t m_nSkyVisibilityCluster = 0x64; // uint32_t + constexpr std::ptrdiff_t m_nSunVisibilityCluster = 0x68; // uint32_t + constexpr std::ptrdiff_t m_NodeBlock = 0x6C; // VoxelVisBlockOffset_t + constexpr std::ptrdiff_t m_RegionBlock = 0x74; // VoxelVisBlockOffset_t + constexpr std::ptrdiff_t m_EnclosedClusterListBlock = 0x7C; // VoxelVisBlockOffset_t + constexpr std::ptrdiff_t m_EnclosedClustersBlock = 0x84; // VoxelVisBlockOffset_t + constexpr std::ptrdiff_t m_MasksBlock = 0x8C; // VoxelVisBlockOffset_t + constexpr std::ptrdiff_t m_nVisBlocks = 0x94; // VoxelVisBlockOffset_t +} + +namespace ClutterSceneObject_t { + constexpr std::ptrdiff_t m_Bounds = 0x0; // AABB_t + constexpr std::ptrdiff_t m_flags = 0x18; // ObjectTypeFlags_t + constexpr std::ptrdiff_t m_nLayer = 0x1C; // int16_t + constexpr std::ptrdiff_t m_instancePositions = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_instanceScales = 0x50; // CUtlVector + constexpr std::ptrdiff_t m_instanceTintSrgb = 0x68; // CUtlVector + constexpr std::ptrdiff_t m_tiles = 0x80; // CUtlVector + constexpr std::ptrdiff_t m_renderableModel = 0x98; // CStrongHandle +} + +namespace ClutterTile_t { + constexpr std::ptrdiff_t m_nFirstInstance = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nLastInstance = 0x4; // uint32_t + constexpr std::ptrdiff_t m_BoundsWs = 0x8; // AABB_t +} + +namespace EntityIOConnectionData_t { + constexpr std::ptrdiff_t m_outputName = 0x0; // CUtlString + constexpr std::ptrdiff_t m_targetType = 0x8; // uint32_t + constexpr std::ptrdiff_t m_targetName = 0x10; // CUtlString + constexpr std::ptrdiff_t m_inputName = 0x18; // CUtlString + constexpr std::ptrdiff_t m_overrideParam = 0x20; // CUtlString + constexpr std::ptrdiff_t m_flDelay = 0x28; // float + constexpr std::ptrdiff_t m_nTimesToFire = 0x2C; // int32_t +} + +namespace EntityKeyValueData_t { + constexpr std::ptrdiff_t m_connections = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_keyValuesData = 0x20; // CUtlBinaryBlock +} + +namespace ExtraVertexStreamOverride_t { // BaseSceneObjectOverride_t + constexpr std::ptrdiff_t m_nSubSceneObject = 0x4; // uint32_t + constexpr std::ptrdiff_t m_nDrawCallIndex = 0x8; // uint32_t + constexpr std::ptrdiff_t m_nAdditionalMeshDrawPrimitiveFlags = 0xC; // MeshDrawPrimitiveFlags_t + constexpr std::ptrdiff_t m_extraBufferBinding = 0x10; // CRenderBufferBinding +} + +namespace InfoForResourceTypeVMapResourceData_t { +} + +namespace InfoOverlayData_t { + constexpr std::ptrdiff_t m_transform = 0x0; // matrix3x4_t + constexpr std::ptrdiff_t m_flWidth = 0x30; // float + constexpr std::ptrdiff_t m_flHeight = 0x34; // float + constexpr std::ptrdiff_t m_flDepth = 0x38; // float + constexpr std::ptrdiff_t m_vUVStart = 0x3C; // Vector2D + constexpr std::ptrdiff_t m_vUVEnd = 0x44; // Vector2D + constexpr std::ptrdiff_t m_pMaterial = 0x50; // CStrongHandle + constexpr std::ptrdiff_t m_nRenderOrder = 0x58; // int32_t + constexpr std::ptrdiff_t m_vTintColor = 0x5C; // Vector4D + constexpr std::ptrdiff_t m_nSequenceOverride = 0x6C; // int32_t +} + +namespace MaterialOverride_t { // BaseSceneObjectOverride_t + constexpr std::ptrdiff_t m_nSubSceneObject = 0x4; // uint32_t + constexpr std::ptrdiff_t m_nDrawCallIndex = 0x8; // uint32_t + constexpr std::ptrdiff_t m_pMaterial = 0x10; // CStrongHandle +} + +namespace NodeData_t { + constexpr std::ptrdiff_t m_nParent = 0x0; // int32_t + constexpr std::ptrdiff_t m_vOrigin = 0x4; // Vector + constexpr std::ptrdiff_t m_vMinBounds = 0x10; // Vector + constexpr std::ptrdiff_t m_vMaxBounds = 0x1C; // Vector + constexpr std::ptrdiff_t m_flMinimumDistance = 0x28; // float + constexpr std::ptrdiff_t m_ChildNodeIndices = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_worldNodePrefix = 0x48; // CUtlString +} + +namespace PermEntityLumpData_t { + constexpr std::ptrdiff_t m_name = 0x8; // CUtlString + constexpr std::ptrdiff_t m_hammerUniqueId = 0x10; // CUtlString + constexpr std::ptrdiff_t m_childLumps = 0x18; // CUtlVector> + constexpr std::ptrdiff_t m_entityKeyValues = 0x30; // CUtlLeanVector +} + +namespace SceneObject_t { + constexpr std::ptrdiff_t m_nObjectID = 0x0; // uint32_t + constexpr std::ptrdiff_t m_vTransform = 0x4; // Vector4D[3] + constexpr std::ptrdiff_t m_flFadeStartDistance = 0x34; // float + constexpr std::ptrdiff_t m_flFadeEndDistance = 0x38; // float + constexpr std::ptrdiff_t m_vTintColor = 0x3C; // Vector4D + constexpr std::ptrdiff_t m_skin = 0x50; // CUtlString + constexpr std::ptrdiff_t m_nObjectTypeFlags = 0x58; // ObjectTypeFlags_t + constexpr std::ptrdiff_t m_vLightingOrigin = 0x5C; // Vector + constexpr std::ptrdiff_t m_nOverlayRenderOrder = 0x68; // int16_t + constexpr std::ptrdiff_t m_nLODOverride = 0x6A; // int16_t + constexpr std::ptrdiff_t m_nCubeMapPrecomputedHandshake = 0x6C; // int32_t + constexpr std::ptrdiff_t m_nLightProbeVolumePrecomputedHandshake = 0x70; // int32_t + constexpr std::ptrdiff_t m_renderableModel = 0x78; // CStrongHandle + constexpr std::ptrdiff_t m_renderable = 0x80; // CStrongHandle +} + +namespace VMapResourceData_t { +} + +namespace VoxelVisBlockOffset_t { + constexpr std::ptrdiff_t m_nOffset = 0x0; // uint32_t + constexpr std::ptrdiff_t m_nElementCount = 0x4; // uint32_t +} + +namespace WorldBuilderParams_t { + constexpr std::ptrdiff_t m_flMinDrawVolumeSize = 0x0; // float + constexpr std::ptrdiff_t m_bBuildBakedLighting = 0x4; // bool + constexpr std::ptrdiff_t m_vLightmapUvScale = 0x8; // Vector2D + constexpr std::ptrdiff_t m_nCompileTimestamp = 0x10; // uint64_t + constexpr std::ptrdiff_t m_nCompileFingerprint = 0x18; // uint64_t +} + +namespace WorldNodeOnDiskBufferData_t { + constexpr std::ptrdiff_t m_nElementCount = 0x0; // int32_t + constexpr std::ptrdiff_t m_nElementSizeInBytes = 0x4; // int32_t + constexpr std::ptrdiff_t m_inputLayoutFields = 0x8; // CUtlVector + constexpr std::ptrdiff_t m_pData = 0x20; // CUtlVector +} + +namespace WorldNode_t { + constexpr std::ptrdiff_t m_sceneObjects = 0x0; // CUtlVector + constexpr std::ptrdiff_t m_infoOverlays = 0x18; // CUtlVector + constexpr std::ptrdiff_t m_visClusterMembership = 0x30; // CUtlVector + constexpr std::ptrdiff_t m_aggregateSceneObjects = 0x48; // CUtlVector + constexpr std::ptrdiff_t m_clutterSceneObjects = 0x60; // CUtlVector + constexpr std::ptrdiff_t m_extraVertexStreamOverrides = 0x78; // CUtlVector + constexpr std::ptrdiff_t m_materialOverrides = 0x90; // CUtlVector + constexpr std::ptrdiff_t m_extraVertexStreams = 0xA8; // CUtlVector + constexpr std::ptrdiff_t m_layerNames = 0xC0; // CUtlVector + constexpr std::ptrdiff_t m_sceneObjectLayerIndices = 0xD8; // CUtlVector + constexpr std::ptrdiff_t m_overlayLayerIndices = 0xF0; // CUtlVector + constexpr std::ptrdiff_t m_grassFileName = 0x108; // CUtlString + constexpr std::ptrdiff_t m_nodeLightingInfo = 0x110; // BakedLightingInfo_t +} + +namespace World_t { + constexpr std::ptrdiff_t m_builderParams = 0x0; // WorldBuilderParams_t + constexpr std::ptrdiff_t m_worldNodes = 0x20; // CUtlVector + constexpr std::ptrdiff_t m_worldLightingInfo = 0x38; // BakedLightingInfo_t + constexpr std::ptrdiff_t m_entityLumps = 0x68; // CUtlVector> +} \ No newline at end of file diff --git a/HPCS2/x64/Release/HPCS2.Build.CppClean.log b/HPCS2/x64/Release/HPCS2.Build.CppClean.log new file mode 100644 index 0000000..22b0952 --- /dev/null +++ b/HPCS2/x64/Release/HPCS2.Build.CppClean.log @@ -0,0 +1,13 @@ +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\vc142.pdb +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\source.obj +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\memory.obj +g:\halfpeoplestudioc++ porject\hpcs2\x64\release\hpcs2.exe +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.ipdb +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.iobj +g:\halfpeoplestudioc++ porject\hpcs2\x64\release\hpcs2.pdb +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.tlog\cl.command.1.tlog +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.tlog\cl.read.1.tlog +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.tlog\cl.write.1.tlog +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.tlog\link.command.1.tlog +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.tlog\link.read.1.tlog +g:\halfpeoplestudioc++ porject\hpcs2\hpcs2\x64\release\hpcs2.tlog\link.write.1.tlog diff --git a/HPCS2/x64/Release/HPCS2.exe.recipe b/HPCS2/x64/Release/HPCS2.exe.recipe new file mode 100644 index 0000000..5532288 --- /dev/null +++ b/HPCS2/x64/Release/HPCS2.exe.recipe @@ -0,0 +1,11 @@ + + + + + G:\HalfPeopleStudioC++ Porject\HPCS2\x64\Release\HPCS2.exe + + + + + + \ No newline at end of file diff --git a/HPCS2/x64/Release/HPCS2.iobj b/HPCS2/x64/Release/HPCS2.iobj new file mode 100644 index 0000000000000000000000000000000000000000..fd58b71969b9711bbd59f646e96316178a775352 GIT binary patch literal 3209041 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%0A1qXF9^Bs_mwuf8hG^ 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⁡)|=nC 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

(ZHF%!Ww<@i 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

lSRPwOSvA93T>fe5trnQYrH^`^X{w(Z_*TiuB2 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

rTS0v{V>yK9OJ_QH+ze z1pB>WuPF9+#Rj6mm2mr7Dh$RcR;Ad3plFXz1wXS?7`&|E*qSqz9JK>JMi?aNg4VH* zuXQA#aA0U<2DSjCCz(|*SQSLQI000yD)9nT$OmGbqEiqGY2pS0rgU+^;f*oZV}X|f zegCy97cXmEd@l4(x}e1^1CgJM83J76JIfet<(+6M+59_m0Uc8Qd%nm>v{$FAE}h#T z9EYU|iquLV1zVOQyj0Lml$~#lpoK~u4UveT?VBz+B9EXQ;0fA+T@bWlMkpX?D@-D1 zTS415C#^=%W@3VNpH2lWI1$Go5VQkT(7JRK7PM*e1Gn#TxhbHj4OvAFblbb5%D+0@28Of=|Pc#C_@t@*z1-G1I%)=7{1(4SUyLw4=Dz> zO&jiOiqS1x;^W}7yn|!%f^ke-Fz&B^Qi2`H!GSB%(fki3A%R|>=;gQBKqDL z74SHmkwG5vI*L}=Y};JVT5CIs3$danBzV1(;I#-S5`48%8$i|IjJkynA=NE0S$+jV zggANq5K2o9E6a@lrroN(5gv;TiyP}#tv;lHV2_!&y2Y;5Rio~IN?MKl-Q1B`x6){P zT<}B`$hB|@FTxmKBwcBDPc%Sn%r*B82b>Pi@db-fsYBhjsY7iRLp-L`%dOmpk;VK@ z<>-dKg#QO$Hno4cWVw%S8JZ6*g|$V(`mMowpo#t^rOGwB1MrY~?i*FyJ}ook(6#YmHU8871=xmokO7&0=-MyvOa^qQl?3p7V= zdB+hZs?os!6eHgcsS)Y^3`D;Uk)Ly52|C$V>_6j<mkqnK`~CU5-jr9G0r+N@tI>{Ljv|rRZL9 zBsu{VVxjq0LG`~27MdA&RTIu+un>Q14CM;r9#r{{#|onXAxd!aI?i#Hv(TKle93y5 zaUrU_6|5MLj>||GHw1n9f&2xoD^R zIlHeoa~Cj2jEU)cotq;LGVjbaN4Rtp*7u|jF&BF;3^dt9bA&v}rSPMzJ)HhmSnrG5 z9-M)92+E4(wE!8-%+A&2Jlg~7f~U)!X1>eQDk zVt-NW--;FWkeEX*;%(nCQZYJQ$$O_N#@PpN;6qcv=PeZmTQnRwU%rjgh2+_%6m#Br z?}|`*0m-xvAvzE*JGD``cz1PAOh$P90@km*x=>-^#jS!n5?e?o?e#z86! zo<>}PJ!>hLR26$&F_>j-xM`LOgU=}TImPZ&Y_nqAqD$V<*HR*+1f!6WwA5-iuD~uB zR)Vt6HYm0g)b+#o9osAgld8Q7ld7fADNnd(+5MIHvTbG1pUU5l4-2-I;t#hbiFEfC zBzkbHGbsa{U=@VE3ZdmFELu!QvNPQ$t`T+Vp=ju+16kCiSa#vnMtJStk&Q8dIweb> zpMd(sHs57f?$w`4&d5B)nAM$KGIuclS=~{FY=6yx(r+OF7HeU-uzhB`%ths;dXoyV zC62?6wp18=T(N5vllH8x4HJTXhSkjHU{dUJj34Uu_p`imNb`9j?0w8Y+%hpt^yVZm zG7SwAFU4xl7~s?>GB}sE)0W}8DSC4KiQaT{)s}bBY#^n)0)5G8)VA{$x*71q-R|`l z_56Y80s7zkjfNjqLHqO?^IBA_auhh$e6V(J^8;CpPx%&l3 zU*T?2VZddb1mm(!g3(GU*l5MLQm|kdOBEPftJbl#Q9CiVHi~0v#x{>@H9sO6TVpm@ zY4Y~Q*1iD&b6QNUT!Bbwcjk36NJ~hvh@}jGAF2EgIJPFBmmD4Wb*8 zI!APOWz=jc6q17=N>4%UVJ&uIowbQ|=NO#1-Il{6Zx3>e*KN7fiXa_5Yj1I(tYRBb zjB}z5emJJ;P>xN)mE&jAaBaZ#NL(2ue^d7V6-gD@PfC{g6KrFV+zq*Ws10|uV*gZZ zhhizT4Du|yCKBKODfUyvex=xN726*zh&(&mQdkjQG5UQ-d}k_lmSVRk_BF-sQf!N2 z98;5ba7<0&YegGy&@kq~CQF6E*FZ@)wh$8TKE)nTtZP%0s_~6WW33FeT^@aLvXaP= zx0R_k4NQIqj`u)Y^PWncX>q>RQHztz@yQ@xrnu*Mu1|)vF1s)*&nbkiP;;;BpY08) zLRNJOA(cTVCETC}Kf+V|$f>_jP9+5=SMZ%+@=o1U)_o znI(snYqf2V3bxB}2_wj%~Mj@Qb-@7fo=HxwflZ{GR;?Q=|XUkn;=VQoi_~2zoE-)n9Rvk=PC4xA=_27KFGvSSRC#XNoh{)6;Ne zU3FsZCFLhlVem_&RERD-)gu8^1xBlF7e6=ciK@-TPdmc9_FF!%@J5R8jd2*!mb1*@}E!O*ZJO04?K*CD zD+Ct&UU+RXI2jbpmPs?YM0Og4vCE9X-hmL8$EwV7+~YXY88~ml$H^hhp0Ff0+dgaU zQnO&X=zUzF#4QhQSMvqC??h-*$lg}K)M2ROl$p1mYIL5cUsjf5^SKnmZHfJ0^BLC5 zpSW@-;B<07YCrzOmHogoiAiRB`kHu?c-pDZXT3WxwL5|aM zG`y->oDe?VB(tAUwfI8UvTQ^eI(Fr&g4w7K%tq`9@*|jHCeNu{%nw^nIYaO)DG6`K zo_6DgEIZmXS$@-O@UK8;p+)kmxZ(xDt+>|V`gL3(%!1o+<@bFP*KxSsfVv`8n^YLw zqS)6gB_4bd?k>gH0TPTIAbGY*F$yQam|qg^M8&?N7;B`2dswkY74th(Z)DpxaC6G+ z;(5^q=$D5EitfzZbQzJEt(S*&47}-6i_E1M=>}INvKxQULXzBf?7-|UaGy-!#>SW* zS;jY*JtEnsvkb|FUSwa#V?haPegc%R=JlY2HNOW+wk2^)N!xFDw=x#wg>{0=kNh`|H^jbS2ZXLurY03q z7zBbr3>Ydj&kOb=#d;z#!BUpOw!w-~=al%~r`TnRU9Z@Uig8#;;!B`b%d;F-5{xxn zuu+PQQ!LK>3&>`<%x|E!4ekz@pCp<8M8oy(Ci7D&Cb9l_XUs3V0(X`9FU!mPt9Fk0 zyB6Fq|AjSsm_IP9s*}mc^zJO&&UeQA%-1e3|1~gengy%7!u(C}2x5!=kTO3hVSd5L z{DM(<2u9`?jLa_>nO`t6zhGp3!N~lAk@*E9^9x4i7mUm=7@1!%GQVJCe!l6Z@2W``&GrVl7dmmJmM z?C?P**P_|sQ_SzYv%?2@vx5dZr6JEedN(^<%&MKt4j*IQHxaYL-A({SflEU>KbK*# z*+N4*ogIFFiGC8qghbET;V$~ZvxN>cPjVB=!8szPu#Q1XZa%j}mQkVE;JH346Asb- z2dj`LlNOj%p;m#D+*;|PoXHLH0=Ka8J0IUqiPPc_aHYP=->ioGeFCm`@iD)!Ly1zuUG>_i#*$CsW3QSv9*fP<6gpTR_tlTo>lC1#b}e0v{XYF z$+H~g6buvAEymfif?cH8`xJW-)Mb#}sen_@NreFyN|E>|VdU9Sij7mui9T2W+#ZCf z*y@zb(y_)Egj}f|oVu`g?{eSYMra5?ix;6){W0f|g&Rv=PMF-P4KG$3(E}bYzmC)z9 z*z>v0yTV{;Wz6T=tT5OP6`yN{b-I(gcC15DxE+KJ6orU$v2oKLnMkf*7hk*1*-`lI zR*uPLAMNZWe7z_oY3q~(% z!MGNMU|fqruo2)-!N~lAbRKX1L zn4BCrG~<*BQZl407>ASv`-i1c0exQua}DnC8Q0gq;$hgSp_9(WFt4*QFu;M%M#gkD zW|ZdkHm2dG^fnfPs=*nJ;w**`_*Ja8(SQ(ST3+deEQd7LyJt!gtoOSoVpEyZv$Znk z_DxO<>hknW{0eQ{@slO#qp|MPoI;(J18t`zX*w-ft{|F7RH)OEM5hH&V^WGNygG z!eE+W>|+S_0ma%B`;20rQ*4W3T!dh_iEk=o$jig|ZAV!u4C+DgZYrRJk#H*L-g%?S z#Yn^}F)>$y@9(jj~ze&EHm+4H;JJ;!X_s+;r$E%{8!gUgLJuEdf(3z)GoyF8;^Yk>t zEDGZlN_`Pj4bDh)ytWua%(4F7R}g|SmDfM*gFoizW|`V8Jx0@O>o${9Hzmo)>t7z# zfxP}~@QFO?s_({Y)YVgGVvB?WJO$LOxjGY;^}X9$*L`VE34kpT5Hg*tpb+tIijDou zPHgN;OnFD@>if;_yz1%_PhIVbjlID{)q%Q7qtdaI1SU|0@pq=GD(@cwg?UiWPF+1O zrml8uV`ubqBst$i-_Jx(Rn?C^zq;zIT^E`s#btr3aouEom*iDl+m$FfAcyz#*8$2M zGT}nH9dtPSsALUYb~tvrw=u}8O*E&Wmbl)=u68tB$w@~eDmm!|tVGEz&M^_1rQQ9G zMu&Y2S7_45hziY*xp1LLAERr9_D=LS4vQxEQb>3Wu2iR}zrpUtx{PaYNrk~0RA9j_ zuv8d)K(RK(xRj=Z%UBAVS188me-hsXie0SOb&B1f*sY4)rr19f+o4zrEv3A-+){8= zRcx|ivlOdU?AMC@PBE_EF7f?MvGEwD5bRJ(g~7>+ou=4Q#m-UeHpRZJ*k;9ktk|Cw z`>SGaD)yFQtI>WAAHgzewiMRC0VU~U>q;tjHHW}*y_A@cO-1voQ>t%w!6~1vC4H8C2YXHD}Ooi!$v zQKMsedF!>8M=A_Hii{BK6PA)KT?PB1Vw2Dg2uAaiJj-b*g4HQ@wPK%C>~_WORO|u8 z9#(7s5ctIrrU_% zH>*1k!DH=kcTs>4I8r%&#g~BD%vksMGGD{K9Y+6DIkvRxk74k>rF2yOF+zGWo^uu0 zs0N7E-y`HUwAhIQ@l;vpi;Tj$shbnPhxuxz%8h07!#s``B|Ql4K@d6#A7RoUzh$iZ z6(Cg><%RW>W)|>=E)d9hnXJ1Dab^8I!_HK@Z3r`nPm>CRyYQ8QZLw4sJgC^u6dR2A zB^+mL%CjF+>>9;xRE!)Y;V3ZV+0BaW1{Pj|#GV|pKl?0ve#b1V%gRF?@i;_bQvtWn z$f+OE+?B!=a3RX^y;lL5DpvvdVLMR)ccuD0rPYsA7+j2sDA=Wz!g?u+eMGU}DE5?M zZ2sk0&N`9!7AeNsAlQY9U80yQgW4Q^zZB8Y=PcOD*1QR4q-wJZ_hzg@aoP$E)z>dx(ztlVn9-y7d$e_vTGF_*VeN|M z`X!Ak8k_AZk%gYJUQX}Ki%g|I27M7vC`Oe&f$9?}xu+p3(qXC7n_Rx+Ug_}D8+sFj zKyWG^;6to~ECasB){yI@V z8#{e9V}+hIjndBNs{&piS%o8B;9h{P#$rnIlrdc@%|GHJ(y5&&&1dldA9AJ1_jnSe z!e+^95IUZ_mS4Wi!>*Js^VpT|tCXy!Eh7~MPvD+lPg*JrjzD<{#*&k83lv+Zn2`ba z6)ev9B7ieD4oe(ei5q&rXrKqxc{yBhuWDM-NX?MWO5LIj#yu>hz?Wg)%x;N)H|@lo zSBdSmp@0s(PgOwfDF(B-$h%k!M&Kkm(wU08II)`%cWUyy$GUJoM4df|z_h zbEXP*=YCaY-ZLM)gZR{tvY_2=FlFs`gYkzoWSf_P`L}u5*E1V+Wt*2HOu`Cm^CC@X zfo)#)kC}-&-{xhsd1vl6FD@O0%|vPQWbQUE^5i?X&CB7ctFxfJmh~i)I+Q({ShlRM z;J4qbvhH1l%18CZsZH24z<593hwEJ658}#r_?uy#Q5~IB7+kH`CoP5D>=gT|V&l+! z+Gi~l1~iNccD!OYDE0-#zO5LYuH?PHQtY>i{Z+A76r-=f-NPvps6dbkg9|~)d&!X! z-&KlzT(NgcPOzJNO#wME4__fij+{_kV8yDHXUAoG&P~x9t?bCT)7fK2p1h7FCal`O zv-0F*7DXrW(*W(uBoaK$^%3hr23IURQZSN+zWX z_9Ikr!5*?yDtJV(6TsmT?qo~J_^M#+oXfNKYPkPXjIu+*QFcf;2uO=1Efog+6dR}* zCwu*jl{nyJFH&J}y@n&_N_@8~Mgx~%oX|edE)O`!Zdko6+uDrrzqa#Bvr~WD+)r0` zF>3|>mTLtL$+n$Rk!@qBv5#ao{(iG=X@_-Twr4lqJu*A?@$AN}Apbe!g8#?fm%v9= zo$cQ+lZBaqBp`?uWq>FMs4R+XVgf{NAS^1lRR~*nGt1=-$iDNA8Oa1CrtxK!c z-MWETLF?9PYh9{XZG~bhR;#%3f1b0vb7nFVV!?j;{hj=7&U>GG?m6e4_pI-E&wG0M z@jux>2CelQbN$A#dAJb5Nky>U?;KstWqB@e2EF;9^q}QDP$jq$gO&x^n76h`p5##U zLg^>nkN3ep^-F4u)a+)r4e52Ww98`d)Yk1=nMgBBan}sK&qpk%Xy!GuJe0~)v#Xl9 z7#*p)tCM``uBc|ya=`!xLub!e;B25ZC{waq`9S+jv%)x#N1LjLWT$Y zdLZ0{P*EGq|QP@I-EZC8PjT7vA!PW>yL8}gLgJ3TT_Of85=(GCutA_%bU}IFb!DGyE(^Tiulp>=k3a6O+kAwN zyHkI^O#0~Zc!}zx%ldBgn@Dc&c6uw0ouxekZLxG7DBU;Lfhxh3=$pGC)gPtw&F8=e z%L&~J(+d=KbGP@6DAuGl>)(Ymf1^G3_qnWkbf;fGcC_^C$x+PR;2fm4_p6T3<)6 zSwB80r61q9Q0o{KT(VHhrXh1b&Lup2HGcD8Hl~Z}I;kyf-*o$McZu&)W>s6UgE$*= zIqS9M9yZe~l^ps67Xv0Al6%vEL!~!mDR6qz6)N#gZ<;FfV!POq&}%uKv+ra;w(nev z&(VD+sgSo9dN_^kW2lgKpkM<8yGO7G1p9+vuLxFzo=b<<+fX5Ih+rcGn=aTa!C>^s zynC8ppMbi(C)517p+epd&{ya<*lXzTI7F}^f~EF<~hpuX<-k^)WUuNUy(jV>04N~&N-26HCt-U(m@%@L)sSB&X&3>4=pSm4EWlu?4c^i z(P_$0pP@RVXyflp$uNmstri^;U&NErFXf^yl!GE#~c&yE&e*a5bc@uV{; z=t{z@*^ck`twVUFci1J20X7@me@FJMLm;->&33SiIUURKES>n-C2K7Uiz-b2WBHwz zs~b=ePc zZBM`ZW5KQw>;}R9E*O`ob$DM1)&@0JV?~AvE6X7o;{sFrB7Peem`LH2HSx#VuKm3( z*e1cGr&$_xMMt;bvT3QRgkDHMJOQ$kN521|Ic5f>cN?Z)t2X-qP4wLxsI3 z1mpT#!Lfe*d$0p_WfZ*e;~(tG9+IYs*i2#$wVtl{FdcC%kGg!I)^SM+A7;T9MZ28B zzmbLyM_0~-8lh%_rWFT%TAYCcd#DzOf^=PB%8~@>+`JOW4Mhfrx;V0rGda}E4TVG4 z%P=52b#p{uubpj<&`ObGn{SRdtl8!W4q45gbFjj?&r z{x*rfcLbXUZfJk=4F$av!B{HvyHq^Z{w@*he{p2NgMd?ut2?szC{1xaZfRAGEv}kY z#Wib`6xZ)Z7faQO8KrNO{O@$%WFO_}J7&q4^}OY2>TVxhu#7p4!GAWoxYdjV>yP>*2py0PcV)tI;+veO@<1298+k2tnoTLjwv+uj$n_oFVmYOAB8(3 zr6y zzrVB`$wQ6S9vo_i84M_Cm_cE2R8p)r&C$d)^3?R5SXgYUdxM;Awm6UqDN`gGYlLr& zy=17c_b0)$(sBMO0N(mM{OgU^6Ki_hEq6%Dnx39@p+ko6kx~3pKdo<5;fu0=#Z>Go zu*Wi~1+!fhE{blTG2pD{_7zjP!JuOHq6Lew&vmzKG|&Nm+xIQl?GP#3Z+Dw|P76C1 z`t{e9Vf6e;9KCgN?aZZfSSOrYRW+`ioUv-yAyy*>ORXD)Gq7gWgJUfFW4XKn)q~X> z4T$ z5~#C{%9A};=fmgVl={+z3BYepT)p;HB>sJ0UzRpAz%JTSx&l@%shv5$qGr)T7W6=Qk*`x~`DICKi-&ja3*bIJ$B!TJ+k5dix>UmSjX_R?04Tj#u^X>-M}1$jP+kVjear$K%7?o)-#3Dtm5@ z+Uy~PgCF2mW3`3~d20oGLNNCX#&t07ydR#Zw(E4bLChdM@0W@quRg%_TU;YkGO-gd z{^iCLE7xgQ&qG#f@%J<;w1K048X~k0^|G7fSFId%)Q-#$|~#|j1JS=8)Y#E?g#?- zO-HxJZ>WIFZg2+No^WTuWq7>j_wkGg`;@rx{(JzQB4lacq3dp%MHS1hH>xeIZf+#Uba@B6{k|9^w4MT_-v zz~QP@IBJx%3R-{Ns@0#P#LtOVqCn}uRVwclM^~LZFL4g9E=#HBie8XpGVK(Uxj-jq zlmsJ-gYKlpHIF@?p7w>1x@-85a1q?zbfNHf2)fruaBruHdJ|qF!85``=nribt^M>= z38|Q}V6mkA90heoM>?@^pJuP05+0&n=09aGC`|~bsSpZO2>Ur9EKms;7S3bxB$0W+ zNHF3qscur7ScJgz$ETVz0FUzq0Y>~Jr{ z+>fBB0cX)UHaXiTXL-=R;qNrXcqZDtS`vsBdZRGN%g4L<7$vdXpNfk`n?;77`#LUu z7|RBe$D+UljmA}uYXUC2Fv9w2de4qnD`7{;IyfoI)Iqx%;`X3y>r*E$eIO3y2&ymK zPH_9dy#OvwI8r_6hOV{;B^C0X%`Xh(7fdS1 zFXX5I+xm><(ABy5-5S6J4#ZWTp1jv@EFLVy74+8Ne~F^-jcS(D1w?Ji5dBg-V<%7d z^%TMFE(#Tg4NLAf(i~jL;^jf0x(xZ7EaBCC#~)Gdutz9;-@zd%_jGYoj`5!tgIBk` z58~xOC-feDhUR2Pa*EwklFr4a=JX6q%;^zmj~d;+y}R&v1|9}Z$>|yh;^j7Zti|q7 z_cc6@v_HvKZg=~aGUnL{M`6#-=^6hepff2_N8-j0|$lYKpQitPVt5j)Bw)EXmRfv8(Q6RPsc1oM?rg^ z_7hvy#vG~=_d^sK|7$kWJn8#9G}CB()i$wLF`EeE6ZjcCu#U`HhN8hTz!JnFb_uQ* zak0q!85cSCS6qL?#p0QV>qJ}^;<_BymAJ0L#jR&Q$8|HVTX5Zu>rPyIbjERYxQ@bA zkTiK3nErTA+X1j5Ne95GFdK6Itp3fvK)X}nOL3oi=4W@D<;jBF11`ezdcuvt-5+i} z++J`QE^$t=s=L_^f>g-6O0b_AD&*ZR*j<7>FW8HMy(!q+g3-*Wj)NMcIu4pS)z~e9 zeJI!`f(6jcXn(ne3V9O+J6fjGvFW9+){a&y?3ida_{w`PqU6hWuz)&Gd1(i%8 z?7d+qY)MC3t^KjpCI!>rg7p{7stBn0Wkmf4o z3K331L~ti^Beg&117GOjydqqO@fG#clfG}RKd|$Nwko!$G?F^@wrU>nB8pswzM!kL zGZ-4+*FLEgeGQ)x>Db;jZFQ)7t^&+?xQ}GF54S}>5NK0?*7^k9S|43m4Xb=9L1#;= z(ei+<4_XR-4L6jsWjGzNuytT;tnp0Lf#Ak8Tz25*9LsC#Ek9c7ZMuOQ`NevQ0wJQ0 zU__gC$%fk=cn;j|a6@oeFHc9DTIx(n*GrADUTW-C@y8mfG0F(FKh{uE)5QcEkEUG?J-VDNvnv?gY` z9g+%LjHRiADkLq4bte}>4P;&+YP;7C-@unH#%0C3PC+2VPdo`_5(R-H2qodwf^=8R z#=KxjK=wges(&59aZ-C2&T}ud<~%9Qd5w|t8jB*IHCAM(WW)Gao%<9`Ox~cU{Kk;q zI1X~F3dpf?l?V%ln8(o2MgK>YA?7F38e*=F)PI$1h#4>V@eQIwSD^;B5L#_u(^Vld zW;U5yQwFdrkZ=xQm*BeAez#cybd0zv8K-M%VHX>-wCi2F7$(=zXr4KF*!)>B+r653 zRn@8~N))_Qs|E|b8Suzq*>?4c88&m6JRY3XzZI|qw!gG#5RT%9#>ScFDmB4DeO+V6 zRJ#lGMf*6QjXO@J31iwoHrA8fHPkFg1K!;Z%Tou`gHaFCRPzCutNA3n(Q-9E5dlZK?CDnX_W>cu zJ;PKJ4&^qh=DB+kZ=YJtXQDjfK`soDC&X*+XZ?^-73R1C&p|BBIhc~8f~)mbzWenm zco3Pz4C99|2IdsMVEewF$KaVPR`ShJUCC{)?by_|BRVoHse(^X%t=^!uW;^lSN|^{ zZWU*lNms>Lj##BnhRZ6w5H729jk#wTvsL^pq*hmPQhI4!W3}+5F~*~@Re~Yo4c5a@ zA@3l;Si<$YzF_4E3~Kjz#w?ZfT& zcJmvj6h+J9Tm1S5uOM8TJ8$?vH;6?6EPcYk9W;*UJ!AHcopJ$cFOxS?`v`ca+B~-=8r2 zi~NTDkn!a>u?cD~FZ)g9MZHxVi0tQ3NKG^j+lZqhpPCp8Fe36`GjrI(FHXf_=)DD z{QA*((XH*vDIH0~RKFowhD=$t?W-L-{P?sz{dnn{e!TWEW*RJy6)Zi-Z%2Q*)sC7Y%i=FtCiwBGpOp1|8OBdHmEnu)K4W*iR3&0Udggxj@1yvs<^&qH)co6h{ z1FAt`e+N~luVR+iK2!JwnQ)<0IL0QpJAkO!d7$6TnJKA_wj9muReHA_f6!4 z{v|8~*lnj)4mDDn*ZgU5(qJkfh#IH{Q&aI(165EDwBefPP0IV6nKd)$d-3**=m{=48hOT8CV78UN`LGNhv51#A%oHMCNYY^88ZEq zBTl~ig2MLA>H&=AIO$JgpJMLb6GzbX_3Cgv>Qtnt+La~bBO?N_RanPwpQH<>miS|hW{p3X!{9nN;>6SN?U7(? zm5aTR2Fpgy)1OU_b=}EkH$jh50d+)lVcarS7qj!>Qnlq>BvYTu-o@-e4bL-~wxywshLW_)Ad1fSU zw5!oV>rR1{XDS0+1H+NLLGC+WFsu8nych?}x~g*Kfbo@AkvVN)gDbDA{i+NKAk3_* zRI98_|FYHo3BSYJk<|$@VODOoT#qR~+9L09xZj}eyQ$TQp74!@+)>MG(2QG?U2Bww z!_Yniy@T-B71A3;k(D<1I8AUC6Wh>jiV5-Kn*B9;^~g}15uK*p^8oY@mzS!X}q zwYQa;{mS6Yp(~3c*@NAxq%?n47UK-xgJH_7znl3=U8nELagpqP8TEC>sT6Aa4b+!8 zP2Fe1L}Nnj(Q@l3%dPCzaO)^1WOmt9avc9Hur-qavx%5{1Ul8Ox>r?{Z3yi_o2HbA@e&s znD4ap#Kx2{_bFxNf{|Xu%kl=P`v|)K^mSz4)^gwg6;Of$`8pRr34Py_&JuzltnzGk%A<&rYiSrr6iLrS;T0*-F|%3-y*0EOY%0 zb+3mWEb}&+jJeKT_HM507ly&A>%mEBGc8ly-&L-McHT1mTLqlRb#CHkZFF{A;%Sk9h$?A893>|<< z3d1zu=TD18Vnt{OAkKv*WvRJPXFwcYa6U6BD>0uTz8E;?8k~1~;$Va(HUjQt za3{mP0`7@$p=lRmGBKNtaoY3~xR=Ad8t$ENe+ri)`)lC70QWk$FT%YZZZ2{HHZ5Xp z;rJ0I??aLGX~(_92mPQ>W@}dPc*%xiDqfxM5ai>%vJu#C^OSB6GQEfxubu% zGC9K(QzmEH7g=h3WmXjOR#KH{629`A`sM-uAAa+|Z}B(xL!mf3Y9-R7wEY>4onoG9 z^HUl-L$FH?751(a>_)+E5$s;UDEHEFQ0}F}<2+qs{}7C&Ph)8LjK6F{!6LR`0|Yx< zuoA&41*;NlxnO4r)+E@4f}tHT@!lxdy@EX`*i(W%D;PC=^|yr$1*?C8brbAh!PvCw z?}eJbd3T0jn35T6v0xVoM!PQh-RlLrNwB*FyHBvK5Z3ARy>BS2sb^bkprJzENWn%4 zcD-OX35HYOO?VZC3Q;e>V2cD>Ay~a&KNjp_!R{379>Km8EDO!8{@!+m3VVfu-67cB zf;}eKdcoS}+4NC!M~AnUVASo=*a3naDA+i`CJJ_mIUc+0RfRZ-8Kj3U-rVw+eQj zV80gZOTn_jHc#6b3Vai6AHksYZ}NVmV50<^DA>`0T`t&91pB#Qw+U7WU9{dsZ0o8F z74qH&rStw>LxsE#1^Yy>0OZ=*A0^znY;+YYDp(LJPydcGjyyw!ykiABQLwWGTPfJj z1iM+V?VyHsXLw&2D&&nTu-HUHg}kMLohH~7f?X}xd!QDn@U|HW^&I`Z#zq+meSl!6 z2zI_;YXtL~&bt$h^%h*vtUhm}Loc>83c9jW9mM1T1MY4V5JySjUl7Z5FpfzbUTi+c za@$mQUGS-N>w*XSjZ@z(kH6(NPIwbbgR2peUK)H7Es`HUqu6ge>&H;l^ZmZhC(hOJ zKiT33ewTcpPJY9M>XkQ32mNENY;)84;bn2XvcvOu{Q4htQCl2-;KyH-l``0+&|Wt) z1=s~Y&+j{S2A0E$^H=^E4Xb%-1A^M}3@kRDTi&=JA6GYAy~^X&*go;O3BNo(ybKFt z)g4OIcD&Mje?w_6aNXN_Mp^u0zy7&={{gBwezRk}cyUlN!nB~`fs+O$|#yLQ} zuppR!&Njww7xa+KRcrGbt|eB#wwGVOX_MdRZ{M2l!{A1)O8eG8S^PIx4$Ys?bYxbU zvl!S|+pD~>mPx$^*BwaD{Y=l3rPp{RYPfH{5lfNRsF2pc+he$%hu4?2*T>)$U8Bto zczsNJ#roM}eq(vj5Ue6TkCnOnhJV0YS^Qb7WxiaHfAQMYW2mNmCQmV(c8Bn%ys7rF zhPCDSYUMW{etW5P&wP}M%dsxmt$g_Q{BwWIkg$3;d}IE(^`Og}P{smJm*ziu(1fNj zMOipusU-df&A3%-{rI+;8580g%Hn^t*#-+F1^$jFjprx*_;XvI^ZV9b?$>{{qvnuu zd@o|Yzo0ySG$@qdC|>vRdeek_9V(LSH$?{J--nOb;)7-Qh;#ioOQ!ndN)|e#7mJTr zKLzi&ekyC3d!<UR`W7v>k_V0rz0Ffmt`zX|bA%96@o`S5M!D1T*X%ik%8%Vs28RsQxO zwv+Pr{)DEn$OT~n${y7G&%)C9g!gr>HcfRnj+O3iQoD3jEQvi_l&4D@nr_6HU-~;q zNz>H#!L(deT;9jaV2NJI$03(!G{BzW74z~NuHk#hjldc#6z976jpH+S!m9(23YBK& zv(3mSOW#MvOhqO9tRR2ozdlE)Q0&X!X>e~LQ7X7C5A&_Bot&%e`XhGn{)eG`TFU4Qs8zh-Pot_d^p8-D&75}llj&GV_41~x zi?$*4W$_;lDT`MZm&JeNm&M<Y3n7$XOdw|V= z>?PJ1LtZ&%dsLG7u!!v0XT(TnZ#h2qX~9q$gI_CyP=!5TB`l3J7)Tu(g?(mJ;zPn2z=b zb~@-odqaIG8@XJypo<6Fthaym!7AB|?LPIHVHHv_{H;-bA5kG`m4Q<$mm?pkY@iimC#$@SAkRmu zwI8Yme8dvqU4gt^Y5Y?7iPlf~?ShohuT~?_-*FUT_;v6v!D6MPun~TF-lvWcMqq0z zlfu8ngx?lQxjJ4Q)+UAj1d0mvDx8}Uj=L0H2Z3%R?{F8=x&enBU2LK7JP^A9a{fSW^F?viibP4>TZXvx_az{*$l|3}(Yfn=5-aRJA5os#Gc1yLqm(Z>Vw?NSG^77HFtK zzOcDbrgn7 zw;9+bu0p1|fc~Cava7wjgA9S{NOKY?nYnc7%;l< zbIoDU?n9t{9acF*frFvOk%Ri3(-BdO*x&gOT7C%BKdpG!HryA!X^1MP9sEtSW%gr8 z16(T@u&{_DoNb;n%brtdTh^u!3-2vzQ}9FnqCD@Z7?wzU8+^<^p&&D|aJgoTHEzQ2 zKUA-1n=UR(+?u3pXN2otwy8b|osDfVn)%DF|02u#8^j1j~YOq`FTm zquXehuAXQmM5)J)tBzGKbW$aULj?W8HEpuJOVB_iYNuI7uRmHXqqpDrGWs+XaAFz# zM3XX`)2{30u*&rzE5C^3)MvQ~(Aqm+P=O&7$yxb{`;Jy(s3-nmMh=8j0t!@{#4kNq z-Di952~b9np}w8r01t;>`CN;97^SRt>DKU(Y-THKS34EBR=^@(zQlzh3YPDXj$(x#L5oNB(@uX9ZwSsr#a zJjA!X-eS|jFX^rVPw;VHb)Q}xqK{KxUdCi2Q1>a$^zDq=mmPowz+fPT<~`5@_n|zF zm3uN%yv2*CDy&=N4k}On=$(iu74wok>Fo;Bx~n5xZW{`oECav^Lv-6`#jb2@_Y6D#eqC;p7%w{H%FofDY$ZeBruc}%x$7Jv5nk! zCEnJ<#x%pDmBYZA_QB>uR@+*PR7n}8lEPA^ld=xlF$=tlp!LiN(PVs#tqzRKZIju@ zlO-4i(n?=WhNw7lIYdRZQO%-~M=brbewMY->k>E}tVnSCrj9yj`+2FK-=C$S$I5$b zWqt|w>9XJ+md*_6ItuA}K&5M6>4q4O8%{fXVxaChRIxUZ&d{_;q%g*h?_Bp6n*v(7 z;oEL2r!R`XYD(Q=qek7aZ5(yqfKm6V@o5Ilu`kqstDPD&`z;Kb8-CH!pqUL$Z(N?Y zU$!1J-yCFv%!&tv8T_h)?|QSmKV&twaRzWHgJz{Ttb9+%?w_?M^x9L0-HAfn;=s9H z1(FyzuU7XRQ7aPV%FL_kJZ+yX!;F(kw%i*7`v%#8tdbzBG{^B_B{<1dCDH9u^#HoA z1lgU_tWUKA=n@rR7-y2%0rX=kU^ZJisc8n#btTOP&<&3_8$j2MOEZ9Oc*z#Yoe!X? z5afAZ1q;2+!4`Wt_Rkd2Q9)hzLpJe^_?TK{gf`6px>~)G7(iRrxCLGhpzDsascv}y zU3Ydmf2mD?8bIgObxezg>((@57CFrhYmG{9O9SZGHn-NP0W@k|3j^rbw$y6te*JPK zjA*E*AGc_!A>I)U+afu2KX41O8sar< zv_rgAdCm|o_Lj}~7KYk+PT(vu+3G$q)V7f^bsX3<8)|n_FC>QA`h|C)vHCis1c~}= zhH0w`WtbLwzr_OVBQ;%B;E7?{UM6*^{7K7;@eMa3Un|@?sCjXt5<_$j3_x9k4dgsp z%dG3toG%S`0Y5q;U+z*SA`*w|G!fAX(yknF4psYfPDAgF}&mjV5ExU#nh7XwK^w zW}rq)P3qxnjksFnd@FRgX&8iSJxmEx_A`^RR^|HmRfo89LY?b}q|^kLSEg+$$(a8o zD*8nJpQ7&5=f7{te=AD9?*z-QEHz(g^WR33G5@Ek7ZN33zi=(`|I)Pif0QZtJ1zAm zselvte}YNb&hq~})nlw$=jLvW5>+Q-N~oW=YMmRN`_5SmC%g*!dlL)yhfaMSN<%s3 zKlXYFlT%AuH&vg$H;a(^QJ?EUz6$Kkcr#XkZxg_HNf zJ{G6v@8S9fu4TwA_SI+LIujRj?`&LLzFCEfiwazbAa}Uz!i5@6t~sTejcX1rE=tVD z#l;4$+K_8pj^TO_7aPbi3hp`k9)fEmuIwndge$Yo{$Ym>Q9Aokly0s^8Y>gj+3yXA z>xf2YzaU8mUoV;!7IHyKYvt=jE$ZNZsmdbyXUy?=Pix`)*?T=8*7phHPUz0%$F)={ z<>QmQj|}=Wl->^q{ad(W;X<`FHWBXgaO>c{2$!?sKf&Dq_jS0hz{S3o*k-tI!rcb< zFL0rN@4XFoF+?rz!0m}XgnJ`gn7@b}f-idyE*BL)fcsmx z*v%4q74FAyx4_*FcRSqA;4&u|4|9O;b4~SgxLiy90&WRh#y=J=)Aa$;_Xw_IzOGV# z+C}CRy?)Ar$SM>iwc^=a2j8wxqVTH~$_}3PLniBAuG$o1?^0aR(^qTd-_UmqfE?%l z!gmb(Kk^-e{+r*yjRDnByD@-N$g2`;fuTa)a>33LtWmHg!LAeRM!}vCY@=W=3HB$! z-Vuzgi%tvMDxJRVf(6mmXe`fAA+Nh&`w4caU_%9?5L>@X!I+MtQm`t)>I7RQ7-cE? zUAA`m-G>BwOfa;k#vfWz*87kxr66`R+W(rm*Sgl~o1-o9bn*_T{u=@miPq1x*4Mkt5({i|>Lf%xtP7v%5 zg1sVGn>_n&j-f(c2f;cEcBo)O1uGS-Ot8NR_IJU4*4D;xv!O!XJ%T+T*yn=n5G)L3 zeEn_thQh`a!MX`HLa<`N$_1M&*rkG9DcFsI-69wa_M3S77%Joq7HpVc^@5!%*u{cT z&7Y|cc{d0~HGhrWFW5tZZ4m6Yg1s!*Yl5L&HR*#Xa}yp+SR1U1VABMfDcAzRmI(G+ z!JZfFO~Kw4?0vyL6l{lJfp#`6rx_~jogvtHf?Xik9fI90*kgjN7wmb#UKH$2!QK|^ zeZjaTLg(`-*y^Cm&_Y9nyfXwlTd<1+yG*b@2=sE`K}<_4Q$ zD4y(RvH5~sCfHSi-747ag1si#n}Tf>?0vxw=wRbG&`{W%BUp)GX9#w-V3!GYm0+DQ zr>aIN4tskWD&&n8Y^-3%2zH!crwMk3VCM*So?yK&=hAWXHB`uJi}{nr+8HY3?IqYg zg3T4|6u~$@)9;=k*g1loCm4?q(f)1|?0&%>5)6wF#$TSHZ~%p15Xq^hA@4fDZWQcS zg54|FSAs#i#Jt=%OFDOh)?mFPU!&rsMv zCD@^YEfefa!Bz`)zF=1fcC}y+3igO#PYL#{U>%@atJBiiP$92}VEYSponSW#_A9~e z6>Pg;UkH|m`L~WEVyKYUMX;`d4HfKg!O8@iAlOBMT_)J|g54z83z)Y@i&&3dG88s3 z?qkz3&`{XiB-kjyCJJ`6VDkjy%%5Kr^44IE|FNp8mlz7>8U=e>umI-&+F!1rLf-M9 zhIME9PBK);`?+AZ3HDpTo);{NI2WsTiwqU=7750*@oC7rSg^|l+YIVF_3nFy3VDa& zUSq=zg`=MZs}L+@1K06hVq@1bhrZd;7?hapTxe$8ja~SXpw~~Z<|ZG1QMBd@>Y6eE0<#Cv6{uKLT#x%~y7NGj&dUHx!zv7b`*-o5G4?R-lI zWW4xs{oZUp=r^HcFx0Etsn8Qonl3yZdl?!pY4@Ibf0YUbkq<#wq-|Kn$a|ym@Z>6L z>3dJE;^cy{CVZAR{&E>Wn=y^6=Hm|F3^-4&g4l!4uybgI&X_$*9_Wz>LgfHIhZ~!m z#4ECp(M7}Y^ z8N+U&HMp+DbtkU1*i7~UcI_x>5Pi+fUs1XiTTfodKklgy^H-D?%_|=GF*!%c7edC0 zt>#<_H-9i{LDs;$Wy}S}%f9b0Gz$7I`>qRA|wGyJB~7zykld%hgI z)8_e2Q}Dd%_z)hsWD1=H?x@tOYn4?Q`iXxw8Z z4}jfB&6FZP@u_}%OwsW?=4Gn#R=SA7l*->rqOl0l)s6YIqqT^u{ zRc}{fU@GNXpDMmTYij^J6bReG$`Lg7Q6B5ZrxYEpzYx?6{h;sfXj##8FqJl!Vb$2+np9-W8!GGVPwiLHRe`S)RSViTKIyQ|8N zUtP48ZExKZY=Z4>DjF>9fqc|^sEz_P8YM3XjVPRlfj&Rz#X#MtuuDK)iXemD{h%&U z)YG7f)YAa|Q(-&kg+X;v*n#+elfs6Bx@`!bE&}xydeR_Gz<8Ibr#}NV6d_@s7AW?2 zLCT=LrHX=7S4rN3u)t|k1qCrLrk>KW+1ZNP0cyFTh9Xq<7?j>kg;$j{m|M_O zO|ae$U;Xi%?!U20qJN2s;OMsY}-`UC@%e{ISWW1gGkL7Uj@}pZH2n2nBL7+ zDA(lbAhmc&t(`&2`x5LG7+F}z@AKxvys9#2LtCKp0Cd8mV)baz(kj>jojG3~$MCod z9$%#%)0mM;_%Ss&OMZdcwX+F6sLI5TMYiFH`D1El&#tW2hZ!LO#vq+u&N~Uf(I_U^ zR)!7!C50#9gBp-UJX)8sZ|UlO`x-oiTW2PnDbnfd$@Zm1#6ps*}`Py|<)< zp`Kj1P#=-4!rX@Un6O_K^BF(7a;bXYq3|)M3ovZP5?0OJAr*{^IZeJ%oBjx}STjLI z$30#Y^kKiHxzF+_?n4E_{iwouptX+YsDQh<={Cd=Y3Fl|(uK1zFpPvox|*zNYs5&X z>80CFq}R9;rOK{}y6d5TMfrucFBU2%V3w|bJQ0bQ_3uWw2J?eR+q#bEY&6z&-`m2ZMCyKHdLcO((jpZvmVJvP4D)ZabO>xzd ztbW~;jQVwC!FZGc)>ay3v)@S94XJ_Y`@va}9$oPbk*EVIFpSSbLVU zAE3aQrlbSP5!!z5GsU}mf^T}a1zaVCmFg=yhkJ#`LL;+XxEBJ+71rAHxL^7P^K-rqUf&PfB>z=lBv92{M?V>(Hqf)0mGt_Tpt?T>B|QYiH0v<$r zy5^M1zFgQE%&5I9gMZ*wn4s3cr6q0MvGhu+<8F*pnuugKl)ISP^a{+T(tUO*{kLnt zdQ&pH%`V3^HV1EuCfCnw+~d79Zu??ds)jW?ZK*C+{Zq0*W;azeOjWSqRu|)7j99v_ zP!;cxRYTo;R;|UVp~&Yxp=K3t)o4}mI%R4tXh;j&nWRJ2*}iA<)?(H1h@fr6Cd#^Q zgvuOqdBZD_>kC|8;`#~~%lv7$PRGTO1Zy%IKK9xi5YcQY zYwMM`uEO;bTr67bh*7aR5Ls6Ne(f=jAV%|PxpH+?#2(4k6=>P|f6{KQeC z;@s+{Vo{^&1T`v7C^*lUlqK^FnEWq{0p=WIQdZI&qbnY5!XwTvw6RooenGV?&H*?p zn3Tm?0T0>ZfSxk~1f^#Lw5-YzIY;V~vJxY8dgg$fqx4BxW|Yn}awyIb`lKuwp;MP@ z5@7y*g6MdEk-qh&_0;$Gn)?gPJ!+i#UD-=N?`!UFG4~gl``O0-^(pt)sWDCBU_crS zIJltpCR=~xcr`R00FTh<67gl3pYv8^N_g1)nf_pFA*WvyK z?w{d41NSYs>}CD}_XB(nbx=~x*B%6%4P0+riJxP>wz*IsNzIMgjLjzTR*#MKPXBsm zn$TOXG3yg4$vnBYzBf6(lc(s`2dk+5^_J;6rmuFouJ!C#Ypo|`g|~!viOOmNV@1|K z9az#7+j?THww}^Vx2-qUbL)-0N7UZJ%}dbG?PGQ8VUSrpIkSUJ-b{Q%kD`81XK;S4 z=i|`U@iE+bK8C**AHyl47MooOK89PvM=bQBIHrn6Y+wmK>cDowN0_EWU@2k~8&-mk zVKoYHa@{2jA1zxhbNRRy#pS^&W;)9*|pZ-E$D{j7jS-+hgCwUq9t`zJ>!EO<(7wWTqm#bVlj>80_cB#h33dZ$jjja^y z9KkLV38mwV$g2}X@>QLsNl0J}#K^W`l=g}fKAe^IC9B}0Y0O@h56*fzmF5)7*`=3Q7&Gw~J( zwufL*!HNXyFW4c16$>^-u*rf=5p0HFa|Bx~SdCyY!5RcxBiJQ^T`Snn1iMqPdjwl6 z*b{=iAlOTSZ4&Gq!L|wZkzg3x+x#;Wc8CeqRj^`o$d7j?-^Lg!ixk@M3Jisvc!C`&*a?D76YOlkRtk2bV7CbNykIX1mWP4Lg2>>|PL6^wgPnbMG#hy5YkUx@WwL!sOYHchYw!Bz`)mtgk^_L5+K66{mKz7(uG zRA+R&`xy%5Ua)b3Ef8#pU~54wQE7g{P$3USeht>iP$6%GV8w!+BG^K~&KGQrV80UV zUcq=4wvLyoWu!t%ZA)WqpnRpV{R|cM4iJnMuHq`qv~NW!f^7yhMy2^ZLqRDGC0%194Hfb# z1*;P5V!|Vhh6zo;O-Vm$};?!~E7%JrT60EOa69qe3uw{asDcGH$j>HxA?lDxz zYtzGGIflZqx`GW5?1zF?2zHiWb%I?l*iC{xE!cB{y)W2@f^~*sgihbyh6;Jbf{hVu z8K?>BJI*vz$a`9_=LGw=V4n)s6XQYsZZAWHyi&o+1Up5rg@Roq*kyv3N z1k2mc#v3sdz75nk^&Mjj74j|;>@vX~5p11cTLpVxuy*^~@L(QLg>*3N~1<69tX$0bUl=Onl|c_eV-pM&@@fQICfN0Y-6Yr(f^8IRi(vl{tgyF@ zqm!Y~?+Z3euxWzL6s&lvU;kdzkN-Vh+P{8N7EW~RRA1TuD?dJ=*soi6vuAfb`}I#m zr>*zn=M@9;>(}AjN8~NY_<2L5%flYI$u%aKwYG$V?iyA^64y4 zHHumYs!~yBfVvY6Ul8YHdEN?zT?Fc0g*^gFhx`XnI^?%O>5xAJb*=KZ1C)-#kGJuM zX60Y9c6|`o2e{@VKR2Zu@rF5``nARX@#sGEFIHVMXV|cc@~Y~ZirI@6;y<@5&a7Fq zbcFK+mh{})>Z%2caoj=8^2L?a8ecrK%DgaZW_8u<3LJ-3weaK-v**oR+E0Z;3dbAF ztg5M2=tvFEoR1@IRBZGxGCDG<5)tiJyRf?I${xh#1$i-G3xGX9BJ>hvVx=+C+51xjr1UlemSiLt!em zIR*0tyH>ED3D&%%+=yrGvc_Vvo%p$J1_#IbXG+Skm9x=Iq%R@nS)$!I=9_CWbP3qi zb|+H<^F~RF4a{cs_&;i3Xk`m|u59Dl#)h$_6e7luQi#%)qBS|m?adXY6kTOX(N9b% zdPUkBQW(%64H_G4sE~JzVBD*!{XHxgmtZy4ycFGoXI)z;MVwfDJ4?}mvWaEGhT-3Y znTvI&wwsDnnqKRck`@cq-Rki!6{8Y-NN-|hUgdoO{YF z#~E7+#~H(JaZ(}gEigc1e>D^)!r+_6atwtAPcV*9^}EW1l@FUN(PNJ*ITnVi zu0;^m+6@g?H58#K1M*pU`~$!7lA_h>?&-~NfS!&c)@iIM?8guG1ON8pf8N^G4}9Xs zaeDUq{_r>WMnuiJctAK0b>oKmzb z5n7(#xTL?|R9+NS!CPxIGkjRuS3QK=>s!ZDk(JA6#uRA4%0K^qcp*z z-(FKzf26-`Yo~IC$GGAz;=K4`>$SXShW-YL&Oh~yWo3cs#eV#_F6y-Pe(Fr}e8289 zuK@E1fRFbokC$vO>$}l!D%lQ;KHW|qTV_vj-!K-QklP!^a(TgfG8YrF(NRBszGls! zXH;}NPyAXu#(CoX%i^cvO!2o%rdLc~ue1J{E_kG^-wXw{I?4%96(}B+6;x+({}8gL zpejszD2j~|Ex`wstzk-+f?j_VoHtSBgI+l(%DjTgpu!eK%>*`Eg-pxAOYwftdlJ+g zih2iBiK6U8=|_36OOw*LY=JLKlRdgWPBbn_{X^1?n&9k)W+TyP{BW9@+(ePsw3C|y zp|HiHqCD?FBoysq)?HZvr3>~jgzh+=5w_83iexpOCC_^Ls5iNDy^nhHv8?;D+9Mve8OKg7OxV~jeuYC%!OZ%0uI;h9cdqF zkB#SOY}82`loQ&Iv99~thm0u{doPmT&L$?+whcw^k^C4|3=@f<;5!w&&R{kg>$>ml zU~~nsKiIhD;vM>P{itKkd&O?I@4M!J{(!}f$ne8m;~5Vld4ZF{Q^T`SSn?vQ33F64 zUNNKD>uL$hA!=niFB=7AWZ_~=Bw&YS>XB7T;ft+68GKa}gb!L6pk0Uf4O-`$lqMC>RltvOo*iFuXOio}t8kdgElM@)uBG6Nt@pL zr;J~$Y9q%m`p507&Ch#bDYrgS+~l)dz9add&xT2itzHb=03|Lxs?-TdcrP z5H1QfSg=uo9Vys@f;}SGvx5CjFrGD~<1IB*$U91~se;`i*e?ZpM6h*&QAhJv7@mi{ zo`wo}Cxg;)oNB0$ce-GlG3q>6BiJQ^6|_aC6=isP7%Jr5A=ur5tru*AU|k?>AJLuf zb~O~vjS=i2!G0^)^MXa8qj|e}x5!W-?=ivF3-+R5JgtLogdjsXZ#4??7F=9sMd}S5 zKaU-n!tsHQJ@T*6%?3SsJPkD`=!q5bV@r<1$}kKpgJB4a(i_+jhUmtRZ}A%;z3}7B zfpXcezUc7(2nxPGmCl~QA=+> z{_JLYre)&Z{_s*IwK=~3mJJG<=KFo875nQx&uQ)-qL~x=>#z{u5K3fqv1%SSe0<mh0<}6yrdNW}qMJrgT6DuEREuu@0ZI#Oin1^sQw3%^s1o2oj}4s`&Rj3l z6k|h@Hx0v}9!xrrJ6V%4BRDEz4wR#+%cEc6igyFe+;s~a52J}_fB;6fxN61s|Hd9&4hHY`0SL@~Pg`|(zrI?HRS&$(r zCK^_>F)?XLQaf8)DY@eb@Tp02r5Uz#jBTxf#iLcA2?L9hOsZVwTH3W($&*zAvDaaj zGAFXvLADYchE~xvut|;6K#a@YO%!b7?Xd}2z7ANcLsfT4b%l_EmPUEb>n&sPa_>-AJ{KT=en`vt5}{uSRJ$7>}D*1 z*i(oooAI<|IBq;VV+rN_2^Zs`^{E)oz$KQN4);AHru(JMpLAk6o^czA#ICd9xcR5V zbiD>fIvwO1pH`B(qjIt%f$Z=p6xOxND6AXI;_sHwCv=U>ELya)!$qKus0ev97YtSm7P(32Q3Pj(!mr z>tCkxqiaw<-1DO^$Gv-gG=+XQ(ZOJGMyo91%sJ{g6xvmlChm)x5fHng@RTf z_z|#wKb&-c;^{{|1`hH`Dwlw&?e z__rD_Bn$t@tR&&zYykXO;onKBRoB8l3Iktt?v*f5Ylpewz_;Kfoj9-$f~7ccAY6(A zYvEEH*aVm2Ko0Bff%_obd*L!F-cua-Ph6M$C*r`}KbUTn{4a|1>R&?s$K1DAYvh05 z=I_oV?~B?`^#1ejrkHCZioF(dk-~;j!EQHH$osWmj|%pVV4DT|NU-gK?SrzVD62)Azn$9}2cZumD6*+TVCXg}q6FVb)>NQX^P{V5^;HS2W)s93>EUu60A-z>TByfxKOZ91p8bt9%ZBbg$)Jqm0(i^n<-eOU`qt6 z73?CxE)(o}!FV)|&Z~C?+bS4sitDs|E?5Vw2WYIbp+epe!A1z?3sx@JV}h+0>_x#| z7Hn*ujbpr_Lf&zL{ZO#G1-oCc4TAkvFm8dquP4j+azll@M?mTCSZAn^_pD&Q6YS4| zQNp0}YP(=x2(}EuvQMLo<4i+gQy$h(G!`)wG|B~w3bq*3;obRejiC^1JBtMkg=0De z>mnFLbBI+$bGnA!wdMhV$$5XW?H2ZhJPKCsH}p# z#ZTL&&)hRmzrQooZ&C2oaLNvyxUOk+=$L5J;S)j{Jth=7bWEtM-W3D4KW5_#DCm@a z9%8^9?Y$VuK)x3PUp<^56>D$qnfJW!2lp~*rb&gop9pr1p>#8?{jr(W{yr3cT#e8e zyMOI(zM&xHt$%MwdHnH&4w)YZwiahVJ~4#n7aO@9bA-L+RJ4H)rRecu{N?d^7hD{O z>7UjHuU)ukDb7a1j)4WcNqx5277(rHJ#S|9yxpXps{^cDQaf{gMa`n!8fao)iyAfk zceckgt9OCX8R}gjW`ZLNUsTnyVtnOt=;^0ay$FiniG?UV9;djhNkc5dlicX>s2r#s z#XuRIsWE#1@&Pdl)EEWO*@`HHhtEEN^viSxq)!P_IWb zq+n_SNz~XohJxlP%C5$^P^SIO7mQ;BjoD?2rr?_OjQe(cVi1422CRj9TuP&f23-Bn z33&4pGH1o()6{l|5!kJy%T=NX07}}rWVHKCvp0E>K0!@OmKc1b6+4sYZ~7R?@01pb zVKTG-1z&DXGySPr-FxSFF~DATxcsgjaGBG8l?I6v44?=WGgQcXNw7Z&#tw)%YV(l| z)Tt@?$o`8zFx{KjQ<37UxFKpg_B6&{=$0g&L#x5}wmK6oNTd+LT0qrkhC^Y=*{(?oL zLO=evumtB6d1t0H?qofG>_9mS*S{o|?B1qK^K=)78qsF^2)~tyOy0U^>i@LMjUsm%k+KublGWy2QHu~I}y!G;D3oW^c6R7lxs)Yub(bwSzFSXV>+ zM@4i-cT+->Ta9le_fuQ1Z)GCW7SXG};UdcLcfE)fnI5b!To%!OrU#?J4n0;NrHiP> zSVT3p)=*)OMO0%fqS_yesK)$LA7ADNvZM*^fhSj`G@*H>NU|lTcBB4%lTGM1qM`Q< z7uRnj&1p;Tu^5l0ZD4oPAb{bwTzZ@D_hlJrsfl$*0X)%5mtRs)=s^k9*m^^Syf*~< zi(o@gHnqPIhC&lN`*DBWrl22KCq?)vB;|;dftfoB7@HX2o>oJIIYARlV%farRQJdAILf#y~<{2ua_PuC-s|DL6{@xMHkC)`RO~v(i zQl65}{3`y)?yf0K#oWb3%7+?=8doiYctjWKNrKpk$c}wt2W3`3~c@GHouwZ`uP%r<|gy9Mb ziQjJ_udYdyN!5#1!)gR%4vTAy^$9b1P|tR8XqmPd+{G~2Ou5^Eqq7z*ny=UyD*2Dt zc_H#z?;<}7rHHdYa*cr{u{P~wVY;&@*Ocpa^OhC#vOh}HoA+;+~W|Th5Lj) z3%4}@vP;n|%Pu>B>13T<9_7oH`Ak9*^V8MqRO2Kcn|ciyqT>B_Q?I#Zs(DW;)K;&XA$?T4{ zK-XKh<{Exqg9b3e5W{8e#OC~dS3_Tq-xKf>!{W=9-%P?z`As2^Ti5r7I1P~Z1Guc~ zU5$9{Q{gwMkVoN-#wcCZ*qPv^#$txT@FJcV8dHZV)sRRKZ}Z1AoRP|FV=N@C`62Tx z!S(N+ArVtl-YCgXR9ZWqX8^p?hEnZq(%9-yJb5#PCmad#$M&5A1pU+Ei0`1m zw?1lsmC@c?%hR3lAuk9%Xe`fA zA!VmRW1Nj@e|mhB7#mXq_>~s;#{r}Mx%^A1QOby4qNh~18OBGuWl+>wQ+=9qtsELV zloNmH8-{0O;>OG8s0+2qj-Cu;q3*ePrBZcg7tOq zNMrjOO3!IE#yPF_m&)6d@Z{|lcv})BU-?VV+wW8jKA=29$C;NjlVy1}GuhVFV7_2y zGmN8!zBL_>D-Dn58Xli)czluYm=qMYz$=Y$1fwzTv(*^)*=kJlI5BrU08d_QfybPT z>7U`TnwX}Y&3v0?u)0>BH#Q?rTV|eR7z1z^hKxv8FH`5A_Zgl&VtDqb;o0ZX=8_6| zkVAMH`@&GL@(g}xY>c7ocqqZMBk|EzeSFwmLp3(TP|5OySwJHxOKm~C%^&BqKguxQ zNLvG2G3(fE%38Zg!y#2@Y`W8u3>Ei36(=;Sx6I>IdBOlwZ->HV-VZbN_K(76QaB9; zJkuCwCK{tWL1UCBXbf$w$OxAJ{Xq+SUh%Ev^M6I2pxM6r#R zMtOq9C{NIs%XexSK9tf{yY+i!YFoXF^1|ILRnUCNXy3E7)zLB8nPFb~b?W0};R`9K zNusW5>>Wdeyxz!njrB8Ba=VMR9Gi!d4MMwoIW0qdOzA~i(c*q19QlvMJhoG0xwE63 z6p>G>>I_DiF=RGm;kvDCZ~Da7gg2x@SQEoOG=;rkC~Z5&_yZTTKex_sjCFMjy!o&@ zJgA=@lh!V*T2fn?SSPKig#rH&r!A_Q6YX75F?&ws?D>5T=*{~Bj7Hs@%DFRPc&%bi z<^0N;O068-(p$+3o4Qg=J8BpECj89Y!T>%Cq)F%2U z1->ru)%?eu3AOup%)97Idf;y3VT{@U#2Hj0fGyA%(PG8GM%59 z4!lFuW)7*4_cJ`x*v*F0gY0+#EtWJU_LfXRKBXQoz=-*a;2IMp#b5dvaN1GYw@H$v zM{$`C80gzq2_|3lGnDmqtyI@!08UwFNgtx}P5)z_QYuO2u{85H2$@Rv5V$aDY`3ZqG3dNFd){w&k80f5Qsw*VPT zVj)~IeG%NY=AO)7jC(TwVqre1kUC97W9X37QyeN}sIbSux%TJB3(Mo{%H!h-N@C0R z@@o3|@lkoPWqWzGKgjPk2Ihf=PcEn}@EcJ?Uhw0^>QT+#abFf+yS^;mmM_)rHFs`) zw+5tw_L#ED<4^hVjSQpag9(j!^ccjG4{*JNc>k4BsvyWwze@c7cXxAROO=|G??gEI zzddnpWs`9l+Vr$#EJtm|Vbe_pd)^FXMfkW<(iM{zE}B!RJoxZ{{WbXY!k(;zD#;Gy zS)}dZfsWWK7s0->k%fE}JM0p#QqSsG^{TeEb5vHAH(A~1C>4~}m1IU_OENzur6kW# z0qTF`X@6WSsZ%tR)O@i=W3#nC+{564_KtvyiKbT!_i(r);8qxXmcd!lPeDJan>kV; zj{{eYLA^myIOa{TzJf9Tw7+t}>IFMju!{w|T(Hf8y(gGop9Rxg2?fh^iV*B``9n+Y zEk|ng&$O7kII;P*3ocC4`p1$C#lE!*0Sv$?YHBds!n7|B4X96oH?D zgK1m7))oN<;1+@1QU+d{p^5oibqZXF1;#4#1OF4l$m^{d*iRoki+v>HGGm%3ZEwH4RmQWac^ zR^|Wu-E-f0Z?+^XTKjJYUfy}XcbD_-z31F>cfnR$N+!DrhB6TGmx15Z)wD zV)5ruZ3a0_vSPpf&JCM8g_(25Kk<-7EhL)`wX8~~2e(RR9R3VUZjz+avz$=KvfT}L z>RId#V)Sfx+xhVq%|B8y;YF~Q;aV_u9SX)8S}@ZjnUdFn#wQoo^GDlxLWC55>Dwg# z_KnX&4{f^f*>3+dKAEP;jn8pNRHp1vxU(iL!JTPdiaTrFH7H49m64Lhr(m?j1e;?i znLZ(yv_E1Ops|26ea1^mV*^eR4VvaisWwOYV>8(b{(rI}{z7^Dspy!z#hua4D6dDG zqa@EXI-W9(j+YqP;y!r6rU%w%6qxo*duh+ax5BwWYCkMbY@NIf{*qfKEAego)#3W6 zry=pjmaqRGS|_$lwYYV1N#@o`kx8DhwzXna0|xE<+xl_C(@?MqZI!m+l(vd{qDog2 z&}{4oGQn(=dMw&2(u^345?-(eZ5Br7D!8OJiws>ab+Z(A<~41?5UzQ+_=_U5c`wJE z__4Tm!2NXG55WC6+#|S8!o3uCTAXC{1l-TS{Y2c)!kzA`a6bk2n0=<)oQs-AU)3-{Z&(_DN9cNXqW5w~!YlHmryZn1B13i^g^IoP$LB0H<1zLjkMRy4H=)I<=f7@?oePl>fEicn4IzpBy>BUC51hd z+uFZB>IaIpY*mrF1J)-8ISxal|3fkD%9RT8YVChQUBC(X^Y4HqRc480k~iiBJ702e zA4UK_bfLs}A8AEplob^|v(${nou%Ss6&X@8GAbBHMg_ybm38-pVr!91;_hdbVuLTu zs9kenbgWl+Qp9M$zfg?cvtsnV6{8QV7vVSd~6e^kAtC0vvDu7;inr2q(I#lag&8qkT$2q&a#v&%NBR{Dc1N_>+s!P zM|N{bmD3(R%`aV2y_zYhvRjx`3}C+{)$fs?Wc7aBnavN_5_E6GO)657RDv<71iQyl z`RLwrv6T;pZ}1A$O~8jI6)MKUA2nj@OeuAwDODMhDtA98)lTp-m`vFpc}y-;580I3 zj5~SXVpD2e#7!wu*d`9|1UuVOQm6!DN{Kt9)Qw(Br7KhZl*-MJQnJqaYfGpUD<@q_ zZLle|(WcZUn^NnMK4QX?k}@S2%amaESW3#2V4pmdB!KCP6-UzegDP$s9$n;GI!|Ck@a@1(J zQZ!w6;JOL={fZ>9jsoXyLr3EJ6Fr+>ta5)Wtr|VLYT?4_`Lnn|_Tl(5c3#zaGiFsy zAL82$q_`gpH967~718n7par{Nn4Xq$)FZId@at}#kHfS4aBLyGOv6j=w>r;koMAg> zq{Eb_J#g22&+u%E{uXbGR(M%7_W~Jyo`hh#nQ+@0KO9q*UpJ%7Y&28A70%{zL`G11xf#UDz63B+2e6w7odL5%xm(P-3C)0~c+Q!aG@$tH)~O_#7z^qqsYKW;XJZOXWLgMA#878(atGW2Qt z6d1ZWFcQrU=#sO~+!TQe(Iza$zczZs)g~9D(I(^JDi7CaTrYm3w27xZI;a@2zmsF@ zO=uGqu~cnRkWrhk(-P$hzn)3jq(`cX$fQpy;oU#{^(Iw9u-H9K#nlHU0v`WU%=l22 zDfFr8phE_A(8c)TAF6}?*o%eroO>*Xs}dM@UMD#sqhn`udEj!@#D|G$A`0(m)Pzs& z{c6G|`-F`?rcS6tC zaK8Ze!*Rb5ca~Ycrp(3Em=opkUD5cX7+x}BzBw?)Z!@sJU!>fX z?Yj_ivZc@;u4pMR{a)Drvb|{0+;isdy`{ho81F%sNyg`#>W^o}EyT zT<6n_I04S(cTj>{nyNa#VBhN6w-bdZObW@<^pOln;!C3wUWBC`1V!IW? z#y!>@M%1ml#}s=~u{34a)>KJmFSJrp^~52dBKBxflkS=ZoKzpz$<^RgwmD^0(+_X^r#g=)MTx_4V#r8?uyW;&*xHB(_ zv)FdfVoOSjtzay+g0a{N#$qcNi>+WRwt}(P3dUk9SR=}mU=Lc#s@Z7$ydn(o*A{j0 z3@)4(TOQvYZ9wITofG32uveq2qTy)FJAMwfR}X2r#pmI`)_5(CRfXa87Jc->brF<# z!1Qp4dOjIgqN4rqe&xdknz*Q`0@1jpj0D_3Z6|(HXz`&y;dL zGkf_w4EMuvXG#-4$v)HFkD=kE--?uI1Hq^b1fw<(jM_jj8gYWrh!gA!#c0F{Mk7w# z(TEd_Mx0{2IONfW=T(#$x{tzlmlaJ} z9q6&StVfpL_G2xWs8Tv1(5sVriP(~6#d#R6XXwTJ_LoXoxOmZ==`*Tkp1XHi#p@{Q zZN%NvGG9?gkti=ut8~N6nsJ3}pP*@m_KB-Pirs_)?)DRPTsFnM#^3+#kzDa+~WA90i1=aC+fR@#QnyUVQF}dvDxXxfkKi^2GNP*DjE85m!<; z{YtS7mcr>*ian*+2a0{97!uru7qC>&DN>B{O(c$CieV7fViZ#0g>5czHxM!**kDVg zRQypKx*jP#l|8tu$)`+;e}HyZMSOEPj!tLO>n+ptVmEGOv|;Q}R{V2({kYKq@0B-n zJR&+^9=dmF7-XMZG_|5(A`As~?s^tN{30B74l|+jY-1;|`6>c@oKkg4xedBoG0t{n zl2CsSu4qNg!S&pJ7wVeoh4ZRrR`0z?9|E>m_p^fbMEa0ShJx3I>t(z!8+(}`Dl-}i zo(Lad+I_a6=+0a4I&-ErDbtjG>-G4h>T;(+J?#4rj7ae)DmM#x&0q8a`98@;&o~&qv@M z!hJICZEBM*gg~NPQ};}FIXdVE-4(!VJXZ8*QAP!$j0#2>6^t?}7-JQT zGAbBlR4~e@V3bk8D20NZrPwaTK36P!|0B`erq(9Ml!JijbYv^)SzJ{~_6Kzte=G@q zWG|%o#VU0P-$^*BWBxg()XtqZdUWlAiUsFa*EC~J1W|az4xecXmJ~9Ei&IT894b*H z|8)=PAinM>&FOYf+4La;4-9aW*{+_>cp7%PJmfd=sB3>7E_9q2{Vc$pdiJ{!SI?3P znk5*5eb2rPI!~%QrkuFjuGqVZL7A-2!;?`ZZ9vrE@{*m|J~t`ZMH*zB?u?#rV16>? zY0tMy@%973NIuP*<4-WnAa+PoY^fb27lP*5v*fbz>2fyX3JgFrl{;5xC&OhYYVNQ? zW$rLO3=4T3;4I*NvEuhmMSl3RbC?Xz7 zx)67HmcmB4IG%LX)3xoQ@mA&Wt?Pk1(cKZ9`MV9z$pw0)A9FCKHeS1WKJLy$P4vt?SB!7_+I!& zAv)pHLmm70p=~JVq5J`CAn@|<{BUVU2Gb?K4NpmK#fHM^lyqnMiPej+nUi6jD-ERB zNvBT~{c`d#txyEhg%`*VHxVA2f+3R_($CDTBqTiVG!uqPJ>}Of#*6vGTEsty@^i4q zFX3s-{8*+M6NqU+z zsMufB-7AVM%W}ixWETmqUa@M}(6HxE`_@5h6k69k%4U8HGEA z>_M&eNCll=D0Z8rWB^0l-LF_a5?8RWrGid>#ST+!oMPh@%5uJuYjeJBtfCp;SY+*DeGxS{E^ykUiG3yJZ3u4fMLCL6toPA zV48ZXjj5;X`*ihGnQf_=+ULDSPCSX?n$FM@rp7!E|ny0Q(?EN>G#N@Mbl z9r^IU9~&lI86`i-0(Vha+WiCUf-~&@KFvJzH7>|T6TX-&*WWsmf7sS5cdGyUxYi;`(oTF+wVh@ zh)GLI*1!t(hJ6dy$UDKIQb=J`@eoIp=5Z*rLoOs zxWD>vmknmOcFi>Rs}t{Bz2tWDBrg^8Eud|pIF$GTbc;g{uwfR*7;uc_;kdIn48^^* zeP*%1ppz*UC!+^PiUlcIS}WMga3$DhmdZEhb_jM6@>|@+EESaYKc1Y65R}&>X$NRY zl2RtC?r#<9JNZe`*hh)>ES3S1wOe8LrrjYaCw+^!jnZYBRiuJEIL8s}MoWnaELfvrMM!_aiY>)i z*&HLR!1f){_=^?s@-8qq7xgV~h+?E~Q?&lLg7Uggjp>>_esxD@{N^&GAm3of@61hQ z;kzH%j^I6HJRXXnR=iAqB2A{V-=Dp5<+z3=>4UE@)4A~l$E>8!sni*SZ*hBtzzKeB zVGWKeTnGwE9b@Nw%c@j< z$6_cyHV3<-JDI_7P95W*naPiM0~ecxR5F9{-dAura>V+EDS~PUDWdJYDS+G`^D}wi zojodyZ4mDKNvm<;42U)y%Z)k9>!VgW%HvM> zZd0mOhYB{A6=a!_mAVH90qdP0LT|%G zvfiwQE2{HKT*JR!5n?B*{3_9?>YLCRlWT+`5E|M#)OE}NpS0BB1xj-ukUs*FGSDY6 zIYCHF*S4<2Olv}7sF1@Z>I#%rPZa;gSc8LD)ut1q9?c3;FB7N?5c}I~ep}0aGj0^7 z!yrs7))c0;?LC2F0`Oa}!bQO%Yp!sWz`aknT=U;I2y3J(WnK&OI$6B>LwuP318}F9 z^O@B@pG$Ech&#oK&z1I>;&p+F7by`h!6;sWbwV-=cA%w#&bJhsuNahpb;sRo#4ma) z(fQ@y&*l?^`>mu}U(}v-5RHhyf%!?TKXXpag82(ZkDj#{OT*_bm_K&I4gPL+q;|grcPh+Vac48`7r4{Sb&zf`%t!^D%N4uIQbFeq#qLxr zgnSae&_{+sXH-h=us*z@iQL(ZQX;>^+^L;=9=5(;fSi$S?A=^jR9js&YuWUf^A^lJ zS8~jKvj_Q^uy?fBZc9v-nMHt!Rd&#f^Vl3MTP))|{`~YS3YIl&E#16L?l#ZpfpW?$ zCkr;q2^9dcSs$y>{ zR*Ae6cdX>ZFLS)#9?9e9JrSV!CFb}Z3XGR0j2DSyTaBAf! z19@*6t{_l<^{5IuZMd=0+^p;DXx+UrdaNB3jUR_Y7A7o=j>=lxt0G>vhQYM*(ujE{f2bT{6=^gsu)YYUYR~wKLZ6Fx6fnd}If>9d?Mr|M%wSi#N27*x=2u5un z7`1_5)CPi48wf^iAlLzx5^W$DwSl;!HV};3K(Oe{($AvAOO3Q1=YSxRWB5^bo=D8)*mC3`GUZ$>HvqCIiWTvwV9OgR_OQE%q z^aUU9)fco}s`vd1{-Iw$D(GOezCNqIG*1WMAHv5~B$+8R-T7mx+=5amKW~q>N;{7& zVn(*a{)nJ~v}kcnwb&sC9+N@yv_T!|838=IDwNk;>t#wI7@t#!GU&L6U6C`!Va3We zRoJ-v0w$Umv!sH~w-sA#DYuK*HAmwwB1t~km{l8GUkoSPaiN~F9m1v+V{|&I_oUf> zi@{NL(ovKH;EHWt)a*{X2>zI#Sa_IUGkf|>?p`x}!HjPmF3rp(CXa>Q$DU#_7pvx> zrE0dI^9c>CM2J9BMrE>R+MlpAar7opt zhbAp488sJ-YFaQhhy?qIVxGYl{|v(~ZW`klsJeAAxN>R_#mEfWaHR{&M>&fl(fAc> zfJWo>t8v4=>e7bG8-SUC6Q||?AwYxt{6*}xbuVqeIxAf;5Kwm z7=`o6CKhLQqqvA&mbiuElG8UG0H)Za3Yfjg5{vGmc(*vI=#Bx#qI)Q=qtX`L7MoGc zDSozf(~d!RZbs3&%AEoD)Q@TWZr3a$6?Cq}cL;WarR)Mx*$<*&9b1ga$(h$=a?&Q< zo8%muHaS~t(>0fzNsTX0^jn&ozSf2j0ZPC}nw+F0IR#^K3TA7?_z7L8xa&SEsKJ?j zZKAt3Mwfras=NjRho!rsbsPJZ57-I?4sutI^NTPC-<06Z*~VzvG67CeinmPYLJcOP z>eA8n*cbp(bk71+ip$f#ZBWUsPAbGR;DWXk@7sIgkNNra?_QfVEzrrnxfO}S?5Chp zFm;&S-&>W}k)2q%q2aAVxySeP*}Kc+MSkntyzJcEZlUafxd(@GyZKFGj$y-ZvOfMR zeP(wE^~nw8j!(N1iwYL=E3WCyGW*1F21a)u4?jU4Xl|SA12MRdRb5?j!DCOi z505KFXv}3x?;6)QxMyp0HbM8p*r@E7(;Ls|fE&N8wtA6q#Q6IgMzGZ%7US^#2(r98j3YVLe&Bu^fuAoxBe_%WDzE5T3k zePTz?^LT7^Fn!USxwC7Pd+I^XAZiPr{;ock&Rh#|KGP9seT3kjL!)H99WLe*^SKSK zrMQ^2%p?wxUV$WLGKZZU+ng;ZsyKcqH(^PckiZuInT9*0CqCZSlv#?_krU|XuLeHIhAyXs-y{dRws2~ z0z)T7QgqT-ybzr<9aJeUPbU?DlN*zC(k!^3PU8L8Uif2vqLa+YiWonXW^qJXRQuSb zYmxaFI$EpXL{)W~Gr5JTY6R54l%`Zw;83cngIlVq0#H>5azaK`)zu`Nr>a;vWKdOI zeX6Qg3se=2C2r!{q^e>|jYHW5z5xT5hZI%SJ4sa?(yXfLYl0sORVCvQR8?;9O{=QI zjL+dvRlW8?RgH$KYKsu|R8@_EhDlUc!-lB3V)^n}*{r?!bJZ0sjDD)CNClk-729g5 zp!0%aFDX_HjUs;MS}N$UUqvu3XOZw46?;&zHxzqIu}>BILa{Pv83`|Hsi0XdC)hN_ zE>U+Y6#E?1UwcwlaRxf6pc4TleyJgZKh;(L66 zx`#{;U}WIp`P^QzdRD|vZD~oPw{3X_t@U36i(0ccGVDLaz}j1_^>>u(j9QE3%cr%H zjVx-dC91VZ$+B?4p0#g-IL+R5$99gmV>@5mQCA7JT(MP(J*L=`itSMBW5sfyWh6YD z5O2eqqS(ob%~FgTXGpx4D)xQF@}Lhs=}D~>vQ*F+2uk9hwh+Ir)_T!2;k476JqJr7 zepBcuu=-+>f?+jF1w#|}JwztI{j6ZVJ|pV+qf{NS`BaWCZeu=4_O16C;<5-TV!xNS zJf+>UTLuGRfXV$DJTO*FdQw5N>Oinoh)=L~mdbb9E5@#)0=xI+r_s6%m6Bl%lOs0g zPV3?}*~87*$NkhkZVmHzOLWUIw#j~sG}+OKI#PO_Y`Yz;9p|m?EDi^Oni(N=0w}SY zmx3zA<=M>(P`^ThEzEG(Sp8$jYxpBePBEn zp|p^lhBV4J?R*X#`q$N%zJgIbLb<2;8|iFKX7@lZK~Q@MdZwD*J<|6Q^fSE#$7D3U z2N_m8(|d|}PTNZ`$Y*-@X@TiYr3#a%Y16yJI2sGnyN~u%xICno-XoJt?|#ji-eXPh zB}iono~E}OeAA})1mklQ@~Y2XnBL=Idb54Gr>6I(kg8V>#>8rfMN(zv^%$^(`6{y| zhEo(eh_3eXU7*T^6sD1)*a=o>sUS~UwpdTaZc*%)iru5weTrqHev$B6TMA=tig6D= ziI?kH#a)SF-%~8E*iRI@QLzn*J*3z%&?lV3neQBDsi1Q%D2apGM&i}ljQy5ai9RkG zKdB&!p`^N3KX0-Vv%9MiIXa#lt)GyG3(JS>7_e1?{(5Ov)a}2xbPeX(|$&iJqt!hI(yt76YGR zm}ib_D5ShS(EIKFk5K{kj7jEzw5h zCR>`&Mv`+)Xrm!}tc`}7I1{yz%SY4N2w#rhBn*~%!|$$7cTj_OztQ+lCRZCQ@{)zW zvwF~WknMqZZ+Z+Qld`%J`NuqDjxhq}Ns_V}svU_eCq890%X~zNvic{26Juyx&rJTWq49sq|c($526E8=`y0n7t&%z#k9 z>GuQ=|3SuWQ7rRukor*C9#jh{Z;-B7&Joj>@Zc8Xy_fFR0_k8n? zSW9r?p;se>kt7q6GJ`EJW=0XNTYKY=`Nb;5EKHbI>Fy%Y*DU0=1GCeU=LJb0h1bsP zX?SmQzR4T*Xh_B%fcpd-Wd#5~!J3?whvlJMI6WAy$pO{`f&(J-&sc~oGDyUS z%vU#kVVBU2Z2DoQczljjl1w5M#N1yf4}-Cu6pTe(unQHtMlsIg5qGyL#xYXCOvdrd z5F8wGQBjvuN>434E!r@zXkB#qyHCPZG%hkY^ucKT#1Y}s8fS;UGx3KLhkjB~zxd{8 z+^FVg{7Clgls|ykCHx%~9rKUyN*0~yfG?x*m!lj0*{XcZ%i-^RkqxM!+x2+kM3?^) z-|f^4iZ&eAH#+9g@ONLvTWgeTjjn3M-i39IeWP{TwngisyWTm_wlAWq{#+Y$7c0G! zT^`>I#(s$F#%T5n(fYG)u0UrEH#?UJ7eHm=j2g#8lp?1^=;`YYBw6FpL9U9;o=`6m~i359*Bxp-)Q|LtOi6` zvXejSHg$nOK&ZB0a_Piybj+^B+oJJj^nLxo4Bl>Du$~ocS;P3hM;j*nP#BTOEK`$4 zM29|R=!%Bxil{8g<7Y<7)$9lutGpKX|P6?>n zMv}sebxW-Qbrr6F+3v5@Q0os_cNtNA*;miDWJsfOvO0*Abzg{ zwchysAEjPZcVB`kMVJ8xo4woc4g)2ACxZH4akd`sWNcMqsuD>K+Y^$nWj5=KiNA0_?#Tx!tq#^DA<*vpZnR zi~P0>^wu)dlVeUeP@C`xWC%ADW!KLnbh*50o)17hIj*q%M82DTN}`WXjf=_@AKdbM z!b!%i;XJPei#f?_f*G#KLohpxw}8PoWJ7Gb!Ey}7S!%@IFj%(v>Ra&aKha?aJ}(ri z`y;JXKmGyn{FSZT2Gn$vp=3Axd%;bIx>sE{$=0XtTK^s&g%M`t zwfTpdJwEbVGl|&AgCxS~z_1Y2n7i40!x;PQCTck0TgnkysBPV~{&=tLgm~K#^?zMH z>_B2J=hM0*a_)XX@)v)E(iIBV#rJiS1g2{>-X{RWs+-F4H{c$S!46hA6X~ zInW`vgPWrU|Bvg2ct?ECWuOpGLGXj9_7$cdX#VNg5KG2h0Bnr$T)Z3ZYE9C zIL}Q<8h?2(Vv$!j)aBkU7HQm_kckN#e?)=K6ez6P+-LoX0C8f zIw@IxP190RZVF|OR<}9}v;0ckNC`s5kq&;?2#UZiU;ghCSy}N1KPIx0h>5JM_(Min z;k*WXnn`rZ%FE{2+wv>DtgM)sA}h zr16&rk(Cvfy4*J{D=U7T&RvSEteBZrR{Y6ns*~kwGF2xlPHkFH)}kXHWB zk?Lgm8b2o0$?`Q#h)9v&y%muJ%!&vOXj65TSe@K#81h7f9hN*x%#Ad?h%8^9A|fl! zYDPrvHZgf3azV2qQeb%TM5L2>PA4ME*BcR8aej)3EPpheh^(07&r?&KEPpnWh^)B8 zEj-PO2;1OXS}(OkmLnh80ug!3c=SX>zBQwWuqVJTB5u<7%Y%r>@>g8$n-LM+UB&M% zMMRdbPb(s+)k*C2%+<+?Pn(vKfAHg+y6jt>XIuH}4XI9Iucxg}4D1$Le>zBYviw3n zCbE)OVCB~yCEAp)wWrbF=Usl|t z@s|fHDi`C!L?K7q7M=7@CszK<`LOv7YZTH&}YML1$B zG786oZn0@zIN0&;uSnz*TOb@iG#)+SkT1%+X=S4w28>zDKims@@ZsV>@sox{`GbxE`ztu1(CM5tr?3pqoYnFtT!vBf zEpSg!E}ZL#s}n9p$UNkX7gqKZhOW3+067Du2v;9mTwl>2*Fao@anac0!2y(~Qe0)Y zrsHA<*bH2pIm1#j1!IFJ;BsfsYzO@k8vK+j_F1r3Yz_J;*jK@x81}og$Hg9#>v2)q z?#6XLt_N^6;(7xYCGID<*a`MCT(9AJ9~XOv*mHCcQi#1kr{g*U*SB%i;0ijU3mY8{ zgJq$$?q3)G)1Ud5Xi$IbTZ| zAJU=%#WMai^3>VrM}Y3RY#Qp!1$$I~Ds_>{-t=M|SHY@gsVskO*BJrMQsi3n= zv5OVENwJ?R_8Z0SR_rOoo>S}<#okctmu=j5@30j1b-~mdn;(`!ekgW=VmB-He~SH1 zv3nJJQL(=$_LgFQSM0KUH{Lat3Od&*wpOu+6nj{)=M;NUv5yqnrC0!!wtQQjrGn1W ziv3ZsxtK|2^TSfe55+E4>>0(LSL`*#{-#(?J2$*GmI^wZ6gyC{dlb7*v8{?drq~X} zK2|IXt1E=(97|y>u43p;GjD^=V8wxVz6%I6W4P zm5v6RVkvAS)Nm;{ku!ckkMz+~eDoZbE;)rK%tYgF+vy~w_dw-3W>N_zlti}U!EAhU z)+U6u77uS3q~X$ATpH@h&OpG&TPmW|K&8eiMMh+%!VFNHWE*higQ`JGCxF=Ajm{1) zARG7^oXioeFDn`xZ8({K3|-Rz8{Bc2-uWg3#U2E!>OvJHRoZHgWLKnKoD;0 zGwOzxc*jPO?Xji;Rl3s-uEV$n;gS}G*~mWP^FaQRn?snQ5@Yfo3WqW|kyOyRQ?Yw2 zg<^w5H;K)oP=K1`^%8v`;G(XC-HA*{d|<^$U_1LMDftKBh0M7*5|ku*8K~k26LJ!$ z<`ew{xMHF+g@)tX<+lfkUQvC{SDEPKFFDb#v5DR<;wCyNNp!)O=z{IXlFl>H17`NB zOwLLy>4U*S026nU6P=SzPiUf~AG)WBe%{gZ*n`=&n>ciL1*Y4M8moySEcneF~(9}QGfAj zTtA9#nYdQsxp*}^BNs8A+@o2n8 z89nqzJUiNOd~yBJk!XXv)~SA6wEhxsbqTmS8ugm-8Sc0E$qI?OJpKm>qHa?$rbj** z9rHqX)eKB%b|*v@BN9xAe2Ez|Se%M-;si+MF(yD_;^U%`m;hN)8ZKV+ft>|edRFPQ zvrOe-e668;bARaok2!V<(XSRTTkyVUgzbC4xaV}hxkBGkwwD`hgJMsE5+84ZT4~i&@o+5C+X27XdtVXHtf)c-Man3h9bIID9#>Xq5 zdPnH@BT!NY{}U8-e!w{dEl$zO{Xtz}FqX_6xboXL&Z$YN0!KRGfGN~VxR2TkRWbee zs`IL$FZ|0dXCa*I*hlCJ?|gVDc0<=tPV6oJjIvV>#(ay;%lo+R{M$SY#@F&4MmxG< z6Sl%w1A@t!#^Hp@iAfXrxPV{)F3vxaWnNiMiFtk>`8n0hL82%0$NDDo(brSP)#$Xo z{PUvz7{Qk;FTtd!ZeS=k|Ipk>sKar&y+b(*Tr=Rdo|rU=i&J{8L21MKhKdCWOc4a?cPU-@%VRFT{xOGigIHX_i9}uEzT@3LxN|h$w_QGiMJ~3* z4fQdo3cnB1{_i*y#aW7b5n4#zcfZGCUbMVbHy>7sZ_8fZ3dghcwrS0h{V6L&Oa+_2 zU{_%iL1136CV4{3Tct@JpnjJod4Rbek}i4pF@8UXGx6KSKJsJp zBB|H}CKcQzCrom9uV7RobZBg|Kbf(D8wvJE{w$<($As9C=T4|&>}8kZ<#WVzRAL@xJ!-6!1t zG`CxJfHR--GJL`H{&4LVBw+Rnpz6K3ye{n@(tVjmVCIr-H{{Z1YH@fiL) z#Z;VJ{{6#phX3=B_&Mzuoj)p*_&Ia@kl{QLGK}Y-v$O?#kL;Vm_n`bahHrl?!uPSs zg~q?$&#*lLsh)#W&oL7n{UI3E^9K1L!+IiQSkE(uASSc#)&~9|$%qkP3Ne~Ya>L&O zGz#ZqNb(HO%?(NV_w;10u?vGcvG8m7(L4h2FSy)&KHmhLhvI$)E`AdC{qzrO-hpR+ z*UPy0F&%Mr!o}gvF{rf1;+lzz75GWeUMJ&XWlatD4z71`QLC{~Q8XyrJc5dq_7GfD z9@KDDQB)eg#`POqzr}SYuIF&EN_`&J3%LG7EUZPS*9Y`MZvd__xQ@nkEUq(gO~aKqym`dX!O{fZ={OEJ&>wA} zTy*k*-jzrv$cjmqNU?UXlGgDX)lH&jXn3Z@zkQxBe5~RHlA8EdX$-` z{>Uk|4~v*(`rF668`h$sKa+QtBF_CgzMY{w9p19cV;TSYc#?$DWKSd##z?!Vmq-La)9et)Fcb&7HG z67l=KVr&Ttwp+2&pw|RD(^6R7tk}7V-Hnb)akt)5*asPH#+|+Sy=^RoF%D4TuEdg}!o7#~AEBOQEkE3ikwq zO|ewa*#_!(gS~Dk(|5{oqR~ADa2`7^xjE-#eG1MebiJiJP07>pNAoEPFD6SD;Q+_S%)UBC&&Yar) z+pC*gk(0mViu?zT^rZKVxWY?HI&}qO$B$t9u~YXY?bMZ(uZf+y{lP-IPTd>9O7bdA zwh@`=<8Te#t3=~{1WA(QKDiK^LWLlw|XNbtt{d`A)(E~?#2EyGz5%;@E znIW3uXx!)%ZU~3np*k_dmh1`F+uaim3(uola^TDSxRjk~gbgx_H`$FFXphPo?G8$n zfU3b2aE`TD9>m&pR|Trnyk!ZaEieJK!kI~_JlnXS-2zj8?^4+tM)SAq%>HjBfl!AD zq1-P1g}r7AI5w1rp;sz<1X_N1`8*&Z%^q-FL%9?EJuRHZncdyD=TgLNAEr4}!d;1R z6uzv<9pI>HQQ_Df;0|*9eQD+piM~mDF7?j1Mvy(0l$QY}$kC`dBBpDNJHWYoaAvnX zfg;Tz5~vvQI|Ii^L`<&{R~U-V2zG$$Y|3nMLzQK?*!WBNgEE|HQ>7N{05=%Sk1CvQ zLrvHRa$v-j0#dTctYEG1{etzdRKCOcTY|AiT->p%Q84z63wEhuzf|lF#TpfRP_e^M zrav*Z%;A;_I!A$$@L1v{4ygaHNlImOl~O8H2`EoWiHVfT+bX;*#pUV3=A`t9y_Zs{ zq5mtT|1nZp9C4+Tlt`&ylv2ScrGimP1*4P-Mky7HQYsjwR4_`ZV3bn9D5Zi?N(G~o zexy=LN~BcWvBZnJuTM&4IG$1}R0$|gN{NY-%G)ZuEyd+YDRoS;HRrEO58FE_m4W*I zO6Y%#gbt3l5=tuQe1=jc*q4?HItM|H1f#5qyZMSyRs~z37-dzkTNI7K2A=` z$K&BD7Z(dnj+c+RMNx(Z-ayFIz4{=RH>B`SVz6}Zahmh{+iUvh{ zjFNZ8s}6Y_?|%?3eVb2mW`QZ+PD#S9MR&A^&%yB3CYYRS%&`c*!~NyC1lrPAx`xSv zEU^rL(UVznM@yTfn7@bYbBTG9XPIEg2Iy%KH@`>)opp-+-cr&9Den5<1H|3omdbaS z1A-+t(1`}j;+Di7qwgT(d*iC7?vNvEfckj175P1*{a8CoyGE z#L1e^Z)}Y8Bqr^;xeU_d>$Ur@#qpnDaZr2oiMWzMD(LK1EE|F(Sj1BKPLX1Z6gywB z?{p8YTCoj^J){^1Wq?DLQsl2Vi z+frPflyW=6W+^#_Rd`{kmpF76>yoH%+hZ(9K#w>+ z$88uymv7vfZ3nXAFRa6-IkDHWq?>y-HZCq)`RCfUoa&v0n*FU@uwmS&gYe3?;brBY z!>e93fgXv!I#d>i<>WZ@O|wA!U^8Po``SLs;9rK9@yU4=T+ULuj#e6Hmq!?6wBf48 z*5_vJe$q~!cE{$t2+3}SF!w1!_hZsV{8dC4jbq}xyE!el9iIYAzGV6)n!&Q!EEUtg{R76mV|9-&4)o zpMg5tVE>1|;^Wt##NEB1rWtn|K#4mxG$oD?K#7lkfRZ?J;9C50sjn8pL*oN!saf*nuPCh=5Huk;h2ek7a~E_gTIex(pdX_czIFXOn$q3E|Iu|A0K|``7LB@2q=Tcl^2T zJJ@G8yhze}s9*DQ-*ag_e{OiJW%zT$Tbbnkilp~HO?toCJ~KQv?{*@rN(N|uEZ=P1 zvH##?i(yJkjAi}<+=t`71NREtKg6AGKEnNU+&{*BG4B7s{Y~6=;eHyz!t@!_I?Rc< zH7lv0vjA=cTV$!AbB$s@RxF4x#2qJci(jUbV8ax9NilwfxO-PIaBs2C6+;qOj2mT3 zc-#d~{B~0;q8N`t6L+ki#T^et6RborZmliY6vd_~R;k!L#TF`dkzz5$E>mocV%I6Q zRQYuq-@nd?0)p3y*^rSct?IdBlTQa zfD()qsbB$6J8)q&1V)gLDFms%=RlR=x)IljUQ=X3)x4RD=b?w7bpAQ>s?j|)uCNwe)W0F65LU2U3VQcyd`t1&o^-_GJ&yU zt-Wz|jd?ynJ+;Rkyk1{wIamz^mW6`dLb-kX6-tyZa%0#cVO-%em~oNiEHwe$k3cUr z0S|&`yYH5ncQ*m&_oEi`y}Q7?`#I2S&ATyo*sbGAqM}!6(5NbQf|Ke9&$>H2k zAQZ|mbN~I7i+P!UHUsp-x6@C-@qTDJatn|fHShjK1|}VH+hd}8C{z#%9?18sq81vK z<&RfI@r>B+sG@T5f&r5a#>qruNc@uurlVW+`TdCPX%b5#rKe(r>srK!6|URE{g%D}wN$bdf1>x`&y-sd+fvaF!v#j+d>B4k z?q%VEPVnuxn#jFd)%5|?)kbw}wN-+fcv}{m(tEzU>Q7EQCj{Ca_3`5Y8=u-$7XM&& zc>crj4L?R89}L(?L)Up~SA18)vAe@(QYr5EFg)-*w;h7!(c{th3-Van(D5)lmo$#^3*Pn zXPcL^%fj=w3iJG4!}&z82iA9m&)f~IyM-#=O|inVqG5Q(t;8ggn;z!lY&%O51fk*k zrhR~VW$FfeGSqf0>I`}v>wX2k`3e1IB*s4`4t*F9ybOG+44?a)I7CG=u#tFp;2&MD zHUW^SwM8W+c90hpjg`nPCy3T{pAZ$IF~K8D8$(%m;AV*-C5h3di@I$(uD4x_)W&+- zg7WyeU9jdB2ajA>jE`N!@^ay}iQ(c2PvXyUjreoY9bAWd_NF7?McRKygPNMniizVk zjapgV2&*?>&LX|hVCUfNazo7nb(g8YE>s_Npu}BV-BIU=yB~o1mWksgrEUc^*I<7J zwG|~M;Jgj$8C*Dq1ELo(Z`*_7;b;LPta4P=2w=hs&zqExSqBLRCxepjn67VQpnh$* zzY3Ia^%KQz1|_^a0ZMrJD=6Uw7N^tQaDd?*;f%WEC>La`p2RN4O?uExXFGThIEu9sh|tfuPx(z)l2Ur>AWMIyC&IyEskqnU)pN$zHnW>;|EYYam^;6E;`~`t z7T|1IjO3M>2Bqh}qI&*0wR5~W*hJ9PJTts?=6RMmP;4NoqdW%&g=uwC1M|1g+*=!r zH9RdHc0?nK48|@oV$uxhm*wAXG=u~Q<*Yb3l$)R5Hosr~APo2wa_Fvo2p`xLMiI9E zpCxBra1rcqBpQ#}<=YZaSz#yp1Ki73+duaRvsGA@oYMO9p|sM?a)882Tn z4!UGz`0AI2VUFIa;98aZ5#@;W&yL0;LvAPEV>7;N%cQVQ0geQs^a3r1z^ zbAf&Cfr#n;5BAyhFXhYg|A~D++WOBkB_9%DpUv*CVAc(9q zxKo$6#hr%lmp$;#8Eh$ZTPenVB)$zgtZBvFcNDu|qoDt3=z4=T1*u`tp?!egyUD(GrzyJ9)nZg_1hg$99Q#ftGLGKqJjVzfB~o3Gf7iv5pb zJjY7hJ)_w10T(;bQaB@9u^EbSw`lQOqu3>itx$}cNs7BG72{@-g59LpZHoOyvHKO< zsMzC*J+0VZ6?;{&_Y~Wy*q4g6f+a%^f=)Y2#i6r9&tBPv9XGoUZGP?J{L6B6GJw+6}wcG{0#XGHx)SR=ivsp$mdpUr8x*k zenXAh1$Z86fMq_n=bLwP)onlXOv9j`al6Xrb`I>oiG`E#uGof5%Z;WelZdM>df}es z%rIX!VZpow?1(Rg8GuU7_~4E+5`ugoK?#8chFjBjE+aO_CQ!}dMPky@vKzxU=;UCK zG$M^l*jF@6SoNdxqI#y7#t}TU_d>&dFXJ^R8imW~+Br031j73+2bKV9d-Cb8?U`4T zv&5DyEL@7WG@2%7F@FjRWBSZIkj@`@&vcd!A9Xs#L2U)A0jC_4DC2WMNp}Ma zfvDgBC>l&}AUQ`SDc-Aqcg0nMi`KgQVt&OtVQ$S#^ufE$DQFsBtF))_P?^$LlIBzg zH$bNd;#XQoeOhF&qf&fG^UBk}1C0-ARaQS7Ibg%R7F3qwYi=C?K&1Q_d2mD;EG*=$A)pMDBcC{29si??>`(r*+QMJY$y3YKL zg2G{Ll;F-ZDaCyf?&EP^fcpg8SuWr{#whsAyf``HDkxGxjLo}PrKN(-C5o+3jLKB} zUa8m}iruMLqhb##_KIR}D8@1^;eD(a8-Rj!v=nv`P^?HXHh09`U5c@(BiKWVJ*C)l zioK#3C5k?<1A$^_*IBIOq!yWb(EBv}cExw5*mp;yvF{qGgP=x|?K`*II>Dw>bMDMd zVZVHpIv_Wqk-PE*SRQCYx@9RMiYJZmC$@aL=DR%XavAdg2h{ zo{GlkS8TrHDVjOe+(SSuFs7XRJR6RI_X3#ZxB@KJ8!_5vO<8Xl%rM698g*)e(VQD$ z!juoB=Hhq~cU4TD72@&foW8F%8I{y(#3GtY5|G+#jbfTee&b9MBZFBcndq5i@*SQT zM(x9&tI(*;q6U#aEOXRmxwyl8GCyeX7{i6T7}E)LVr(+*Fuh{)a6b-rmeC5_S>R5J zxLS;qm|23&v~Q)eLNJZKA@0}$5_dGD1iMVJA1QX7VpAZ?;_hTi1)WO8W+}E%F-pIULoqh|1k+K( zlRcM0{QT~X^_}RswBfWfe16Mh zyW4erH3;$FRkl4q95%YC;L=7%CE@4Qx`l%jx3Z({xwP1va7BDL??WFJ&)Czptp4|` zEVir);O{KFtG_-ERKsbr>aPibsE9X48?K>~^0+qLEiv?IyP{1(lc}wBjXB&Vm$O4R zUA)_|TigzP8vEPMwa&Mb2XWmnH4G1B4HM?3^_1YjuwJ)0oc&>iFpXOQ7>jOM)djaO z0^PidoMOnf5Px-J;Rb>x(lybB9J~Qnhw?Tl{)d>U`J9UI#I5C9Hgh3YdHl=S;T|jb z-ihwsQW_gO%31tLG~Qt1ieJOHqVbK<0UM%YcAY;q+7Jjw>sOhV4c9ZKXx(Q8(eMPJ zvtLASNO}Azcl>s9pa)_%9KCY@SC63@eLgCHVX-2(;GKY5cMEvv3Dg_DEU7(R0NG6R*CaD55!Hg5q@HI{Cg!0>90Ar`6$qj#~b~V$F!? z?v3~?!*YB>bopm6hq0r5v~FYHXuNzEKd`QGSF~0cmKpGxQY|IaFh&mQ8pGKipnWsA`C4XAGkHyF{_cByGG>o6 zHIPBLG@-ufwMnMh-Cvvdb=n@*=S_-MN`1cP>7SE9s5(KYzWa3xRjTYXU+%x+^xrdk zYR}U@H(mNS1j?Z+w0`+I_1fNK!Jby@nd+B)*FSq=&q}4zTGIakv8SGQ+gahVa~oT; zZvU63eFRoKq+l?O`7NtP;wFs?;%HnXs(pf{qFrMb^ZAVVHPQH!Fz(d}jQeQaQX2Oa z@jOY4JWw_u4R*l9&}8wuQY-8E)UvBfee?~vIs@+2b%|F*&Dvr^7vI}LmxN& z+tiu#4|*B!$sT1um;IRm!K4gm2-N?pl<~h!25?-i114{+(R?^GV&V-Fu*b*p=60@|S46(0nBjN=kk)M${hPgB+Neq^ilq9;s^N zz!dt~vWh`Ty~jWh%D&eF2t0kIibd-yuSF!18Ez)!)NKg9)25*`A#2zo#_EL)ABNv- z+-a9>>BtPXdwH(TRCW zZuh92qlEGA!Cs5<+{U&((b$6)vv6vQ_S~lN|24!0*zDd0V z=Wg())7REZus7B;JM}$bZa&$+%KqU!Z_l)o|q{*mPkfp$%HP~uELU!Q#G=0JC^6UEH0DUbg#W2d}mr*N{$E^UqWOZeZR z{gT*rjHr^q3M(_l5 z8cxaz7yos3dH9kY6*3?rTF#C%!J9Ibro~i{l=5Zq4W%2l1^yL0!h z3Q-=)!exIG+W~s7&{q`7>SrbQPIKFs_E7jp->+hL?5i#lW8I<JYqDHiXv z-)R?f&JGVU4ZJ0x*>LC<7cf_X!r&gniv9Fg(c0U*im0y&_irSa(J(s=J5j!RUUuNO=b74seMt=)c6x7tdtZ_9un~) zi@2GKnfcmh<#E8~O8n6T25ly%M4vWl46=Lr8$x!7o9j(?`A9{Om_T;+fRrpuLbau9 zB??Jh8-ID#PeSC^@WEgD5*WgZO8tHxO^_7LRnZF=f8L;o)eT!Cn-oil%XK3yNss?Mi^&G;MYJ|0B8@xa7x`InOG(1_ zOp;K&SQ=AfaU;$ci;s`=kw~CkB->IWapTP#iN{9zNF-1%5+^khaneM-Olq{AGGzZG z3Dk=uk{XFPX)2O!%|s%By23uGBsC6k(Nr8xGjT|ut~r8pr7BZn5jRc65@{wD2^3oe zxDpnFgr-I$&YFs-r0IwnG+fP^hPCOU@*Fl5o5xSuqUHtd=21gq+Q@t?WGvT-9Hoy> zL-)RJTiOWKVH02HaZg9-Bh=8n2r*qXHRl@CVN($%aFsqn4c&_{k~Tth*i?iGT&0gt zL)R=UNgJQKYbw43rqai!p=*4VY2#COO~n`Syk^Ql4PE1ld7garqPlA;z7o%CruZ~; zjc={z$rqoxYbw4<&ugamG<1z`o9D?FpSo)*zL@7VQ+yh_7EtUiX_b;MI(61mbO}7A zEiM|iHBH2}wb8wh*7zag(i6JIZ{P5t#5JK3EHttGX`Q{_+HakyYk0ke4+tURhL8}P zKOR2~N22dDv8};{@AlYsJ;BCu6ZT1esIY(4Nkc+9dr4?hXsaXynkUzo288D?A?bYv zr9W_g{Cf~|%wLH1Z_t%rUC~5aFcnPwao#hj4v`*6Tl6DT54>(*jCGIZQw?9>i zOFzXOmr4ym`~hbpDDm-x#qylj)ZKgf_MiGT%$Q7Uo$zf9fd2$9Pubi9S7i9 zmO55}lBJH{0wqfwv6Z7;61fai4-?9FKrxhna}EC9VyK(&SHim))RYL{{tA@1dj!;N zxB?FMwGwwPfD(7yhfUlSAnmyTHQ;muRoH`65hyO=3OEBmadBV383yWT@RH-)0O}45 zpa&f8NZ7kOsi#3nihl%3Lgr2|5^oTc#M==RQ#Z#s6MsvYnobp{8bh56O5#{#serQ< z6qm&YoL_d4NAV_Jy7x;Ve|sack}`!-!TG| z#CsAbiESzBEL5uk*Z?<;n-VmE@48sdLJiQn5m2`_gm^`KHaKs{@?{{oaP ze^{#bm?^sjpoIGfDB*r6DB*qrC<%E6DB=DbP{RGUK?w)iy=Y^nzgWrKFHEHmBP&J0?i1By9x`Gm{ z2$c9Z6cjngagMMQ(pjk*P=7HzUjoXeGpOfG$X9?8o_`9;rZXs;&Y)~MgRCH(zBvFjAu1nM~x@57+P?>5Cg0(I3vOi7x55?c@ptHmBV7L?dSCxH@s z=qyme-zA{7nXmjFDDit4DB<)Z^3W~el<~VPH676%;0j~C`1SQ&M z5hzKQ)u1HapMjFtZUrT={T7sb+h?F8U9cyVO_v}jiLJe*aOw-FHw{RF(KtNTHTPJ9`ZaJ3VZaMc=?mvGe^lyFrHO1L^4lyJ2SlyLPOP?B5qpd_{{EERC> z2lbZW>Jd=F)w7^>8%yRTP{P&W*qKMTIvJF3bq*-u>U>bb)s>)xs~>_Au6_zixY`a% zxOxwiaJ37R#KyflNClijLA`6Z8U;$Y8V^eLR6ZFLw=oMir-N#Ykcxxq*n`wv`gT32 z4d(6RprqWt0!nz^0ZMo-z*Zr`b0<*3GY@|ko_R{B@H`Kc@VrT}hZTDUl=%27DB<)? zP%9A+tOvz*DaHMhl5!7xYQL{kFm(K+yU;YzN^5r}gQ{FxT zO1}KBpybPU{6F^I1H7tY3mcx3oP=-^2mz!hNPqxAia-DFD^CNG>zD&1R~`V8D}P(L50pCsBzVY3rNB?u*hqg0R7>inA-q}j?O>>xTQ-6+K!mKCJRXN zejw1_9^!@riQch5qPGCZaEKxxDUaof)&oh&+z2E(?odR#+z9s+kcX|ni-b77*MVqd z3a|MD$T0UKP&MZM29ng*Ze|SC6kHpSq@WGZ7!Gk3&~83^AU{G@a2SK$3!|f#?a+YxV<)j@N)h$NNB{ z<0~N1@e2?=nR|_=xpOuFNOaT(5*E}iH=8sM8_T=Y<7hZFY4L1fkem0K%(Po zAkjfPUdnUhpFpA`HpS7A2qZdA2NE5rK-lbqu3XQa4J10w2NE3@1Bs5IK-3Om>;Xu0 zTmd9GUI-*Q<^ze25+E8M@tU=I_C_GlaW|0YcnC;zJPAZS0Q4+@M8`oO(eVzD=r{}{ zI(`Id!aDxYv#~849Z5i<<1`@A(G*B5$QeMQqcf1`I0r~{WC4ke!9dMe$0$8}Ignh( z3?R{Q9gyf)3?wbnN}#QLe{2L29XA7sjt785#}hy;SjRp+dk{!;yayyYJ_8aR-vAxw zy89cDTt{?EM@IsX=r|2XbhH3UWgYGHY{TGnvcmPOrJPjl|_5q0vdlg7@yaz<QM>8PNaVC)H=nB-rLm_$riHkKBDP;b`pik^KJNOXJ#BszWs5*^2YrErj)_2r`Ti&blIyq@NOUX(5*-_WM90lQv|k2BF!bzWK%!$Gkmz^~ zNOT+mk|*3xfkel*K%(P!Akk6%3`a*Dpe)wW1W3-F0VF!Q0Ev!XK%&DB^d?_N4v^@$ z3`lfb4kWQ$1tixoA7}vUSfOV(0*Q`WfkejxK%(POAQ~g{nms_G<0T-`@eYvaI1D5@ zegwLNb^NVotG97<)CCe9O@Ks4OQ1mC-$3Bq=xmG=@XG2_$`*4}gYqe4heIs*V6j zs*VFmk0-vZld9T4(snlj5^ZgOBwxA!Nk1n;&t?Hh-sb>GuWuxf@z8aQ2a>+jWFU$8 zDjNuTDZo{ehf z#Owo-nCk#Z%#DDg-_#sPVm=c{Vm=p0V)g?`Pv#OmI}%9JoChQ^PXUscX8}oX=~^I( zc`1;@ya7mJz8OgRFZbx#M}Q>eT|g4^0U(L_H6ZCDy#pjU`5BPJ{4(nI+kNMimINMepZ(~0>M zAn7wS0g|(407=Z9fF$OgK$7MQfTUk?F_6SO5=g>M0+KY(1d?7=K+gt&B<9sX67yyt ziTNfV>ABqjBr!h-Br)#=l9*oxl0L{GJ^Kle#QYVI#QZam#QYbK^mDu&oSsJwAc?sV zki^^)NO~R}^lVQciMcnB#GC~rF<$~Cy_;b`(%%>ZBr#tJBr#tNB>jzrdUhp{#JnCz zV!jbbV!jio1zV8&fy7cj1|%^b0Fszr2a;aK2YU7}ki`5wki`5Oki;C-(do%l2a=d; z14+zHfh6WOK+^7a(X;7560;vjV!jwiVjcn{eT&P0B<2Y~67x(TiJ8^`m0rtIJ$nO? z#JmMaV!jPXV!jVZdPWZcNz6|JNz5+;Nz8|Uq#yCIp8W<$V*Uk4V*VRQV)k}&`YQ22 z5_4T3iMctD#M}-@dJkvm*^FSbpc^HuNP(}ku%=thP^K2lAc^;7T8J6kU zbwCpHHXw=lb|8uQULfh0JP2fS1IXqEkj)Js=_!1yXTJfmxdCKz1IXq^n$sJJ2a=fU z14+y+fh6V*K+-?xp=bL5NzDC$B<8_D67wh^>4RJWB<=oeAZhon1)?`UF=jcC)SyFVyMG+HKRSinLxHwom>uhPH*Vml^^)3wd6Tfo1M6jtN$~R)IxR4u z?5+(okepbpm^9S^TFvg-a61=}Pw9qRG`GW0Bhq~eEyLWL{pNGnA-IynWFmZ6`8XqK zh{t0NVrT~It=B!z1bNwJ@*jtt%t#mcACyez`&hTfY-IO&b!dO@shl&$EFv$ab=0ZM z33(r1!x5_(vqG*{_>~fLwm2J(J1n$X2jf?w6*&CcpG|d(ucjtJw6{x z+SA3PtCtUxN=HCvDT3|j#i8ww3llimb-JEwd)O__vH4QbPV9>opX%)1T?5sFHux&< zZ!Ybh*1oL2My~j1UG3$1+neg%}xbt$R67B#$~SkK`1K>uJuel{WOO!w?H+Gjdo%WJNQD~`?tkGd&0T% znAp5GIhc3Sn=*o2ryPCn1WjYdTp9m_Fi7s|#fe#G08 zUI2GDc1N?@@6tmFYYvS_Sg)%J^JFJNN|>Jmluwv@i}?iHcG2@Q zzP(0laEO$Q8as7LVJ2+#=bS9rsvPeW93wsQ&{;R?Dx=3GcT998t@a^()kNYM9q0? z=rYDhZR?v~FuhQgo~H>}YdF+t97{h`1KN~}Y$nwrd*K5M#_CnmeqY91Z>GUR*&F{> z*x2ZK*CO8%*eKP-=#9G7ye8Q8@rlI2*?x18lz(6|`Y?%#=u$WB%V2Sq^O1h+jpPBZ+-f zU^ysDeHcE8U^(W`ifB3JudCE@%)ho0%Q1gedCO6n6U#AwmXkt9mbV;>usMDCKF6Zk zkuArfW))eEW^9T>P5Z^{4r4hMwLKxr(U#*0S&r814p|OIPejYnJwn3Vw=`RhMO~_D zInp`GkmWeXrpd`|w{)vv%dv2eSdLCkeTdZOcqxXeYah&dh-5hyK3dLlEPS*Q%dwqf z9aYM5xN8;nIj&lmUe0VR?EeqVMlNeEZ8mb43uiVKE{<$A7IUbO*?5%Q5zR(>KE1?D zh-5YvURjaZn9ac}G8+rnN62ir^OHLqHE1o92sUHE4-sv~!X&4TMC@%WI97?xSnz{8 zHPYKC&56xe@Pm^=N0zr4i#H~mex7@eX?{*wype52bf?&Q(J}F@xaZ>zD^Dzo@2tpr z+*yt4ddPab!|pKFV=+BER{e=(C&v@A9{005WIY@`5v|AW2nloF)@(f%KUr1lv7e(1 zS&w}-O-{bMrCSYKkHr^O(RvKxSSzv~i!;hukHs04SdUbWwY2qc$HLYldeOrPfuiay zT@Mlb$g=2pSdfO!BTIby_;x4s!14)O+2MF#IhUU$=xOg&=7z!D!#>1#Oa`a11vnY} zd5irVNUWVmTX>gwu!&z>J-nTv*sF6)@sYYCw{pZA%v6j|QK7jrf*)iS{Zx@%`JIDT zWLIKYe~La>$(7Y*Wu(x3m$99pocC3CDv-PK@Po~wi4jfBq9v7@nnhD9F*S=Oy0ceI zO=(U{&7z4;3LWXrIUXZgQXM&$*u_bcGe+dTV0i#4o*J$jQ#>_tH>UWyiVV?p)k_agwB*iz z*pqpRm6z_x+|OLNp3IU@!&?{{s`!*cg?cjeII|-5WR|k`Vly#PPiD!>6%saP0fsSmRsBXnk#^p9v^mP~f;=7^n{B{`K?m?izoTbRxMgE!}F^axC3mMayv~=V(QiW9iy*mSgGK zN-W1*j7jFBu^h{mosi{N#_@zKM=`rYmc!8# z(Q<5vkTCZx&6Z=?4OO)q+d0aR<=A4=OS7bT<%RVZy9LUlNEJv_UM9UG(tJHD?vnsJ1!9L|JM`=zhN3f5(?h-C< zIZD0_XE{o~jchqe{;tS!{9U88hFxlXEoFq(`(I zCFT1ZC6)F$IM&N5u^c7!6J}N~*XJnt$9)b~UfObWWGOS7bSI*+)f|16f+Zc*wH-5iQ5E!%j_!__VU@l}aqfvi;>PM`=zh z$Flup>u`C?u_7m&bEHSCQoymst7+UCr(=eU24VPRMdh;dnxp;|g|%EQg~f zqUE?cLc-j)G+T}pv#M%2=5drE%W<7eQ`uZ6cln%Oel*;m_wu8h^OX#Guc%g08B{BC zsa@F}t_+e+s0@-go=_RowAV}XBWRkAqbFh+oE{-z<;&pIs+K_ujxtmR&1{;&m4RCg zTkqxf$P;5b=bnsYy&vW_A>EuE(RwexnP#PAVS`Bg7BrAV8p(_6i#~Z5hKe9Vy zb{stst9%qEq#YigWYP_ z?5yl4W~YO5Pew93Jvr9i=DdhzXJxAhW~UVg4Vj&e?Cw$C?5u26iP>>NhPxa#J1Zjh zc2-p0+gVXrZ)ZiA-cD&w%+87`^mbN_2xoRyjfiY^R!yp?%1@%H+^)xwP3#U+Ff@f9Y;^ZDnCC$!rXO{&CaUps#@ija+IMezu2b9sTXcp-t1g|Je=9N z{&-c)&Z@+U${?}KrJl>~aAnZ&gvtQ3H1P|SK|OoDPH)H26R`|hMo3usGH6!SGHAz9 zhRWa!n`Hn&*Y_*m+bPY7*|{Dc5y{ZABgbX@hJF817Dua?TW$*;M!rSW))|DxP zHD$`c(G#%@Zi$ev@@25Ss%3B&M;S6Zx7#$i^WMR3HEecPr&aMG>l}`?qKB;2ts|J7 z)*LiscGB1#<{@i!>q^Xy6EfW8u-RGld_=Re>dQ*a&Z<`{F*~cCFK>2Ab7FQ@J@2H@ zk>xA@4I{!;{u`vXQ^^R!4Hfr$@Nt3L0MSQ3VGYm?C)n@dctQqfI=e##$k7wA^3RWu zFn6tF19U^x`#l_GsPZqiX>#)2Ez6g|ny~$zHC5{O+)#19r_80E%kD4+=!O&Q_i#L+ zGN@;-SNlCyPsB24$sR(DfRnKDWl;5g4@Vg)gEMTJ+b)GC&WoJ50Z4O{M)F8#3JGumM^Vx!<#<@_x^n%KANP!t{Geb7Fwjln!`tj{}7XM{7()riYI{9#Tedj4v_45!JNU6zg_{>m;t*6}gkR?qEe7l!NqPv#XPMoZVsU!#aGoa{}{* z-sN~g_Tg=IhitT?C!&4$B0|F4H!j=gb)QtVgYqp$8L|&w*)%yfkz2aeuzgr}rF2j# z{cz%Hj1rG6m#KT;H~QtdD2i94i$QVH-X&|U*NsZH%0{?PONK!OpExXW=oE}q8E6b*hlCg z!JVJ-;l$c+ojT#J4{Tu9Zj0E%Tl;jSJ-oHIRno&-yUm>%nay0969c<;o0CFEmbV!j z&I@NVHk=pPW^5QxkHsg0%Mxw%xt=40$<}$B>)_-1!&3K7p zEp0R0wL@kpug^=E8DGw9te^7_&Bk(8UfOIFF&EBktlt^gZ0zJvA+zy0yCa&7fqZ%; zzKe+Pf%p2Y6`74&Ie0~8<9_xLG8^tJm08NjQXhYQO|`>aE7)?ZuNTpBtnXT>(qxxFMp8gVSNF2rzlM>HF+v64k* z90E|0xHFAEr`lM%BD2wuW3R|;v|t}0v*FH9HXFVTpE`BJUG3OrY`7t!&DijuQ%52W zV{h18iOtw>gF7{1GfHz}GdA4dq|lLW<0oG>Y%UIGGd34Twi%l@RAe(Y@B&Vufr9<) z4r4Pm)6|Hnf7x&|#}l#{+u0qm8IGQaHe*MGgt-fkZN}!it7>#Kg=n># zt$2U81qUTK18%ImG&pw>Ti*R}_TvQBh@#VWJ)o?-Db_F>Gn!8qm-;%EUQZ;{-?XBf z72dQ0nrnqyorhYAwH#Hg2&?mukK5Qs12*w=+3w3rzz|RLrqQu+SU?9uQVkuuN*l?z z{qaIOnz2r^z}9;zvOxFn%66ev;C*(7u|QiNM%h)}0zJ&}ge=fb zc86L4M^8ixv^PS++=a)jz}8(=wLmX$lpzbW-=@jQZMO`Q^XcJQfvxFPX$7`sS5yYs zWiItPc84nitPXYpWpF9S6Dort_IjOGz|j-23?@WKSoty-Th%g{!cm6G;0l{2ciubL zJygxDz?SdO3PeTIQZsepocl6T5B@i7L1WDMXbU3s;J17hp(Xf?gN9my@7Ue7{Pe9Y zpCKvXI{Z#c;DmH8$!!RvCD=09Z34L^*n;7m6Ke^EaRRTd7ojDX#;3!z1Y59%X6PY? z`{P@-;hG}01h;Wi6}1Epv5yK`f-Tdk))H))Rf%2QGR>Wx(h`*B#IA0c=45|a>8{A! z5^Sj(u_f5j*{N|6TY@d8RhHtqVNzU*vnj4yHl^-L!YSQ$N^ER2RtQX}Q{PD!EoSE~ zPHs=PrN$;FRKxnuVHT~cv+a~}=_$i;dcc)Uk2~CC^yCs6Y`deZ4(3nUb~G&CU^`X} zES)CyUuXMuW%=XiTO`!EDcZTtTDZ>ee(t)lte@w-mnL;Y|Kt^PyQ(2vWs>~Rk%wy{ zNfTbk_RupJ^_uCR*K1S;^tA3iPn;8f*>e=0!cko0kKBLYx>h1S4-N`P{0d-_#gOk? zfB#=NN5<~|%h&gRQyFF9ZE6(i&oSzgLx!t!}l6QW=)EU#J_vkS>e;llSZ(b&sdOVNu`qQKE=Da5J^cf8OdMDHWA*Lms;!cPE zZ1A)$$PV`ZrRi*{VU_A+^C-p$X)WptFt$g(jmh-C7IX9=4E=;Vg}H2S6pwJ#utTL? zLpv&`Ab-Myyn@WUNx4^znk;L*()56Pno=A!O_KV|$e-K`mqaT$WngVpnAv3Vaw^nH zSCM8B{Kg55btx#w!z$ecqsHY=FU*}XmR7iy&^=Izu`qXNJ@TmWlX54FisbzX(ulwf zH9Z3-PMt*w$}AgmPo7chPI^w>?81Sx0&hzwr?dBS7JXPZ*6fUWJ8H1!B5$pzlGwk@ zUDYPUq}7;Pt(Q&YcwPqTv3iY6_vkC5$9aDC=6a^Ze(D($cOBNK8sjPQjqx0hAL}Wq zacfksT4O!ClX5&A>WuQ-TlYKMxV3A26ium?U#bI4t&5Y)mu6y8cQAJ$Iq%|#$Mw;p zQVkq6aiGIt(C{1TY|?-Lb^C6^LH9njThumH$3f5SWD92Fpf%yBKS6yAT5gBNyJ>Xw z101vz+-EpG$MFS@IM|j;anQoJ*W=iLV;Jc@d5;a5!zL&-6&zg`60GT9{;FxOh-oQ?f2f>)x@uX=;*q zsrW)<#{f^*Rq5-Qgd{pGKl0+wpD?iyhO;d1URl02BJO}760xinUklu5q=i;xAK;-? z*^|JegP~Q}2Y7fD_VAvPOM9wmx+kUE6m>hF>Sp((0_#57SKM>UoWHls`CVns|F_Kf zugjdT!S&V{C;ryf-2fJc^pCRcX4XB?x|=kY^RukGmpwlWmqb4gzI~zauX{_oFW`mJ zLg!!O`yu517cZI=a<}3I1w!sSd4YqFyCr|x7jk1Eb^bZ}mz8lp#NXtE{MWH{$MJs_ z?hg7n?looH58{q-pRbLY?{=Ss8t!(lDdUbqji;ZJzkcg>@|W%i`Z@V~jAvDZ(ld)+ ztc2X3pm_jC(-G(*AELPFflN)=l?Elo>#^?MEC#d6iM|O8aV1vwS<8S(bk&$^?4C{WxTQ$R{C3Lp}{T z5poygY{)&3C6HL@Ca?waImlZf@m*G6CnRPp2Ofuf0rDltmmuGUd=hSA)!i^g(XMEuH{*Gh_|OyCD-HAAqa{xf8NBo(h=; zc^YIF$i|TUAe%zoQXBhGL*4_~0&*v0OUQ>HQz0>H+_Z&k1{2U8vJGSh$WD;hwIR?M zG7YjHBz7SW?1m}m4tWp~yDtP@hddkdO~`X0se#OZq$!IRLefSj{UPHpLjpS^1nNOv z0=XC_AP4dW$RUuw!UVwV2E1rQM?k)cTmCZ0cOgeZ{s@^1`7G|?WFyF}kZU2gLvDk-3G!CRn<4)Nc`M}Okas{HguDy#JIH$> zn>WMmIFM&U?tmNsc|YV6kPkq%Xl~5EA%l=u%{=fuR@-fIqAe*!>=26J` zkdHwgfqWctP)lQ;fZPN56l7W}+~1J5K<p1^Fyw z-!pLELp}t#AF_EHV-7$LgM1#c0P;o163CY!cSF7c`7Y!^$V8aAv?lkAA(#4`3~eaknciXbSCTtC{Q{#i3vy>s2e4I-9-}+r-?+l51t}fS6Rcg!<>l%aG{M>(HH#%0$ zaFE^j=enw9IQ}=fs%AL;H@d23IQ}=fs%AL;H@d23IQ}=fs%AL;H@d23IQ}=fs%AL; zH@d23IQ}QPI-Nwj(di`GjZP=gZge_{cB9itv>TmHqTT3p675E(lV~?OokY9Q=_J~X zw3BEz(oUk?NIQvkBkd&KUuh??9(F#7<<P1?o;kf<=#>5 zGv$sb_lt7$W|UIuGpBf*G}G?!!qEg%xsEQ%WhmE2xm@M)l)F;78OkkGu2{JZ%572Z zY324P_px%HD~ER!HhuWQ#HP84a?O>yOS$`$!~0?z7H^7eSiH-%-1o}GM>|}iMLv2b zYW;OkZliK|BWL5gQ#rhCv)qr${i<9P-X}{w$6DkwwUw)buQNtpiX{cOd<+>?%wsNzSyIQ#o z%572Z4ZPeE9fvIPnNO8FtXx~Xdl!ElEb^JNl}lGHOSx?2CM$QPa&wg{Qf`-WdzCw= z+#AZZ#Cv~93vDk)$Y-umE}-0R%KfEW4WAPh+pF5Jy_Gv(xq-?JQLaF_nabU-9KHj# z@x89x+sf6%%S1_YZHs*7bmf{UH(t5Rm7A&D9OV`%w^X@*DR-B04=eY$a=$D0w{pH3 zPWozEieu$~~rBhnh~<&KCI$&9#v0^(!|=xoeeMs@!tr?of`_VVCkftlZbi z`4Sx+w8*{q%fc&I(VK0N&x}xRv~ss7ce`>}1jB}XM7h1n?N{zI<&G#vYmkfH-<0c? zX++09rqjJA0*9G&hL~nPCe5Q|b{gm6J+&1NYQ0^Dyrr>HMz56S6q1;!>wM=$&oM92lQn@VU<~McxEw;#KRx7tox%ZU&P`R&^qnTM! zMt>-GT)9Tg939CPp)aaj2j!+JH(j~wl$)>Io65bTT$|>Ojx#OtncJ1STe&Bc+ojx( z%KfTbREiT{tVKT4RJj()jaF`)a`Tj1q}-D&ocMNIJ6w8&>#DA!uK zF3NRRZm@EfDmPxa%ayxBxqFm*RJkXW%V_1KrH@5EbFp%Rl-r=(7Uk|x?jGeHRqjdU z-c{~D%6+Nax5~9kb<)z&BD7n|Whl2=xpm6DtlVqL{YSZvm21%2(b32vpXq#t!*#O= z?Tm7M<(4V8Qn}5_ZCCDY<#s6dl5(#q_knW%RW2Fx0>y5mSmZMulq2FT;=kVyG6O%mD{P@Bg*;OIcceB5p1k-{gfM| z+%V-gk7X=0Jj zv{CL%<%*PBsN56E?NaVVG5 zxtElCN4XD_JO3Of%@dWoCaByB%s%A~C|9Ge<1fh~pJ}XIQ{~zz*HO8Pl)FT^%aj|V+>OfJs@(m`J*Zr@ z^PRNBTjVn%mCIG`ZROrm?knZKQ?9AsiLZr4KGRXTF3M#qm!sSY&OH(9x-mD{7-@5=qH zoUgy5x28pSwo=Zo++E7ur`+?(y{z0R7di1Yvkg-_nmSHmpD3VS>!W~luK4_lyYO0o2uM&zZzy+2xh6S|j^-BmOonoOl-oVr@wd++pLs{Q50v{sxnGn^8sUUJ#UhN; zDA!uK?#i8`+*su%D7Q$trOItoZmV*8mD{h}Ps$xt?(~sP`kGmUJW#HWa{0FH%3Y=0T;+GRm#m(u2{Je*a_yAsuG~4w^;53Da>JAx zsa(Etla;$lxw*;}D_5f22IaOWcZYKKDEFvxPbzmnxtElCN4XD_JEGh-%KfI?U&>V< ztNCXU@=v+O%C%OmopRlkJ4d;G%Jo-nm~tbPD^zZ_az9VRR!PZZ|BhMYGo$m3NpDKr zIE#GdMW90F4qD_h-7d#B^vs=YkXzK7tl-0?X?K+VkTpK2Ie|g)^%X6 zfki$O0Lo!*fki&^HPB$@zPAX^euY>Ag1HeE`OIFRVa)Bf2;=uNj2X^cXN!DhGtgDc zZMVp0;$|9iHFF6T`Ai|uT;^t5 zZOj_xQZ4eCl|VNzx5gr$`4ea>bLJ{RJ~I($8*`H^@|ib)wljCgBA-d0W6X`rWm@Dj zcLUwQ+zyL;roq+5+{s)ci!cWR=q~1#SmZO`13kdp&lX`G$~9R3fw|EZ`OJQxoy@&x z5yrXZVx0%(x>vXp}W3wO=v;}4z!gw)kwQS?mu^ea5iu?~ba zoIK}b@R+}7_o0=GJpN*v2oCgBz4^!LURyo0nA7@I-0@v4~X*b`afxxa{Jr6u-YDD`hBA$>S5R%S@TZ z@uFtrqzp}L{}w=I%4q!0N*OVy){L5o?O&c#eMYs!_Rr3VDm)eSV^AP5^>@hr3o;W^ zcLVfU03gNeq67G>~&)MzY~{6QSDmz zC!Cp3n7H&kI9U;D9)`Cs`%lOZ>r{6#oS!b?2c<{tSB)IQ}}aj13xOpOyGGIq*}WET;&^ zpf&h6V*!{`yeK$08bgq5VI`OUPl?06!*TSd#1Z>&yp?$7o|!R;XYQZgDDlkQiK&NX zdcnSrP;%qoY&6)!GhgKsZ-h=fL&Q)b`Yf>-;SaLP#MGCd;kis$#?gs&Uq&Udno(K& ziK%;n5XCWZNL5Dgxx~89NG(Eb@mH9G5l#j#jPnQIIub;5S<)P!RiMa^EX6;R`JCD_ zYEfCw@y&>Xd>NH&I#ug{O?43ImsZfG{~xAj0Mhfi%UWmAopSsjYOu70iK)^!CZi3|dXi8AM zV@xZcYRSa41L_M)5o5Xl?LYp4!gjleP3EClOb;)pTB@c&sHUULWjKZaPmhI)LD zbBHJH**Nw?b8o%oCG|&^M`HdA=wS}=lMUfDe<`BAUj`1Zi6`yJglYpx*oHu&Eg5JS z4zHo_%<#Yp)Dvhha}>j6%#m#se-{IZzu`b5aCl8F{)@i_KoWBhNJ6XvlB?VfBw_Ca z5*<5$B<#aL5`tO~@%KEC=%7BL`1=V+bo>q^Aw0-Mxwb?g3EL1zbkO%`61F9fgg8_E zbq5k1=c&IjKoVa*kZ79$H1l-2-fMuUEWKti&`^}Q*Q`>1PXI}|y{_En%KfHX48lo# z2|!djc=iB#5k9=MHmKFx4v2Qk@tV#+qW4@qOWH--MCGnhZW)kV2iB~#@!bj}da<6Q z<#qu{ELh{wa&G}mWWAp$_XCiGjfUkr&M8d*k{oIPB(XFB61`pYY=)lo1JPaKH5-7u zTs!{@B-i#Oki_SOVU+ml0@1zYH90_1@2>z7e+58NssSJ={iQ%s`YVB?^w+7s?dtDN zASwMF>hBYv4Sb*f0(5{&x>~G*5`iA(v-N@Yh&=$>#i&2fD~!eiy~c>Xrjzu|1Clh; zcXbl;-HM(8lGMKlB&mN5NK*d}ki_z#`a1$7ssB#>MWM$fF;`dA5lF)J1dlh51vb#5R3;gF5@Z$abQDwSwh!0>oX(xemliHq7 z1lIV^$t{?WR|u|GQUDA#jKS~1m{+3~dP4rj=1$Hl$jzQQ-Nc&Ar0wvLfH=}2jTt|6 zCbQYV^)==(xzqCo=jYAJm@;7!_7I?8E8&3>Nze7hOyl(R!)5`qIg#kSn+I9>o8FtF z9`n$?0ric?EXDQG=7Dt(k}uCp!Uh1N@}?9PT!p<9GLp!|?&5&6y=R!yqxME!&4K+M zkJ-$Dhr%CH%U7J6KRFv&HnDf^*ok?ZENVh1a!J6y&;h<^batre~6;xIuDW&EXGZFg^Y{WA+?cpVR0LsO3j8qukaE$-O zUJ4mW{gKRr>~0p**!QuzqN(F#hXzX3%N$89PerMs@{>qH zrO=6!LB%kFV`ysK9`hfn(AdI)viH1NgymXt@^UA$C%TsE94OVgLxHHwZ0_|Qn9a3C z^PnG;1vuPgoLt)T*16_u%qqR+Q_3jz=jBc+oT#dQ;V7c`h7eV>iAP33LGD%d8ZczQ z*U-kgL&>8pHA>w?g?YVZj33XpTrb|=KoXP^^Gx()?2pl3?`A*l-h`NWw`!PpVv4d8sudlL9Tr_PJ|%W=v^Un9(5NeI|NB@|+8|_X|GddlQT=I45XuVr zwc|Q;GjAh8*+IW>S<=v@YZmGkDT=O#J*$%IQBun8;q(cT125kbf0`>OElUl4N&LC- zsZ~hbQ=Fiw*v=!A4_5mUmv;9KR-8?7MQbZaRZ)agHIDC5rBn@woT|prv<0%{Ntjf% zsvuRIkM1!2slZz;*g|2-@nmqFbv*QYEXJ7-3di>TTDmWY0N-yQsY;#dyHqY39`wRSRIqg zO#%B2Ak-Z65bz((Ot4g~_?#=&qS?`YgGKStsVGxld}{o-_;&GQQLf`~#oiheB-!Pi?zHHIQ{&IV*{*RY z?!=x6vB}}{#W4n3Idcz($pb``SV6^JIMYe7`%1+KESwnb99Qo8i)+(4_uVb!xVU|E zGpK7=Njc8vcDh;>%h5(!Q8_N|M(Mc-d-l?^=OE zyj>2$(RMiva4*u0EI)Tgt{%3n34o@1YJexyacfd4M3~#30&drUp`ILVdXo)49S8Qo zK`-t!Fe}w(>8Q}PNJ`p4-dVqMPfIuIv{Kvhl<6HcLcpOKt4+8zmb44anKn!5wJEvJ zvu>KUKyES9@>-SLqspAW&blAA{mO1}{bvyCxVq+8Xf6%&}_&z9e{+lxA zv-$1|g&%F*PWZ`X&d)7#exr3$dUzL=ACX;$Y$j69(X&f7+!%H-FIxVy7!#o9na?3x zLVf|+2J$P&A&@^n-Uj(Ih}Bz>4W?WvL57d z$RbEjEc`=8Lykg$#6VsJSrhUWNUZ-7pobsgsmD+52Otw5>A8g5*zbk??}EhBY=HV# zwIRQOtONNgWIagg(&8C6a5`ioNb0Vi4oUsvCXjiM%^;}@+Z=K&WJ}2VAzMRY9|>~? zB=%!4?I5Y2+8&Y`-HwpeA=4lmL3W1h1c`NN0(~HRKwbig)oB7-AkT%|3z-f{{c*aU zFCgi<<4}?4I+7qWA^Su2g{*<{Iv=t&q#v?1WIsrH_QV!Zfwq+2uw1f66d|7(uG}b# zFgIDb#mb?Xv|(wiO~Teyj;yP2-IY5>IT}L~z4QV@{H;}PqjFCxM{6*Nzr)IXt=uu? z{#33t%20IBZ7pGGq)RxuwT0`aTz}=RRc@Yg%ax;%E(uHZN8;P79MvV^-carrS2jbCkhoGce`@*bSOHo3yIZnHtLaZ=@wzG zi*h;2y{jD6KuO;;)HMlPXpzrc2E!!W7>j&nigE?YT?<4bHSvbVg$Vh~4)wQF{gGjm z`1UIIwQ}DpN25IAuZuY z+81wXT7-FNKs34(Z_+Kod_ACN`Fi(Sm>2@RPKD`E>v!aa>JFIpxhP8%~I}aXt1TK{2F;ofKX$| zRLIjITU$4!ncNhvRg ztY;^_Tw7y@#~&P#lJ1|sx5KDC3_I--2aOp%jYD3xQD53?dcmC!v+XrmK-tNJs83GK zMGUYM;}!7RzDzM<&L%DzTaMwNJ&WZRpdFd|73NLmF-{s3^_T(U$4|#Vva{c-cHcT~AQlnZzOlPN9qYEyKi52V{cW@_~h9?T4)4!>h7I;wnTi9aS2Q!`Tg2cLfq z^D_3#J#OYdlb;#=OxkOQDPjpZe^;U>nyUKnJ#iqVf;Rw?3Qid(6`U%)oOLSrWk^cd z_bL~|7iIW`IJT6o;5qq)lk#}OVyVDkx2mPuM8ht8cblGESwj}=6t4ergM{io-JU-MIwjkSk?NSz}{sA=g9S&cH>QlPpQgbFOl}u^}~zY0--uh z^-$_GCtEhqq-Q^LU-U=$OO=|+fGa2@p0fg!=XXM;Lt>570OdcPySNg2lATIS2y^-k zYynU_UabhiymyP@&1~h?D7Rj@hn0I=x#yI7LAhU*`(3$0q}!8BdS_dN`PhzK&&~`k zNLd2E^p4({Zj;!$kR}`bnArN7ln#lhzm;5Y91{#tnK46Rk25<2#{CtYx`(M{ZJ+Iv zb^zQ@iEZB&KSVA_32?lx{FIT{_Mj8?1+w*{6H{3YbRb^Dj@u!7l>c}O1i(Ozb1R$! zgsn!c)qfo>OgX@RdMx$QtbN*$6le=j7v`KBg_fV~R;DGm5x&mC5x|iUYS3i^?;bra z;eEfe@~7nSyTMa4;mu4OHNrddX3c#6657l3$R^z@2Qh`Xj?*rZWakag-rdFG`Xhi zJb4jEgU}f`g|Pv?46*_ju)8O>DRg@{zc>eA7(NMYUs6&s7|Nsp9?B$QCW1-FF~CC^ zL(DW6a}_gG*R3C90Qm{Hn5!^;n3P1xrHdQjabFw_ob?1tzpl_rZb>c1D6E^F-09cD zx@U>goNL`1t-A^Aq_$u~ElJ`=9CWkO1V^`YU@l}n zWB~GVNK!;@G8h*pJH~(zKI~9#v_(FC2`~PxRgO%6aGRBTNV&(9JEYwE%FzIlgso{2 z79voti*gyt^-=CayIXC3zrpq zf8e0OLo#wQ24@Vx?CR~f8u#q#1t}}RV9IOSE}jzU4<4a8kR8a;pK}XT5nPk;AN`_VV)|ZxaQ|Vr47_8m zUTT>jYDF_k1|07b#C*Q2l;n)yTUkNaNlnfR9D_f&jB~&>J#9N8&KQ+(S;mM_myI00 zr#_rAO^s~hg=`TQ5{JWUmgB!z$*n+WvcT;Dx{}Yni~nO7{iYlZYu(KL@UX#?*1V=I zQ0d7YbD*cJt?dP0EfG&LB=utD7btCOxzVM07-U8~YHLHCk2E$*7a@)`j-ZBzdd|`r z5$jpUi5lG>>c~uiUuuZ)3IunW<5%qPM4XdfZ}vMC?%quN>gvF7@0OyXH;(Ci`Z#+J zb>P!snjP~?-b)+bRMCO|VtgUA6EDvL1M}zPsdevA#yizgivCLKUzl0>Cq&W$%z9djq5vgiuC*_ zmE0TWW<|Y}I#2czT497QN~(#c9aJ)ti0XSY5=k$qw$o|*>*fF$iX@ckM1D4+RMU$m zvI+F!iJFp+fJ04EO)zxhP_7K{P<=^C`d-~vA^Ay3$KZB7)zGUZDz9c7BviJifTx0y zsEFq>q$bE|V%j4k$UPrH>E|>_%fxA@$)WR`t-F`?zuUUo^7+e>-eGqP-<9NF$`@Tv z8=j^M(k~O?LmgJi1?NZi9<^cA+g@PF$!LpO1LI5902Lj%>7F9@Io93Vy8YHo_Ys|6 z1vwS+CP>%{ewk4KNi}ggBrG32kp*bz8@UlkhMWyaZC`e>)AkXPwokax_NR8udqlat%I#O~6Xm{8?kD9ak0rj-DDRRf%}p%w8L~&hktGs; zGnJd8+#=f`e`AP3Mu$&c?EGeynK&KGf6j3>89=)B(Hm!$BOIW>ogpw@`j9({IsbXm{*wN*o*RQ z9a->H4k44eLTz7axJHA_cpXOtb~PzymXmR^0<(9JMQG-fo1`2)#fv|xiIP6L zWvpK1Fih3JU*b){V|4=^7_%BzFiIa6iQ6Hgq0pYlH%#;%7p znPM50WXwIM;-@y|M*XT(eLP6n1V+5M5t9(FymOiHu#h=;}}9TNnE@Mp8MGz ze%kRP)J?{RGImIiO4?-Mvp0N@ImjQ3=jij;%fPBde|D+p{lz`~#aGASsFk+s$Ww?s z?RfAze{di^hIz){CfdLISQL`wDZDs%G_gs#89#n}Vv_}w2qY>xST`1**_BUP;sSaw zIKIz6|5>lZ^}N4Lynpv^QU2ox{A2g|d+sjSMX5)A?EXC}Sa|)P{i46ewG^HW?`5x} zL6~fsHQUJ|*A@8j>=eXUsaj_m7NSv6JjvjF0A*Iy71R%-AZ^!ITct&KF%cIi27ek5 z85OT7!he|#zX(V^Hh4wPQbEeura*FbHIRh87wA5YYaMPqn zx{I*T1DRKtslKSY=O$eX+vmLBkg4p+@I!ANsQn>hiRUHH22UJ9Wh7n5F%Wk;clF8O zQY?~OCp|RDnsk+rM|?Wa4xd4-$Nl>YK7Bf!&w0$te6G7E2JdqY;GX>fFR#w<#N(cI zW~=9OD(b=CSM0Ze=Weuzl(KqAF?|L|eacp*4{S;3iDdwilHkK9Jr}{ggy?Ld)4SGp zQG-E6ca86dS%*UE z0^~F`9`yE!X2~NqI^FB4LVPPg$)`;0%^o@;Q@l1~J*FB8p2q7NyAqjD8;S>F_T;J2 z-uUL2Z5WMxL7chcq;k|)JX_^rWKxt$0wFP0Utg^=eOOj{B%yxnr*wHGN|K zc=|v>DiA#eV5U2&Mgmuw(4|o5_MV=ek^ERjx$8dM^C>x}dk0pz=b3U=2Uf*rabCN9 zOI`fd@`3yC37oL)k5u2Ip>chvA|+qi8btjqWPS#Z`2r6jy`TY6-D3s&I$U2Y?mc zA(yj2x?-Qrs26D*r zwBSM^<1tEI`8^^=swkU^#a&!nEZvKqc4xa3$rBG=B&=@kcA7p;WP)TY|WxE;PP&ozg42SHf1#m07Cn97&GZ3wb zbGNvqGnV8`h^BsP2TFkbHE@8bg|Va_=(keO^DgvKsfyLaK{cHwIn%^uy0fSlsmQ2^ zhT<58gNlV7f>IGy9)e=HpNs2E$-1ax=MMZDBO7Po5kB1QcwO{~sYRtW*?ApL(?+@{ zNz;IK1l>&<+4&K^R^o7e)Mp^mPrVuG)gk5R6Vo^=dL)6akoQ4e4Y>o7TITy9S3y1i z`6eVr90D`~f-#6dEyVQ@WGW;+!41&+0pdvqRxk)q>-#w5(~uO7(nmb?ZMNaaFn#S+ z!+{??R@1MV2>U-U+TFQn)uYGgj`%kYUt*+m2-7*CmtHi?lB|)?quXP=>mxwvHKS%DBH=qWeGB23Uzu0XkKm7AyB4&`XnN#fh9+<(ev&r(C{r^f|MHrRl?>W1Dg` z-Y*D@S8P5|+k>#NRCCu2wFn+zRF1Q0|a&pDK4)xti!eiw@d`Q*@lJTr=f- zF^<2Q7GZM_<<3;@Jmq>TSEAhY%572ZM&)S597)Ry%Dt`Jd&;du_fY(;vB+ocSMEXO z_9=Hjxth3P?DblN4LX!-rkr27EaiqOH$u5zf&SZ^>izE)VWCDmi--<-Dj|f4uFB;o z7grq<&v7>1Bv^z^%#`b|+(_kemGcLeBBU(lg$T_ru%KRm0oiQYYJg~n6qKvGfVn=DNV_= zZiN5%>v;C`&;J7}F@1(REVu_}vami)N&h$uP?Ep&pJ<7d4kg}wu+8-9&~KAR>#)Fy zRavs}T%JQilz14YHU$@+lhO?fD-C^gj)zut=^#O9g`4Z3#rlf4!p(5_N$=Km8qw?u@KDt2J$~zWhi3pz)3TXUy{(d-^xP*)RVf>=Ad_At#KoRl(~)&&XB>G^v{k8-_FZ3#}6 zvY--?k%8_&GBS{^-1$KA$vlP~?Wgslfd(VRUYa>zKdqk(B>rXs&B5U{0sJ4q{uTjI zOXW3(@P9Rf}f}WkO zXO}423e*$TCf?i$w4ob?__reT2Dm5UHBVVC#ykh~2giI6=m@9z9edVm{sf|JY`n$; zKliXd>Q6`rJi6ErG%sKP^m8b&&K~o%}EYlRsfXUcs2Dh59`2eC*B7?lb`?oBdu9Mcr140t~)s zcLqeL+e*VJbVH&W$sJz$jyVR3=%f1TcqvMsq%P=8?%p#Ba`GqVWlznwZ%rv^8}^Fr zr}gPS3rhv`;gtd?dO!Rma`d53)ag2mXj`>6lYyH?_ly8=0Lo5S`JAKH4s1pIy-34GqJ{x2l==+SmF1 zn0n~$!58@)6Q817l+?r(@M0u8Av*9l9xvl#F$!~9y@Z%%&0HQv!vih`UZNY})$|Pb ziLRLt<2%LWXBtHk6L>!%x{jMJ2+{5_pQ|axDC^(-AmM&s9!H+yNG%425^DO~kLTkl zUO9u$oxKUwV<^KWqjQhp@Qd>&|1R;a|E!}u>29>51tQe^JZ&7$I{Ht+0&YUS23*xD4QeDiv{ zqcX|DIZ?UKjg+Xm(7BeFVG)PY;iqEoBVKpT5b$(G^~XgX%R|hA}v(KGW?=x8(#JbbC$4F$Kp|9Aq7? z#6jj@I*vjdGjPnrF$>2W9Ap!&!7&%dwK$4!%)>!X{L}={6aT6BU|0+}+_ysRg?s=K{e}RwY5O4?Kw>Z|Kuze2kY_`_4w(gsdo2)vd<$|J zgEz_k?m}{6)t{%Fzp8;l5X{1FlK9&K6<0apf|VqoGsr zH$^$R9^p1wglXo{4maB(pIM_EeKJWQu+5=z4=eYEa`eP5{u-ilB{~{g>Kr?k(lsRqk`;zEtj4<$hN#7JbcXoED!&n3<#8smirf?hNI+D%V4~zRFQA zmSXl9`mSAcj8hKJ)2aN7_0@0m%tT-RdGRM5V0wrs`$1GZI66w%cCu_g} z`Z!5GKB6_cs6j}Dzc9b-BpGGnSNU!~6fYSC)IfxnABGD9r1M5dy4e~gJ2x94`4&RB z+4d|d{Xo3FFZy~12={owf|TuG@V-0v!~DaZ#04}O$zV5w8il9MKNeFMFOPsnCL$s9 zv|^6Xr!({zo^2lv@x8(^=drW~Jn+d8c$#%ceoVBEp1o_$kR_cngEgpCOxs2Ch?C8W zSdn=b1^~LHy~e`;^j(BJy26Gua;78jmRgD+>6^zw-F2tAD3Q32~+ zp8Kuu1J)Zo4yIX0urVn>G(ldC(>`*G$IRfK;M;h}E)|zQc(9bG$G*mFW=)afN_^~a zolGYuGWcm5m-!gHk}iqxv2oD+=+DSiai{H~`BvL0Iick2lr30+F2=oWn^bJ6lb1am75_X?* zuK+!S!)rdkf10M|HDq)P7##zW5TxlQjyVSDn9OJCFXZ@7R+kC!J8KF)~d56f8^+7TVOK(F)JsX){mdiis+daP{|IBH_OG|X?jbeJdc zzw|@yMey6M%tJ03Pjtn3_}}z(ZbB?eF=bqK!PK$boqe$>y|JDMihIK}@GQS(?4~BS z856hjBj5~RkC}}53Aq#Uc$v03);}ifcrx))W+*)vyn(L{FFVIP$$_#v+U?9>9X+| zj=Wf+PCNZ-oG%@{q2e@uz!P=+rnElTD?wK<)=X~e;zVn@z{eAd!`F*3k&a?MFY_DVX z`YC%|WUpC6c)0fZpK|HM?RBv&KYvJcnZ2$=qk!+Tuf2ZJz7M-cc)Vh-*;c6dQS8@>{Z_F*EB3Nt?u+gGtMiXEibk%~=K>?4X%14$k%QjBX73w96HmYAcT0i706Rfwm@_xJXLtxe5~ zjy$psGxQtl(N$c>wYff@4SGCWn_ z`sG}@4LNV3PEA@EE8&_XJH#@NSY5xYkq=B_xLQ+la+f?e$!Cwp9~M4es;&tu=VB<_ z^1Aw!i|ST4u3EbeMn>RXI}>JMJQg1l9|6aAuS8*tUhlV|d0>goTG<(}Ai5ay1T6=V+F)`nH<~z;kFq?%k zJ{c!Ji7)o2WH6+9)iKK4MrDzW$MbvaL0;iC*?FYJ*7ufH*hWzD5VoB$Y|Rw}#r46E z>zs|u5sX%;U=`p;!KT}gixwJ~J&BncKLqPW_?-(JBv0Q`f**v%ea4=Q+YgK|_6Wo( z#7Uk$2CpE8FgBOz6}~p?wJUhp=g*dvP0N<7Y*>`6s{_{_J~0PZ@7BkX$8)haUFI)L zqe#*vX6SJ*HrXUI0R!{B82mi7Y&N2U;n4xHw4q)se6su=<`ztq3-Pyy3{SYlnOMF! z98XxjI2+58-IFGH`BS7}vim_WgDLKEv3qa42w!F$Se>RZ*_WRkUKmGa4p6-M2YKgC z$ZPV?6brtHCEl1je+A_yW1*~8)FT*BC;-?~y%nqF( zIIIp30coUfW6Q$ky4B5%Qgs4xZWy_a-HLS-hX1mfwPw|_MaeN>^nlg5@;F)hXD4J~ zZCM^XowWl&FMNxpW&ru3I<2!&_%>*=MMQOOzTFpm%k1{~HY}d`0zRMe8`Aic@|aT5 zKUi)wD<}rZay;J27dHI|C>8xbL0PWvf-=qyv@V4$8FJA;_OU`6LRYb3dn(4(iro8{ zVjWqKm1qY}7%16U@Ma{iJqHWEJB%st=q?M=UWu~cF1H=V ze755^>~gkiP_|>pb>2kj3igf-xeggnFxQ4$r(H4h?U-L>9#-;{Q!8hSrI1&hdIEE( zifU4?R;PA&V|RF)-_7^R|6H=+NhIyv$+Z=54CPRU7Obo>Ec`6DG4{R*h?Fo#uLYT~Xvz}xVrXS}u-uR(KctOz#7i);E=|-FwN`q{!G$DFOK0PShewYkdQxq|?jz%oH zx=9a(@RGw;T(7=qX&pu@8mf3chL>6_jrha+&vT50h)yuJV!MfEA zP5&w_L+v8}XihcJx~p5#xawS^W?qLW5wf5HwX(MvVNOji&CmVv{s6OiNM62iU2=i| zX7*GyEMMMaT$jfoq8wB6mZIzPQ}BIWj*0Lx>nG2Y7nhqWMLUh^ZDNf{U^d#D-0g#w zo0wta@}7kaw|8CwEfJYZCCS3EhuiGL1T3u3#N{G5-HKiwnl13m;^kt_@9|=T!2}#} zBCFNV;KMRTCPCVJ;;9>Huk*~HC^mf3@9@W{(8Ka+lYTGrs&s^s`#8=2WPIgWXyb$j zspNr&68U`+vBHFl!Cc3eg@-as=Z}jIOcbn7glBS4Md#OIw1%5MI=&wU@bv0axJRO( z^~U`|dYp}){Ml%~73CLWS^3du$Hj`cG(~H>Z+^ZBg&CecfR-U9Ix(l1nJnDX%$xVM z*LlulV4Mb#bH)NQZK=6&FOvmalV7r+5%bcDF=OCRQ>g2}6>L!25iHEPb>_ChtU1@g zmM&Q6e@u7;Pk0Q6FoYugrwJM(zx4^^Vy}GUd48gx zH#uy~Oo#}~S;G{uRV|z!R%O;TEW&sE$$U!zzJ-`A{~ z;W;gDCHd56Sa$jTTZLb`7a8P`)~gbQOTy!MI9deTMYMhm#g2)1X0B1Wp8*+W+RP}r2P#~9Eb1PX|4;M@ZdQ!*QoWIn2c8>lkv<lmdioKv^*jAH@$l1}7P| z4d*2|$zH!pVwrTD_Y9NKG9^xUzRjdVjXhL>2U5mcdx+g59w5q5xco$Z({2LSJCw-) zDU;dZuoDmu^mO6tPJn1Jz1p`KQ2tP7UIm>>(S5ze2Vv+4^(ltow&G5Q*ZiH=ECOCr zrSN(rD16zi2Z9a-Wibo`y$W;$=r+&;Kpz7g1qv^{GaB>>&@rIQ{DVOGs*FzqY#b=! z8l2LN>9XDMLu9A48yIroZt<~0Y{+$vQmj%jHf-hIvlP2Pv5OSDL9v?@W51-_yIHYk z6njpwzGxInynZ%>$qtGQSFA!Y`kUlC*tC{=*|ZjnUTwkX)fS9iZNcc(7OYCK8H&wP z>{P|hQ|#l4U82~fiX9vCpYahJf{apZzG81H_O4?47WnrLw;|U#NU=i|;|??O9o%q1 zzT*P#qL#Xt6~Lc$x3>~Hsm_P6x&ZRtekJ-9jDmoiq$Fh0z#!D$ZOn? zfg#u7`s4BpTA=cN+@3+OlNIACl%<>u0{`LMQZMy3Rw(e=DiNAB%G>ZxY2$%j>bO#G z=RN-V3mMJxa^F0^ud3Af5!>6|{Z&a2j8k|J!BO--?vU%=G|eY@J3ZrXsq<~~7Nd(S{IxTBM^;(c}o3)7Bh5CFG9Z6@J8VQNN`)+UrhP zN)vwJsuip28?9q!mpJ{Itb9rjlkVYG_2$V_M6K)pE7SSc}tZ*#uDMZP4^6GYXg1qj1(*%u43CfT?BQokn)5gZaOb zE9z1&v*jRt79WKv?mEek#e5F5B(~VXNcM7Ca7ZF{VBtQA!U*dO!K=h7jD@efd|oA zpQA&@=cMqbvq2YH3c@!&_cuw6hPjo&_+%tL|40+*c-U5xI=n-;ER6wrXvF?3&uV`% zc^Z9(o8(V|StrTU*z-Rz+)@hcPyg+YGIt(_cb{a8yKwnN!%@SJtpz#Q^|}CtA1xmm ze*T1NmKjUC80T7?EMpef^EfX9i!saT`X__V$4OQuPmV}p8Y50}6?y0{IA6knGVp|k@Ua=Px`#f}E{}ELCU$PrfYY6psWB%r^vLHb#REUJkQ@%V*d0jT4N8@8mL-0&c{+Td1h{zm3#04 zEv#Q%zi?UeIVLO-j8?%4|1E%Gih`l=3P`IZ-wxQ7}I2`Z4~Y{h-Lk z6vIU{R$N3bT|~peTM!x#(Lu&TRDcZ#c>~@H%b64w7AFdh@I`iZFOe_%4mB@357nd= zFQ{&}j*IS4X&-GO`#rAymklyHKH?E#BN~lN9EBY+BCOGji>F9mIP3}P7;V1)UEyfq z4lp*d=?2150Kt4P|E49#^IYP)%ozjmU5r=u+wFdvow+>-catB6;$-Qii{S}@7$)0V zF+2#(ZB{Yc1`o3(CG<(m9vr@erhxVgB7az)II*5}YKp}%mA;kN?Y0XS`y!dew=uE4 zbp!CtpcL%HDVUE*`fXu`T<7D8U0_45Sr}R3eO9p_YP_E)_M~D@D~7hXeFj?ZCghqK zppxDZim@k7Fid2z@!nO8lVaulxSWH;42XA;c(xD`1BGiQg%ktUe6O|^X0$|cb;P-#DA7S?~8 z{qGjmW+rM5VV!wSYFC8y*~l`efe(fCzff2=AkW{wu;xNV;VF<=g*DmsgCne8MV%JM zB}1;6<{{XXsIr26)rR8E*A;tMvF(bzq}Z#9Q5;KpFxGZdqhB+sC`QsV7UjN(|Z z0X78ZnPU4XMsY0h%s@Hw9duj@M#m*XxHliOV~6v5_p>2b>Ig|ZN->GYS$l$=uNcRe zdUxI|hf4!`EmnIyiAHo1M)c3{!5xk0)8Cg74a*&AwG|YRh%KGOCCqb-bj29fur+-I zK(VH0AykP|wrdfL?zJ0X4aCqH;fF5J(5Dc(4H+YId(v&~v+?0yj)?TnBYq4g>D92& zV%*M?V80=ixp;PPoN^GyR52icy!rmamv9?!WeJ?ZbKO8=a z!1^vr(yOsYqP*A|;0M6U&F`J)Z4B^!G{9+V$uK{^50`dlgGnqfz$NiAbPolIS8L)% ztWWM>gLCj~2OE4$`2CCxeqc5myuvp-JGa3PG4I=eN-?{08+@vX9N6G~&e1cI!3L*$ zH*ACZdC}3hKHPuduyNfn+8LRmh5J3N4UU2u6dOlESbv;-+?+p#^{HW zWtdU2J2;LzwyTo;L`KKqo8hMK%M;A}WgW|8hqM0C4&MWm_Vz`fw8K-Nw8Jm6IPLJi z;=M(*Gvso1i^U$bA=fMcEAjrS*d*|?V4Mst_mam2t5J-CTCl$;MnNsuARBTW3TnYd zD@H*rn5P&8wP14;8wELZ)o^~tI2&@EB?w78N-2h1r&X~F71Ld}k~+%CcYZ9+>i4KI z(v=G(?J~bdZW+A+`JOI&hu{lNiOAlI5sOYTQZ@H<@A~dTTBeMu~;dc$xiCD%x5uxD~ zgeXF>8BM$oeHmEXL4;^-b9gv>7xd(2@?B){S;)A7@wln$K8vWZq|f3^oc_T&L0MT0 zN}nQ+8z2i=Uv343)7xB=t9ebfybYAr5f%(IPUi1|(nh)+l!eN8l%W+#UxqRyn}!KS zuZCckXgrRF6zuzo(W@cYcEx_F*z1b@U9tQ;|GB+w$aTJ^*f$irU9lf1h9x=dJ3pfs zrE^7+-|>oKaY$IfxP2Hyt}|FMZXYJtlL);#g7-dcL#{Ir@=5Ncq>^~!6`QEof2#cD zw=Bycf7!~DBTfFMc`TwfZrYE5DeKGRtgejRDw8w2C%Ph&jeFulnG7!YPm;-WQLyA9 z25cacyY8C!cgp1Ns$I*F_>u*qFIliJ+fdy3s$$y|qw_-IJ+Igcic#uHdT|>zTp=~i?b1_SJa4*g!}E!snVk;{OpL(!Aa|6d_5M{SVc#8Jm?%3T zQE+ev6M9%C&qK0<2|Xs8=RvK|&Q0ip%*zHQ^o8cS3np~Ai5Pex{Cvsch44)DpeNAJ zl#V9!1mFJ8?S(ikQ?&5tYMRhkMAJoob}(~}_VNl)+RM$Lw3lfC(_Ur?`u6gzDw`Q{xx$7c7`+dIJ*(KC z6yq8|60g{XTxWn{7}aa<#iIH)9%pJwdiN-HpJFd6_E*LJq1aBv_J#zN=W;}>q&G&f zgA{unp>u{)=DuJBve50q5@P^Mb#{6uy6_BFBU)aET% z`>Hy%t$O#N@pBYHw=Tc)fsyd1{*dsH8;qdn7~O;ls4=u zhP2`_$emtgm~&Ey#a`oObQI8|3;$|ueG_IqSs}W@2^t z!(meW&{jo>IK1hXIQe)EO=rUVEZZZq7a+cX?LH4aC0L}U0zdl)%iuB88>+jB7QCX& zX=U(pplotp2|Czbb37Wa*|fY{s|rJ|F;oQmy8TtEk6^4m5|0%`us$~AI#(%nwPN0e zZ6(#^ThC3_q#mdSpKX7k8k?@6@G@-wGz%>VXOIqcYlOaC?-|4#cB*@THk; za_lxn%g9Oo*b#a5Xjl!y3`bi3KgMh-t4Nds!#~&7%hts+@pb;s9eK@v1}hzhE)K&} z!rDUk4RS)}Vn{;KzvMN4zg*rxh9Zx3U??(Qh|~B5ggEle#^qa+?I^G3gr39lAk!Jv zwfHA3(_IXTpPV+(V$e;XoDXps=qS+7f{q5g6qM!3Ytk<%Gcx2lH!Ai`8xsGq#H0UM z;{93Uy{uRQxh(NYZ3xS@D0ZV_nEY9)p4t4Gv3c;iR&Rc*uoi^Ox~&EhF@D^pSe{pY z512I&ho6BA-Vm8-c_^OGgD$%3bM#K_vN6hH7WPom?(TuqyXYmYHJec>Tz!>E%TfLJ9o*+~^E-vy6?5~Bqdi>R zIb4ojHC#CqRa%Uk?dQg!e@d&%H&>TT+Z-q!Jm9)Wl|BKV$b$y#xBewndPVi|)khwQ zKehF%|3juqjN2{moU6iLS(T;2PwKqF_cm&ptI1JI!9|d}R?jeziZH-F==T_ulv+K^ z%ztJNg^ASR54&~!Dt#NchxhqanxD|MDjin5t@K(PL z@B=%q12Qf5U#-|4*IL1ltbHPw3l0=)v<=10WLv>#GDy6WHQqYKKBgF*t`e`vhOlnR zrple(hOK#C$xqsM1}&oBIvfd|J`J%17!T_1N7=SBhqQ<=?RnX9EcjQqYH{82RZHp) zg$qZU#+d!w5-gV>x0R%APVxwnL$f%Uh?!ONMj#HB!U*o;KnyX8iqJUdYDmq&S=F9SF_-ZH}*+yQx$@54Lx@fmebQjFky9O z_2xeo*5?1++x$GX@BV8|+tix2HCRt_C6ZijSDLA-oIl^6&N>o$(3G^Rfu` z;b#0x4fuXI%ENK4z&bOs(#!uHZE7LReSgef(1aOk?m88BNdbNychPU4b>43za12S{ zfPmeCYp#GJqj|oF2}L8dHH0dU+tOM?T#06od9Q1*?g=;jsVt)%CC8w&hELVL&=3W+ zi35ugg{NhhYdP1O}#5`2+= zBr%zD7?!KWncjOaF<7;OmB1>0u78dzhfIzIIxLg3r8^U-)fPSzb9xa?;s91A<@BOk z@e>an*Vu9KNXj}I(fF@3jJCokrX1W3dI0FpL90O@2fYCFNl+%uYw8?!j)=}-NW4pe zu>~yH_iQL`Hlq;i*NXjC)2}9(WUKQdOljV>f4XDxCfEwW`ZAEgpBczdD6?_Rp}hB(@Rt z^6&TB%FTj{XWs{?8Abu2Drj>qPGKgf+8M3%tnP)X6mvd-kZAJT5vs%)EKG3;zWthr zCchIg=(!>NCMuyE9s8PhohIKc&HjvytPl7*XVdeut5na62JjbYx(=FM`h__%Q;xk% z_xe33Xi>c#_528?lxbSbCDF zQ8$48ALu7RscHEHU(@~$UnrWEA(vapIfBtqCD^YNqka|aEyez+7@OL1Z^DLLhvS4Es5wjuJYs*A8JcAlT(z{l%>lI_GH>0-10!`4CuXw3HQ(GRDrY%#m zO1-h$(YAf2i~6u_thf1(1z!H&yv=_q@Y2XsfDP-BTcX~pUp$(;J+pQz)BG3A-{$GMk6JnlE?Ir|Xn6&0`9XxtSV`={lvs85hzi{+-!$%0HN0 zflgV}Bc1YD_yL$8%OI;xArD4$3VE!jI)&pfd8F%y(bqA*z!!^-VMx|o7pxGxE7+bk6vyJdKE`=!5|8uLBp%(P zg0ad7#vL^TYf@~3VxLs(X2rg(*iRLs=9Bc;KPu^QoUULMicMFH+oVf8ZW1c-zM zhk$Qo56_3-YNs=YR#wL&+$lK=89g64*Eelx)rqEqhIdByn-O1%NKHwZWk7!v%Yl9o z9`Ejv*|2g?b>^i8kaq zpG4>rxGC7U^C_eS{9_I)#b=qF%j(wXE(5c|8w{AO%WM}5Md7N&i<=snO&7~v`)je$eGwE} zfAce2wlIrNSiIO+qd{Lvf0d$p;9WYCqTvOpMQXA{`D|OF?CECN*_Je)=a1A17b!oR z<0->M+OJroXn#_P(I5Vu_?(Rrap(Hbb57{(Oz`+p?cw1sQyw} zK_zWOXxu~*hbLDL5QAo_5d-F@4u8Vq`eP7v!;%;)h|?e85)$r#F!w^qkiRL+(Xi3J zsKX(&8D$bEUuiNZ?>Q2beNwz;ec&};@j(^t3}HPL)FZ)8vmw`6tQh@R60c3MO^SU% zv1=52L$S9M!;BJmf9|O+Z?7qth8ZNmXqD;6>xPJo?}xYKK@0zByrUf5mGR5#vA}Xu z%i_h$Li#zYpzoJk(6f}agM601g-GBb?}wKS9Lx=n(23r?eSfY01?eC?tZpb!-N2A*=2r=JDPjqB zlMThWcd*5_DfX~pb5Ndg?>rlV4^~taRXWEHxRHh#U(r7nMvHs4SrZj2mSeZj=$1nE zw=C-3%zE5)T|p+fUErzny>(oIy{o&_{1e&I$O^OY_T z)I!K4Ik31xD?{y|6b8p@(KF;a%TYdpt+t`G;%fjnC`a)v`oI?7Zs~nwS&Bi~ozlF? z6rEY=-7n4C4U|@zW`(8h7H6#%Cqu4tKFUk5RvStyPEKO{VMO?bYvcS~T%5b4`f#pa zcd~oXv<{VLgn@dV-Lo{i8FH~77&hcJSki`Er@H*H=AxRh_q@Prx1|_=$`B*)F)TyO zHIXvla77+;R?L&pK?sQg>|q|7+=DFT-k(P0iOWC3z5{(t$Lbk9AY1K~gR_aYK? zXhHK9{zl#>jWrR&8+qgQ*Kmd#Q_SmVV`?9)&jr{S3W_lzP7;)5F&vaq^Z(Q(#gOZ8 zxTs)Xu_4#_v109t{YJ586l2AddoQ#h7n>%}mLVt`&Krncu3vkpMv%7~^S#vG-iG%| zoAxd#%`Yj#M&aj_V!POZZ0MPBA@fh)!cid zdv2!JcCM_Vj+ZgR`exuNX>AVUAN-o;JU|Q+QD}qiaLGy zgh$Yawhu;4^uknH=^|q@;;SYR7yGJd_YVfM)oGtPd!yJ3cf5(W9{JWALopNK?jrLr zaY`{Zdln?4?!s7zUe4_}Icb%ZM%p!XGTM}lA$CZ7*(4pT&mgbV&k3);bqP{T6coiv zxZq?jPEMUG$(_{D)Uv$UY;jkOv<&Fnjg9H^kTZFB^zqpKA+VL7W;%zTk?4CwqTsO5 z$nz?*F9$P>-k3AY8=Zr3D8td2+siq|W*A3O$lLY7sFfg9vqbzEc(nt$MEpUrM0{^9 z5kI=aA`y%2A`x6jK5dEkDZcE=zDNWm9&=0_58TP+ByfQiT;?U>*{8&@vC{SoJ|N4& z5T7*BgM}gd(g?RWWEa3y{tJf}h6wKpXQCCfej!sl7EE|#scFQxm5JUMT$nyIj;SF5OCGau!W%5_o`Ltq}EB2sboc}5D zz=AeCj&Bw0K*bJG>^q8mUorX#BfDLolnrSk?w<|Yhuq$a*veNno%Z7pg+@)>rCs85!`%|`J z#YcoN!|ZS$>yq}4R7VO4CXd_sRwtK0{LiS!_K^xVvEcy;vA*%G&N7xiO~Ot#CJqk z^EkX1eU!)GJU_yk+z_`8{AstJ!@yN;db2CsE4yoOm1*KnZ&=vau-H_EKUHMuEgGvT z9Wijkq2vRb-51#3RY%AuCtF~!xZBTC5d;sVp|luU$Ms(BPYr; z{-W3`itPs0KOBkA$ie#avawTj8I{dThRDE8%ii&$nd!#Rv2a<;|rMyp=-bAqQZX_ zP<}6EOaUnEULLbz(yM(kDEiHuQ$S&EIkQ2TFLOXCYrdYO(50kf2rs7?Swpb3ijg%0 z`;B7HDE1e{SSk{aBN7;jo7u*KnSJV@Dk~FIo^Xlec{|T6QuTN02bpcMHq ze_Q!2*wWY(!wpHl7#MO*cf4RL5KAyN1_fgd3D&OIy^3)pc>bi}_fN=j2pFMXE=HIcFai?@ z)l#-hdHfV`sBz1x|L z4ogz7)rvJMmYoCc#FI|S!2y?b!U5@8I6Z^k?P&%xfeaa(cY)HFwT~6bX+-1mx z8&RhA#GQ}Ykn7MTAn}+>67M0!9#c%sA`HoC_cs1K_s|`T)XCd{d!5%yN)5|QXfHW< zbK{<`m(1IYKvN$NJ&fjP#Xug6-x;^n%inq@ty8mr-wZ71_e9g4+`SW=)KrRXEuLm{ zpltqbk){Pz#4W}pT#nGT!8ABy2vJ2|2lkr~8TNApa5gtC#hFavk2!3u|8Pv^k-$uk)OgxvfZVD?+zG!#QcU(U-j1M3eQDxi>1gn*80* zsgk~bTrD$LZ>aU4eQB0^Oe|vSFbtoNgtzuI({Rjf%k2%PD~&Fu6CRz!1bo{rG(u_5 z^udanX(8?5nYWZbtfSGPOLH+KiS?F4zG>o~4$7~e2igK!56Vni3QDbVt;#)yT%(Ny zn+Itk*!eaDCyQdAQj7~RO1#?@`+;Ix6uV!sKPyJ3q1^k9V(%%|7jjA7rJoJC&Yg<= zSTSGTVg;A#QmVEZOp_aEWGdErK{wy5WLM_N4e{rVa~ESw4R5Q$)b*;Q$WPm4N7GGa z!_^?vh%<(Tx}&q-y@sJqol=}AJUxtFJ;X;xhT^Ux(-z0MU3@J6u=xIHS;b=5 zfw<5O-zziO_D>W}%`h{1OlT(CAm90!V`lVm<}-54WE){3%z!D!nQZ-?4zr^tL}s!L z$=a#q_xT@TlAM6Vq+^R)%lq$(9@S*2pcmR@AC0`_^SZ%fnI3pc9H z#&xt&^TxHC(!g^DdvjN?G%85{>H_j2^7VAm;jIONLJ!)d4>i3LvG-`b9v=};h^NPAI}uOmHhxh1v)cFhkbKk4!eitheNI{+2@djIA9=%qE`*TH z@4Gfeg>K|~v)J)pdj(kRCW>u2ahkr^_6)gZBTT_)+$db_NmE22fEKXVtd{AiXEPupXGt^7kC?3YMpc%yzG9#i{ z7#-AjDa-@jewj5B=7J?83mI~q-{3dFp0S~{QE*QJjBcM4&aSy55WyU2*_F0KQnc$K z?ME3S*u5;|);IMy{VWXabmM2?@Jv}~!JcN}+wihkE=0&Rj!D7ZKu$0uBiqIXuFvY! zTV|-zgJR1Bi`%J}6D>Ns?wnt_Z$?cxFEXC=5X7QWiIhu4$&r@z#?1Jj4egDxzz6ar z?RZt67c;K@74+N=K$}B)ZqZeWV+eH89x#k_$uPraG?X~{iT)u>yETRredBV-{0LeD z;|-9PW=P3GWSEq`PsUfFO(u`t)9CjcIvwI?U+8pNt#3fSWm;U!uS=n|#8{W8n169} zL>yHFV5lxpkMkG*AdgZSg?-h&Gy-m%qr9fT<@NrczLfg5RxyTLEGF$Zg56+4uJawm zzOUFX6?;;#=M{TFvA-$ywqoN@-|Ta3$aUHk<5WF)7mqtIJZ8os^u{a85>tMqtw*%0 zB9)e=6c1)UHIp2>v(oOC0o}W~4)2zC&QPVlR!Qfu9U|+uV??FNf__02&o|ZC-k{Yv zsJ?M_FaSe!t-}C#@>nL-&ktkeqLKVZ ztyB!T&fQ>r!Ps>y7>5-J#;#+*{;JsPime5oOFa4%BwnOqNbB0K7_7lhL`>Ci#bA3v zj*bi4Db_Jrp}wu?dRZso0Mdi!jz;JS6aWFGRHHW^rN0dLaj6b!OaW znHZ;Gu&Im^B0+mMU70GKU*rkA3L;dm47_1dO$N#}J-Fr{uz~^LO-y|t3CSN>K@aqCC%idVG1_^m_RU%ZJ4cSw`2x5rIS&mx3w zf>4i{iHNu2D(3tIe-A;P#GKzEB$zLDX&Ti>#4cYJ(!gPUuaDFY5sQnLEpJ%RvUm!6 zM5GQdRM#AuGi}Cw9kX)LxsA)38%+PfV2@00I$?d6p(OqQ=I}&ahFtP^YT0UpU~2g+^!C&HovA?GyP& z`JS&c%`Nh$NW;k!gDoaLjT?BA>l|rT$UPyCt3#HRtwwBqr|rAsgj2pVzXLVMdJ^>utdpWHv z%b$ZD2>O4Z$AV&DZ|fS+mq5=0g@3+vJ?QJ8SAaePdKKt%pf`X%4|*RcmalDn6!edv zkAprANLfig7*DxLES zFoGOnn)J|gz(Ay9R&_FMW(c@VyWITcn#tjTaXJKbIB>e(fI+o!2k!Iy-kfe?E0&#Z z!W-Fn#%?6~@%?%r9~J$}>1KX+7d^mCn!|&iM>cR+Fd4iEH-)AJWj;9ce z<0&LPv-*n6EVF~o4F_?P752dw*Oa%nl(Hf^8{1oYLs)OPchr_c+YLd5cfM_U=6&f) zS8`*7v!);xe`lXSEQvqn*kzn`PD}lABSW)p@0c`>3r-G7nnw>oHpY#7O`DFD&TakF z+riSoB2yTr9#5081BOAy_DzPx?la()M8ST3=R?OCQvI@yY^Mf^z9Q4Byqs&)C|8RJ)?N$N)KZS+!}znESews~XlWY*?Lf?k~M<3G>kL z#?%OUKNF_zz#YxjUtpV1;L>h`x8K|lxDATIkva z<~_{KVHvW^pTfMw~VME>7 z4eRO})}mdpu(@spcIne@Hq(KDtE5@nBq@!M9vWV@VSbD}&nU?S$C#Re?UN#vI@XET z#W#YO0GNphNT(cmX}tfrpv;FIU?k=P`Gm(gwp+6ilz5Zv#s13>U&J%yng*I+Pa>9J zLy*^kC2c6ZEM@_HH%D2VHJoq2qqDNub>mfbS#Olj4cdcPR|g(Be4=zBh6}cCS`Q1B z34{x_C*|sDxiaKBoK7Jar&9>FRI%lXVbf=BU=~!gD^P4lMhaJSj7Ybat3D~3b)_ZEpw>JJon|{=bQzIElEud83Zx?$xaEEU__APqU@2s{(M9HH))LF1#0aqwuV$@5GLg&d}yjWp{auoez8 zf{G8okjUyqviJ3gctDbmL?e(xAD7{pN51*H4<=6#6EJD80k}PpQ>a~L^e7_-5>Upu6m%Tu zPm?}FFeH1?3AV)k>N*!{yo(jPL9v?@yH~NTianv&Zxs8BVy`H6CbChUyU2!U@K&CJ zrs5o3OQghWtAXDz^}=1ubX3}{7_a^KGuWYhO>|-1wr`GXWt>gZc2=iW6nXJ2jLyAv zX4a&B21Yd-;ywOsP1~Z86}6ih23DsYg7G|f2X1nz+s>GTz3z5aw;eOSI`uKkIX&7- z{oN~nx8%aF;>k5gWl~TbYB+^8s1A!4mkec&Aztc)Q8k-pU_|BNHK|V|t2ew|+8C=z z%_v1>Ng}D+|5e#7%I`vtIHp4{7Y?W#rT>Lf3DvAe5^Kq+{oHg zgHu!fd`q9|wvXX8KUVYtU${DTMv=GSqoXjG9eW)36S=)jCzQ%Fz0?V%HE@C+U7Nb! zd?1?D2iK(XYs&9$9_FP^#ZG;Pda2{la>%PrRp4q;b(;q=8|RE7KIX;q%*T{J+guZT zpO-qlOONdzJhtS*RzG9PpKbYR=-FP|ATL$LXM1hOg`e#NSzCkEU6Nkvy&&&da$fo0 zN;ZDxy`4L2I5oHidoxUujSLZ*>7|4bYEmd?I1uJko^kpXe0u1~nZNqQi^tBu=#^==e_753Yx)tLlIS$odS-Nd6-A_dfDll zM>i(bNwHHm%}h9GGSLDzW-|;Lx@fA*nkGzmDF0AX8I0l-^QO(;(at_W!?~7AOJjC? z{gMWqCBQeJ?j2>Kb2G<0^AQtk2-Kmw!aSW0j^j*}iM{fA^#L}u%tonR+0@Y3+_1-FXdEd_) zU?Tt7BY-9l`H4QGT+&;>R^?^{Jbi75!AyV5zPlN7VR=NZTAd$k7+kzms+#@T{vN}6@qyF&h>nm+B{n0RNO(ac?$4WuRV8{C zC3=;FeH8qH{NuROZa#a8$Z}~$F1ca`K&b{ucH#PULGA zwYDb)#uJ103;$9DUiE+JpZ3evv|qw+`Xfp0sYL$)gF|^iOEXc>`dci4(2w(rS*mR5e_k@2l zywH379#K9RG>k>G{=mej;zaD!Fdv+d^_NFj+8OVO@eTBsa9$cudfEEgM64qGTE?4R zwEiUjmG_S1b76k|`lGR2SN2RMGgRTE2&Z%*GqA%AlZwzB8)XVMyeJ1tkFOZ-L+4+H zbog-)>sB{5tT8o*)t>_h*k0mGbLtqDAjUDo$W(h9M>_;J zF}uz&H&Gc$cD3^!hjnLM9%pXY8%?_?xRdJbEOV!9G?-pdN9XaI!X+-!XZ>Y~d~8CR z>2v?k{m*^FJf9;{yYaa%nVUqFr;CctKKGC2&SA;|en#yJZ)EgyZAH31F|IhA3$_+T zVOxcwu&qCY!|Y@#&w%y!hA~@nw(&i9W~w=NbXs%Fu#Hg7xz>DfEzF$}*=o-9oz|Rh znM8t`BZ(dht7UvwYtBvlr10lfB~6XGmUxGnbHTh0tW;<=rza=-od$+!D3UpKkp2L& zf4WFM8s?0$f2QiT(%i}+72V)J&ZMEMsQcCJOmnB~-<_$t`6D$Cg+S(jx;cE1Jxcw6 zlbl)R+>DXZa88-oPt?j(HB@hh;0$*Lejj!&%?{cmG;V0R&{UvRQ;Cy`p1eyVVF}Lr zandXx<4(bO6wawQkH%Snvl1r-K^0C4KMKZLoHW2F^k{UEyIFgV$I0qanzq}}A(Ld$ zzSR!ym_~<<8I8l<`L%#(O~8la+uVcuhr$K2mdVl!>XH5E|ek-;V2a*elIvC9?X_GA+87R7E= z>~6(4pI72>?yfxJHO08hpI`%Q$aN+wc9de(iq$H1o?;(Y>>G;RqS#%E-K`k6JCo;f zyEAz|H|Aq~ZOCU7&yeHhqAXAxWi(_s5J6zeQd~e1}V0WV)GSSpx8>q8Wqbg_S5TaL$0%jV%X%y zK6jF0Qxx+Qt5K{`u{DZapx8x<5b7rP%KkdtR|u75kfFPoWE8#c;}q-`Nm0cZdH@@|m7I;ob3yO;l_`u#3nJh#D`_ z$AP+K4%Bz&JAV7m@8jsOZq^K}6S1g)OTaW5cgmv>SLzcA`+$P!q4fJaH^f*J{u<+c zV?mxQQK@-z3~vuD$-`%c^cint`p{>7`hG{$czJ;N%kSi*QqqwYUxbC27;FIL_b&z= z2YP+d7sm{_&I-lOu_5fGr`Xks{Zlbyib*BCN0z^TJ(B;BW9Hy{%^hYh{QTz%{*74w z4vx5>=X6oS;(9C{ZOcK{XKHR)y}V({npMjdB}diOEnL*FaQT?gqj)_UJ)+WQo-@vv zaffh`J(lm{WsMkwOAo^3CuJ$!&bkNvK5-^siz-u@@Y|z3;w=SICTl>MC+C8)On!kP zmO)Ppxz2-%ageHDrO0)O*WZTH^Phd^8*=3T^8*mU9Mbvc{cAtaeG zbKf1)!^~v@q0Gg5zlJl+^WDkc@2d&IkaVyL_D!TJ*ef;^civDeJo@7wKyS#AzqD25 z$d$jlcn8FBi~u*fLE9PhXbqt2jCI{o|36hjnNU zwAq}~huMpqnq@gu4F_KNA}pi$3s%W8!-DF#CoslKF0u<1@1EgWqqXno0e_EsQ#mB`&*9mSBbS5-SRk}%BIma(Te+l@ZAGJ*Ml&P6e-Gs_6X<^J z%w}o)9G)7foeasCOu@c~tP$)j8;U#sR4gosJIm+o|Biev?rA3V?GNO&gb6&ZOg&WNz@8Cy2j5T;Wt~h)C*)x+Ag__Xrw@z2p~5< zKfQwFuTA=r0q$ThZ{V9afa*PT2b{IAdBXM38*OrX1Y zoQ;pCA!j9z8In8}jCm~B8#WYon8$*J^Z0e3*W}>i(?=kJIl9KjIxKeis+CK8b)K7} z({IVl+qb|uo3Xjy)dnFG=x)Ae&@=-C@!P*t0rV=c>_k~@-QSJ$QUzQE~kb6Q4hGY{$&{-X&P1n3C zr>3(9vOB7oy5m*(8Co>fKZlU(T#xb<>_!_(w;~JBd30+I>2VPFOpb0ykD$Y+hm#$5 z*^Eg^s4jOiBJjKI3Ik`Cy?aN-Vq5*(o{A+V5E4rn_>NX>)SH)0GW|p)6GN`^3vioY z)L()P0j~*`w4v_t;zyFgi5PTa3MjL4KClozpym1B$BQjJ zwo-I8L$320xKpq^p-&|N;wCQmO? zdCHLRsbJ(&!N{kAkxvB+%hRKQzK}znI`2oG))^;N%gTjI8?X(~qB<<%*I2K6&C0JI z5RaB=ABfe`1tau7?87q4+I~HCv@n70@^Ci$^mi(28FHPz;77sw*^uj;tQbezNxbgx z@Z9$!YyZQFy6cknKkUOY^KeN|d6)@wmxr^-;g6~uW=MEgF!Hcq{EmD@F8*Qu}w(^nnU6zbJepKdiZmsB{laC2>x16)ds>wrryO1H-q*yRcQ50;g z4aJ@F73)qp*CeHsyVaKNapwQq%lYFyEoUas-Ez)WpEqiKW=P6eFqX4mEN8)3&Vq%@ zc|V|!=IDJN_kQfEHD>%su#Q>aQjxJE-Knshr^!ZGCD%2V_oLCGiMFD<iR}IQnZJHP|9GJ4_4mA!;;P7=$uut0*jO^kd0Q&0-kg~ztqzPDicVno>3lPJ>jIy ze9)0n5u7Wbt{D70DDkU6$AR9gwUZ$%yM{6rjN{4$WB-R>>@gKAEJ-`#i}^`B$Q-sl ze#jRY_~P}R@&yy(mXEn-7ux1;gJyuzy3umrJ6M1N49XT^i1&LDqEXIq< zVGHxab>#k+){%qlgB6i!?PT3mz984cUre3xS^lJCAmKtgtjlW49R_@m2cxFXudv<% zdGY^1$(v8u^%u5cn1^&CG2}Ya!PA0yHiQYkie0T(SjDYD_2{2N#hv`Wsp4$m_gKAg z1YVES+m%+}eIC@9y;k6zq3VqxtZjjE6pV^auumyQMJHHx^>!-aL^&a>-WClb5Ayh* zQg7gduBkQ-m-DB~y&u)~MO)He0;OuZ+LrVKTFV)7u|A^X2u39*Shz<20{2GuY@yWP zK@M6QnZ(sY+fYnGTVJ?=!Ta*u_`;Gi`TY74+6^JwG<QfJJtgE2Po^+KdlAwggRds za-E}5mV$AaM!~3i1Y;vhuhMj&6*h(0X!6`FG}h--rS$788ygNGS=N&_?vlhPzcD@Z^V!UFHDb}65+q)-u zcT-REj#F&?yklbB&%1qW-tBAiZm7+>s-&NH3`yPz#=H}Zc_$e2POxy^Z3DU_2j9&Z zfe7YE<2%(6oTD1m4{1NDzswp(f1BMyUgUIIKR=mR_wzFwFTMlmE%lfo*ZCB_Td>dA zkn237*mH_?CqI|&>inGXey5lEMiHmU`uWMkx}Trf_;ZuWMTR6l1!H~+#{3kF`6*a9 zKYtBrxi*Jg^afIvBaJ@;C-AN?QFe*j+V3;oU3SziddXz8!p`%0SYbJX#%C}lmd0Q` z(H$>pePzgXt^uzIcAX8m&MS(&p;&kLYmelI{Dn=UIk{_B)Fg73-+^Kk!qq+HuaBUJ zeEwo$-R7@s^6OhFzZeq!5{&#M82L*u@|R#?{(1}Ol{w_s-~T1@YqyL-kE;D$EOU3u zJ9pr|*;PH1Zkz|>a~~56abHhl+YXg&47mcMDerM^i_d#Zted=-P43;Ka*rY5J;BI(f|2(GBku_omV1*B^H(|A6`#%A zCfgM{CL?e3(7)S3Zv6G=9?A`lGxp1liFLE=vbACER$nATuES+L1>0#uSfLzcBiKwE zN|zg*mEGVRa-)a&{4XiHDHS~|JB}Up%Z`b4v+T0fyBoCLF(hRt7|TvDmYrZMJHf*B z?j6LuDo4HBft2Ow*k0<)rGhfu-k+8J?8FHPU zAfp7^Y(uh)t6=?+{}M0Uo0vYt^(ovJEsY|{emD;u=h&pZu)T>kGmRANEMt3K8eQwr z<1k!iH{bN?NOngp9DZBW^B3lJezWhrxpM`Fhdc=?nLlUeRr6yR#ENr}rtu}w{rA{pJ%1;~ERKk5ly;ST851WVX|6;ER z?XBmHbef0kGz)us<#Pr$_4QH}5@o}^$qowpTxS21ej>ynH|u4Bk`7Adw=F)vkF1lDej zy|S|+7=c%h-*-ef727|UqYwW66jq!ZR*s?A>tJNr0k&a<@c}ixjJv0L<-*2>#imw0 zUy-F&^#yMRyGs6GZ*G58%-yfLrl)uVnVam+XQY`0rjLp|?jOu!P7sWNlEZjRu*-TBk5OD zhS0%)-vnE3L$Xq^VBb^BYnwN6Ah*s=o(io{;iXK5coXjR+NO`3RJq};y!$H8alF(! zUh2t`E7~uvJYST;gf~6xaeaKvrkauC&FwXtrjH!O&?s-y$=Jymq48eoQL92y(+O4K zNmbB1CT0~jgRa5@r!#@7nK-GA7c;w~e;rvBa~1&mG0vFt8T`Ekyccu6iO{VEW3F)y)LF>cGa}s3 z4xA#Mg6aa4j~v1cQpXoBTi&psW$_fQ;4Nk#L;g5>v#z(Tb<0GP4ffLbgt|$XzRhYf z|0&~eJ+*8|snKM|;xXoTZiFbuXmeeQ>(K_d((HSGkV(Go)TPT7E;SJ-_2l4gqf^U{ zK!Q+oGZ&a&spQT!Klg#^oL-hhI2>!G#$s8!b|x@p3oyx+eoj%@wTOhJ*6W)a>YCTBZgBcL34YZAXDH(4HevnhSqXOX&Dl_u?2p<)KILOsH~hy=F5AOALduHuqtafpz6AASrbS7Z zhpZpHL7D43{szA0%f1Q9Z2dbZ3+SJqtdsA6GS7L#wB_iH*7(#i(@Mrh)-rjx zzOk`>oxalu6Y($;k4eJ1<`N43zoU50quI2Pj99_Xp+E2Y}L{uqP-*#UN1T-`=2fC=3QY5Og0<%HE-%<)8963TJW2&L@Kic5=4%1I>BX3Q zCHRCdGOb7oZ_s-?cY3KAKzyc=FWsVs!RcVfA4Lq;kAdacAUPX!8ibV`)-W*ZvIlG0 znaeD@H0*}?-?mvT+KNhmlOtc5p(@HZiT5(^Jh#`#4kqzl=9Z70Xw+2As)ec!rHG^oe<-OQu=Pl3-UPHb3pJ`H4f;vupuW?X`C5UtCF}$vusp^Xj z`(?zO{=EhUiOj@0A1j;dnwBkCj$Ogj$$YJexef|zj(KYjtt{@WO_7=X?mf-U@z~GX z+`VUBALsYjwrFUF6efn8fAfZ+)xLgId_;Ukd`x^%+>4Jc?3;+i3j5?2$Hx@92*%eH z7A9i(d)Uu{0zY+W176$L%+!mc%*)L+A3$$?t9gZY^J32Syo~w5OlIQ{OTwF*W`=G` zINS2*jXW&$o@We$=OVxL_IP1@I{XWZ@VcW5OY>ueCHe9AsKP{keqnKbys#+IH^y7X zMQ$z3&%dAyo(bF~9~s{tp%L-n__X|3&QB{t-C&c14AO!y^VWA$vW8hR zg%HgY)*#p;tUUm^c2u*Ku-nz3g~H|*Mio8 zUI)4W^ajvY(658iAo>RAwV*eG-VFL}P^y62K=*q3=zM#<+Fqk)#{7Q1y!!zVwewAQ{DaN_I zf*qq6y$^zMITN{enPQhHcBx|IO^J7>Vp|n^NU_%xds8ufyWC3`k$tXWGzJB0QEZ)J z;0=54mleBNF_g5uw*n@cJcFj4q&HKslND=GY@K2o6>C%MH;O%@*k2TTMX}Y;!}8o_ z8-jtjVco#elFNfV$R9vaEsZE^c9ifa!uj<*Ob~ypvhLEhlIV7=sc&4;P}d}zP&TYw zQop2Okdj{ z86qtOhFpgpP{A&9*mH_`skT;JcpJAh_qL9`EhPXdz-B=Q_7)(~egV#tu^NmqFea`c zfeB5MRcv`!+pwV%V#}j(Gpz^?*=aCzOIy&if$=Vwn7b0@$GnR3Y-HaZk?KJ`z~f|` z)M#>iaBSI{##QW(h}yCAJp|lv3V2Se#|~x|El4>|$!ucMq+$lqLz25A*XOB_vfs-p zdm66L?16=+y8U8#xcSSxW_6}N=zN2qI$P%24$9Z~IcOa87ocRuUxLzhcmgyDiup#Z zqd}hnr9B#p zb*R4u+fT7p#V%B=hK;{_wE6T?{IG9i7*uaOh({sLdr@QL5SIJjnKoQoe|Cde58bfk z>}jUGWf;iVrDRJvdPA56!w$y6;7jCpW~yRgo4sMG79fT1qrZMX+_XPV-W(q$3Wte@ z<`}b2kbK4$@i`e!IRWY^s)bm7(W&PP(ZdedSp>>*Z2%>^-LL*ChFpiHkzh291OuyE z3`}mZ>dns-fRAeO^T1HbO<%?D&qoAUcreQMBi!^KF!}_>g>nK{#;;qocyW^*-<5R? zcVG3jLf)MqH>5j+V`)sY0C}Ithk2N@eFLW16HG%XM5g&7vcIZ(t2e)^k3OPenbKr*e=0%aTt5Xr9E9j9N#`2il)x5tbE?pP*62 zw`HS@U&2Nivxto`#(7uElOfkxq1ZV#@vTi}EY z?95>~OY|~Wq0;KG=Aa~zsUk5iSfJsG)DBAxkh2*S#qZn$iV}0~17$%jP|J-W8UHER z)Am=_VYLu!qz$FdoPh_)86D~7<~#5p<4%CAm&3LIKJ4cHU+U&Y73i>zbk_dut}bfD z<+^?QA=I6lQLvF0qw6X@fG$w-k7lCtVjZEFpL0y#gT!b_ws7zf5vzPrz=@E(rtXFI52#lqF=>d<#ux43cD3S)X@ zU8=Ce=<3G@7}NNqWlNSu2kw=0qO1L`oNpkB8*%y~Dzu&<)j2gWp8{)4p5m+Xa4|7o zqW0LqaS>aGfwKK`I4H%|BPzBSa-HiGyTOKB=N`rGQ;cmMd#?>qwU@P?hhFx*N`|%~ zBCcIDn$Z*Ax(*iEt8ff%*7B^tT~U*4ByYko0_VD9Oqx{vXz-lGB%O+H1F%$ z9!CG=N1|z5Y7BAq{<8GwXcBj!f1Te6YveTJJpW0c%s=u0JswkV@<3-zE9o{+dWjzZ zWs~C(&?M-?pv-SxlOGnUS;vr=b%N2X6YK?z_mX1oDu(a0@%q?M++p{d+i^ z-%%x}wtE|YzP9)4UdfnyUK{|v+3<%vZ~G1}eh;Dc*GuN$oS#SQ-+8^Hlx=ip!nTrw zH#hG2dda;1XYWe@qpGg{Uzo|l%fKW+H7LjcQNyC_ilC6N$OM8!c9j}p2$BjUCP9H( z4dOzaV(q@SYB$^3)-JZy_Ui{?-P^i!aj$EO*0#8`;!^qle)rsW=FQ8@B#_`||8ik+ z&-=am?z`{abI(2Z+-)a_mOk;H6NPI-R{)QV-VqPO>mUB?0Z?m%j|lR({#xlze3 z_Op;Z;{sY}9YTfiI~%_RG5j&^P^Plj)NS~ z*_Ef_DRU4C>wR(rV4#r$^H5*P40p*GozRxy)QiCy<~0#RV~#^jkWB=uyRX$g4A5ji z)(WOCPOIIL$AjAKVzl1m`=#*7`^#)=eyO(Rq-27>U}vKC2)5Z$h0eu_U8UI7igAjb zJc}vc_F4a=e=b`x)jW~k9^!PUs>Do8#=P5%VuI}>l`djS_Xd}7b#)N z^&Bi%S^$3@d@fp=gVjw7;Ln3Uvkcc*wzL5LJoq!Q)M*aZGcABWkL#Ky%Myb21(RiA z0S!}Skd;YE@mE-|j}AzRPaza%LtKvEhlb*hafc+u`%zLfUQl0C+tSi-?s_8~0)15u zF^C4R*=hhDw-gz*;`|vIwZ}f@0nSk~?VfXmS52N2{#T{d)_r*|< zAqLu1`O%EwXy35WI+KP;g#}DxN>U?-`+_}Xf-Q*@6hy)ie+qgJ<2Nh`rr;mQ!N51v z60s>@Dmq3#J5%(tyAb{9okl+?Q}mO%5Pd};dKofF4!^BO289L|j@FV+$t5Z2ql51W zlr$TpappaBrkn=&3gBtPABhZ%go_UIp)PYj0)_+5g6ANeFWWgFfal;^OoU9d_j8>y zsS7&oXhpKGTAG5fA2NHiA7%<5Ix;!ghM&w2BX2NyWCbQ@CVo};&BxDc8GZI0D$#5i zS;@5X#F=owoPS{m8(_`q#^!Zc1);5FHE&u+InUOT#_U-Zdm2hJYxFbl(J6DDg%2gu zc^*F7gTKJP%3fb>uc>6;u1Yp3*O}YP!)P@UjP0s~J6o|2D|U%uv>8b_%(t`8Vu_W- z-cszOkcXXODeP3G*#9ba1e$+|?wZF{-2>#~~gz8QFe zV-7M@Twy4DiJ6+>g4h_aHn2dwhCa;FHclG)9m`fhH<%}{;bAk5Sa zM|u^oGW#b1(DoAPyUeTONBN%I#3zd|DY-6hP$V=WZ*U}UGDXHJ^D#Bpok3e0NCddU z?RAdB5^p%n+78xrglaDf}M7kL>aUek`@;@%syY1<3j{ z@%uP_pT+O<_0v(-xRHC*=l{Ka>TuutB!j48%c8t~3S@!{=0|N8z`?e+)ijBu?R9 zfIO3d0#eu}Rk7}JItRP2w6J)_uP6uSt8D(`5s6h>4PyGAi?6)oYORP05? z{-M|;G$9i1Buh#6PcSx9q+GK%gJA0w!<1?JEXL(+I81xC*aM2asu-ItiSK4KNmEdt z3Y}XlKb09w~Hw5VW{7&|in_d{*McbeM7+QZu58G#vT&@LaBXw6^G;0xKLhQHSf zoHpKk13q<@|G;PS^$vW_=;JjF!MrA0ep=a*lBk1KY7S$!2My|@F; z>Wq_}yOY(yNzbn!k)35VHm+*pxAcO~tj>eatj>qetmZYdn%B(gkY+V0$!fuv)q*jr z1!GnVcAMBFUj_gkbM6jsGP%cdCmiKbHhZgZ01n48?4EAsGQ&Esp4e103t$ zgfA%a-F>hB-q=QG9zYai%eId7ufO3Sy*WAyTU?;c9k})Md@SKq#gi+`F4!< zIO%H@X&Ed4CsoK8c*1kpSnRLLVx(NB1Uw|zAWNmN*bMO96ImLAPkPcYjg;!9SV=o4 zqMLCZcoCgkt__4&M86cB-!tuGfcL+MxY3|AB&1x2qnU!OuvAJBZ9}=021XA24GAq= z;%s|;Xr|lyX{K9sW8J#insXXk*L2d_c{Ad<;~md9d;)y)Bz|5i7_fMfrBW=OUSk*3 zn`qeti>luA8>=_nZ}p~K5Fx_uq+EwvbO?5>rNpY|ZQOM_2Iby>^$t5ioG}?=`v+rS z|CRzII6ie}JUZvD_|!*Q2FAC%#gD)|fbD~x;HMMC2qNr@4`EwF8Q$ZbVVuC=Ksm5e z0_K2{DFNRFbsZYyhti`sE3_^QYHwX(Skcnt%Xy}b#H6~k+g-zV(9XGz>N3R<+-8U zyhtQ;*awnvE?B!t=PGbSkHe1~oPbfz#9Ijy;b+ZtUu+2=NhyH&xc>Z<$7mzG$OJ2e z&2VNhjC;myFn?25gM9~``beZHXdmVTn#i(&o_*LesSW|0*}@pZve~0x6QNCm@rEJo z_{l@@I}JZZN~t&2fh7=`?z4}uV_1%#=U87U;QZFQlQFS@b$A+l=Js^>*TOG{{~deH zzWRNT1|s-Kxz0QY7{L};%5~0CtVS_Tfsk;QD#j@gf_*}~_WOQq1f;b7uv`rK1z@XeN9-pft+hG71X;w+97V#ae9pP17^hoo}dX zt%1c$j0u4*WsR{da7&4I?ZDj&8XH!{MtZva!uqxK*zws^$6qhVP#yb#=aY5G8Olr7Q_x?(i`%CnzREG=_1;r9Jmm}AONn?i4P zW|x`6tgHzzM~`njG&(aweBtyiF~lG6fj)+?I{|f{AsDa65KKxBF~r|hJtO5h|3dKy z_J*ZgXAH_zunCrOoy!#4rkG)f_8b)y%Wx+rV8Ae<1TlkOo%W!hShBtW`|>u_u5H*{ zk0uC1PK_Jv;oBk`Hmt8(Q(t!;ZZ=@!J}xu$TP5EkMoRQTM^3{uaKAJeSe=1+y1KTG z5%`L{!&+wMYfuP0itW?^JCDII+ zG9)ALgg0+l`}nDt_Q_bZf%qZW&E0!F)7z<>L(br2Eo{Z2-d1tu#DeE z5q>jE-5uMlGVU3>vcC*Qb+-%{K@XL|>skh+T<2corC`6als!((gd2b|kZ{2=cmkoX z%u)vb>{c1r5l*!2LDRo9_h}e?{Gx6$IwSC9GQO`nyxyYuOv*KRIi{jy5}Db%FBm z+SoC8_!4yC#7TQ5T;A0)OBU8+dlsW)oBnRb9m>X{+mY<={u1wugiS}*-whrNMKW|G z=J*wdxYI|I83Dz%svDE@=mwai4uSaSrbb06))6a*`j&uQh=B*2#VaB76BDyju*J0TS_EAf@IDXZ` z9#!n$ioK~=HOf<-U2G{F5sDp^&7Q}`%e+sT-SfEGzfl_Y9JYHNTi9%yW@&t9#=X+c zz&*O<_;CkNaaJjM5A0yEuq%6|oza!O($3Ijmz)5pd)BffXfEOQv)S!29&a7+UTMs0 zG9IV#T!bGTXLr;8D|{wnH+-5DUxd$U@;CS;@G+IHEe3xNd`vWVUWR`h{5RpB03Um2 zww1$w75*%X&xijnTvyv`GVuc{xJb!fX@dRP-o@LIC4z-5C3~d_cC=z`8jdCai7(z> zyvyUaLZF)hLW}q4_^s7L4T(RN-|S2|V;&54>$^0I&J4>hs;@t$HHeG zjk7cB9?^0m#9hQHM%}%2=lNCb*!{e`x;?o+5u>gR6f|eA z(#7$+xLd8$qAs;fAu}G4tj(vUX{$msx^`%*#-Ob_%-r&~Zogpb*7u0c%(TTA&yYEn ze4vwNh^-Lw!*k3dwnF|Xm)Ho;6g+J8X03H!_(vdI6h2!cSnk^xM?d(i&=a&(BIROL zmxoM95#uGl-DEra}3;xt(^w#9(Y#m{ga} zLGj=uw89hRNVG5~`u@RWoUWH6_lj;L;{*QnQuTbiH-{HOefVe#-WymiMK)sV(izVt z_rznG81V}+$9V}qPnPkUtt|64jNo_bymxN~fS;N9Da*kderBF-&5q^pd*glue5zKw zhUhid%FgV>Cwll7W0XlSog^&uYxW zY^+8WBdf74k=59r;5GByW3@fXYNW980QUr2Zz?y^bQ;hSrSOmBsgX@17qs}%L-j^P9($hcPPx4>UJ)LwWJ?9i0M_tTU^BWF0ffel5* zSxfmwH9sBv&tWsH!0v3Pg4UGwOje-R6i)UjPQy(^+9+{;(Rl_E#mT?SUmjo3$pUu9 zaF&T7(?$bBy0+24^h`_jrw3DzW}|_5z7()=?YPmvm`u@+=|c2VJB@xwrs#)sA$m5; z{%sQY1^&rqTy+nFVPU>+SBXf+qKXDz6)0?K$zmZq!)PG>OnO>g5h=(IZ1%v_{a6JX zHuH1xq1=R_S%WfDNj~-wlo?!#DKf4Q1r}WJ_^EB=AX9P5D z1Y?`B4L{FO26Hx=-;{JSOg+5+Q~3M{UbDjSn#$hK;4>?EeXPA+0RQK>hH>27$4IWZ zu7Q6G@H%^auDzzrzZE!}@7tici?UA2b>^V07mV}U1jBl6i*bINU>g;?NU`>>^8b5-n7#U>#GBrPXd3L9rC_I1VHQf!}MpF^7`&wj~Lwr6}#+Rkw$ z+F^E((OEFm~rePRnZl~>0%bo>nNu;kk5(-tahy9eP{6|J21^#}wZ1Zwt zO7jsAz3kJlMtJk`(u-ci8q!*9&@$-`IT4;f z=KAHKi9X~Mp1@vzh=1}aw9-V+&b8O|=PR-cEN=k-1r}e<_i)=2uUEzb^7YEt*=3=m zbpJ&rHJSIyAM!QVyHOObviN5pD@cA0J}RffYZe`^Bk(^DpV9NWzrChx{{pTlvv_~F zy=Hy+BCbcn->I^PlL+t0P(PUyf%<8b2EW;a{Kd7+Ow`Hzb~x)Nf;< z<25TLugQy9Ih2nE~KyDbu z0NKehnKM@cnHk6#W(Lcf{(aJ)1C^39t7t*;QPno=g%d`kv6978&=);c+ATsQZDwSbDXIrmoBuF>ud!j;rO)@ z?n{bYt62FWa2u?0SWws-n~)a7M?DbV`pjP4u8doiamzCQc4bF;+m&&zG8`*ywlXc^ zPGo28ve|zUUeJtR*jb3bC|*$f1R9|Kjc*IizGqL54FUaap621V;?-c5R+hCn|6To$ z#SN=AfiI^OzdAz|3U5m^(Vb6oPK7FwDzST~bT4|rG#we)ANzTw+3)Lc-+o^uUPaEb z-Ubu)kM2*m>BzpnSHwIy7qVHNC zY@qmM+^&mDlNkZ?dIuQPdP1-%mMV0nDTZE* zefF!0u`!ZocPJJ`y%ns#rCevYV#g|0sn~qQ*ujuzYZdz~s72tmLgztCxy~yZj#5I> zj5!GQ*&<81jwiN?y^WRQiNagS14atH0K&+99>*6pV~Zk;JQ0+O$Oi`cJLG$cAT*** zA|Qg^Km8pQO@Y1+m)c6b>lYA9krc5s2doztE$u^87FrUU^@8L;W2bv@S{G+8tUt;_{Iv$amRDy1NKW`ZPShL zV0vpKZ(IwXI@fjZ$tTyt$IHw$tKczsqiBJoTvN#eW6wme(=1i!EL4o+{}L`{sU(Y= zmKkRSPcwUjo96lL?l#ZUkXES?6hIaDC7b7oNWsE@cC-Q^`2Fh?o;#a9je$;O zsE>;$;f_HL0guaoxf3{=U;$ddH!-Jtz!?b(Dc8|*(>}*L_f^X;pT`_fRAZG5#pVS%?Y}~vWGX!P292v|^4m55P zwd%0&e2v=@`xdWpdj;3aeQzeO&;Z92R9XBnEK*~QeHK3J(ev?OtaDAotHPvR@Kl;XOsvmx-1ewjPeItCU7E`w7I0D{tL$XFW6TtRp@+8v3C^fh59PthFGf5 z8Ln8fVizcOg<@AJcB5i9DMsa4(sH|EN1=Xk@oXWcvIqscB`68U+9zpQq1Z~r{JV?~ zJb zR=lQ~0E?hC@La1Br-PxPI-qzB&uVDk9w&=UlvB`6iJ7hok1dmQ6ado=ivk;ov%_Ny zicp3RLpae_a~#xMxEgeZPD)X{{N0@yCfAON^zOqoW!$q91{GaXR)v^_<%gwooi;*z zMRNHR8zK8t^3ZA~XpDJzf%yz(rzA#Z&310uI05~o2x18KmtKR`$0W0`Cn6C{$XhXJ zE<>@>2ftMLKXJTjgk&tA{NH9$hmQp}`8roCEliK~ok}5~G1NWL@#q_CkIGEA^*Erpelicv^QxB(Ea z5{?tH1>+9kf^mm%!L}*(QN_Nb*tLq?rWgi;?6aJCA@OlfB#Cbj#g-{n zr`WlQ{RULO;r!kQEaf^c+q;DhC9b>!Q;h68iY(Q!W4VTQ-`&VathgwQ|Ga&hI2=(` zR5fa6>*r4{p>pxZt+Kwv_f}K(N=Yw^{9n7}lpsb%i$W6&XNprAeSvpf&mel_IN1P3id8w^Us{Q&+ zlw4%wjP(8aQ}%sCct#(m~^)51%W1|bK5m1s0D4;UK%ntDV)_Q z{JO@O>$6>ZPx|}u{=wBZm{q-tz2>zJ;<PuuKK=w1>?~KGV86tC zu3xaTv%k`!^jH_u$#s8cpK|>OgrmHszDT)#K77h`%6H0j%6H0jzR{EG<@jEa>!e)H z_;UpNm8D#s^=YvO6&nLdE8!+s%5|z0Tddeu75kcEoB=4$at5Hh_YuXOQ0(uDy{y=W zAhT8uXPVbr%5|;=CGkFa1s6A#ok0Z#Px#w9>JgaR#N=Kc{DqUNsn($u7O##+OG%mZq0p zW&0_;Doq}ykzSrPa;OQAW%O;_eoL@PCdyQ6q?eAaNU+q=H}A|{t+1(2H4REI^7H;ku+tEp5{yj&B^V9qlwfDUrv&30Jqb1$ z-zyS~lHuN52Ma2>H9vY4-RLVe`G1wjM2%nlnN5=B})}LdlU;wu!a-~_Ve$4$GDN+V8-h& zLbdGWQ!Td-SQy{=OsFRW+>u7WH6V*cz+DQe0>7ky`xKJ>*?@q%5+Nwy=r06|iR&of zIve*$E5SN@C@7-lL2*etU~)0$#$*>!FS5=ZKRuFHk+I({2ZD9QJj&XUcEH3_u;!Qm z85FEwpS^PhOZtYX;>k-xSHx2T#*>nh1H30QiKiEsRY~zw)46!6?l@7v8%x=Z$QU8> zKcjeJx%$LYo5{VTf)x}_v0mp4{R^dRO_H>lj=SgEyWct~oq9FkjL}0e;gZh@?yuy(t&_vidkLr+y4kpH7 z0c~n%Ruf}2(r}E4elpB?5}YbYQV+or?s z2cM0^5%3ql9|V6P{G;IW)eJWp{tyTu5l5t4=Q_o{VJX+SS+QFb%R@29v#zCF=P<>N zP^?z5dc`=LBhPX;N8ZaJUcorTE7(@rb)Nt9G` z&j2%f$9s9I&zayeV2zFf_Rj?8`ILf}rxax%Sed0Hf=?RK^8VBlxCDc(pE_U5KT9h!||n%3DVbuXJa6aJ3#3u z&a8S&sAqg!1tyOBTgbuT;h{3o&AXH8$Cf8|!r(v+C$cewZ|uces>`pzsv8+H>W6S8 z2xmbv`a~?2#7wGu12tv1*HfbBOb6MN!`N2AMjM2lyYmQ}S^$sg=KQB^v*a_ar9OD6n%b#%xq41=^^REkY2 z#>Cqjv4*y>Bw7@T7UxHc=HU?T1whWzlZUAB*AijU0ae zaXj%S9MrQL*@fYiJL8EeoY_6$K6|~QbY(oTwzP?Z^BbW`R@dx0904CXl49ZtP=AK4 zBkX(~l#G@91k?}kOA3)j2(`}ygvf6Y0!@wcU50*Fgvdb|Z3x!m9v*BzC}~a+F=kEw zOzpv^wvW|1m#-SdgsIS&-#5rerLR@+5nGQ_rI0*C4O$+mHiP7pH1?sCQRWdQ;;#fG z(+DG(Z1^;iN#1d~zGFF5+5X_Cq^6!X6jE;@RsiQl@n=e((A2_{@(Ln_y^Cx@(4|?D zI&w{UfpsVlU(nE@_u*I`4!GkO1t{<{i#Z2@t?)4>*n0HcPlv>vRZNlO?}SXknK7_{ZURHW^g|gCp2k^7u#Gs>EEZX5c))D z3D&_4F7(4(&KFvV_@f<9nqO~En$NUyZl$O9`;)N&+IysMiGTU{lYsE*wyVto>@bdY zNtQ}3dP0%V5-+AqK6@6zJSMMAwhJ}(^kU~WXk}w?>DS6=*(kz~Jq&(3wX{qppa(U# zRwS6;k!j5yKZptUPC%aynx~+1m}&|{*OM_cy~zK3{7UhgfFDbnjBq!8EY%ZHTr5Qv zTOEF`Go`p3->?8I%;s_>Xy1qyo69wTSOZd;%cdl#&E>`$+1&f!9?Q$0P;gr>4b2Nl)l+EyBYXHACx4Z`ogU0@$OWy;EN z__GSs~pXWwnJrlpu5A3KIn~bN|{dXTA8x3dR&!TQm$EME7<>{ z1`Bqtr3xLYw1VwX>@~%xMa#3?u2jO6DpsZ#+BF+)vSN!BTdvqD#nveH1I0LYE$`q+ zjl7q$js&|5`l4XlEaf_ngL)@MW&SBkxz0@xMz;?o_7h8CneFzg*dUwkY&>xlo)DTX z_p3%zMa$q^0I?mmE3_&Tk5ILqAKyL~Cf8l@QMb*WaJNyitJ({pgBR?rYL65|iz;?U zi$l?(%DvIzdDy?Ea&P?392y7isMyV!tkAG4@jHDtBHQq5bM~d3<%&4Xy3=zISO&Di zpeSf_K>RUa7-L2Ga5{nVSo#TP~Rhw~)zVIwhA@jzM{o2>P2!d6pIPY$x z|4HuP7#SJ!hcxP24C>oa5kG9yx6xGJqQQ+1LQ}2!7S5+u<&WQNd=MS&DO>(qMtzIK zI;d|kRo`;`!9{(Gc`>E)GaH4+!bv4c86jmkavO&vQ(FhkhDQx9*iEQDg0V^o#wsP) zol%Ub@oS2U@U*8k`Yms?x-mn8mNzE$B)p#~V>(vhcQCDPUXyTn#wNjUj-$K@n&Y;j zDHsF%a`==(SHNd4@sBx<^P@xNxC7YO|KOW$QUq3t9j9xyxkKgKP*-!n2RHm*mhXfv z+3DCLyFpbuQm%6s>a$??S;}=DR*VXrgyUo#376B$!}?gN&}_IW;W#~7!f|@EU=@nZ zR;*UBdd1FHY=dI|tJp5Z{-W56id_ahO5VH8QZUnj+7~lsI!j@;CiL8^hZ5Uisr@t4 z(K@$0zI_G`Xt+B*>YmvX9yA)Js+jZJi>ulf=fF%iASYT>zPln?3_rdXekBZb)iBgS zFMy%0e794%btjB;<@i+_L*1^*!~=--1>AO4;g@Qk8;oywHejDy!=P|=_zjAYqU)$B zcGH%YR+H;yoS8MP{WR8tbi0_CL>2K2WoR z=x`|g>Dbw)&(1z=dc2O=Yliu{wh*LT#|1kJ#w9m`aeAm=M=3Tu|m9D!f`K4 z3HKAley-U2z)rUb^5*)02=UwLzW=U>kb`3LI>-{`prkpYfcgK)Oy?g7r5!jjU`(WF zC@fx)!F>;z@Uoils7PlwC9%w=7BalHV+?#|55m~ z>HGl#{fCEacJFzc-2s^F%*>rb<@?^9PUpADrj&2jOm?Q%_Jpc=q+I7t)Mvpsp-!+r zDMsZ^u(uVX7AY8qUgcR1y$Uu~F;1uxtX#2Kimg}H%9b+t|mePeZ2o-}-2G4yTh#Ly>k(i$gmiY3lJOgJb8MJu;|BtE#K z`L93Be}lVf{#%KX^5*M#=0E>S{XJ1J|E=@JJ2TGL8_W56X-t7*{S))de7&)lub0LY zcrxefbuEo*QX*}A6M=6ZQ|HwCXm z%xHTgx|m%kTz~$C+O;*UjXe~p7p>iQqp?}y?J<*P4ClMGw8lDQJJvRj9%~mkudiEE zUw2;ps+x1^&uv(bp`WbhVf&kl4}x-^|!TZfUQ*@u(gV(yvW*q zQc|k~W33YGaZ6#@kYe#fPRHhoQ`k!b#%5Mwx(I$04dSFyy?>5dO2&NyTKy$+xGxfebwJFPa-LXdKu zT$F=g>{AKGiQa-$D`xbr_Fm}GXc2NM+_8b~Od;P1$34YzA+E$7Qo5QmZ*L_1qyL|~ zGxh6NW$(;j>ZWg!+lk;CbY}dJX*KiF>kz9=_IeZS#xOpA)7e=!hCCeX#vBd>i@aO{ zpS(Q~KC9ECh+C=?Dc7k&oe-?rQkcl97*#I`m!>*#j%l{)^zWfe0NtVLbf`MPHjuFg zlUki}hIOwx1+`Gd=QT~8^j0p+fe}L83CMK_y)PfFL(oemJaqKmQk?N za+cLWSHNf4ebDNlKT*L;%5~YJ z(KNahw|WuXij?bwPzHkKTM7d$im}ro;o^zgmn^MV%KaoO6T9PySE>>(W28NL+39FK z;#)VD6;*AYQB;*Uy<~nOj*TIgDPJG|a_=Ni_ zqd$14a_Zg9FU?P^9$Pj1naZ8dh3AK!sZ7i&EtsDeUCK9%jVIo!O1u?M92rl{DT{C2 zThu&0p1_Wk+pBZD^ArZ9+2A~SV$4KrUm3r1PFWPBnFdg~ z@3f+-so3MPbx3^b6C19on);6o;mY!@N zFr`pjv?kQ2K~RxrdLS{|GQu9dKEllMQ018cFuPSa=78t zwBjF0M0SEeMe%6}BO~1(?R8!+IRS;XC2@Um3c$2tIc~gW#s&<5w$_}}xMBUO7Ccl@ zybu9LnvhqRxi|~)(wofn3wY^Aa{4+m%yvU73^uJ7w=-Qh-|S#Do4L_!H>;BKQYV>E z^}QzcDmF$5CKVf>&W4SGXA`hNsWd?%IlZw{kT*7TNiTu}oFhz_9A~*n{lJ|0z`lcs zp1{*`wt<%;Zq8B8EqH#0*$(wI6K7Sg{z%+1Bo42%U%Ix@yks#Vyxs)*Ez(<2yx5nu z^PQ`lmz)zJ>yqc5nrzZ1KWCoI$KzBhDOz_l#ctZ^}i@WnSb@FY)EjRf2}5NIQq2+lg0-vG z*Kd@q(m4X~WAj!2W9rI${rVR%`SO2oLU*h4lbkWoCX*$5K1wgtb_=4-EsuoyL~;xL zUp2>+ZQC0i@7$5`4o}dC?qMi-46wZNE>Rz0x=1u`8?`tnd$;s7sU`{ZXescEzh!e>P7_hOkm9qr##`dBb^XbZQS2^TQzkv?V=!L_9+azyXQfMX;112apmP52mElqg>*xh^%= zKgJ=dCHR-*Z;@PHl>R#+x4b)k{xDK2y5+LSfISen@^=xy7O9@0z6a zHFAqNb*;JH2D#N2Lgl!0a*L%d!A`*!%`E1;Ji5!wqk|9?F>|5e3cx~MX8Thw@(JIS z-^ah;TLjdWroui*do~H>&q*(SzhCCdU6D{*?l%%@79>=al~8%1NZ#3L#1xB*Vv5HY zIL;2I)i#F|Rh}|a2lO=@+&$FyA|s}@JVG%wU4#+eQ0FgCkyV$LWRg|s?ue}N?)dAk z|BLE9ACv z__^>Y)AQjkg5MiHHy?H3vl|kHPq~G&;@ft>?+2f%{s8#*!#^B8W!+)$xp5Y+Pr`R& z>(RDp@Uih|+f4XJ!Jh-a4E}ofBj9g_UkZOK{G;K296sO2jAc9=1AQDtE_OOnGU-e( zPC66pY)ch7=P1TFCES&YFx_8Y~(M>c)0C%5{FG*e?{j zQ?Yv$`?F%tD)y>kn80GccL`KkdG8sP!kKc4-J;m96}wxp|DcY`vpJZ_Ecw^RQW!2( zY_Vd?72BlPM-*#UY`bE=SL|WMo>OeMVtp}=C28qrDc3nlv0;jRS+VOB`<`MyRBSTF z%_P2)Ed{%{VpWPYD%PUdR>iJV?6Zn}QL)z*drPquFh0tAS6a$-niOkQ>{k&l+-;V^ z$?u9isMwL1v?%cnv6SnSD>h59YQ+{ScAaA1Q0#|_-K^MSiv3x!zbW=l#a@QBYS?hf zwSQU4b#P9mO&_hXOsVTES8Ro1Rf&ZK^V@sD8eUM@-dhF|xH~?;Y78aJD8M0eyHK0V zz)}dJ>fXS>($Tm_SBl^1F;aAP)<;!COKT16C$c`F#$2{EtZQ0ZU(>p&slMgiTel#m zvgr^~OViqhx_V=yvgW@T^{X43>(wYCpK-M5bJ`He(}vjl@B#!ah+fChyZ?ct=|Nsm z)6`slfq4(xc4#wj{fsTlTKA|BBm;44EN~~>5l{`)jA0U!3`MgeONk3XvyXWXu!7N<&V{bzW8MbxXO< z0OX2B-4MuUri%`mit{T7 zM{!naEi!B4YZ_WHK7nI;tnjjEQkpID3o<zme4-j;`b z#ZoQ|`5v}MF@N5&Ui~yn-d>B66le2xX?-2CG?=#*&5*Y}v4oJ52yDIZ7tXjD-7FlQ zK;cyrM&>J=SMcFuz0ZfwvI$NnSODHRUT$iNarajD##Hp|{co<5K~ADCp;jCoED4rVzy*q`MMj%4|T@R{Y5rXp2H zxlRmuDp;wdpzv>fsVu%7`YSe@Wt;EZN6mmwhtXhR2W>-z@t2JJdHj|HN`)E&@6$im zD}861krZ}16BY^ww`Kq&LSXsY`t|3wt}*QC|3JiMT@1}%-xL$i1YDm~EUFlm93b6B z7wX8EOj9tI{*GxvOz%JJbfFhf`6QP}x#o-S8cwVop-8#Tr$I?L=75B|NwJ?Owtu<# zJv`TtB{%EwZgDBOsVlJ8Hm*N6n6D`}-y=EvW3Bq6T*E~d4r2~~8J|ZAhogg%aLg46 zce`SDDYkz({44PJ=D>_zKfh8}5tov~hIe~x3AYqcw`bl3OZq*TNZYdaWTk!u1>_eD zU8&PAD94d<9rh7EV>s^nmU5k2K}k4riG=&TVh<~}e;oHXp8H%Dj{EMr!f^*>*TRF$ zfCnYbJ#s4~cptchlql5#P34g1fS(u`ONLj|BD97{mLja6)-V*6K`PeKxYAxmi% z#iT7mdi>g#pU$X>r7f<`)VCflj|0=-ZqgDV{MJ&g^C&0@$6Skj=+8CU8LqFV_lpjHjc*XWC&V+Q8o&_nfqOCVM$vh?HI-de1;rR6u?ncF! zr-DV7?U=BGr*RZl6yX=cZ!CW0@%D;p9TeDu;6VZ5U}(+*kooS2u1vH&1irkd1p2JzJSo@VdMLsATMC#J;SkwHDzb0G!)pTtV61V#BlwL~i<-4_E?G}m z+EBZ;VKaAptF1e)aYJj3H?Esp?xzN}bnG{Bc7`nI(?y}c2z*%}LgDzB$9|+-=i^Af zV6>kJmNpaa!|e;QWI`*NN^$#{32Cfh>9XTrn2wc}Bf6R$jKG&2y(F; zSt>)ptitWSffmePRe5Ztxc%hP9xj-JqRrW^Ub=GXx3HV##0Y%l#6o&Q3yBn3E#$pm zCt4~)A%$`K`&nww(cLPfgQpgc>TV`7f-opU}@#?^SJ%7ESdOh zw=%JdR)ut|HhxhzS&b3+atYr_Zo5b`ij?cH11s3iEfv(88o*}#1G2!cH~l@?(=xTY z#tuQI)ne_vY(wtvwZRCAgN$8{KUQQYrLHPijG$vFHO0IZm6Ypn(vV;$TPj#e8-WM6 z=T01e0$-uAUY)NcMoPBO5RB9I1WWBDa((+R1CqyI zV*k!iVu5~07iv@wi1LhiSv;egdC3TTc_~urT+K~VuJg2m0e6E@UJEwi!HS>LApHUm ztT4mLIheqgv{%wF5*%^%RG0$Xdnb^+l1YuLTUwjzYu9x;(Jh_G-dK?#FS@E*GXj5J zkg;lFo+u#YI#(<92}>FEAX=P@OJ`Re{`_jPKO?3gkMaZZ+nY~-iOSB&Xa~fJE{9#z zPgXl)H(5sv1#9bDS{P-A4gQkaAntnGe;cry@69N)v&=lSb~k3l+;m;OVKJ{DNZCwJ zn%UyW=2rsMne$8NSSW7?_^o9Pc8_0G)6{Bb`dL+>C%!)I0LQ_~Q7%1uvpfUi=XbG> z%?NyqPrk2>dD%_Mbq+`V3U;KWIuyaT986`)QUrMcPWKf-Q+0D=9oRIJ5o_(-7OQO4^LwsNkjUtNoZ@HMOI*Veb%(+#pcl|?t2i#}<$ znpsBR&ogNo-c}8k6o#1bwSwJesbH@Ck@=A&*M6)+SLt)D=G59c?zaIer&O(UndA$U zSzTN%KR?Fp4+b*EYa=7LHzrVFtc=pup^GNC zvu9=a>aMnnjKKfZ{OB<;ukw&`ol6zF!crN!&FQvP_J8!V0YUv=Aeb{)-ZSo0*42FP zu&pvPelxOLq!uX|4-t&xA%apT_0e?0l?_` z<2NfkBbvstGp0=28g}+j2C>#P^xh__Z=@ijpuZL&$1>=z*W$D12C~Fs zQ)cDsN8*oh$pOwe_3LHvKn8|rsOV-zWCXs7NOo8q^FE7|>oh9XVk!AlS{yTc>X#94 zPL@yoPnu6%SYNxUzB$8pexBmDed{S3cEJo1rldg_=pG3-aRv|5dt+5nOYPuae0G2FS zx~yVx#gdAp70cq=*X)dMd1()VL`O9JJUU|I4YQ&n%0Guc@oo5X&BlHE_QC($8u71P zE`Doi6VQuFSEe5FR~=8xKDR3IMm#YIF*_Y?8NSE*a@&I@r)c0 zI6J!R?wwEN#_RURLm#;$e&?*xay|?{PG4qt#}jwOx0}}8Ud#0Fc;ev<_YUV!7QK6qh8 zv}{MT>~{>_Kf26((r!i)ExRjPc84K(@2v2wXxSc6XP6*(3b*fMjIU^znFR>5mtjsZ zF)Z7`*X)Qc+ZSE-Z{)yp4F1-u(c)R96A{53`2Eg2%xwuLBaH>oF?Tih=j&FP5bq$Y zgHW$mM2~-C^I;nXz<+sj-wl!3(c_=qoEN>UFa%u*TOc~o%O20cgma2+$*a}TTc3(X zx4zg50ZeM}L4S%~_Co}SCk)^fT+ft6Wg=W^$^ttX76i*<`+#z@Lu7pW!vDm#54dLE zLr6@;*8k*OT#B!r#qv4Bu+6K{6?+VVa#Q4fAV!u($2}YMuUS z^lZHM?7Q&W6D`|`f>>-emW)TsUW^X7BU<(hH~>5!kKVCkNwnr)Ilo00j0LsP=H#MswejM`-@ zmlo1qg9HoGlo9h5S$a}*4C}^~+P7q}p!%cQ!XoN#B)--@Ek%yXuk zkS{MYgZ{)nPoe@Xzde{$$S#vrf6JY)qp}@2HU|rm?_?HMd#8j}ZU0g!o zvIl=Y{M77d+06U#XWkC{S#%TroOLb!)Lnx=Ep4dFkbRYjXDezd&aU`i#flnih`AJz zJcI@=Y?_l_7zK$f=NTxMu+eJkP$k0-tv!433p+o9YdW1>igzyi(*$Ob`vOhf@`w};VSG5 z0Cg%-n(G`5O1@(>C`rpqP?F~Ppd`(UKuKE8)NpkgZXGB|bBl(<7GcikO{%!Lg;0M2 z^)rJ#18SF{D5G{5if7pV&QM2zdeBf~KNlIS=B`FO-CzX`;0VOHz4@y#c z1SknNT*Dm)N>VyO!!?1D^j)gd)u80PH-nPAze6e7?|xuX1;{AH3t^=j9nc-lMyPXe zzX1Nyq*7elux>_UEB2q7R$M-ZiUNRYPAHmLiv#n_vTvH9#a&~rDKV}wz&&9;*9tnv zIk&!b(VE8A7A(cCUuD9r(dXLD^*UU)o9BKP?uX~5n)lV!u7l=T-6*@GarL;kOUyIO z#Y+tEr*H(%{HB!eTHVM6>9R59Mdt1^NQvw(x!PP`7m8sx^tzk}uz@A<9OrFj4wgXm zb7mKlTgyy1{>g!rZI;zbx z!e0K;hWZOD)}ITzB?4CzSK>vS(u`v1H7@7E9Pj0*tJcZOS0W6vWH`_q=bXm%^%c#{ zwVO1tj6R<0(yb|^_%O&Pp5x<1x#y8l?CNw-} zq_aIIb9k0rIYPc+;@%5W-+X4Xaf`v5p)KDkTwFM-a5hf3?cbN>UT*G5xmOflkE@@U z&*|&Ck=(-&iZS_*7OrB*{4HZ6hexneW+ZoDq)*B&jNfCr z^S7*yoE_X-uG5C)&XjrwjKN^Yx@-Ub+Jrr~dv%pXkgoRzXM--Z26ETP%hJS%os z@cky!i`%~LrO$sL&9mnH4Z%m|GZzor@)&XdCTC1;=+Y5|C*nmXFtsI9BDo{7C%D#d zs<(Nqzh<1)i`?(uSWiCW(h;GOEMIczSno^xxh!9D=`h|q##ca#@F}57|AEcn@(arf zR}~&tSXX#-;VN!3)`wyJh52y^g-B%UoJd~OAGOKAysb-J6wE_K6dSTb>Nimo3rxKl zj9!^{ZkF75x`J?}oNWR%KH#0*IHLb;CmdS-bustVS%<0G*TVKe^8(a5y$?_MV z@Wxi?9;r1`a_O?S(`V{s4I`7-Zu-9Jvr`u~Uev#S9_|FgAM_Xc?#&38i8NS$F zd+|vfPu?FFxWCF?Gd@{5{|e&wa~^eSmLEC?&U5l|2Vd3J06G``h46WOjlCvk=i~ZY z@O#653_hCswwK{UX=r;Jei8hB_>yAyXg8ex@V^cJ1Mq(U|8V%!)sBQe3Q}+g{5kMr z@F}nHOxq3chr@puei{5{;E#a68ecRL{zmwt;9muQ9Q-f99}oW__!Hq%S3VIw>-A*# zG+~Bgp1qG0wh&e9Y)iS$hZI|{7<-@c>}M3aUNN>-65kz)-J=+X-{jdx6?;uF)2EFw zEtE+TjyWvxnZ70N7MdL$1fwc0;U;Rh<%*e}n2B$#Voe(E(~5mwvF|DNL&cs@>}ka! zC@*<0O4p{ZR56s0#ZFeNT(QN9Emy2fvC9;@NwJ?O_L5>~f$Tdrp=>2BAF-6{jLh}0 z<1K~OM6nr)736v0B9_9;V8zN5D_3lmV%3T*R_s@b-KN-Y6?;&z7Zt;P6!tsbRO}ta z=H`3pJIzwAbGBmVC{|S9g&SZg?E9fusbVK9R<2l;V%3VRQEaVZ8x^}qv3nHztzwTV z_M~EGyI%Uvv6SnqSFBmFixs<6v8xsPgkoP&?0Ut%uh@?i`;}t1DfU~%9#rf}#hy{@ zABw%A*gJ~#f<+>1>Q-M%6*~PCJ4&%(iXE@mc*UkEHbb$~6rH)%j~ zn>y4ebGtXpAIa}3gu)joILu4XiV`;1(h=|<>|lb0%JG%nU8<60Cc@yK*z#hiduzHA(c~pF7}3+iBngo;ht1H(Y`HZ z=j7!Uq(?s34RKWfzls1HOr&k(5j6H~W8lZ(Ga_EkwAXX&^=bBck-cUEejhScM&C)f z&UuP8TFQ0aQjF$C30HFew` zL@af-8dL>-VW&nh=1gjxJsv5Y8K|>O<|!D+;5VY!@IL)x#??S64BWdZy7nw#wxgwT|ZbtoyaI>XO;B zRNdL;cABbNcwD-w+o6W%Vxw!R)qbl2YbAu58z}&f$qwy3Ql(GQD!pV@=T(|Dj!vtz z+3L_=r^zST>U1UUvraQ6)@dr(yrz21>w0_rA$!d_{R}#(Qm09Y0xlR8aKZkq;oek? zT`>vgTFQ0CD8_X}@+^;*l5h(ZV`pWDsptQ)6ck9*4++PbBG1lJEUwsly`H19MrlVBV1cEMmvGgP7J z77JFS*Z@np&Pj@$q8K~F5+6Im^6Xon)(qo&_gM;?5~H3-IMx^mSEX3BVz;nGFe)?p zXtu@m^kBYgN1(2uzhGQ0{>DWS1Qo1nX7ZkF&b_{Im7QwbV~fAM)dX6jYiiJlpD=OS zXfykHq?w~@mGXMbF-)qVY^(G7MpBRKHA<(e`e?R!fY~)pZ`aF{pb+{LOy*aLf=N>q zdC}hpGGE#DpkSa`i=#eCifs$ql5eYiND6b*P(Fgu2qM@maRkgzo>d6-lPu-=6|_*| z(wFDr=KA`YKza7~;*R%78HSOM2cr!CuJVDD>(Fd0*eXle%}hOAJ49W3QGDk!dERla zJ=!-Oi2@fro7znUeqrY<#m)tls%QTm4Eo0a53My%$wuurWaptClL0dGw+9x!WK#sF zZYSqf9B$NY9;37xA53*S*mDmZzF$4}P^=q0cczUReW^){YtqJ}&b+jB+7)0AD@#{k znz@~(D^M^ZU00xEFMg4)7oWB_5I$JFfpzmz>MmQj6#2^zKKtQxUT+|%8<3~7^#x|& zK6QVuKflyovrj;IU2Csd9G?7sR_i_~7ssn&Fw0;lH$%BjA4}m>7R6}JmT+HI?Awab z#4Yi$e=p(KzZZ;s0m0Z85bU$4!=D&Nec_9ia-I7@NjTPU3AbA@nyCeo{=qPDy+k&h zchAOyVgoo1`6IFk4Qdx;6Tjj4EVAi`@0M&jNXwqHiK$)J9=9+IiaJj_( z9OV+@q1@?;TzXXH5-Hb-KvD?CUWs6zQ|wEM-JsZwians%9~9f8*lUV?5_R>eVU$6X zMxxCLC@3;ifR;2RsfK2lD+kTl{H|lmrE1T|esGF5WmwE4Zvo0v_TyO-t zSslh)4n{xgcdE~ja-AEY7zlQgrCjXJ<6%1#!72WLX)*g>h-^iJh<0&L%WcRf`tqBqvRWXGqsO zJY_vFEIZnKY_h|{A-*mR%bsikX6*3LG?%`^GcKJirlV?cPSy@j3~Pu+Xr>?(vVhtN1N-afOa zD)DN3>l+ALm6%YuJ#s=-;?CXpP-pJ;$cgd9uBrsW-Vq*$nN}-G<8fS7V_wGC8r--i z-hNSO46CH$iF?f>!5|bCH<<}kSArT2RV}$w*D`!Sb3jCV5uu{^CGg81fIr5Gi0G!C z0fB*264%QyiFaYJC+!|JWoBO1L*{nP!iIC#$gK9Hr8j2gMbXk5Gij^Cyos1|v~M73 zE7DE#ZQ&TK3>gh66UMrrNM1pt{{XF#(5Sd#%uc0Ruy$2)$`#uev5uUN>F{|emW;n5 z>PSH~SI4X>;uqAIvs1@e3oqs~n=}=e0W1GXhi~-9;8rM9UN{`-3FR?@raXqNSypFFXKCCO>^jAsR_uAjC=?`Ilcg|ZMDeiHNQT7A@jG{M zmR5Y|!s)Ejlnn#p?WaO++)=r8uaP5p@$DxU zR3&!B6SCL99pNDm33tR33~odNq{7)E6;@CxJQPp-b~ip1p(r@a-Nm>Rfp9UXRDm!s zjX$97iVa=Jg5<#;?C8 z0HUn@hj*p+bJ*r+6ZvxIc#QV?+iO$%3+Jb={qyl48#}Bq$W;4J$y)oV;g*{SO0@R- z-~LH_SER@+aN{s|h6;^|mm^W3dm|!N=sx{YD>WnOq*AkKx%kK^L) zb5I}e^y*`NeET5OM^r#*d+!KOKuyDT1q_Z>+SEAPO1H8;{?V(szPoeqWl|r{2bEeM zKaNxe8|XHKVtw3zA30szyI3FlmKPyX*Hc-B9Ln87b@B7Z>LijAGMesTOZ!!F_@Rz`6&uS@r481tZ;4gr`96qLx zIji8G1OF`ekUCRP0s7Lf{XHFW*wGL)AdA zQHoJD5R7v}8D{&eiPtZ?b*WgXlJNPxN36MCg*sE!K zcqDrVaj$m}PfUP`;dt~8COjz3y7UhyO;+9!9^sf?!3WQR2JkyiCV3EbF4?E|Tu`Mc z{eU(kEGTAL5UK#b^YDA*-4Qd?URgV-5<0MLR70$I6DbUYI~`<5s(JD-l}(44C(d-{ z;Na*?GKAA}BPLwEvk<)PZ*2d9Z;rUr_&&d)uL+uFo|B1bY4rT#vx*Q3y>TXj;dt$7 z#hwT`3mhF3AsCggj%zB$LxixFQG`5-pQo==j4;XAxWVY^H^Co(Joo^9Y|kk$0($#$ zKq)eW%W3(l<*2q?Z?VRqRQdP2BUNZtXyV(gBmV_O%7-8V$dhZ~lS$UW9}0gx{Nv#_ z!k+@a2|g8=^Wh`)PBVOd?Zxm{!ruU&e9dc$l&FdnQX*0Wqeu~qf<&+%D0ZJ>_bc|e zVoxc?^_B8$fu&sMWW~xA`-oy&6#EqFraVhSq@<;M5&9BPCm!L-Dz_?enphKi6(*4uWhbrZLV!-ZILax?Me(Bvv%%!Qw=** z3)Wq#om7BR>uqoI0Hr@vcyAq#fA&^?^8oww!tT9IHHa}T>sapMcut#tX%VY|pWWF$ zjzv(W4{U7u=a^?IYl)Z!^0rw^)REz}>pI!Kj2`oetQdw*cA-NH)5dT8A^g7fno0i| zt{LVg2w3T&l5!1e3)X7yx=x#hyG*g`6#Ir^c!!PeX2r-p5+B(|-XUxOb^vDtIfB(C zl_Q4Xx#|E%3_>V!1cfK1i8#v2>^{d5BMde#u zo+-c+e#EhcKsXLm7SB~0IIdx}MbjDrA@@q`K zm7)9R!`kaDdEJdCo%_fW#b{!}ruFCXrAcG#;xtOw2?!s?k3M^b;-vJtujGp;XUC12 zL0V(%BvZU8#@N)Mok@_6QmHAthnfV2P|2m!2A)~ixO%lw%95SBNzSooC#YFMMZ;{K+uT}0*Z=jh!7+dA(8~eHJAhlLlmpFwrZRem)>ezQs8wA$R%ak2HE&Z@}Do+ENsUdfG69k~Eik+Ck9MAS9HYMtdqNz?5l6W#%kX`X1O( zM=3>(qQ;}Bu`fz9u##sg0My!>YGU$C9I&(w&g^BFh7aZ;Es}zm2 zsQ)_L{%~)GdobK@z#XCASwMy(EkA8Jiat@C1V-)=*n>9QuPy8e3)^C0?^@V43o8aW zNP2y>FYHkE2#o5x?uqPYief-Lhuyg_+sl!Ls+mh>^uAlOAx#!zK6ECBs0 zVmAbB2v}<3{Z9h!2?9pDDf=PQ;2?r>+C`fL6#?Y26H=3RGX~p>1jp3adGh%!2#D@l zO-Q{ENYo|zgpdSALK4^-?Ta`x1`4bS_>pilo(hbEYjsw#(vj;2Oi6A_aB%%{qWpK4 zjEv*7+!&a^A#@2(39Z2}I{sTy3!bYJ<)6fse}-(UlTXE4 zAC1M!pT1;JJo$TC`=0rGe8l>A`P-NDR0DRTU%ojWo46e*a~MA_-nz~g7s3O0vsnZ= zQg6tPExQ%z+D+N*Yh!IB&Uj}74paCm4pTUO`_|%k`=d?aw*f}LZCmrkd^{z&G11Y8 zNrM;T9hbv+AZC8l;7HT})jKqvjKn)n^O@yM0}{zf9Lli%;OY@Ln3>+~gDx3VZMK4U zjKMS`%?K!Ms{Z=?29@s<@_#gnAlAxX!gm9H0d?)U_&&k=-D=EDj#QJ zWsL&YZ7fsa45Rf2fp{71T!e}uCS4M&JbRVVcnT(mF(@0JDqk78#WHkk>BE_Uxf!q@ z^ykXrGmuO_mCOmg!=P0k<`Z3sLOX2~l z*Op3H?dxy(Humy|{Ufng9|v%Rc>u=(_c4JyXu{uer&>Ewh!Z#tLEGR24zx*2t7(+3 zxAU`Zlqx?_#k&j5aU%w{w)rwo-(cY1sKEVI!|>QtX_yPqC{q>DcuwSCThbiKVOO@c zbe~iwr*yPDU`p;jrXx$Zm$QY-P>rC9L`R&vud8Ko60GAtH!>WjmgHg5tS3agt@D)H z#tZf7v_#w-Rq}(;GAYE|MU029GMW`#_wl4JQ5W;KycNaCjXXUiKjfa@zLAmTYcym} z8F7brO@&w*j1Db`29F)&%J>#kC0OWR+C!c1kUt=Z0QS&^YoN_g(e-1z0Om8Zh^#~* zemK?(hKC+*opj=oCLBU*de$B)keruDMVAqYvjbfPh=RTROZx@)@rT6t7Y_QP!9h7m zhP=;(vz*Hy{-+`B!_@mhV1oXD+P0sFTbOGa=heH0Upwxc9)NY4l#WN5cIL+!Nuh;XBe%?{N7(5^$=&qKMHa zikQHthzX1aP=Wp2!YIT9_N;}yW?_G}FwUt+xQO=21!Dr+*TPoYa5q}mFD&d=7PiU4 z9=EUnG)+k_q}=n!oq%KVSX4iByNHBAzusYZ(+w;Sfzzcv9ReDcCUp!U|}^7 zl2wCA2eY*gd4S#|UutUfg`JTWR%T(GDlfr>C1Rkihi3W#?bPMJzhsnK^NvIFRukt> zrwo-!`^MDyOsb$fpg*O4$EkjQ4kCi0y9??!*VtjDTsP|XZ7N-TCKA=}b^sDkzpJ5s zS5y7&l~TVGP`~|?$9&AfL;oK0EY)ue3Y2!di|TiYQNI&P{pKpaX-*Gx9R+S!gtq_;Xh#1&4L;Go&xS8u|9%OW_UhlW5Q;K|?o|-P^882i zZ-{X`Cqi)!;b5JRRt2R1RAMu9Nz+kF5K*M5T!|t*#dj1$={TGv>Q5BB} zN|7GzQluyUdy4ewsw83Gzq(eWsp!9{f{7x1I=XO0N6>v|LL13Yq)%wM1FGxKGb(Qs z=}wi{6KRU{*)By|5--Z4NZ;X7r2R^fUYMy!-<3^~ZZm3T_loq-RPla{Zuq9|73trq zz$ryq%6=iNg441o(rn8uDvBu5-nPu5ApgRYycY84fc=!lvOMY?9E6zRFD z8x9N?^)^uFC{(p1xU9wQT=F}Xy&%fA8EPfdC;G-+DSy3?e)(xP`& zgC=QFIC?bbv7?j*U4fFgG-zXZPE(gNXI7~||K&fUKnwCx3iJmk@GShy!~V>xKW~8k z%f9Y+aQB6~5$?foH^HUldox_x;h%?#S~ySg9qI6$`SE=u;C;|+qCe9o`m?~OKMRcd zv%si73yiW$V9#6F>lXGG3p*2eNjQ!IByNj^wOJVTX9-9BS;9SOVb56DdlvS-h0$Iv zaT~NR?0mz*ZnH2Rt1aPvYGF@U7&U3h_f-p{CM_@?wJmX1YG2q%K+6@_H0=vJ7h71f zg)OzPb_;vb!k)1(9?381y{okAypFytAD%ALhI z8Rra0h};ukJ<~?tW0mA!Dy|!4Ie$Q&(vpMunF*^32GtMivKkEuJlI9XhXrNAsthjW z=vcT1!94;l*>)6Mvg2PZJJKfyz6tD7{Wa{|1>YkItyECx3oA8D!o6$5sVO2>UM}il zGjocF+&sdA1{T#kygWgkmfEJ;1*4%-n>!n7&Xn6bzGFh5j;^mWQ#X=GfPB^FHgKAU zt70g1Nm>>7Vcs0669O}WfgnX|Q6NE?hvmH)70QEasAjz5wD9|}aM_fwUeuxy(S$piu2k`)ijMBg=v>Rm+TjByFOH z)z7#XnVq{EL2RpB2x1}zLBFvGqA%=l_$;vh(LOBI1wI7Exkd>Gq*cT_^5V($7HuQ& z@j4IMNDF+z_$5yo8IlE*Vg? zC>&4vG!Ml)@RDLB+P^RM;Ans@5ErE!jw;BrhfGl^q;Oc16)7A)riSLLhyi~Xb68{! z_wjk0*N9;A89s5^tN}emYIi32k8^~S2ORR6fuDNK_(!Sd-pFO9OgI(tL;T2ThoK-W z%t#kTT|+a)X==$_g)4csC5Jz5eQHHd>B2hT_Q3a*aM>O5o$SbWDgoD6oYNO}zGh+H z)V{Df-&DfAXJNBYZGp|vK6ZVnrHi*Ar1v6niW5HUYWt-4Qn6zFg8HWV+WEL7VNuQe z`o^a5vN}11$wXBbm<;TM9>6|=3Ah*o5N}Vz@|B@*ZdG8YR+^xLwh%r{D^JxWMtP!7 zE-)8Z140RmVohKaYXWn((GLOjszvTLI&Clls7LrBqmAr|yz>_>xB#c>r&{agGj_AJ zn1H*rcBidoTN6gAR)I!G**bUkTvw?-ZWMODSk5aiE?R$yu z1T`)}F!f01A(OxC(B%;-)@_!e-94eU?4h%Kvkor)zjxqpI$7Ns?}9ng&nQXAJZhC-!cV_q)$ z%+!Z=g+j+$3Z*aX@F+lmVGE7&VR->)PlwaKY!rGH!vEgW+qh-qEgsF$EhBf+wvm;B zb~8;chPyPFq)VXl!H2k0u=^2(dz}7FGz}wujt+jO?JL=^yk5(pN3 zlO)V!r7F9bT*(AUuCfU?geS21g>GDbvWL&21BRRi$_Jwsa`>}Fj z7cw;gYdY=&S0;j*lj@c%u9YRqsriwfYW|q(Lpg5)16Z2XU=nyBTH-|el(}sQo3lb6 z0yRcs#nC>4_Ho%AUV$bU&BtwK{=P6V6h>%K<)9BMT2I%7nFgld{3Z97o6jMqrh1Od zB}~U>v6jM|hYRTI$wzoZ#T*1P9$^AB;X;^`Fh)Rk$@5_th+@JbROnt-z>Q9TMha;J z$?JNvmT4iAvT<{n8Lv;<{?69m)+&}`6n@N^#u2t1+j!*ETXQ+h@x3FU@Y=VW|Y+<)r*f_{UNpHONv4^c3w*hZz zZtHSnJ;Wn4X*S}+FacCkp8pEXMOrqdgqXT-lpXs2(?S#d74PMwu<25Cb~kaEg+;S6 zBWcgej3D+F(qK7U(&Tu}jIUT`q!0TBLCXR=S^L7yY765r3ldJu(*asEa3G6i1zME6 zR_Pe?#Y0&}DI|}u!fy7o#~d@erV$%%*sO_uUGzvX$hMSKT1no5UC;r!oXG4=rQkGJ zV15~zeub$XT-MubL7pBHG@JsLI^wBtIeWl&wh!MaBikX7MMlym7G#0Zf-JBoIv|13 z!Xz**EDqVTx=KEb6`dFuvldPs&+O{(;ryHqOr<7YejCX+fcK0YzIjovcmpx4Z{)RM`_#9cr55R-YgksI7<2NHUs+e6n ze|Gcy+NQdRb&XAx3oe*n2YQ%LJn{r0tyaIg&$<|l@3PryFj8VZJfG&tQijKMzH{p@ zIDX+`6^08~Wq>W`OR{s9XMej+06MS^{T+NdOnolI^2!ul+zn#`4vmZk3ZnVF-5+Xz zfBV7ozwQ8W)H0gaC+aW6iIoh%&bdTNp#F!fpL2l5y1{grDWh|%@;HQIb4>L~bMynO z0x(v2sxMV#nXXXw%NBe#58ItJ=e$Id27U`ugT%!haLIVzh6}1y@5tHVceWhiCHkGM z&G(`D{Sdf}&o=um+@s*)*rt|hxOc)OwHB5bYNZdip-zA))|A_)1MO8hGd<9A8`Z`1j&@Wa@d;Da-t#qZG%V>6$@ zZ%gcqwXwt2UlM}*VQl*P4Y6VC-$4dy!}tAZl+FpMN)M&S85GYX{HCWU{q(xoO$!%| zfoL)$Uo!`DFSQG1*C{!5fFk)UQ_XS35&Nmn4GUpVSJa)-o8yoOvL*(5%2JD7B(J|4GJwQ>2loQF75bf&hmnGo zlk`Dvw6L#eU)Wh@VJj`{yB79C3tMYpq%ukGj~4cZg`I=4O1`tSPw9h2@ew{ORSVj_ za0|X(=CKM!kqRHm{Jtgh@!6YJ!96h&H@aC$Y1^|SPtp8#Qx~8LNxQV&tV^Y!OVf08 zCnq?&u{RT+UVC$2z0j$@Ug$JHFLe4bM6LAc^o1#99f3ivDqq<7i-o;yVc3&i6o0T| zg*=H7zUoij#L*v72dT!QJ?ZE(RGpD^Hj}#;CzcJAB>ZpbEMkpc4ZKycl|x3Unfru2d*MXEN%EflU)bjGCMn z!eAp0gAJb=kF483@GoGK3qT=poVCg~3cd}>M;+^F<*SG9S>+4B_db3}{6=}G?nc1) za4z}Olx{W~XS6n`(MO}&9OoK-q;|2Zh&aU{myNAh9hFDz#-*~$!fd6PuaHF4f0l*% z4aav^XgEerE%Yvidm!9P;0}j-8C+`Em&2vLa~0eK+^gZ90{0rY=fG`+TL*U;TO<=ccU&Q&Ig_$!Hr{g{a9>7}hHa@}n zHK_t8r{dJrIERL3E2X&?KJ>Wo77pYTFl_viGs5y7Gl^xS3TG_!vNhmuC6Xkb5zUXfp+{wfk^>~Hkxq0Ea0$8)LimrwBvl|kQmFQ7hC)Vy9S;$}@IA5H z3HpNLN7yRBa!9plsl~cn+{1|xmbU;u=EU+Gi62W_iJy^lY-yLILtYeim*Qt0@+VE+ z)Sl*R;K>15?{hj_w(uEnAxfPZxP#%=!lh8Fhf7U^??=MD0Pb;c=fSPg?^w90-iZ~4 zXFPUsA`IyZJCo1|0y{zb!Vd2a64==m#@Q=@;rt)v3p>|Z*jFv=XBKv!h20O?Byk_q zKCT1cO7R#M#%-!pGH@f*ChPY(RzIHry75})4?<1&9Ejg2k7V0T{TX9%%Pd{489ykE zdY|tD9QJjhk$(T?dhygGY%cZfddGbtu30nA%-_P#ZRPKFojBXiYvsSIhtmSE^JBPF ztA7HQS}ot%&U_~YwO9(GPptd``=w-Byk`j=T&qzFG=9YMrcX5pY zI>gO`kaxt-cmnWz73+!keiK~GEjV9;+aK=N;Szl}!zC`i0hjS#1W@D`ePM^vL0}WL zFYKIbVLX;l!rfzG_gk2uzUiD>iYE)Tng-f~cBW{KCF+lSQiFmc@-kOVlABlujt8jo z%9Cj=*kkA)xmSi5dzWPQPMN**e)^;gdZ*mr#xw8G$gOFZ(N8F2^pl$t%(NIsJKm8F zi{j=6>HppQK)RvDi?n0-;YXlzzTXX(gB`xJ27ISfz6UPp42L@@ekixnm_Au;DX@n@ z=K_07`y$R$7M1`VOSoy;hd!BinQC%`<)*=!HQtA`UsFPK|D zzwZ3zxpMD;>I=Mw-itkc{=!C?`Pvs4)BDDZ=8MGfR6_eWKvR_uZ+wE#g(nn0TS0$K z<$^|~_)_SK;(IWTxZ$-&JXjN(-53g$#Zeq8nQEU&hNo=H;hU1I9~q^_@zsSg z-~rKs;z*2oZiFhW5#USlJqOuh4$KH}rnE1_n-Sowt0q~VRyRf!5L>v9qaEnz;;H)m zN3fO1gf1m~gND*!`)@|~9DzHB06er75hoZ#E6Sy{=s>&!e=WztT?!W&C@T@Gi>rN= zwTM=t8obj=#Iy(}Uir?R;4sjN^aS*Uoog&?nf8fpBH^f;NVo@VxL;b>qZan0h5gaO z-mtLuEQ~fhN$)E@QqzQz%hN4>8BaX}mwLssaEHNt9xl`4JKKcsq^fUQs-iFKv|8A5?URFFB-||) z_PPzn)|a^3E$j;mqdp9I0;Wovs^1qN?*>3+u4ZsNuT%D`N1JbQ-`Jto8LL&T`sOyz zU8a&)enyDV3T>(R`+Q|`*2jjVu6Lnn*d#$*nzwY9`&_vmGX$_cg;N*9tkQHtM=SI6 z0EA6DZ^*6|BihWvw&4Hp_#K40%Hw8k zuy*}|3v#ixSNqc|95Ec0HS4Np>vFkTiRN~nQ=&5Om)2u7qWb=lV8GuGrw#`L_*YoW zj`BD~H@2gswoO|GFByuVLKGmyU=~)36?CtNBSS=^!`bh-!MuMV8ZIH2KlgZ?Yv@pb zJiUKA{dQfERjJZ@(^dCO6a_P~DzfLV<&bFTaSy|)6RLCWb$L8`-+gZcTZz?TUPc1C z*6R_(cF@c*6?bo#qqsEasoqM!B6@j&3H`!5WOv=qqE^ohI=mDlk_{0 zz;|-iSFMnwFYMfGVYg~u*tyffeqv#Nv#_le_PK@aurMr~(Rr|Ql{~o2TJojpDlpr9 zD$e4h5Bp=Ly2J#xD|kA3S1ejFot>9 zUL+W{DT#p3C`WqNO1RWWs^GFcK|G33c0jol5lmm$S%_}}qb4V?t1XOut-$WEu9A>IhXE59g@Y!8d zp7{J8=BDKl`ky^-(ZU4_k2z*e^P<|O`h^R|&so@f{`@-WBNS--sF9;&q-2+fA9k!& z2h&x*?%IozErjfuK<0>Rah|ZSw1#^K;5j)OZu@}0E(3`FMVM) ztRt{a?F*}OSq1jIg}Dz5xDU{CJncs$@gWjV?T+x$cF}c3d8du-g7O00aH^p^CXln; zSms=W$GRB8`(}x0H~PZPQhXCwyY_`05}v?FcoNRtZodMwE=RlFu`dFsrwh8v-fo8O zWM^DzcgM2bZ9pdAZa^>H?MnN7t;Dn+ePL%M>M5{mwNL0yV9#5ayZs&jv?fRUT|5{8 z)U&JY=V95EU9s%Wk{%Oqx1976Zl2whwtLC)EPY|84RsV4#G~?sm8cWg77KH?-7f*1 zoulo1B?zFNU2Qv(pQrsM>@MXofj!rLYxg&_M_<@ss|jqC_6h9?jI<}=y4YFt5dt)L znv%9KKGc_D@Q||WM?oL9dOVW#v$Vd_6_Zmvuh+=5p+Qb z_iv&lzXYkOXHTQ0%K>ycTK3+4ubo26X=rv<|8%%S%NcNq7QPcLd?#9dW4VPsL5skM z7J)^941p0X0*fafdx%2|rK%Ugvk1SG{gP|U-}G=z4}{+dRLi z#;&qX+tF{Kddq(T8(V4?ES#ga;qS3oxh^MVM=oAiKc{3kBp=uD&8gD`lKBNLlhM}} z8LgSh1e=rZDN7tL?Mh7o@Rpot*xw!FrcQ4pxjt|+v5925O5I=8YbeIPhJ&$@G$di-O9)?SD*=WgyzOWMlo&`oC z5!e6=<9Ut(GB+xFB(2PZObzTzMNNC)oiBhofzgmIFcOf!C}jk8r-l8*!sM*( z_0>zaqbANG++lO#_UhKP2lK@4*0pkVVlV6su1;>jwT&<*4O0ZBZ)@R%n24&Q;j6?i zCA2C*`Nw-GZh{KI!y@GBD>!(B;!;vcSz0sXg0?W3>&#Me;8+|phRjVOr zP`NF*t6bG3YDJ!#A9{6p^Mjdf?W2-E1QslF!?-C^5HPzu(Q}6y?LiPnc%&)ZHKEWn zg3~R-RB-jrz2(&{IMc879bKkmCS&-9lK9pBNRBDlxoP{G5u+6VrHN6_s2&9%A0II3 zvePoUc}P1HtO2+bqI@bbS;flnu!_Ur^0120`ki4Ohp|mY?(~J73oVQWIDxIUup2Gx zb_@HSg}q^6Z&_F#8dvfNYG2stXJPwTSgnQCSs1rpOWY+E#)Vu0W7jX``>}=HZDG8} zU;svL5$7ZA3p>Yx?<6icP~y(CuyZU-bN-2)eK-nt?B%KPWE^b2K1~8(S>n1Z>`$}^ z`x7aZ_@&r?05Y2FVgE@ggzU9F6Fr_hUiO#cO+8vc^pG_1p5p#kcc$WrP8Lp=>t6f= zu=YO(r?tH-N$OmQ`JB{xfxE^@InyBV@Hr2|=F0wGJ>(H=kEDTex z8nzj}`HEGa&_1mA29HP{Qq)XfG-L>jBW8io zswA+NEbJo-`_#fJz*rKF(_j*JhK0?vFfK-ta9oTe;Z|DMwHCGozR`+hpVz*yvmbax z;*x75?pO;OXJOrp=&>`a(g{=mzCEShL$9>m1N9zj_ za7_;K;J{O!?Bwwu9*$>_#NHl^=OT#!tROCdN0QiMBXKWDJO!;y#ufC1omY^V!2YCt zVTZ&auzy-u8}KWz723xQK<^H#UiUgrgZMW`<3}NVQOA#kuM)qMI(|1KlXp}9L>0nu z=uUz}mM1Gk?J=96%$V<{SwE}Y@Wtb-vcZvZYJ^aUg~i?42SQGkQ9@*=>;cq9Y0b~D z2hd`!yGd+cvYy%$Ca7oC*Gfz^8S^_AfIpXIqflKC$(Eh2_Ip~wa6$FNnk|VH#v@hZewXoS1 zhQo?<#-V zD+TQhrqp{ulH8FgNr;&4B#99kDJ!Da;y{|sCQ6JE@o;>nD52%Sh?2LgD4|d0R|Qt& z!$@==l;ZXOy_o~+tPjT-(m zFPJ^A4o6wfsi|+O!%8R|Ti_ZT;lyh9Yh(RI4fE@2nwB)wH41!>sWe?qb5c#os;clL zkF3Jwzs5{5pyT{UjG6hsf@`3lgoXmyncfN%S1s&o7RCi6lHRW^Y_o-NszT!S1YZqP9N$a(uzL|ciA%1N za7`9Q86hyOOq|r&ry{=Y&;EaBY(n8IW0MK+RpOT#o0KD?c^;N`D-(au&GI{Q`I={5 zgZCz9?Z3Mn987ew3=aM~vjKeW`pm{N$7k@fTxgw}pS_cj8SG5j$u%~}HXHeoWoP=r zPAAe3*!9{Mc7A4I_gNTCf)egS3*%@)V12YN?3`_3H5NuAv4m^1u$wIG8y1FhzIC`C zS=d(i$`m{QQ~ScsQQ#vj)m#LUd53aq1c8_hDDLP!%i3@i9a7#7(KCJwt z_vdg~*ZcKK(BvRv8KzG*-V5xT2qmz$wJ+klYhk#OBosf|=WgB+z>xRWFX=X!Ft!4~ z^em4w@BfNhzfve1UqNA-?nq}^-W&E<3^&qbmq!U2**t8kdEhoQBNo8OQ=oUU^SUFMccCxr zP@oEIjrL(TIwA^;Xp(SQ(8QtERXNbq-UXWW3}zt9G+q*wJB63|nRrn*a>|wkvxrYO zm&ftmUC*?NWX?UUKti+X2F0?#h(L!I?`7YuK?1$PXx1}2 z9@$}z8RTh~Olt^!L-AuG^`La4KzL5LBP-HmX+uW zJ6y{tu*uqoin=)C*4eu%YZ#PeY&1xqs0gz7`ef6(z;4!Gag&4%M`cmModf(yxLMlA^(2)ci{M)j)VuUHA22>7 zg1)IPP4!~+3+kKdYv62xj0^_nzfzg5@u=_16t%1G|@Kg^6xEpB3U<6Q)bS@bU z#r}TxL4QNAwZPGs3 z>?N=$*jU1)HT=T}>a}aRsdU;-HT=$)w@efMd3T$T3AmbY_o%nlQZIdCQxO<#Dgt|6 z`yyD}WMJ63?HP*Qjt1`UITx3mEuTXEfFyZ@-<1$dk?kH)^>OuEV^hgUD>?Le1Q{1; z{)e(HQClw!;ytJ0o{096C;jGar8Mo#&D;B+b0w*=Bkf9A@*IxqWjEr7XXCm%g_Ce* zH_MfPOT10dXL!G0*^R!iGals^ScUfCk^>8)$y>sa-8`i7F+MhXNX0$w;Fw9COk>L) zn^E3Fi{!i~nC)58+Czm*C&Vsq`bt;mT|?g7yY$UMQ4*qesOz~DEK^t!?_R^vGdO0J z_|5H01tZYX1y-beqPTfTun#`okb?wiPLXGClHgu3 zL+xdX+$&{HC(y4=>O#v%Cs3NZcIp@jH-UO>WX#Len|dYWu8`-kmOSYTJCuO}rEE1CYD4z4^gKi1=4bSM}e}_3*TjBnB+)knQ{GCOwIVFVh=bLC4M*JLo zl(85vzgYurIVP?92!51lFK^VJEgGZ(Q1Z!ygbl z;XyEaTRxoPh?LOBN90dU?xR=hF2?A5Lh+HX;bP7-QKu*WQ#wYWT2ZOLpHhFpJnxmM z-Oc6jic%JgNnmN9%7O;jnASTBcPv5$@#D^b(I~Jyg0|f^>ny6(M}m6{ zJ3RR@sqi*Lhi||PdoJeqmIl1nV^f09=Ou8ih8;B~Je>hD}?t_C<#{v&ik#f|GYe{)8 zZZ?CKzrQ_yHPfI)7CBHw7K4`CNcKlGO|+oM4N^zF7C^O-&HQxTpLw!sGyol>yQ{6U zS;p83?xR_W85V(ZjHKwYj1j~_>xFYXmX*v{kpcmpMZqp3OotNNqB*Aaj(GsY++nGCory^lW=O)431G=w7-%F z*nv->fT8X5qK$zfNCF(t@yM_ZN-R7wyxBn*(Sk73%*8ArZyGX;k$xD)s3W@K4pO{}J5s$;+~f$C zI3g=he2>@gD?#$a-&Jrq__!J_Xr32hv>XI?Dcpngce2J+mNn=T)({w3LtqcsaKE%L zEb7;B^R+L`yDOcJ!R-BTthn-powYXHBQ_l78!BTD7bTKw-$8l^jvXs${S;TUp6pRC zVhoChm5P?o$7iS1i@Eg+<|qZiEuB5xP8Z9nNi8%lAWsh^`T?;j%cObgD|d3qgI&Nm zPk5)e3n8fcEO&d;Xxe&W9v(CRA+_d$oKnQ#rbV_7i2=gF9wr6Z(!$dJOsggjf}uq< zp)c$-Pvw za_K;)dH>j;Dr})Rx}xMt>}aeg+KT_1<4K1fo8E3&f*?Jr$}3B*D8SSdCw>#+utpDq zK>~^vw&N`&(te8S_wo#kPeBMi)A6hGj67<%4OVXgm~l~UgE<5ZX6QX)ypTlZ*EKed z=Zs0$gWJ7e_Z}(dMk?xeU)(blxR3g)aHczD+5ngA`xxCrbYBO@&gVs=19-Mk*;Fd@ zHHn3@Av7lyQ%`N0H@Xuj2s^+jZDN%g2mCGpI0KDF&PmZ zH24ypBZuU8R1#*I2!;4M0s`Nyi&PzmvII(4ME=~L)|cQ@betO`p(mKo5@SMf6VuMC ztiNdD!Uc75@$Wq3*^^)#yq$|ji*c;}ykcq<9GI1(&8qNY+ntIZTk19l%ylK$q>mr- zpN!uR@H5)YLR44}+<3k?QgV(1`C<5RQr!~lJ<*Juak?Psl?oFXW-NYu&e9{gv*DhA z_jBN$1efn8>vxLtcda<54~K`NwgTevId22+Pr?O9^Go9=c8(l%QfD-n=(wVET2<`f;}V^deTfn4Dw8k1 zjhN78UW((=r17yq70%q)pfXhPaa%q<*WDZr`-gDqFXj3x4P2XYgv9lOuW*RP)i$PLd*~bX5*g3|<>BB)< z{t>|e(fq!_kbhqYi$DO|prJA0t_pvzU<5zB3?_`i-jcT1@B^sE2gL)s24){p)jT4IX^%GMV6@q$+3doV{h-D>I!!bpcgZ=}bX7B46LcA$WPtQw74i7O_$fi33CufnX96VYq1kdKAzP0GfrL zc}UyTI7r_!H1MDznRY3KODW5DR)+7)XDHmW_51Jj`)m50Ji_mkW2;bP(NyS@Q&I)? z4gD1x6>YeOEbL_q`=f=CLL@GmR?<7u!p^m@Yb=aMGD$e@f{?hh)(Z?5hiO<$`@+tt z7RHNUCEPX(`f_|kXFkY-#IqxhId;vH?JC4|trQ=Qx%PhJdZ`Z7i9 zz#jp>rz@)Y2o2>zKYWDyao!!!SLy^C*{6#^3G!zCfe=PN)1yHfjW=g6-M+rJr#U%hR zYb`VvMNV%d} zG^J6>q3-JD6WusC(O9K4Tos8&(6y-d10n8WN>I6l>a}bEe@jc(LbbF@VaO_zcgLvo zS3B20(ilNV(lk%Vc$|_mugC3A^NKm5O&Tgv!!imw^N_B+WAvvXa28dBA$?)zI~GQjN?`X{7{#K%p0O~BT7kV~VH|r4EP;y97jf9@3T&2z z&9Sg{3+u2j?je!5+*B%YpSG~)EbLDf#-lGJ+;NZx5|=k>3yh*tVB0NBUs*)4sO{iN zCQgC6H!$|_vqt-)c321zMRo3MT#GHLo_Zmg(oGCN7cMtDfqj#GCc;NKN?Xdodr=m3 zCx;HQa_9(EwjRpVFjII@n;QJ;3;)Tj#D4Ip3GKFz9|FAk`$vXEMo@Lhr)gVDmE&;< z&77Lr)ILj^g*e)ySfO-~%$+J%l}*jWZ&V=#8~S$0OM z_HnVZYhA6Ioyp3q7Yjp1EJIuuyV7DZ4j?udcoPj~7&wbUGtK5Jn}5lx_~Wfi>S+fr zk|vhJrC8xRYryxz;da1fL-Cz-!*}v*r{X7;jJ`0I#~IjnEbM0%M(&kxPgvL%3wzbV zUbnD)!9|kCAngk~G(HRLa0{bSBQPp8k_T502yB4%VUYn9lWuepFkd{mL`^&mjJNM- zYV1xSnLF1G)G`&5sXGjdmT$%_fa~J^4Y4&^JL$7JUcRBJcWh03M|{U-rLi=>NA07) z#PO&r@#L+g6{ui*=_BkKYBm7(T1%M(pJ*v3!Y5kFbnE*SeCb+B3)Q)1;Z78YO3G*#e-0sA>vx(BhZPV9EM0+$~XRa~@&!8>^ z56ezHLgd@+R_JuCLm11CTj&@af@NeYQ2&MNYq6#WHUN}|;WB-#UgVdoADqlPZ9doAn%3mbwalemXyU)VXq!j87E z3oVSsCQ0uN3wz7LZUkRRdN*qy542N#I%cpi$SI7sKihOze8*#k$IG`sF07CH*R_m0 zx2c$RpLqGYrYI%CxO1C7#QF24m$&QMKSg$zdYHEwRpLXnZ0O!&-tKyJW18TQflqmw z^>i4q)H5=K+}Q{0S_msjzG7B?eol@Qsvc-LvQj0U-fIhA^&?-o4Z)ETu$%wjs9#xF z`8AWRoGxu1WGkxwrZ$Y9%b?n|je^Bf^+$QwRZ|1-^yjQpxBWT7e1KmCe&!+Wy^Qly zFb2Qh4YvaBy>QuTd?$_Yos2{77RI43?A&HycW7VO`Kg7Gg(Tc(7WSoug+Z5+UQg`{ zJC|G7)fNT;r^B(6mh@z`M}XH&VMf=II?XTM+1nUke29~0_c*EJe#0g;F7+(tNX_1+ z-^jD~E=uyEnf3Ofd6eFEeI#5?8Xg6g8XVu*K71#d_pxZEPbRYHl{swW9=O2zBQ?v)?nVbT7#5pTH{?%nuu@u!p>@Z6WEQ~mrl9w0{S&iUEP#B z;XnjXkJPn!LH)(ebu|r5`b@c|W}F^3UR_%?tfpr6oVwZbhaWPG?}zAl-#PlqtvPk` z>zXvd=ZYoEiVdxui$Tk7(HawQ(HdoFnXVC?Y?O9i)M??jpTi}k-4B;C^Y4&g(zf)4 z9gd;|_FL_P#07l`ETDa8Z;UbroQ65X8I`A1o?dxIyz?ieum2BjbYJ>z3DS4l!rR#u zPD#F>=$NuP(J^^TBKhZd$7wewlAp#qrrZv1D4uNRSS{W$`OY!VcFZW96+2^XWvn<* zTHVnHzZs<={wvy4RXPg=K)9QzM#FiX&ZhRa;jrUaVc^>c@3@Ht$LA0n`7H3$8mf|i z$LAJ?+SI-Rj{1CB!|1gus!GRHjQ+S{MN{eM(XXsHr?hPJqbm}nqv9yQyy_$>HZIq+#rJ-0`MKKb1i1Uzmt_J*`wnt;_JwUsh%IusnjRk{EUy7C7tX{|G#o9jsxaEq{ zF-}w8dwon^GLEd6lWSTZ7_v_r;Gp&)@{#EbX1kj zOC*2Vg52Nf2`fs)8lP&SirAXh*hsN8Y@^mqC8}|fleb{?hqTdvBB+2m=9Vva>=^Hl zwXZ;bThaD$^P}<3t||~~!$djSf!`CQy1JN`h(7t`DIor3_fISZW>snk}-LEtoZfhem=#%+(1XxIrVfxn)ZG$Fa6o5P8g_XowX>u^Y$=W3AOE-q}>z(1tb3 zleZ;0FDgQqVMU49B>0k(OA_VVV#{e4s~)j2UcNcD{HySv+&O+&wf{-X{|}wgd4kOU zKQCBlUkm&-T{wkP{x4vukZ#PT7^eIsET{apK3zTHkMY*ecQjQdSlM_hX84&Y{U|)n zV5urCQHeZ<29-vPClmPKf1I_O7h8iWyi*D0RIe!Nig@exqD7G(>m|0kZc>Xa{}mFD z3U{6>Emj%3VI#=tTr9MxE1A;%m!^HDBp-R`ShSX*T$;Y~-S)9W=cT@QXLHfywvXen z$<0Mm%D-qlZ_KkYbqGqO8mlwufpnZi=MY*sVWr#Hmd}rzMyxJ>0#>)=l#;mrsS`W* zn-DL5xp81@jlbpBDu@$nBgWAB_^{}2@l6{j(BhjWmoY`S721s}sscEHrRhi402vcc z00q1lZ@pTUvG)fe%2aV$6Q#3o$j9W{TQ0>UK9(60(~_kiW|LfO z4f>r#vUzo;_(iJoRI0~GA*XelYPCsK%iq`dw``*_c=29k<<1I5^Asr zNF?7T&CRS%o>zfVubq;d8&7o9y^bQq+Nftu9`iA};3^2dj^;A_D)5UZl8xv=MWm7tjM^B1%d(uzFSv(X|^Aanky6I_&&MP6_zhw7)Wtl2(A1QAdXJ29p{Yyi2 zSbK;C^Cd`0h?zda>xDxH?VIv&H_Piod^nzZZPLMbv= z(Sf&jj)kHJ7tK+GUkQGY4~->>EBxIj3>{1FpdSCajSnOI-94p ztxd!xf2cb2)+^&mS1-fx@g-;(6^ZigvE?@~r4gHy3c4KrL}zJH-2d3**u#fS>8vUh z9rX7?3e-WjHO-ll+*F;WgBHbiY}A3Foj$eosrZQImq58Yn#N^np;+Jw1r)=k7gEXy ziyiNb9wo|W6$lx%L1q{jqpTL33`PF`yO!OFjHAdvG zQ{5ZY_DVcfb>%(o79R6x+bglE$7y{~8lh4>-x;?J1gki9bq?nVeI<07lPf~@Zx8{u zS0}Hkn37z~UgMtX@-Jg;Ji8;F{6u)_ZD|OO>{B{R`%(m{9Ct!V6Ka~kDoos1Jt9yV zhoOSQC#bVawmD59(+XT!-l?cZkZb9F3s^xi07tn-11YF0T0D8)tax(qymlL8oc*={yyRmMhCFWA@Z2zQGiWU7=DBTnQQ52e{CT_uVP$x>UAY zjiaVxlTlHcFKi^kSjyJXO;v3qclyZISg}ZqsC#=a5C{nI9?;gMz!P!SJ{5)?gw!=b z0$b1|s#?{_N8-s&S^(pEJt`M?G|)u2^buMLD{Csxt30>zoSO5_mF3U;4`{RY0x3ihal`A|pMXRsf9lE)G7Nxryl##y1tJk@@^623Z= zEZ{7MPwMe=__*IC;QYqI#-WForEn+1CwbfmUw>7Ct?(^ED+QcGAm+t413rmyEqt<+ z<|g=LDb20cw?Fg=$@en&E>ZcefN!vBtDE4vLgjHUd{U#$@JWpV(8(mXQ?2hu*7qTN z5~DC=V*Cg`_S^yIN$YzHzPr_ecca7SURA>q!pzDD>Y z+$#74m)q>uJ{T)XjFIq3xQXydxR>nLFRZUOOgj>;6F!N1ul4=Teti`_p^|-JxR7?a z2|kJOOY7SLpQOhbU%_-3KEc9B__#PD;2dFLzlKk6`7C^b{l4g31^bu6C%LV$zTd*P zLebhr_$0mG!`Gxz{wsXnQTY83KEW^77p_pS+u)P*Ubeozuzm|{mi65M-#M712{;eK z_kg03*WjyE_|vzJAuXzx9<`-w5j)ZGA^uUxoG6!zYy3 z44+WW58<1yT4)V?t*Yh^Gn{In$Kbm|!CoLtg?k;o#j2L?Sszw;=r$bypX70f^^Jm0 z@LLXFgNi!|KEcNn3#)~%UF9(!KFQ+}>uZHiaJdpbiF*fpg24yiyIqxZ9eh&K$KjJy zUa-D5t?xbS>yH)I60Vd!RRZo{%f5%fe(GB7hGBRMp1$D&!Q<<_cEdQe=1m%`SlCxs%o2R!O|0p zw;)0}V>wlQBw47w=p{HIY>J}R%jkDb@5)o?8;)$J*=*0~eURfT_+G(2&SvcU{Cz<$ z=hK1{3g;Am-`A^mg<93|g9>Ip$7H=4>F^K*^tmeQ={D&xsz%)JG)8?trq6Bu)&5!G zzXpGVb$frn;@bmyh4WY=Npj($`U~n8V8bJ8bSI+BRM8H$HJYK`+t8Ski>D&lVd|a# zd}=>L3wp2qNbaV7T%X)nH@m5R;etucix$;kLCOKxmwFl^6(RU%s*F$P=VS5man9xW z>++*WbW-s}`ujSSZ~>M~GLBEh5v+Wr_xo5~H^P_ie4O`y^W$KF^KdZFsR)k^Mv6x{ z$3t>+V@3ng;S%b%k7Gd^Y8N#Ms+b3xzKms1=!vL&+5Ch}Kn1u_ifL>?xIRc@FhLI2 zePTOk0!YW!4B2=04}?HyoZK-t|ML8R^V|HY@aPO={>3TtU6a2ySmmT6b&^GDKQ#9| zq{N{zc7*kQG4DqI--`O;{1j~LRj@hrjk9YP%{jU5(x%Dk!UPt9eD+uM`SRi+zJPP9 zZ$kd51<~+Od;@!FGM-udLu^A?;yWt;zF@xdBu>jOEBHp?b4B&2IMeVswUBL&^M>z6 zrw2qc<9cC}i;rxU2Ku|o@21||Dkw$6VTeuj3!3X@EM)0U6`W(qTxD^8R~c@{Zj?_! zy?@J_??17i4f*#~?8JIhp&9?A(!Hj**x%r9D)?66z~U*Ynfs$G+Z0k}7v(#@h35sgQ?a2>tcwy}$DhVD!WMWd*g)zY5}oHN|)N7^YV@VN9_`A=Pb6+PSVbnMInB zG+Mvl0@HrP1F7pJ6>ynTf(=_Nm=Bq7#Tga^DlR2sbJ@A$e784uA{{r8eu^g5eB1=} zIU!D4@A*BR#L~H_b4qb2j|{#U&>iYqOK;NoR`3eCEb@vziJ6VeLU64RHtGcX1A!+w z_d5f9i?KmL3d5~+Ahlqz^PXD&IJ}bYvlq^vuPK40u0{gasDKMpQ&ofA1goK*r$Ec7 z^c|k}s6Wry;@>a)8SJktj>wROsslK^c78K=qEAvMj0`{qi=kHc0=2HCsUUm;u!lVh`Yb6sVV!)>B0^PA9_ zu}Cl43aNdiZ)KPb!m`g&x!)W<)5&vYIfKJ1!(3UNUS=&RQbj&i^)k0Phd?47k7G0X zxr#15&?D5)~*) z;m(j(6>PGKChbYeICD;e5F#Ae^{4H#57&g+FQI^PX0EjSZ=#QnrRr&%Q&aQ4j-d8+AE4?tjcfYlgh zV0mNV!Tx8QvB9r9Uj&QtdKC^p2g&b-zsq}-IOC(YMz3%V?J+)YbF5zRJ9}h9!z}5C zs-)x3uS3T@p)^sZ5+UiHqB1$Ou*mh)fERiLj&3xl)ywM_)}WUh7JfhouOq zTv*4A+r+A1A7`KAi7Kp8v=jTct6VMz(KTy&7Wms37-5Y-pwJl~*avBF=NiL*Uxj}@ z6aYysc4k8VPf^WC3`}?=3iX7O&$mlc$bMlBa9nD~El)?(zsE{3xDwAwr zouVTB+SkYVzK=A>dP{fxf$wGz!uNgTT81_7_Z5s~)1)C~lQYhk#iuICLLUi%$>pgm zMSgjxNg|P&K2niHJ)i(|s|Fi-)-u)5O_Lqhxu*$4(8vXv0$_d8wR-A6jbP!xa5 zL)a8E092FO%*LUGzvbcJetz!8^3+s9NXEl-NbS4mpBUPA;Q5+&vVCkg}DG`4hvff zs`Bom2>Sg?&qLIrg3Plc$S{;0G~S`#gUm}cmph+E)-bRX{GO^|4f6)f#BqPSiQ#)K zeS_cJ<#`3eWB=0oBO`;sXiq3LXB9K!jc9R}?P<_AOnaU?GybZ|7Jvek%KKHMgDMp- zU2D=PLd~<4SFMc30xHdH={<$?!hxYla5TMMPd`b(GZP>Knnlv+jY@mzH~6m{#FrEa1jJI*MT zZl}VX8wKuscyL9uuzi%thpzj32;3Vzwr!icM_U4zzik`pIXdDF`x?U@-u5LC$!(@M z&m(m-E<2tt)v$_6EjuEgGfWjQKaKluLAQVn#O*;eXE2&S(1?+1ps|xq{or{d%%d@w z40U^0h4A#zG>WpRcQIRXL}#*bNuh~Lns5S&lmik(Md+&((NwwCMf06CQMc@fLWv9( z_}gQVIl=v+Jqu|3U`5f5aXShPNwpZ?rAoGsN;qIk)?b&*-P*?QZei8xITZ|XhdV0Km!J?o+|(DplpfzZHU zK{UAPqa1kX1&x^2zbBNLYe>%@_`jlfiMaWl%AgO%H)3(zq{4jZe8p+P1Z=)42ytWz zLIVYDncGynPornU9Q!qx-g^1oPy&Ls1E62OB9T3e76cy-s2kQ$5D0^6w6|;IIPE!F#Jw+ zhCAOzm-{k&^L%R~ZY`WA!$tF3Ux{AYcetyp>YTN!C#ghr1f*4t1BIi z#*iHfMGruTiSfgj1!K+w&LjQ;=S6?tFw@`HRV4OKL<73$zDPcppIrrH2lbIk{q#o-SgLV>AZOG;#CcJ_g#(y_|i}G);QV^jq_9{j`lM+dL#>u4ndrCUE=5vRj?F} zPEqgKaa88U5jJjgi=#4E;>6LRx)nq=`y7*5mpD3BMff>zbhE{giIfdTN2hS~gKlwD zr4mo!s8W|M8;;!Vs&FxN*^|*=vY-3#V8t)Xp2Wcy;b1@isK_ui3JmU#_J7xgp^t< z5&jy^cU}o+!OOD0r||NRZt?PwN<4*^4|M6W;l<4h$|$t#8yqS@zmN4X4bg>>qSvw? znGjtWDcaem^jL<4Q_`dbx=(TI07tOr8@23+=mAH&!9hk9@L*T>+zPON*%6V$B10p? zB8P%P@`5Pr0b!HHIT-P|?(VSndr)do>z$+;quL2Oa)1%hceH|q5ig~hsQWyE%g$q? zxjRsvX93+{*>rTEg=&PCc_9b$IZdTmY_({!4#bNDciIX8%U{o8mCI%$TK=x7b63s( zG;MBy6@5sCoV-mt#gT;^z)30$&p10oRbM7tKg2``^zYyZXFZlbYz*$3)-XRQkwo2% zbuMv;jNGto8s@FAJB+gW7Oyzm4O3=c4@}v80duD{$b~F6fWIRQLTLF`G#Xs-PBj0T z^T)daEK>n^GI2CmTUCBLi{L*+e9Byt7gD8&u$>z&)`rC&eY-gh{~PaT?@j*nc?eE5T@9L9jQnnagZO zx*4#v`3q-XDEIFe9zI`{ zG7u?t{t@m{8Zt1ev{(hcF4W&y6kA5^E)}s9LU~$dHF@VNm5JQdIQuV zixeB~r{4Qy>-A8~+`ZoSROU|?KH=OJY(U1so<6;hO(#@Et)TK}=P;V7rh)QHt#h%G|^$Y`4;Cpt;#DX=j+- z;j*$tY?Bc#f8|-(!ewQnP={L7;!Z;;ospIEGtg$(YrZOQ4)%(5Jek2>;Eo)< zTE~-yt&Hm~Q9Bo{gp#MbVZ2Y>3sbjyBb-UYTjOPt&dKg{E|PT8U^<Kb#V6xjT{x9s*b0(YD8lTa6=BRmyGNeUSOC{!<*&HV zHRe%Qu*jH)%)?z4>exzWN9a4)op6`$?}1x_Gwljdvr;i^3Q?QD<_KS1|NIQCbbtbl>AXuFCe)P_grM3?sYf zafSV{+du{GujT|f)|A3mp!Xda>_Q}LQ&CbP!Jx)XxYFY$pEsq>EfSKSXA9?L5XJhT zr0VP3d5K6^70p1F5eZR6J2^x`G}++h5;figm*g04Cb4HWwdRffj2?H@AhOxFaF<;B zU(f^8Wf*u?m4UT{&8k5dDKT@}}cb2N-5Vf4R$vGa|h|a@g ztJqm&>G1Eh#(9YEG2igO1;Go{L~0kRu+MowC787jM!}6WQLo(5YwxJylHJCtxF?0e zz83<2LqWI&Ci`x(V*h2~H}Yji+3{faEPeIFRgGxEJJ<*r7-ojFnluWAH9J0HJ2$CB zEbZ88#fqyMg%#B}CWygE`y6JF(MzuqVVG_LYG0^&={iHS-LqtiD&Lnl!~X5A*LoNw z_(m0YS$=<~KHv1xrXpRiZb#9hibx*c%Sy{4h)ugQO$SNGr zBjP7*0S`?;4-3K+#=Vi138;A0pbVA-M}Z{^6wcf=Q)AD9RfCw2`{$PGGNX1qX2+KH zb*qDF7Uz0!pIQjBG~$jUGdI^Ci8!IGHQ|zxBh_-3)XYtdde1s@bN#U(Ixa=xtY^!g zOateb^*q*DJN>h00qY9T5FRMRr;brOIoxsZnuEdF#f2#KsUQA|P;$?@5 zkiv^ZI0V|#0lqAFS^c@i%hFNZ;sp~Tcv5)5U8Z=lFEnzutMJI`@1R|;&ES#M-!VMW z=8mIraW~>D?GhI_rXEiU7cZ&z?6_Ft#>LE?z{MI@;>5+z)q4sTCbJA&P~MV9)Ws`K zqYryo)K(C#3^0+h;o`R`T+Hnj7mumZq;RoGm(K8o+jY0A!o@MGFF?Dl&&0(Az{S`g zzWv%AN8w`B>IT4n*(EL-Q~~;{*#p+}R`s487niwl(YX`2xJ)G`h$b#B(Y2*G;?#u6 ztV>)hR}t<6E;=nPOr&hMXieebmTqxztx7zFi=-}{8wbYkZu5U~0p98oJ=44o3aX`mf+?v|x3aDf|Cn?>*qFD$+mh2`Pk=z)hqWQ87qR5YSLmiee%GZX`ey z5L7UPB#>wzF$o03asdG$T$ZKJC;?}igiIOSb2ZX%$(mnxdC=v z-T(XUYwjl}&vU+K&h&QX%*+XwUb9z;Urt@{xf=#~$9)igr7ZYf(&%-(c|n_EzOiW% zQ7K%(uLzR^O`^Ih)B31>?J zEsRGvUv6(*Jjp@TQ^Vez1Ld9mGJ`Yu4u49KRHmmgw z*EVRb#_PvyDcJ5!2PrlSRjhpuAg}m%_yIj*TB!8I6GG`}lK$12> zwT0KPP2Jo+Oj~Z!M&6{4(Q7|nv=7YKCqbVdiFJt|^JTf~A=9JBi*9X4Iv%)A@~&X1 zJ@*)|x$%1nX?Ppc(6#7bX?Src4IlWIX;`E!52fK)eSYvRfpdr=m8 zuhT64@Dq-!wITE9B~9Ml_9i#nTlIN6hI@lPkJXb{>V~^%WOih+3J<%Pcs&2^_{f8Q z0=m_FY?yAIeY~xP9Uq&2Ig;v7%R8h4bd~l}PdzhOY7XPYXAu{dsb%;&tSnUBiM;6+ z4ROo+aAqbU&p!`?hppgL%t78wOKixvV1;&ShmH+dEnce6qiRjrF_VwypXUZiq_+vv zlaJfZ|HduMhnRdk{~P$_aFdUJ&~7L58C2ZyMxUO1JYSY*U=><|*9QSc09o4cue=~>a@e|Aox`6mG@#ogW%WeSd!}9c=I5G;K8YAk!wxAik@|YcN9Pmf(NfT z$RPNvwQe^4*CTG%YQMdVN8!h@S^aFOfl!;iQHHyq5IB#hTiGwCX*-~QC$alwOknq4}znl z+7Y*dymoFFJkc%UuJroIj3&(c(3`DvH+3F;Tiq`%JjpLXbPQq?p$3=Vl zymovo7-2hYhs}~Qwid4~4t3ZX>GOkk*t{|Miag)NF1pDL{C&x0qMz4HnY#KZEwNe)+^qU2zYbVrp%v@1=?~TXn3}8;XR7R=?+s zT8#ZaLZQ{~dBd1~KMQs!U+VX~QH%F_?a}Xf!n9JK==$d)oP?jpXET|~sUopDs+n2bYeCmDp0PLs^s zm-PVBCy@aQX=3N$kZ<$eba*`h=?h>#r^q#lyeAmv}ShQOM6B{}J79Gh`GgF`l} z*^Wat?vRB9J8;Ojo79J|;`j-N%+;4~Aj>8PveaIl9XsLZj-xk@Q8;8P0NG7I=J3m| zu20~IN=Chc<8~ZtaNLdK9vt`Lcom0i0^;D^OagN5VALXsDq4@YBZsAA4eHvt%V|J~ ziKB5j0_z&=2kn{zl>+^eCP=pP(pzYX$;rTLG}e7eF&QA@)|5w!1!yW{SEs=dVOvbL zz{MT7DBC^`jtFi0m;^4}0dtdgPq`y;B{l4d-nmVjPv8Y^n*Eor9J;F?E2oY^ZjAx2g1%{ zP+iE+wNI)O@3~Yd-t(iw&W{f}Zy$D^8g_0TAVTh$i74j0ff_8n`x?i3q`3Q&Jz@*7 zB&;0ZHp?+S8W@XnJg)^RAXh_P0g0LLfyW@R2~*&8$au(iAR9w|2-yVkGe|s92KGQE zKz<8}SEm7a!fy(B9AtAy+3pbEU=ExOnFJ{VU@akK$J3)BW!dsEkQYE63wbdlUc&}v zLMB7r40$}{8pt+~_d=#XJ_Oko@*j{VK<sNUX&UOo!|Vxd!qK$QL2cglvSkIt#J~WE!MwdxMwNf&P#gkV7FcNh;6@ z+bO`#KoMkrNZIXh0OSc+7L^5gDkQqxfw7QseS$rgWm4HVzY+3W$QK|nZV`~J{Dwf5 zL1Hm(;2ua!{0jUPQvAIg@&d?LAuob_3vwjnJCLIwcR}VrVp+P%gFFSY05S~{VGg{2 zNsfh(vI$=i&A6glyy6fNZ9@W3Hz{bZN`Sp!?BdVhh@hu`e^#GXAzcgDZ` zijuOFRBk7XB&)rhuxzI~2qmW!hxxU^fSTFz*KT8~n-+&bB|GNCi>%T64^7^mKsekVJzsu==^6+>6 zlZXFL-u`#}lRy7;{gd~9y8g-gKVARi{hzM?3;myt82>3r#=9r|2|3XmEEI6rc&j;> ziRZE_$%15y$ZjILne2YDhsidPJwvvi>}RrA3}_qw#aqo$No2>6wIl0D)}8DOvU0LY zvKeHv$*v>&3)!<|FOt1Q_AZ%xTF?0TYcjk`vkX(PwC2crEz9tR%Cg~Pc*|tj9b|Wr z{gvz~vQNprB#XxTGUFF{vu4s)-mMvSCRs6=yx}(Ht|gmCChs`Sy$_LXA*&&Khin&F zJoXMY_a<1)(YrPqCf^J;?q<{6P_kmOQnGnu3&|cNdz5S&*>hxXkiAXz6WIZ>Hh8aS z{CA?&9F;|uO*Wb=pRAOuf@}fVb!2yu-ADEk*=uB9lI! z#A!ZRA=zZIE67%mttNYx>_xKo$v!4K5-*F4yGL8iQC-PSC+kl(fK0xLXYRe6Y%bY+ zvir#%CVPfV-qM=zzDf3XvM;JC01gkZsKMA{#&^d)vrWM`2$?Yp#TBD%sU!caYsh_E)l} z$ettn8(9Oqn>T)mv6`b=khLW1MRpe10J6bkIb?Zcm1I-NR+8O9b}!ijWUr9DLG}UJ zCuI0OtqliO|Je9zOV*z3y(X@?53J^>shDSA;^1nlIjRTd92h3^@I`Y}CfPu;Ib=by z8_8}WyCl)IZ-UhvwU+E|vWb{8VBDQzHAl@M3z9X&906l4&T7bOWXF-Ek!6q#B^yDu zfb2T5&&mEtc7QArvkOeT>;u(WHn@slU%=Gg^>-%v1F~uE+@N+Y%bY+ zvXx}FkUc>52w4w&!Q8~bnO1YuK(cem%E%^>O(&a0wwUY&vRla3kUd8BBv~iSQZ;_* zY&A!nNtRAFk8B~?3bNH?$(Yq@>`SqlqrSu}RKxaK%~8LQMPUA@Ty@krR*O@E$Sx$4 zd8)?TC1exGs>l|Qts=XXY&Y2#Wc$f}CR>DAsm9Mstmdej$!;h6itKB$U&$I^o~rS4 z6RY8K-ejkcbtUUV)}L%1*+Q}vWUI;ABNmOHJ6R3&IN6zGv&iO>-9WaCYz^6+WZTG| zBYT7FZL*Zsu3y?&4bK5&-O19Acg^*+nxlr1T|l;u>>jd>WKWO{YUA2>p4A+6G1(Zh zIVrBWpw%4p7}=9#&yu}J7SqL(3BU?zek?aYw7sy^B`+{r_+0SHHI&90}O;(FjH3P9>3zBEyE0)-O}Yt|W`>EtdgwR$*vno zR&&&MWIvLfc#3PTgVh{$I$1BWaRZ$Q?gm7x^B$1nxif`&1Dm;=BQa@bIJZn z_7vIoWIvJlPIv8VYBls@$%@GWWY>_zc6aZMx0<6)CF?Nmp$XbwHNA?%8TgmPq+e7vZ znL5jLBg$%yN+4@S)|u>7vc6=QWb?@uldUAXh3vI7*WEX*=BSUzJ|%lL-8J{3)g1K} z*}G&Xp6#0JU^TQ0WWC7xlMNs%Br7Jnf-FGx4B2+F*T~)^JHL->_xJd$rAg!?l!lYqgs=-CA*32X0qv-?!B|D=BQ<4E6J+KwvfF_wv+5fvR}!Z zb6hu?SPk!m$oi8FAsbE>BwIxGF4_BJKa%}QcKHC;-K(tTs5{8+B72nVuVinLy-W5P z*;iy$S*{xktcEe8fi4?pHAh`QHi~RD*==O&$sQuBCfh>x53-NQ_L6-|)^m{Sm)=&x zI0M-rvh{;qa}Qa~Q9lmB`neQ&Z~Cj%9MyN2YcA7jcwQyDfUJP5h-@O+6tbCQbI6vE z-AHyj**da^$u^QbL$;mlHL^F!J|g>+>|3%Q$fD18!`sMe=qr;QMb?(AJy{xA23gXD zSW?+q;`A7+IjW3o64^4cm1LXAwvi=Wq*S`G&uXxbY!cZrvXx|;$+nRtjl^naW1rPv zAK4_bWn?SKHj`~5OB#jM&&EEh!9KD{WXs4_l5Hm2MwWCj)`}YYtmde4vP!b$WUI)w zkkybS<=|6y#y+dTKC()({i}*>bW~WLwB;$dYoEI?C8* zHP}a1Nw%D971gY&qE~ zvMppaWJ&o-Wg7de2K&e=$(EC?BHKb%LzYy4wX()OtHD09O0wl-tH`#H)sQ8P#oAh9 zpVeR=StZ$WvQ=bT$ZE)v#$jEivCnF-kF1hxIoT?*Eo3!hNrm_Tow3hqu#c>gY&qE~ zvMppaWJyIzjWG6E4fc^$k}W4&MYe^khAin4>^@=avl{Fpt0Y@awu)>ESq)jzrC6hE z?6Vr|Bda7^PPU3{3t0_WQZaVhF!osu_K{VREhk$=wuP*QENMJ;urT&n4fc^$k}W4& zMYe^khAe3Uc9}5tSq=7)Rgx_yTSc~otcEP91UqXO`>Y20$STQ}ldU4#LRLeTREnKS zjD1#vePoqn%gI)eZ6T{6OB?2&@kO$~>a(i8qi5`jm|0zsFr#4ful}l_%$nM*@bk~u zl00g&KR8!b5PzykaBitb&-UmE9vuTAA@d$R)njI%NB8nW*^})t@733OxL21DxPCsA z`9t{=k;Hpx&vAgVMM#vwc%Pb-EZUi(X_iS1Jsit&sUeqHHig!;@^1%x%mZU zJ$sHTsF2M^%9ZTDwlWP}IaN_uRBpG?bnok0>w7S_93!o5-09c{@90MHQLT>k?9>#2 zM2T;x@U7secqb7iqVP^Ow2{-3yexZ0CVH+s+7dU$H}~$s@Ni*bG_cq!H;bpmbK(Qp`z03FB)oQ)7+F~VHBc%J_a|{EyMaVPrdaq$ zgbIlID5S*g2FQ+(Q#=A%F8LQC@Y#U?u@*`+_H`uirI>_{=_3$Ee;!h;`be4@i#5e#NTvC3DXQniN9lzEGGU$ zbJPy9SFMJ)nlmybY1sM0)6Y*Ijyg2eUnL2w{9U*B=VYX`^H=?tRrP~^&d?OpuFp#K zp|YwflQL)gno#ERSDo&!`pO?!lHjj;_w&a7Dkzcv^jE#-ulnBK>+cmu`#bFOJsEeP zx!iVbR4f01&A=1C5F7keZ)8^eO~WQ6WLDLfJGb?RA^3J%|0Eye)`rUW$Yy_47Chedd1It%WJ)RO z{?zoG^ow&Y9<|x{=J}>D{tB{ilsXyOwaKCtK-lZ6(@9Xk|E})I0cppVs!_ zf4bHrHKew92ay&G%Vqn)5$#H(>`i8Vq1s|#Zs{4UI^^V!$bZSbB@Y(nn!2YGe0k8i zr>))sdN}f4TkWk^)K={AAsZq;j>L*kvZYas%1BJcRd>5U_@fy6Yo<}(n zvxPYK)-JMZS$x01-1wMrZ9R38-bOJn7h9yp;M4P+^rz<|^@lQ2ym#we725}{kB=F3 z$c+`R*FFgCrM*F)WBWpnbITE)m`0I-znF~`ljQRyJ=_fj53;+WyAAYTv|T4)fBD9T z-uC)7ZDE^k_(s_%+fV z%Y^qw>vP#oyb+p>P(${*c%sp0*RS5K{ZBzP9Ut8Mm>Get{@k+z9;v2>{_4wU-rQun1{U8NM zBC4PEL$r2(5Tap(K3}btqQJS1d80#zxp5b7sSsBpyGU4_y6#B0WViCOw7soSoEvMm zWOK;LngvuPT=Kf1!y47ab>5XtuqPubLcNFLCgcO@7Nlw`%)fTjWpBgF(TqtmDtjAB zR+s$@-8~H5y$jtv3f;X1Wp6>*M^MV=9XMnkK*@xX2PB41#vu_f4~OK$CvZH4qZ&s? zRI4{9<6GP~WbZohjqF|LtF?Dsk5sdB9WF{eX!|6xb(_>wQqK*Jka|wGWy=GR-y5i> zBVe=lxW`$`3mH-kYcZ#i~J79 zir>1|%73@f2-~!&c6;FNz?2Mso1bjdVm4cn72`zF9909&xbeKz9JP~7dPXMx_Kn^z!E>BiTR2p<;2E2g3UP>>tseeE}(S)nWRxvcInR)$Y&! zFwukH+vMBU6jh|z!=ExqmmW?38zOa^IM_B8|e6q!4-;(`6b|iY6 z#*L$`=BN|NI*=_RTS;~=*#l&)(AzZj9d9*9olMq+Y!=yEvSnl|$!4H0v!RXjF=t!N zQ5&HdH=eMXqqdVt??O->KWJA#_jchIUjj)=d{!aD}vb|*Ak{!Iys=KgAGqvt0 z8EAyh^`PR*kR8H0Vekci_u-M*`~rnjN=qvA_+1(ZzIr%fvL2tg#Tt;W{mIjuy?TMU zy2f+W+m_0QcH^UUlY8igIq&$j+#nCu(hV0U21keogy8wvC2-X2v?~=+I~?v$!n72D zMvlTjgZVAPL$YYgA*J9woGcM8LlB}lYB1RlGI=j$%w0ydn@k=X&Asx75G#Y-7}9>z z9o6<%)%dISo5A60sw17GIEs4g0@C$ZfY(<0*?wy&1{%*aGZtXRyXL_nK|?#Vr)@y!I+6-5BDZQ27HUg zkC|AYUpF1?XOGz(`)Ul^vDG++dP84&(+D@n8>;p2JF-kxNuJI#^2r+WYp#+#BU}N5 zEoIwSZd6UezpdWUi--=(19)gnbVhrrycQTUL z40pMMu(J9~vRSgeZvMqmPtHz+uL|{Ol=vVWrsY+MWCaPUZ50J|2a>QL_nENtz?a_4 zPu7shxK5@$Uw5KpH*QxCd-#(ysX?Nl%yMYwer%5|vG^clC&-5&#WgvXw3BnOTFxc6 z-V5hUZWYZ@)5&I8%~3ayA+PH@9Q81nymm16{y_E%nY{lrZZx)IMiwNK+-K~Q z*UIMJyUBEk@XskuN%GIBNJ$=^J~VxpeIZopuPTf6SGDw4Nx<>)=UacTcYW7vhMxJ< z{13XzUu0HL7lgiDzZ~m3E<;Q`H?V4}KR7gH#BRCEm!N!!87Zk>`x4R;z7{n*a79YC znpl?AL$(f3zH1iZf7YD*l;kXUquoYH5q&EPrG61r73mKSZa1fYvOhQ^)?Ar$ihoW? zERKY+c>g1}<4#`!-0`)?zpScl;)B%8D)&v04uOBh=5`W@+o8;=i(u%| zw9KkjRL~2K=KGa4+y8{I_N?l1NZw#)(5rq%QDm4KK zAEo{Q?PG0D>@v2<3+F}2a+OsBYQSa@{iPn^?^u|U8bRbRcfQ0lmJ}D1m!APE>%8jJ)l+G1QJGv#&MTQvUXlEVxSNcZR~=LJ z8?2%U{n_5z8Wym#7tyJC*vZW#!B9r6#pw4RK z;LD$F@GhfqUxfy~ySi;Zj;*C{4BzI8@SoA~G~_c7?+)_6~YL#q2F=gN4Qt|D8gK8aHM$S+U- zpM#D6LY=W8x-Z$~Ii4nRTb|Ymb-m1v!zciTjeio`HoQsbRZ1ui6c@0dW zKCo53V>R4F&*0+x9DFcEw>{EMtQ1$(ARRvgJ+VIsY^!ZMQ zP;U)El{FN{=Qv~u`N@bJDT|$PNJPDsj8{E4dcf5%zyzw60kHG?ja;=k_kT3s@^YLML)%a%L48ziaPa6=7LYMf86u-af*DQ4Av;A}WCHQCjkWd!suj=g& z>OMqfFsi-3*S1MVpA(E~=B#dv^z zMS{}KU-hCk?71`$_FsX7ic&M6t=Hoqi=f@7wL7T23Qaae33Z+&vC6`pt3QA#d9L1x zqh~Vy>7Vzx`gct5vt3i^O4XqCJLvqXMBQi0Lheq~PQRocfx$WxncOFIJiOrdjJgv& zDVZ&DE^aixBv`}`083A)yy)@*ZMn=1YN8E2tH!H=c)aeNi2R9PPIg6^nF>^ppOZVb zqM%IorKAUm3GDdwMaLi#5flmEh59w})yMcKl)l-Q?Y!uZ{zeDZ$el8O2purp+wQDGD)W?X)t-vgU9^!N6J4|kseD#w z6TZ3;D2_`+EY${@9^COJrsw1ht9<1$KKANE`{`=yr#eaIx;RxEh}SN<{mkUnb!W;* zc{V?pKzls8S<>oDH_M$NBM~J2k@%NcF*1~q1~ZbmJfj<8iEJ{4PRii1W7(CF2m?Zr zE9uIN2$||rGI2r$<}}78K9h~lZiU8_es|vQ*)u1nxJ%ETXB6j-ACsS()44aIK?YM~ zWUm^B`;&4glT{HC^^k?Jja5L(rUNPYSI(u7BtV`B*#h!Z$Ri;oPsw?@JwFHX7@X%p z;E65AYG$%uyuz@9>qLHXQl7A5BqK z)ib(vu}u+L9o-bcQ*3WWZPrd>Ko{+qj2h`1JeLQ+N2WO%PHiSM(=c5J%`{BwsJ#WP zcEcpIdcqqf8R?hI|1OT0Wc<^=|I>yk%~Rz|+ZfjvU$l>kiH~d+cXC`;{eAmJF)@*? zm5piHy|Me~TtDPJFYj-svrq zv`*ed4yGCE`Y)TI)3hDe9K0on4cva{Dqr%hjEsnhgEvEFWFpiIHBvdIl9fh5h7!zJ z$|-1W`y}E)SpSCV|JSQl82vv&bIJ8)Qn|bbk@mJud)Xu~C!CumD=_WQ0hp%kjny{F z-SWhrs+sv0OI@0xlhG7OR+OelK5^+bN7tb#3U87mpZv$ok~9s{Fr?vde^L&lVL-Q8 zb+hnvRKSg)_ker~vM1!T_FT$~oJ+<0I4fq+OvP-NRLq9S0J&i@KyH|P57w~WWHLw4 zFqtE0%xxfhoJ{5j8gnv7(3ty)>;Rd3^VOJ>*@DL0iDVtf@Lf`C?n<&_P+ypPldXmd zcgDs50;POQs=1=&VVviLb$H{&5Poquu0gDrpSNE5cV8rx=aiHdOwa>`r}z)iyNy50 z!=+>`$tsfB!~)xc@r7|}F8A6EZ}mH;W?NraSim#2_Oyb$F8B=0w#qlCs=@pijrS!=URjjH$TC4bH@^VEX@-SAqT~bmsA$Lr%d2Q@J z>k!cwd)TtRhrQ*Co4UT{H(})n)ls!{`gy z-DLZG3F%Sz*Jz*bf@&Pw_xVQD_=Z>ePTo`*3%SpC?xxMYcAKRAQSEU&q{kPcpzX!+ z5{}cuqEZi-fVaajD3o2#$7hU7%DVRKSzIt-Tt#7*d|hR>>VJr6?1VK!p-1fpTB5Ya zC&kA$_DssKQ#RJXo#r_3(ei&)9pKftTOEjvZgn7@sGAh>Eam2N zaM1SbcRa+J6w~P?i!Bd2fD`?1X8V7!T2sOizFITKrvkugG^B(t7g8d47V87iOuxo3 z>DL(c4$bW%Lw48E-dJ<;_Vk(0s$6$CY!Ve5dT# z=Sy@dkM#}T;ydN(Nk>$r$NJiB#tLXW&f&`0Q79%)1A2-0_5hA3ECe|2e$*%~<;DZ&NqVYu)IvtKWRJpkXV?buwl6>S_j7wkp7FZZ7Hrq9Ew;&NO(&xUz zrdz1I_~9M5yolqryc~g^i`bKfV{n9VFf_EGyAg63KM9)@Az5~MjR5@Gqo_y?-vKfi zvJ+$*$de%@F*-w@1lbib6%u3Zf!>hmko_Pr)D@74O?Vax$a5!#)dC|R@eU~ag2TbDl7&bfnnv+1pl1L zNy9ijB)GQS_XiI6r+u-$5n`f!X^pS_XVcHk|$>l2T=00!@t{?;Y&DHf`wX4`;FmQjTH3D z{^law)beW|J*PwNuiAkDAEO2rh6g4qs7C?e!-Zi!^tGEQ(c)|0ceJlvaI{tjmV%aQ zb!GrA;zB^51sCEhE7*6mOg&2T2ZLgpb`u`XNb&nl+2))6t@zP86b!BpnYb9LHI4+< z;qzT|V4rW~{tREcZ3z1X+JHntR!W8lIAUXExF zRP7G>56t)>&o_Gztj+B8jqjSiQ2asTgVEhXbPvKs4J@H%OiXDzqr7jQNuvV&TPaA>Uhnji^s#`Dh2eZ?>=cxE`??`E; zy!W=-BQ~NQ^HQ`Zqr=(_pd^&TTBfRYdRh(UApgv_CnkC$?9W3Y@{~-= z@OT0hj;6tZqje^;4TftYs$R=I8E9tp#I9LY!5uJ^5lm}{if**m&40&=4C949!T8MZ zWXcFDN@01%=K=go9=ZPq__q426icd5Wa#2PwXxa++0D z?J;f(t#!QF90c=eZ-J5AC=Sb<@`L8cgE^dzMr6{N*3PKR$ZFVXo($ajz*`NO=bx}3 zrCoENA}5r0Lf-d=1@(*D8|%2uICuC|Idp9UA0nTi;=8CCP3sQd?Ea2q!eQO?3f7s4f};WRj7mocAQ_ez?sYL+C_y&|KjuuavyqN@x%WQ1J_ zbz!pMT&N2(TA#UHm{N1ic8~%%LtP;^NQ~+z4@zR_`T>hN6xMX~U0RhEJE!kzBH(j~raGCoDjBW}I9W+Sc|XNWkt0bxBu=aj6JZ0!jf zZCDB;@s^P?0#4#T%JbGqC+Z#!hT1e63J;)KfIc!M8$NvrhuMlPwV#6PkxRV3>bq7a=6XrY^}g9_a5?0bJR^iMPO?68-AXmrtXpZu zE&WgtT!Im1L_=_OxLX^vTT&NHtoF_BS<9{LT5d_6hCfPm%+D;X9J4zBvHrH%=rJ8Hjtu&m$ zEx7^VlFSFU(!$-^uiaAOmh#P(rNJS$vWbY$gPFOKI_(MedfmDdUMUXRgE)AF9^7`!?=|k=2k{Zp*WV2QVQ29 zQc8WZ`_yu7hq2N+w@aV7&h0VRtaA$4N|MYtx5YS@P{+B+I&1+6TfjH_byGiNn{t$( zb0*Ww0B4eH5OD5puNWHWMD3OYWjh#dRRZb>h)>wAGjKW0`Es|`mvGwwqZs! zwk!=B!jr*B#J=ui=wWr=%(56HichV-mD9ksa-!7w|MUJ31G98qck z{+DWP3H~Rbu83BvtQMu;gbOn(PY)a?+D2TJ6&z7|PK-?Yj8Zb|rAV8T`Bd4-!u|>E zO3i+yCX+KC(|0t5_E)?)j#AQ~uEIcllsXRD>o6N7uZXR=ZZszoSB<$5WTT)>()Z>; zdtTdI#;cXk%pG&d7CYd&bVXmip)n_MUR&E>=GDAgUB3AyY%XF}c=nh9?fG?SZ# zLoT#9h$jA zcF-%=_sUa>+1u`GXePYhLo>EWQ*T&vXeOoGL3>EY(D~4^kz!HmFVJLaMwI#vn#l)4 z@xs7pQ=qNTcg%xk^2Rb~CPzF9&6L{DpbgWu?15%-#IL;C1l8ju+O?L@g4(_mvU8xB zoO3HQW6OuoOwMV6s?@OKq0Q7G?*h%_ra{n59vTA8|p?N$<^u{1Xk+G_2;E1_MY zQ(+!7`6h9cS^~}3d=oTd^OMkw&6}Yan|DAnG5&XIA3!sAd=JgIaRAzQ?M4%fU>G-! zgl61GhGy;<1I@TG4w`YJ0-AAS8nxNb%pFUi88=o#E7fk?2hF�h)2+NoeMd&!8DM z{t3;v@iR2zMk7p1Fq#iqUtN+@pqZT09-6J!$j*Xha@aX!gQ1yxKboun+E^XClgOq* zGxyFRn@_fa>}ImNpq1-TJ_^m0fbGyG>wNGLG~?6HpqY~LBh596cT36<&`c;>L0hcv zJrmj@t!2^NFq+GSW@54snu*C9pqZFl4$Z{m&AhrEnn{@r&}1HOl-dH#q|6J@jD4>_ zGxkL`cJ0Gb7i-@U(2P&9jKykLsABKv2FJ^*&yG9@>N2+$Yrj3C-Mr?VD{IumswyNQMbH^jp+F<6LVT-Blgl2pYg~=&K>qzZ< zYFAOanc7xrUr}qB0;$%ndAsxiQ zWkutPCTI_>hlgZaeC?sAq6zs$WteO`tTaEjqCl@?MfSvg9rAls`P41gS-XM0L6%1< z)hBm+L0RsQg0e|Pc?IU9D>CLhRYyjWoqb{!(pEObVorD3V_vrm#BA<_Jma-nV9z*hTP$vJ4OJH9R}^YX zWL@DxeSM=&hbV+KQ>Vi}o3)C}NNmY_^17XeC8GHS`E~5C(D!%Mag!z z%O`O85Tl#J$! zld^8xB&Xh6NAj~IrLq3qW|EB9!yi8rqV%%yC1u)@@v!s@^!St-qt8ol-bY*dWuz?R zEaTV8MWpejTod3NGxn09TJrEtTzo8w-u zk6>}J&Cn9>qx7u{qU6@`jOVwSy`Tm)l>%)1R1&H~RwGGeZv7@*!(azJ?MoTIkuqb9 zk15M7&(eG}GGoY^OD7Z*l%JnSZb&aLESXr0Pdu5sY7ki=+ax#T=$m%IZ4b|# zkZ&wYgJmI}uCt$HfTgfUR`pp&JkA&5O2}X7g|uovE+pX=Q)ibQq!Vjx8vtI1j!$J24GL-CX6#sC}yv<7mOb~&4si_muXL25g}23IXaSf zXeiGp7(1~XAKB8uh8fifPjs?6NTNY{E~)ywC`O{8FQY-~p%>#Nw5GZkkLWW|C-ubn z`kp@ep4#=q8TeX@8|9S+xuqo&GIA?&wPR9KF4i}iX4eE^Y;kURVR~_Cp)n+JS*#6p z!ERvbiI1^nT-mIo!7^vz5mgbPX34k^-Ym(7Xx3^we!(&Y*Egn}87SeX(`o6WO(%HT zhrHsV(o#g*a2*Ev|7wr_O?w;i0t}sa7|F}k3I#(NO z@{vqK3nt4~g=!nSxZ$Oqu2J791?dyUVKJHHt37ZlR80&m7+5YF!IgBVN_2n5Yu2%bX?Up? z?$_hN+Td{g?)u?yZtpyZUnLykhI_vo1~)Dwj(^J`aptCr#F-n9|E`pKe#_yeo3!^8 z$Wy9;)QUr7HzuhNq)}UoK{KUH@4E=oEKmg3<%588TR>jpCk%+g|xj16_ z{QXKM={vF!C>e1W9N`^t5WCjnigf&}UG||mS;Z%c3+AU?340hyf(acx+DKlv%yPIW z575|NB;NLg2jL$-nZ39>C@1K526WE;r#kn+rM5~OUz(+P4MB;G;? zWZ(~9jR*uFyF%Uqc`D>>kf%XD2#I&p0of9&2jo+bXF$pTVH)J~kY_`_37G*YdsYsB zjBJ33tdOlB2SN6RJQs2#4908lo;)Cfd{;rrpzGC;(j%Gw1 z0U2mp2DuV)1>|FpH$lpP+iJ)Ika$xcI0`xK7D)Mi#%++&U%mtKN6591jgUd_gp}Pf z?}p5Ugx>@5@OUqzJjp%)DUa0;LdxjI!;oJ=J^}eX=9&@*~K9Kw=g^U?$#@9)N6&M<{&tBG3{NaS@Q`&!&*_4Au-%o-Lb0%2VKxkn+ft z1SyY>M?uPyT}#NvA&-IF1bHmv3y`fKUxviIg1}dh$3wP2_n-~r36Lp}7eJl}xe78B zvJJWuJs?*=o(*{mWCrAWkb@vUgv^HA4~cmQfzvQ-Z~8=0p$CTm?sgy7tGaS$gz;u zL6$*cE{D7f@+QcaA(0mYe}`NR*}Ez7A7m!vt&n#@ z-Uj(Fk2Lw*H$59AM!_d$+C4|+XhA>;#)&q6*3`5NTI zkloR1z>JPS2IL0F+aWhXu7`Xa@*T)0AY<{K>Pg5{$fqDLgsg^?j}mW!ydCms$Y&up zLw*gp1+rBVwhD#p2e}op2yz>wjP6~De7prx>VZ9wQV+-rm-lgfFX~O?4{Vw6@9jn{ zFQRJgDV%zUmq_kMK(kSh&F@fecU+U}Jtk#Dzzj8bI$Ey5YLsc$O3w%*$Io4J(gSnN ziG|YmVpf1Qr+ZzlL1~c851$IBLE8&+4XyTgPo6$QgUGH4>8rWc)ES&MO zLr&SQlxry2V<_bDTD>@9TaD|Wl9vE(2;E+tF|*6#Z;u&0YV10g=5a7&#tcTgW|n%~ z3LgeMkKrrym|#2UCMwr^ED1%E+nFzK(SxzrKz|f6S8sJ^9@{dAku+U&nf4DO3s7*RiU;j#Yutb^5Vg z>+4vz>Zq?{>+4um-;c%XwEBK5MhoqCmdu>h-_?)pR$s@~*Ri38()xbvp`U?6u~a`+ z;Q1zAtw9I#a?CAJ^ed z8|tCe_hak(vGsMV47dM*b?oW&b!>edTVKa=VnzLUY<)jgztQ{y>)7t~b!>edTVKc4 z*Rfbp?G}Xkv4T4NSj?MNJ^$1Bv7I~DSFsvnT8ACRpdkgXq()&1DeV1cYb_jxDbrEMO+6ACRpdkkyqe2V{SLKem2?EQ?ot zKeoOfTi=hZ@5lb({n+{mvh{UreLptz!l%9;Ti=hZ-H+{v)1R>0Uz|#{nxoDqyO3-G zSsB??WYfvEl08fI7TLRG2goAP?uic^CEpq|emRotLb8j=s>tLkVdmcDWUI&?C#xoV zkL&}oM%ahTxZBujj_N{o8rg8Ni^wX;rjpGjlO4c}{~jg#E7?x6cgTJq`-Q9*_W3gY zJIiX08bCIfY%1B+WL0Df$nGS&muv^wt7P(_P~+~0WP8ZIA&bI3V#Zvo)g1l70mHCE znvH`CXl@i4_9wFUVuvzoZUNbKWDk*TAlpJ#L)IAYZ;iW&R&!(zF3Yg{mUY8VmPIy# z47+Aob5~)H5M$qTt2t^u*$$F6WCCen6 zPBx3IA@(pcZp2y5Q60%r$<824Bg-PoCMzYYAPbOPL$;3W9O`x>sSadWWZ7gR$wreEla-R~h9+Nej8k7&%~9R3kJ~2A zx?2rx4>bAuVVt_qYK|&}CSPofQx#To)brSj&4goz)f~M;v0=N&zM;AOWDjA-+o;xJ z-v+BWYA@NhWJk*vm9)9ztmdc;GCx@{St;2PvKz_t*9*0MPm;YubGyi}(~xyH%4&{k zOV*xDc8@mxJCCf4Y!cZGWXs4NBYTo;7ukno(by5#xY5XJj_O3#nJk-ZDA{DPE6A3U zts;AZY!lf($UY*A!Oq0SFOJn5brRXhWP`}gBda8vO16S*HCZ*;7Bbmo+PM2EStFDZ z!x~%7Q74miAsb3If@})em1L{QZX?@Fwv8+)8GFF%JamlJ9R1Zq!!97Zn&xJZttGpg zYzNt^WIvGoLe>gy8aIx&8tQDa46=N(Lb5qzL9z$P9wB?3>@Bh%$$lkkbv*rIHIz#- zKUopkc(O%gOUND~+d%dX*)FmJWRY!*4;rHks*%-3vWV6WDlHE=A0@+Js-;(`6mekJm%Q03%xg^UV%Oe{{Hj``) z**da&$X+CSne1z_@5oxTcm2}RYK}UKtPfc}Ss~fAWb?@GA-kXKC9>DZz9ajQ?3j~W zza(4DQR!rT$qLDe$*RZ}knMuDLg(ENt%m1{4lZkLHAnR)8$eb{RzbFuYz5gSvS-LX zCi{#mwxjEAyw%X>Crc$emuwi>}j&CWFM1#Mi$@6^-F@)9MzfZRI&@m zMv+}X79hKgY%SR~vggP?CHs=B@yV`V60L^kc(T*T&L_K&>~gZJ$ZjROgRF+^d9p9a z_K+o>;`*hz)$p80)`RRqvWv+AWY>`0PPUHhd9od3|0LT-mXV5mj&&YG_+er2<+52P-y0~GBv6`b! zAUlcd9I`=VrDPRkOUP~{dxC5e*)FmV$zr>@eu=l5qdJhCLN<`>T(Zl^CX(Giwv6mC zvM0&jC3~N&VK>(=aaKbeL6%CEO*WKlBH0wO8_8}Wdy?#FvJc62lQlZk^-E)`IVzQ` z8`%)D;bd!}t=Dr^His-ob}!ijWIM=SCHsbK zKiN^IyM8&=Y8YoA>qj=0>=LrMWb?`HC3}GERkEFAKal-G)*8>!CjQ!54Si)YKUpzZ zDcJ(D>&WgWdzkDsvNy?oB>R=DRS(xM$6F2YLe`J$QnC`Vg=E*0Jw&#F>`k)2ll?*# z(bM?AQO8>?PMtvJC(9xmPj(sE^<+!Q9wqxLS$r?09@BX@!D<*6B^yXqPF6{_f^0R} z7P1<$FUj_j9dU;1ZVRiSuT0jRYy{azvMb4^k*y)Slk8ct7sCGwBzrphI+C4BHjHc%+2v$Q$ySg(PF79!53-NQoU>iO zG_e}SX~?>eokw;)*(9>d$ySi9Cfh{z4B4k-Uy{Z5as85DHIz%T?qtKsE+U&kb|u+O zWH*yNO}3TnW3tc4oDA15O|0gqu4Jc^jUXFIb_H30>}Imt$(|wGPWBnuS7Zr&UB5K5 z8v4p)J;+9qjV8OAYzEn@(3-ZEafY2%bJP+2T-L&Bjyi)ZjjVvIh%899i0l!v$H?9$ zdyniFvWWi12N*N58pe#s`jMSORzg-zb{*MY$Q~v8E7{v*?~z6L-8hK08v4p)Cy@;z zJCE!#vWa9jlHEl1I9WB>yJYW^HOO@R5@R)t8Ig4$8$dRgtc0wbY$@3avM0zkk^O`0 zBeIxtT)#M0!?-fp$z+4chLBApn?kmXY$e$yvS-LXB->5aeE_~Kr1S0>R&&%OvdhU< zlifzPo$Lj&y=32#wajweXk|5w(~$Kc%Oxuyn@Ki@>`t=Clp$lfITg)Cx_@qwd~trn+J$j&C~M>dx160$0?1!VV; zJxKNn*&Ad(lc~Y3Us_uYbp%;ovP`l|$R?1@CtFPRAlaj2Z<76;>{qe|*{)yOS`E+k zWPY+NvK7!;>b$$!YL0q~>|L^`b6s<>R>M0bvd(0~$SxqeiflUBtz>tQJwvvg>{GHY z$(o$!`sE0#IqGz>USt=M<&a%XHiPU|vOCDOlf6Lp71`HhErz&$X=yd|Psz?C%Oxuy zyN2vqvNdFPl08fIBH2I5_K`Im>iXqKt07*~6C4WHRaLSe!0N3wxr=aOAUHj(TGvSnnCkv&QF9@z(E(WBjXX=F9@ zmB~&fJC|%2Sq0f-GJkMxbwi~-RrrY>6ViA67x?IigWG>l9t%HBIu7$Zu&ax!B~$B2 ztvfY5(%L)F*|8cjwbcr#RZt61n@4RawSB&Xh|N(r-HT&x1EtzE=${Cczi6w8nbyhn zL78YDKF}FCUqT~;<)U`GgQQDQ#+@i8S#)Z6+3FQ^Zb)sF8A{GC7_8gx( zIj6WJH$P`=ZXOa!f6#6&hMpo+MPX67{zm*c$o%FPeVC8gC68Ey`G19pVt7!p(x2g$ zk|351j?k9L$DZ-&T)7tK)v zk+%&y*J_ShO?DfZe_Qnd{8%Pd!>$5VyG)2@0nfow@Bd z#LBpgIgu_IOOwuyH-xw{d4U0=A zjQdX_NTCxRmTlmX@Dlc0qG%pVm}riwhJA)@v6|$Z#VMKc7sZ@&42u0f4iiN~l5w~G z{l+NL+R!|V0Bq-*|w#Cuu_B(qEXrz8mGQ5OQ z{IJ6Ddy-*0DnHZqh=ysCh+o6nSAX)n)KCWvcYwhoqwad!bdmIM^AhGAK zRsVmBDN8U3-a@*3AFgbWtRoe$b|X(T_O_v1Tp1TGQ^B&nHiS!YV%Bj4r4(7B1wy=c z=n@zIe-tKN(EVp`{TXy=%g~`c3;9C9n{7I|2b5kM9|}lTl!+q&ojkgS+ZiUia@gXn zdbo8`l%z25fHKn9B15q#TPVe4_}Hb5qCB@Z!cdRtr%=r`a{Wx#V3;ua_mnBRwk#^E ztYqD3F>Iz7Ml~Gx>d5^cMzwA>0(2Oio5aH9jxBZ}oWlLF(zfG;n_S3oK*K%I^Lw8z z-X~zPc$;8y0Ar^p+oS^4r6@OzMGWPtsjEfEZHLpUHiX=(9FbLzF5d51dWYQ_^gzwv zI2UWia>U_R_;HMhwZzH5a2HCucm^h`9lH|7f6fo-?7I*qvu`m>X5TIu{~?7fu7d3` z6tk~IFaAR0ZO=ApN1q(HR*%lUMd+66%JH99ZW7y-c-8np>O<=TrQbml{z$}kjcx0t%?$3rv?(Ybb++UF6^wdcO zEDr8z>~TXS%^F%;*hbcz-xn6t(=2O54d)$e&1y z?~`5k2`7=l9(kluW4jFH%C7jp#?xT4Rc#21UtkJMKh3i1hpo3dzrUv#|4+}t{6LZX zPC9fV|8&fO;)9>VKR2r}7vUci)c0Yb4}^tC1*|>b4UK(ZD6&wC0hhnx#qsD zq|!+V%R7d!uL{j?$+9vl%bJiqKZ_A6J$Ye8Wz}%CW}pZ`WWXy63kup>`PuO`1R2T& z&;M~;j8HaCgA4t%w?go9ytXlEN%i6?Wue4np{La$E61@9lXK(xaW6yoH4@VaV-Lgd ziBZH@l8GYGQ9v0D2OVK`1eynwK?Bu6>qQGne9?vTFu&LvW1dpypMia76f&j;1h-!!Za%9UCw!P&(Zw>aykg1XC1b`^R+Y`2zp`{5mRemnX3XLx%T-Bq1P@!Nk`-katCC=a z!~g@H{_gK3b1QW1BF8Wk)}?kRN#lM}RfTfS&nOK%DXMmw&oj!GEGknLSkfbuh3=3c z#bkT+Y(K)Xg5Hx-tjXDJSK9U%B4Md*gabNiZ;j4wXFPeLw|>_Nuq?hShM>-hS|<jnFfV80aXZo!@r>;=J&K#u7!dKn7a{skj9=x|x9wLKPs#zfQ`E^P3MxMz)cAHO(b z{S0r3jD-wV;-1|6N^6X@60CKRo3Y#ldjNSD^o9<T1*%6a}QfE<5(DZfzUS%th1tthTqoj_ojw@P3dQ ztZS+Y*xM(S!=bgWz1?t0x!Zm?cc8uI>8kE_%yY0L%U;t|)jk}v9@W9@$Um6H0)|A% zgCH4Jx@BaO>*ZMZh?QU{avRi82sfWPjP=*ZJ)czyY%22IXI%)Yv%=Pbx>He(PH+p{ z&q|O!Ps0|a&lC9l>qz`jkCr}KmtC-MQQ3Lb3))%<%HgvmOUo83sd5A&XjT?>fL1`E z)KPi5$+`{v*j!WSh=yQ7_E`{QN>f-=ws`JETG+&Og)HUfbois>oz=&@d#uNmztlb^ zWLJS^vxEgi>N};AmM#6%dpWaNJz87IhHdRWMY-o$h7_hqt+LOGsD)h*^B%X~#U=cn z>i`ap#L`lN-2<#BN4UO4kfGiMna5-f%*0C?-&vBYxDj&6RH-DDjlrcz%j)i#? z%rH#I+{isJb70;Fvo}l@Iizxg{Lc4JU|xyeg@<{ur)wbkJ5-DTW5&!Gjz9A;ftow4 z4K+z_!(&#zk8IM)3@IGUBiI^41*~fYyFsu=1pB>U%t!6t^Mbu0*gJw95bRsQGQgkO zZ978+nCAvNQn1m2jTem7U%Mrj>vY^M*j<7Zf#HokLj|m}1e-0`LcuN)Y^7kA3DzK3 zqhL1(MoFmS@_=9u3s!*Yl-iqlZyO4I+s5@d$dC{5Q$3NNWfnq^&nxoT-e;A_ANi8%v)Kpx@%y6))p7$UX%#h}H38Ihh=7k< zKdsUD#oK$1j?7LFuf^`fQ zQ8$<6?Und{8O=82@KmEz#>IF?W&Jdd$212atCveuu7wEjc7%{j>7ALL<_o5#2h#%q z2tp)OHB1zYom>u5J3%)|O$(;_ySdQy8qM^>CvOVHE#)2L`Wa=FSlitq3iOq~w)EC) z>nMm=<}5p#cS7lq<)@%$Dn$Qb*;7pVVLEo7@>&tbdOJ*NjC^P5@%;ptJ76*#zLRJ8PPcrg`1vUs z5-om61*}@Z)*32cT_@O$f;}i01(A09lwcG@8e^!EFX^_8ACrmbQR1{-j22g zwy1&`hoMe&Ls7=7Rojf8gt4hdkg=2L5sX(AeuvT{hSMS*hr1{0SK)4@1-RLp`I^Yy zkAqE_6HmY#1oIDuZMVQ=0DNaeH^XFk5NAMqCwmVT_9ms-TVrHzjgh@IM)ua&qk=sl z*d*|Rws(r50v1;kX^fnr-E!TE#+C|Z`gsX$h(G_~KJfnEW8fdA4N*O4!~trhOY2$k zUE7cq`TtvONEvF}|C4P9Bkoi+X4n5cZOB@zM4&*chsidC?`%W(&Nie0Cfg9cvkl=p z+Yr99lD#OEjFhfq8e=8X7%Q2^SjjZTHbi4=Lo~)VL}O12#x_J_Y(um?wjmm08=^6` zAsS;FqA|818eEKTI1!#?a3XT?PO5+YlFH|6kLFTn08}PT;B$ z)rLe2+t$Hk8^U+CA+<2sh7e~P!gsQFSlFACW^av=y){Pm))?7aV{Ah-#x_J_Y(q50 zHbi4=Lo~)VL}P42G{!bWV;ttnnPJy_6oGekEERt(d*oKTp&)lf>??FlqF)`XP9NFy z;WRk0W2fiYu@rVjdV!u9o|h8#HWiI+s?5@(Sb6oMV%t9)M5|`3%x-ufcO(1^)ul7c zSbjIVF@I^%XsbHMj{SH8LyI-k!zgO-4}Q^(O&Vo4_+gYZpkH)aIYzyz``EFoBe0Pd zdSa&z<`Hg89J@JGxHGo-!w2X`V?l0SUj3!HC5-qeyK!n2p%r`^7H$mZp3c{qd>t4D zRl--BuQ}RBq-aoducxYCbbm_qoX`_tSka-j3~^tf9jn4noAPn+$5p+;u^8iLBb=Gx z*tSQJP)j?r$9`Phffh@)O}f})k4B)e?bWGjZ>1g6Ib+Adi0H`YjI_8p_b&QXvo!*v zbPM|+FCW1U+^L|hSDm{1K+RB;7eU>osJ@^yb~dQt`1!0D{@x3_@y=g4?9NH({B49S z_W5dI-kr4bceuk9%gQPiEW!)}X9!$ldF<=4Gv6D5VAr~*dEc)$dRFl~zgEaa% zO7*(mbk zn-1R8ig^mQ0XuVx^jqc@*+7iJ55>}K_F@A>bUXY&ZSP`qI&<2&J$am-_!iT)d(7}iWP&%+fNpNc>!cWc=E-F%bPtsiEe(t*rgL21 z!*h`%%y)LGYt{Fl8ZbOO%^b{X+kV((+^?sbI6eppL+)Ajx%cxpZiYI?}(Xt zc9`$I&AaoRdy)8@TomtU-=!h-m-TE1I@%a)wQe@}br?tN4f-cA$)nf9JO<`XFd3hl zVV(~27MM&0{D>@uiE*&VO)&3(c{|KIVQzzYFHDSWT3cWq5Ay+-6Jb6Ga~@2HrpU!G zAA?y9^9h)&_d8&+RpK=vy5mkNV6731Or^1F1-n5oDqY$wl`d_MN|(l-7L0Mx*vW

*w@o82>x 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

vX$ANzC4&{5iTQs|s^pmTvj)Y-Ya~ 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

G1 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%0DtLK zTsI!U@71(Orid%z!uHFu4O`uN5?37aJ*sR+DTtwB?PxN%pCv-{sqlUcsT8^ zEn|vrt6pwc>rx$RuX{83*(t}PQJvqgB0Xer%})%#r40N9*HrYC%(&P|#;KW+vNidO zN34=dGGeIM{n0gW$qz2+NqjElkjI~&riEPGHRpO)uRKkfyRYbV{KW3mj~fGN$}J{& zy!TTBw4=wxjGR%hwhd8R!oHYLe1`e%2#})4<6tw>CHN%v)mY#h{91hHSDAℜG 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 JUZd~){te7d6ypE@ literal 0 HcmV?d00001 diff --git a/HPCS2/x64/Release/HPCS2.log b/HPCS2/x64/Release/HPCS2.log new file mode 100644 index 0000000..9ccf70e --- /dev/null +++ b/HPCS2/x64/Release/HPCS2.log @@ -0,0 +1,6 @@ + 正在產生程式碼 + 2 of 1334 functions ( 0.1%) were compiled, the rest were copied from previous compilation. + 0 functions were new in current compilation + 2 functions had inline decision re-evaluated but remain unchanged + 已完成程式碼產生 + HPCS2.vcxproj -> G:\HalfPeopleStudioC++ Porject\HPCS2\x64\Release\HPCS2.exe diff --git a/HPCS2/x64/Release/HPCS2.tlog/CL.command.1.tlog b/HPCS2/x64/Release/HPCS2.tlog/CL.command.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..7e6bb26da696acf1f5d35defc4e317326e957306 GIT binary patch literal 1534 zcmeH_OHaa35QWd$#Q$L28b#5#U+{d6-`o~WG%VE(X*zT7 z%$e7@^Zs_FKqd8cqO$6$DUz=cSx3ietD~w;v3T0y+rks7r8B%9UW{?i)JMb@nkBWXTk z!&NL$DR!}eUY(w3LH`RS8iSmIA3OU3osh{aDe{SXmbC}2q-W$UTqGL6gLRYHCoqvv z!x*s~U!E!4%*Zs)t;XNTac8et)V{;kh}%|I$2#H_TTE&!l*#CG@8h$KH6mA|&SB|* z_#&?zF?S`88ta9cHrJfaXVhN4a6mrG+XkQI_t1a4jlZ@1wn-hB^k8tk{p;=j-|b(u FjURvh-h2Q6 literal 0 HcmV?d00001 diff --git a/HPCS2/x64/Release/HPCS2.tlog/CL.read.1.tlog b/HPCS2/x64/Release/HPCS2.tlog/CL.read.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..721486c602fe810a6a40400ae8627c9508f182d2 GIT binary patch literal 94420 zcmeI5+fG|a7KZorNb?R{_9#-+B+;n5@4yB^unldSU?S9h|CgAV|J#dV*EXK%cG=GU zsfiHr0Zi6fwa%yd_rLyVuA1MPr{;5W)=Zkq=B~MDZuRd(kBes6+&AOqTJMaScltWf zPi~ue^F==$>8E_|PR|z2hmGe`{l>KY-N)v=e&bGGe{cTwUH&&TneMW@1*&uSv9{j|7`vt_@{b*)c)>5zkezGPMWWJZy_o`os%9#o`mzy&1v(i zJ~`6wPxW=*%=G)q=27o`)w@r6eygvEKFQx-JimL|d=gbY=(F#ekL_RisK+OLcBW5F zTB={Pe?u}Agf5( zy-o}M38)5XQ)B3E(kzUn9Gck za(rsxyL3tu*{kz{Q+jCqm9g~cgUC&uxGav=^p6CYyze4vaI z4o|}es?8HdJ7JCX;Y7dK5Nv=7jax>0Z=7oI8bWXYF` z5&x4Ve^h3))Se%MD=(yj=E{+k@}Qq~eVwO;;!9yk_T7ndUuy*3p~6sl8pq&}ZBSAH zp_1e)aSv^FD&qR3HJsk3y?FLhyw5r+fFp6_!b-comYuhviT0~;9YYT-+A7XdtILVE zd~{EOENR73`|f8;v6#tnlH0ALlDml&uj{D|($8=vFY~Oe#nTCKrtCkD(Ya8|DXv;g zFn+Fs))YrazO@F7R;~6pRkkDgXYg)ozzdCmG+j%!kgIRh}Kwwq;!Acb*}7mm)*H&y}p^AU036)rCjC$zq_VpOrj$W4iIt%=yW1F^nZ9i+#1s7J` z7Mt0kW$RVKBQtRtuWF(Ds>O$xfR6lnu)1$O%oJ(wuBH6+LG%!&+R5%19YgQFjT~y; z^IHpt*T~;7EfCRRiD%&`vuM^k=~(JtyUVN}M&vK+$f_`L7t?n&oXbkMF#Yx@exr-} zPW}`Yo$Pb+jPYFfS(y$zr2Uwx|GfYAhK8xDu8v<|I};VJ)n&shBUyXqD@*DweN6Z1 z-roi#+JzaNGvz*rq+Ow1C`WUnZ~pz-`qO39^wWtEm66k|1ta{ru{dd7oKHJ0&wKR2 z_oWfOoV{o@B(aPejzzhJv>CHCxzAo&AOF5Ec3opk!oLNouH{?IBtd>$FqTYTKkMI) zBiv{@7KG&V9bvtfH;}v+dNPKlT{qE(ba-?F_BA8Z#B{b^$cJ*}xpP@N^7iDk$Ah0~ zpMF=;Cf9<>QJ>t2UTgsgAM}$M<%o&cP!iA$Evfxe?Njc99p&6 zssUHOJDrU*E@zoGWu=@Gd$g!(W4%0R*N4ypCOo3(`U$#uK$U7U0h5Ov2>xf%mAI6h zY)%x5*|!clGAUP95W@ZEtu~{lo4l|GuhEY{eRJHxM25!+y3n_dnuE<&P|Ar~%%253 zPCA2`8aB5foj!bzhKR15*e64dfsC~egneIwO-s~(*%s%eL1JbKdS1TppNDSC`!<|T zHZ~bD%|ji_39_8a$bC=|#@1s?*}WLBI%$_}5c@&-MU*7M^3g6iL@v?QgQ)bN4ZoiZ z`HW7$bIAf0mZ*UZ#XhHrM8=-fm<&wOyc3Mc($dLzK!?&6Uve*b6lH+0N`g#ATokzs$(~Xtr_N_f% zFWC-?T}f}dMBM>VO!^Ej0e${j$}7E9=GCDxoma}K{d(vM;zTS(;&~@4n|J3p>9EKj z2H%Gb@HopHqSXE1!e>DzZn$vEw{C;XC5qSv+eZ`45!|*<_iFrw!))?Ky9O+C=~gxt zJIN#-S?M(Pp{W$!A(A+=q7feSQZaMs4GV{(Q{RVp5S_^R4$V(}s7B9``|uuDSi|VZ z8k$BqEK^w;7kDO;eiutTY4^e~BNO#c4;pcgRi3wSg9=MLHQ}eJv=KXgd~$Z29y^9c z)=;^4bxhiwDHn$gj^22;v-HY&IL4;b95_K>i-|KIX`Cs$&;5Qw>(IW(!W^cX7Zos# z1y|`7i(`46Ib<$fZvoRjn|zK-t<(iEyidH1^O>oL?vbJ8GQ4D9WC{ga$2;4X3tUJ%hg>8BI+ z*^GBM>Fa9*;+?r+eBXyG z=djeDGqeokl1cY46Trh~05|D|yp|YFIPIb z;eF2VSNc-t!QH9*i;hf(+XU$v3cE6Gb<^-YI{kPdIw0dVmn-=$9;X;l6M#xZYX9P|)NYF~QmHhWi`I|cA2mggR zrIO8dem(+o%|x(i2Yn4ZmumyIP+e9cNnwpr&Up8eI$Q;=+ily$h-LAhpG4%H-|JR3 z*!ecEf```H-b`+YXqoNZ(KX6!evT=3Q*fUMC(3O3?wsa#s&rM(^)=I3)_@N>ju^VT zx3vbWz$WfRS?iqWMk=i*`f=dunFCAnRDKwR&k%6c!F@SKYenU8n`SMRjl0J4ZD%#% z71_mlWQ#mX;IzAB9mCH{(A2{-5tm|Z>bLM>UJ|t9h8*tM}zkltj`AzS$QFx-P z8Iw=!!NWolZ{927jBe(4&AaAAKOryjML)$`;d4w?E>uC?eBNz0U+cH7^_lMGmy}`n zLp^@S_}^o)nJp~Dk|V*GXEgdWeG&|u6FD|EQ-0GUo)59;lQ08cUb6+gdrcgUuDjP~ z=n$Ui@oi@B$@+llXJN{TubN-9H}px5Y!7{EPBqESQj33s&e!Saq+W`=HMa(Wi7J=&1Ic=(o9F6i82+pPs4l z5B(iKZz=8%Om|V$;43{UONkUNl$)e43XUn$n|`PD+7GM+vwbFn{LTr!BMV6>!UdBUx3%k#~)g4qx!!iq2 zI_2cZ2lR!UiUZh~6rJqY#_!>4;2~YNIs_*@GyUz}3KmRxSgUUA_`C$}&Pi(qz zn~zHzPA=Gszd1$r4TLY|0AH>X*pxRkz4ACX)nlDtitJ~^=JX|XQ#M0G+1I3GUFfl7 zmtW^+dcm0brU%G9F?vvRv7v;b6M@nMcx794kdNS$F>LC2hy%X zx(p^iZ{c;FrHdh{;g;c!_MXkr_OyU0XR-0{hqK?{L(7)P`cW8~4?$l=cIJ=m=?w|>( zIBE{MZQw5_9;18LPiLh2H;_&r9gBvDeGt*DPCk!Yd3_-4`x^auMkhF<>lu1pzVM%i zbz^n(VhP9DiNi2b1C-ZCOAAMKJuG<7kv!@H;^|9M9$VVqu9In49o9O(ZgUx5>{ww!FrBPB1175GBB$&;KmQ*&g%mf`?B2IRoEEEd{+~JEGDn zX~x*4wEI-nq2t>4d-rXYZg?K+S09%0`?!PFp&Nv5@}O1Ba(YN3kr>fgUm87N%d3@s zS|ZLew5$ica){h2M?oj1o!v5;+aPoC)3?F)(Zr4ix9!v08h_yslN=G%1T5UD#bmyd zOycu6bcSGq!v8`Nz3yAUM_tN7y7gCZrxr81L-SMLvl%_d#>0DDslG?7J~WMTSbT1( zp^A4Ut>i(Si8f`>!%uF23Zn;9Ow#6=0XL|y#4fjpx+ z*nV`TY*%a%LI&Na=9Tksj7`bv$ENFRas7?e333PM$F?`vsn;?l2gjn;@P0zym&ze? z>EX)n?H<||ZlhMJ=@0LJZiDWu^(7p<_V7r7k@=<6X*TqU22>G$(}^@Um@mv>!ZJE+ z*y-~Ybrfon%(*+AAoCvdi4ULU?$hgBXXpZ1a2FcE3nID!oxH!$3C#1l#H#^O#1?ad zc(u>t50W~U8I3+<$%F9GRtchoV#VS8tZmfVXA9rqve|veat`yF9SMwMdoTB$4s8=R z>4v>tC^Lc1cgb@lZI*iehNfBAMS5MJ-tZnoz!TZFA9q%>5BbmMeY?(rA9q&2o`!}x z^z*o6Z=<)!@y_ayx@2Qqyi&9`d$wasPjrV4uQd}?(2R;|yyhl6_V~u6gD;fPu}YQv z^Wawd&-N8iJ)7sk6ZSJFYTxHxLtKUVF`$yt_bWXLV zwYZtN*oY!`p8@m3EZsFm&c2SjJ(E@hpEBL;cS@`0EF3xM%j|x>@HOA^9e0sq+Fg1Ix|FVJIDroNxi;zY968>dFZ^%}KRhIt%>cu5 z7a1bFvgnPwQ_pH?hqfQJi7Vion6{c$!9gJlHDOfa8G%y``YPQcK2x5(4*7}O`_NU? zerh=PFmCg_Q*~V=f^qKyBkjI685_@9H&fqO!TMLGX zNB8L(_B*%OXtS1nql>U~+m0Vzkzt8j8hF~b%S|HuuFQc z7LN&hurl??)TPddZlRJ~=`k|a9Xz%0%t-MO{krI_8f3kz_}v!Za}1v8=v&4!$AD?G z@&b(5WcR)mdRC$@zO?%JeW>Y8$8Ms{nIoh6o9=3IhBR%G@qsaRUd40^*3%EN)N@ig zt>70;<9AWth2Bi>)L>1c-gqe=VO#}1dF_;Za2?$ytJZEWUS?T#=e%QB#eJ=epM>X| z1lO&sb4y>2*wXt1{4fgc3%Kgjifd(5V$P}_>B?{NtS76tk|!9umFkf# zrd9)|-6iW7nW6+uJ+cs+ny@x?_zSgp+o}3MtjDd_yUT%}#oU%l*u=9Q3A>d2#Dgp8 z4Dma=G?h{lKW^ew3-67@cS){l&>PGTu{)yFS{=h9$RVnQZ*u>*4!-%Uh?7iw9riOS z_tX|@IGuhyZ>iaHroE7*TIzP_t1F!rd2M8?j%iN3(RrI4V7qu-y8_sZMy!X<;Ph&c zGiobS#Sm#n6|?zdR%@|Z3*lGSzJc22gSejcaT_&x_@oQ3n%}e`il0p6w{cG)^2ToFY#4!LEMMPqDFl z?oQ7Z+9}n4o@dC*qpU+(F7{yE3DW-N_Tyk5{|7gsFhi6mJ!&cacDMMk)t%Famyi$Q jv6`eF8K6tM25nr^PQ6vzW4#o&p_%HbrE~jZKbHIt$E~r=9@TYhZI9OC$Dn18a2?K}X2Q2*B_bg)eT72z4 a*FRLwex;x9>tAvX^P_xwcfJyRx7`6Y+pb9f literal 0 HcmV?d00001 diff --git a/HPCS2/x64/Release/HPCS2.tlog/HPCS2.lastbuildstate b/HPCS2/x64/Release/HPCS2.tlog/HPCS2.lastbuildstate new file mode 100644 index 0000000..0396176 --- /dev/null +++ b/HPCS2/x64/Release/HPCS2.tlog/HPCS2.lastbuildstate @@ -0,0 +1,2 @@ +PlatformToolSet=v142:VCToolArchitecture=Native32Bit:VCToolsVersion=14.29.30133:VCServicingVersionMFC=14.29.30136:VCServicingVersionATL=14.29.30136:VCServicingVersionCrtHeaders=14.29.30136:TargetPlatformVersion=10.0.19041.0: +Release|x64|G:\HalfPeopleStudioC++ Porject\HPCS2\| diff --git a/HPCS2/x64/Release/HPCS2.tlog/link.command.1.tlog b/HPCS2/x64/Release/HPCS2.tlog/link.command.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..713c02d60d629b0245ef02de1bf1f13fc14901d2 GIT binary patch literal 1554 zcmchXUrXyi5XH~4;CCo}@j+<0Dn1l^NMfzgv<*$F7UaUcT0v+P|33NI)!)pvlmrSs zNC}(Wotd3Edv<2NKL4txj;?j8NSRKQtE(aZjJZ&$v5u7@Nwmw?Kr_@xXJ`|&b}naC zXs@=u(xDEJjj%Ld5jI`+eg1v-F;R;-#@EM&F%-ldgDe5d62rE()OL9ZAI)Dxw2p}t zb1iUOF`Dq(hV22!j5p(I0L%6=9aclv+nh0azCXuigw9yr=M`GaDXccQp)o$HNqhdD zRm)3{S@_$U@0E{)7=2D;M5~^OkY0c+=WJC|kQ0Wcj>kNAYqmiafwin@#>i4)tgsB( z#V}Kiwv;9yscPCFk6kvx;=XH%0s6=kKtXv7Tbl^mm&hvGaFs^-9bsKL7K-b^S3YV{YB^UGBHt zd?tpt0dWDEm@JwwO3?MeY#A|NA70KFwQgZGV;Otm*q4$N>mbRnNW7+u!yD&x&dncS z(ReaHOB<`rP=i0I9P3TiLjvLwFR|xMM}HQqPQV+1-O$9WtST(tfSL>Wog*z>mSShU l&njs1+=sZ~CYGlOm1NzZ3zon|V=@1%uUb!A$Kkpj_zn7r+8_V` literal 0 HcmV?d00001 diff --git a/HPCS2/x64/Release/HPCS2.tlog/link.read.1.tlog b/HPCS2/x64/Release/HPCS2.tlog/link.read.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..f6772696b51b6c61e7be01f09dd702e4bf65f1eb GIT binary patch literal 4730 zcmds*%Wm5+5JhKQp#R`yivmIt2SwAJEz7AJNfh)*;(+Lv*Dy&eyYq2s#)$a1iZ7~b1E`qD(h8wa8m%oP%^ zkw0oPu?%Js2v=QByad zY1vWwnxoHbx5L{b8^YPOiJ`gNl5CTfwU4NBJn=cQx914Tf`>)% zZWIFtG{^QQg^FJ3cqU~P|m*3_N-f4;BSIS;Hw zUs|)*jEK5nuOZ->(VCc?hg+NlF5+3GtWYtpW`1v5(A_fXX*(X_5ohamqvx=fjP+NP z^RUaD+9S7Q6B~5lTahJA+$IlvM%kx4O8G`EH*&R6BjSoWx%mDVPwsD$otj*-|TFz`!V}t^4c+ z_uhD?t-0xnQDykk7|#!znWuja89182rVh^!_EE$?8ON9bUON4p+}~sMF=`fAe(^^R Z-}fnTn{8kK`pY90DJJpod-Y^7zW}FFezpJr literal 0 HcmV?d00001 diff --git a/HPCS2/x64/Release/HPCS2.tlog/link.write.1.tlog b/HPCS2/x64/Release/HPCS2.tlog/link.write.1.tlog new file mode 100644 index 0000000000000000000000000000000000000000..ac40c7133025de0cff8dc34c35fcd980604de02d GIT binary patch literal 778 zcmc(d!3x4K42J)+uy^n-^f1JOx2;a6Y^O;2-xqEipya9gz{rv<&jA62l`R0FT@%RUE Kd+|;Eq53;5zHRyd literal 0 HcmV?d00001 diff --git a/HPCS2/x64/Release/HPCS2.vcxproj.FileListAbsolute.txt b/HPCS2/x64/Release/HPCS2.vcxproj.FileListAbsolute.txt new file mode 100644 index 0000000..e69de29 diff --git a/HPCS2/x64/Release/Source.obj b/HPCS2/x64/Release/Source.obj new file mode 100644 index 0000000000000000000000000000000000000000..1f718c72868ed92e4091bf3664831cc1873e705b GIT binary patch literal 3505506 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⪼h(5mKFctc)2*=jORT*1ioj9uTK{6T?c$hz?%5X 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®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 (GHW%(yLvbNXs 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%0Ao3K7q17 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%0AaoGU$P^_yL6{Ao0m2|4g{g7q1R5%GB4c4 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%0DRTa8{ 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�F`NyVq;4ovXMc9QWXmt?iv;$ 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

^|`%+Z%Ju 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

h)yR2!P`RglsNQtKL%YJx?FfIuM}bUC{E3X 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 b1k?P;eKxEu#mK7!e2lrwt!C|<6ZmipRs_z- literal 0 HcmV?d00001 diff --git a/HPCS2/x64/Release/memory.obj b/HPCS2/x64/Release/memory.obj new file mode 100644 index 0000000000000000000000000000000000000000..dbc1689d518b5b9bb360e26faec427e2fd6dc811 GIT binary patch literal 1381483 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 GA*%2u?? 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 gz$L6%CX48aS4KF@TkU)S|ROKfBk3@}~Q~BKF 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Țoq>YS5csEJ z^nA}^+zsZFj(|?)`JUUk!QkXYr^oX>B!j===XR1i*XD}cEd6|syg2!M&#TjJgmfBH?DIXZPMg{9!j9@M z&bXccUo=nn@X2?5amLWVX27e{xEb*3v_g44h%(oy^=6H!@8LFxUS65Emg$B;%jFDC zA2B#l{6d2#d`<>lMCe&KZxSB=c$?PL+6v|6R@V7|z`&);oaCUX2r3bO<3#+lMEn%W zrbIlAA`+U?apia2R+tllmRDF2Pd6g!vbQ3d6VYc(ZJEww9H&(WBP8ZxX0phd*l7|qT^`At zQe(XQzE~OaXP=e19RhR~Z$(+W1w~C|2w{{Vm{VrMlrpTTp^QUHD)U&ZjQO*N%4mwW zXl)zIzw`$xvKh*zy6j@$1%FYCA$(MBMT12|o`VCbq34Q{&eN%Ew#nextImGwZu2sk zX@nM$l57_f<8@#t4YX&g!S`@P)K7I(=pb%OktDHUu|-<+ zM>|&rbCH4)Qw4j96_bLGZb&|%hd%k<0B-otAIc5?`9sNdDY&BBjNQmQ`n5Ty(WQ4m z%Gv&WiZ%2+*j_$W`C^DguchPuHl#3vWtOdW$?3Wld}Dw|)QSv|jzHX`90=j_hib=s z8ThCz#awN9Az9zCgY2PwK%7ps>CD!%Mn1o3da1>^k!#>&Q-j+j+EZDzsdb<4@H4B_ z{UXqB=qBsQO?+c3U(yrJAaHRr1dN|~JEaKxo*M29YX$5yXw$_zTOl{0-PoP5`8)(| z_7?2T(hDN53wmSeOTcuO0{x?Z#Gc~&WP9noM8jW7**4Dj+_`ScsGTn7u&v7_oUNf* z3oz@czDFLjt>Ucl&DbX{YsS7=N*QlM|9Wo#Tl;blql1;-r;=e()hnp#zj52dm)n_o z&}ZR0uW#E!RZizK`LAvx2fNa;48>ADeN|E=gz04?3+0z75G1^s;H{y#?BPhB9t97B z<8&4eLD|$uUUL*A1-y&FQSjX+M!^rL2sF@dZwH$6D0qxCIl5U*Gzt=$0>ixTViYXg zYRqd#L0$G%xa=sn6s)2aFj&@o-w5>In>h-ehnvO4EEb{2jDo!7dtC5c90M-=Io-Dq z|Aj5=DEPwq8U;T~*_#~&1ssopYXaBPcA@b(-{+ofVia5pB!WG0__(J78Rw3)GJc$+ zpwp-JDEKiFIXFY)BogW7Qv~bUQLwUw9|hL|MsgH{?_m@?N~7RYcxoXcNn%5q2Q&(z zohv&tBvIlDf`x zHFjzc(ZR-O-o_D!>u_~8v6ucob3W{Ys3Obb# zrXR$yF>6qucoa03eHsO?fa7!)FGJb4QIHgHBsp`G_nR06H=rUI1@+t8fhIi)-YiX4 zG^>e5K|)htnD>2*f*V`&+EGxKy%jDy3jP(WqA!5KvhH_=qyIk6QSe3FEWW_vc@&vZ zkhgq~3pTqSF`fAM9yRe#9AQV8PnuD13(DT?C@A1~6dVj(Pun@_$(xX~#1zDB{fLXLuOg*8XPks#%4uTk(7KIkEzs!ZW1 zxM<)XLmVE2GRsz@AYIpjPi8cyR%D1#5aJ?AcsV$~3DcvXnAaNx-x!`91zi)l22M6L zxScqSd+jymg7t7o&yIqwu~UPXM!`k|>?r7(Cq+P`-~+H$z)k}pA8@1K&a@l56CR2V zF*-Z|d$UY?UCi?NPiPeEDW#0Jp?|%f9tFQbCBvku8U>5EZAQUAaTKJ_!grQ$>jOZZce#79 zDtB-cJaJq3w4V!#WjqQxl@O*s9F8;TDNsBLn#(?og8zc!bQa%2*|$-U6mTBiSd4;i zHZcl*m5N{#)NgMGn)E2x?<#82g0d-1Gzt=$0>iv-ViYV{^V(5Rm%SCvj)K==){X{? z@T2GIc#Rdc&A~Vt4R*`AmlV;PU*VWI95;)@SPVts#>5+e5ljH6;CbetbEWJ2ICaA` zIPXov8K##Ld^>^@hmUy1u_I#esDbRt2M`qUhfZzuR9 zfCrD>lUC_Dr_w%9DI#;S$Q_dJAdwwN zT$9{QvF+0p%1;y-;?3xvnudgxut^}=A^V^};HDYR{ygv(UhgE0d6!4!ZWfwFI znpfMK{{bMIrP8${dMF!E)Z0tnOf~;lC3~R~ueTbMFp*;dd z1$fP0-Jm~{EyH+$Q@@5K8q{@Ev;Ldai9+NwrGGGhhG2c%un$v$T{6CVmK)m7qU$=% zbB1=uFQ)eh=+!kt#@*1t-qe`g(qoY~zc>|&fA%~HokkCXp& zh-GquyO|TP)4-vx99xq*hJKF!XN=YO|AbX9lzQqwPvMpi$sO22!#fS*s64{W(*$n~ z&1DbA|LpW^M|e@R2MF7t=wBR)rr>6AGK(EhxS_~y)$x}1^*}=h@pFfcO-nN=bFUD)>xpey8VDr zcPt>u{IP%%_k1kK-KyIkq@3+FJ*zVoWZ3481=K1hfFNeYUEFWgiMiUc##UYRSm3Oi zm*LbIAGB3h4>wMMBG=fdVL;QfMg;6Q;_Q?npy^o|{UTteL8N}eMe0Ksso9+}k=n_T zAE}!$bUZs-J7P!iU9!FO-9)=SPdekAZa zbq7$%FsZ6$XPHP$Dkc*5On_u`_OmmwluK);&QY|{`CAkS(b?|Qnae&#=kLRFq60zL zM&}P1oxg{h#RFL!fFcu}dCR+kiO$5Y5uFdG%*{q;0msq#2f&qVy^qd^fP{(82^rJT z+38a|Iv++Nip~ilb))kSfl)U)lVpB$ro^i$I{yfyob4M$=M3B2=uEAej?QAu8=U1O($tD%*`4@6WHQZjg5-zi zW-Ofy&+I9_PqvqiNHlyLo)bQo4$lrdCpcp=q_qA+b@X=gUUiPNK{9SW5@0z{-o*X$QjGVi2=OTR{ii%t!fb_6WTYiZ|L z;CjlQaPHF1aRg23Q!|~{(#|gdZU&5mO6dWE%&AB2fT5+GUy+Cgj0BNd1BRA%jt55F z0fQv-2MkI~aaP09&WRx9nxxUvPKIsnfI+Pq4H$lDN6gj4O)u@ZX04ODYiY;9B?bc5 zh^aWPrJW?O4f;;k6tI?d=0d}&rJdSp=PvEgLw&z!FP)TV1TF2HfEy_ft`l@U11;_R z6g@6rRKSoldl$QYFq=aXgGOe;z!2geN0o2;9+p2yQLdcU^(z^)4eR4PJzniexN~|e za>mFRiyXh0o>qI3?Ul7mlx_+?i1^i>c{FyIG`UuLR;%G^wq5=LP_^0e7J#Uj8P{s- zpB%&d0+2LTH`4-;3s4R@^aWLNO_7#9ghI4#l8Y}gc zL)R?egPh}j6r?{?eXS9LAFBQ{MXxUwM4#PG1x263?FLr*nbA98`p)9*&H6;mXGTc@ zZ-4MvrZ<|{C%nySqTk+XVplwCByI0OqUcWW;pdMKh|gux_AYJ~|I6ZS6sdge0e}jg z$B?_JP^HWLbqZVgm0^A>?m>bRXAa)pj|aHgTX75T#7+_AA$`d60>8$@S7^SCZ`yQ4 zq{q>yUqs3LxHP!*6e?VgYnZPIIL_A|09vbyrM$AOXT;P5r{>qFGJ2k_7Yk|Z_^ ze5{UE!1pgJYvBEch!RtrdimNL+KOAHt+-XSx8j}#Dc2;**S0rL$B@?<80M3o*2=I| zzQ#{_LPvrRr)bm)$1`y&4)+jZyc~#vt1?@0VqPy_TQM}d73Z22l;?NlKMA9J&B4X) z>>Dwaf+=510^5Ae>6!vozV-w(44PLP>69^lycM@zL=W}-qP_G?q7js@J&7AB4`xSS4p4%lPhWcfdz~`iIjzCpmNcVtPu>l8uu!L&n|E!QL3au;!DqXKC3mXA;( zrCeHDagL&m&Z{U8qO;wKGnajg&fCCqqSry#P86u_9i;l!%akI*Vw7xs_5K^fQ`=1PALM4 z&O^{I0(Kfi=gVDmzMRpS-HB&kB-1=6NPc*3#?r~~%%0-=WP9n|M8n77IpK5Z@a(X2 z!gC|5G#{RON-0X)pgKIiM?qps{1yd@!?U^UU3jjs zsPZoQia1mQuackXXk!nRzm^QJrvo^tr)1##w3Y9wo zM5IU8>=#io@1%oEpF)L;P7RlK1T4#IEAC?y(oyz=bC-73A!t&cn(4f@;yw;=GhifC zN)H%hPCar53~j}IfD zwbjmD+M$Q~e$ig~bfOWow6h*=q&&Dz(De+ow9|zi7ceSdNV?t)N!N2oV$jI!yD@}h zM=96E@<%BOmeag`DTBsgeVnMr%RLEyP7g-T8aacJ;}_G@a!<0svZjgBZQ(}|zufZ~ zT02bIT+2PH*K##mFMkQB+HQGEK-A2PY_$!L9L4++kW^Mj(`K9tQ5|LpXbl=9UIH?g zJsidAZN_o>)LA?NW$|znz2A%*M?sUDaieep3(MEwB((>*qqV8Ieq?l^@-R2r$P=%& za8)eQW?VEj_+pIn2w^A^NdN{bXGqxQX)|tKW;1R)d52a47%RIOcTL;2fJg>(yBT*# z{$^ash{4Uc$0&Mzu^`+vZ8bOJu4%)rnh^k#@112oN}6<*-HpZREKktlJH*#d(h7^bGP%p~v7N|5U;`vPM1IZIlsrksTW7-z9|Sg}o^l4A$0zQk_g(K2o# zjbk^NKm)){^xIoE(a!DV{S=!n!;d!jd5tCJzoH>Ji>pu;UtsY(il%(!55kwE5&kUi zZza`lUnJd{z81VMx!$ET<^;>H1wUj{FBEFTa z(ehywXlhF*tY`l0VI-E-{)+8$$1jADuwk>gMXWpjxt!ndmVSG9lD=(Dvtyl!Zc&uN~R)?rb(yauH6H=FczV{e7MoR z@(+-kzV`IBLh+csCIotex7L{6Ka{X)!GGe`E-^hNYm^aRN%(0(wtv-;?XXE!vZomX znvm?@P7HC77;lrl7J=>dItUD z$C~YauipEd7tE#L2L*7)iXH+@m_#*^JIkuE?Y=P9-iiJs6Z|WH0pCxm!q-*}q z=a*l=kUmfC*BZn3v?!Z~cxA#>vV=MXGIKFAR;%nFq(G38Zz6xV#0J+FRFO-3>b3x5 zdO|<%^|JRFf|&=Z-tU;EV*K?%N7(|?luB9pl3hx_IWspZteuEeDdb~_1^1Q|!P+9Y zrI@zDt;|IPgffxe&1vtskjS(XEXg`MAa%B9(hfZL~amC~&F4nzW^l`;kDv0VF zYq=~JV)5C&qXgzDNS%?y8g^VUIZ&^0jy2izam6*5x5&SWNlM6Z#X3{*am818=J6bB z@6Qs$OR-7c14h>Q4ym&Ni7~10xMFg^Bpg>vHtlygn%g`Fl9I19zFE+ElgWR=?=^X2 zygy4chJBvb|DN~+jW`~u>3=6exb(kCU;pb3411=pBa!`^dpdrR~Z7Dlf=j6{q<2OE*Bt4&mwKfyDfUB35c z+2-fO{EPkO-xOv3&4uP);y0gitma?RvF6rIn=dQ{=4+8OKc&pSF>k*2XNl%V?~7Xm zBi!4dLcPrJ1!qv7!A<9BCJUJ?U@{+x9wf;$>RrerIpe+2a5veRr=&L;h|K;*1Le{C z6)usPa_CU=5D2Q~Ou_6jLI~spIJ?# zYFh)$GL8BGEG&AXA>3@^{`?NP<}PcfX&3El9`O}|Ort)C8-W_kxx!e7RXm6mmu6JJ zH0tMi8ufENyD)MTywSiof^gAdOL`T6Gw!_1=4!Mi*h+tajUZmnC+0a$Hm!Jj=*~;X9~l zS?4XJu^uwEMLw6@Z1?~*2OrRROo3|4N2XM@T$Vdh4uV@P;65w~9Jz58C&A4CxW|Lw zB8$O3A(4y0%aFrAiYeOXPm%V; zU?L`*s8NjBUvCx*tw(OX08zR~HnkXBpw_w=Osi&?wFZP!gCoD5XGSriJZcnEycn#D z6_O+O`D;GkC`K1zU|=Gn7(cTb#b{dt%rc634i*+I28Ww%+@BxCw02oTO}l7cv%*&h zGKzT~Hv%=daK+QNLDDFY#o*o1;?j%?7{&Zgk7EAEQ4AwT!R}GUk%A!$qe{Uo-RQhg zOyS!AglZ{pGc7=Ok)AL9{PM7`h6k62wSO$57_BcaPew8RA}n;48!VmT<>43U|7w3J z$SCHw_GM@Z+ZT+BJ!xAormbikcxNEoCDsLFaYB9+qr+IOw_yAfU6dcic$X!PVxqgd zV^H(lm!!7H8w8iLyE_^;ouil>$>azmfu8Pd@Jpt6J>5HGXP%OJI)bwIbd<+-T;UR# zY0({OJ^?|8)lK$v!kq8v-bG$lOE!Y7J>7d`_1hEO)4dONucz~w6zu7!oOXowbRSZP z^mINUkv-i<$PwAoQKY@6BVxk&6?(c)Axam?rh2*pwbq`FR#^gH;4KEz(~0uZdOBUK zo9gK_pRcFWg&63(q^I*UtDa8V8eo>5ZZ#|{>gmGGHXV__r(+E@?V^3nXTCy^p6+AZ z2-M)h;2ql2^+StGGb*5`8;8#&%NMkoaz&3pqoAi_2r1~+bPKb0Ys6(KUDK`6H(}kH zuQ~_2HSG*bx2E+KbZh?dD)fvSEQ;c8?Q=T2+V67d)_zsTg_fPY4=Z+?tq-GNULO{2 zzqJn&i}QV$4p6EOTSb55`!Mga#6B$eu=`h3tE@8$Y5XT~a(4xHARZ86|-ucVojt1osfYtqp>c%U=iF#RBf4lE9Ih{V>4I#cPcJ4uX@*UkBU< z0ryQw;Kg%_mzu$r{)ksnZlmtZH~I zvSI_+kCp2H(%&(A+t<90@&(V4Xa(77)5Hf1vD7uA;KO%lvEI26P1s-N&yD!8(kMeP z|FJUN))V&Co{8Lt6h`#?8XN?CwP$_TyYThBF5`M%nCONin6-`{fTnxDRPLPsQ!sxe zm*u)QdRRIK;M{MZPOT+P<*@Wg+;m(fvzg375*U{L1b)dBZyD)lvNKOf%SZ%eUq+%l zcDfZVk(utdLrt^A`7zKYho!=tAC~??kXo`4Y#o*+peA5X^sqDuc5fNUXHsw(iOOk5 z_^`BsLSz}qCnRzisR?rUYk$!)5=GjVk%*XZqK2h0myw!7RA5*dan5alTI(_rt+K2t z*q4z+dDO79co|7oQ#97dWhBk#88=cO3>pPvP==7g z;~RAo^Twrxi$(-yDPFT^MCXu>ab(e=k*_`n7mc(xEaOtGFE3A~Tl@u9=o&Xz7R8H3 zThZIqexJ*@^w;%VXzAIPh>HDYTOy)msQ6eS3U`2YiAYS&4@`B4s`ZwLenfQh4NSeu z5(lQT2lNiv>55^&B2=ub^E6UtA(B|bf;&}a+2J<{7wHEckY4}Ap^4mcJTIT}7!cut z*PZ&VQ`${-T#Dztu4CHW;?!~b;ACXgn_qHMaFJ=j0!KG3zvXt*K?7GnZPr{g1;uPZ@@J z|Eo-I^n|UbPUKco7}4`XPY|%88qURswYrRHb5Wujl3-RD=JDHZE$LTODK*TK%iqGi zJI$eccR=d2LsE)+zpiX+b+30|Q_#J;Lbh`6$Mgtw6;3jQx%X?j*Hb1_BI%BvuvwiF zxlbsJ=(#fw0%moBd$)PBstaa8;NES{2xb-c;uNM#o1lB;^0#pBA%K>3`XY4>MpBA< z*H`Xnb+7knnxK0JLbh`6r}PMQ750_Jy{TaBT~GIV%HZDhmFdGhVWUxdKcg_BXIBjY zqfvYL;gT-c6q4wMB$!p)i|@^3why{jE`JO6{u9u$&N)b(vyhbH-v3tq-s)cOle9ti zUIf|7z4%Ca!lkal&%TDa_rG+nrws1>Z)JM4C+rS91FoSkqUX0zA>a-?1M=ImaPI|l z?*+lE;$D1bHnVfky>eNud#hv!p5Edq4Es7j?u>>vhGGEsCLi|N<9gFRl>mD`9!Gm& zn?5g^^Hc6FGh@)l%Ep^GqY*c?1`Mj+7+T*yvl}fz|0uuZnlRv<3WUmwWQWKU+R;($ zxMdjZxOG?}s~%AQPwwM!dl*ON&G#77a9t0?;{SF;Ebf}9Ws=#Qcm^de1|;v#{8(hi zNx4B)xt|k*_HB7=o8~(=uh_j=?jD(n*!t);6)g{`Otc!5@}T@ppiCx|v_Kh0C^r*| zxFX#*<=a7fG#rylLT`WWtM(XfKwkcp`(rcs6<;48HZpZ{-<$favIOnRMRQm z=HGv&x4BIr%XrAXv>^*Z#PN*7P`f7&t49lXHOo@zs}SD08&Ck;dGhvxDB@W0{LCKI ziBgc?W0URsTPjBhC33Ws$Rw7?o{&s`0mdYhh;t`yN)1V0AIs@FzvpyF`3ml42_s!@xJH#pcb3VFhR1r3tXP?S zEqhgOU0<5$KcsD%;xT{tQNNnyDS|6{qlnNXas%6=h`KxZI&iGGkmae{(L*>C6s#D| zbOo^EGM&jhDEVh8RLRLgJt5r%_tTf%5(N8sc4UfRHNw)NuF0|hUd<+Qqgb8jxW4?} z+W5Xeb0VrU_42Z2Zvr!y#%M3ct~Gm+TrEsqbw4S@)TA=?WNqq5F;()@)Kk+v(M*gY zxbsQWcvgr+?nz?o+Sv4rm07?WWzq2ep*$7-zj*l3&ZNkWK|3?;qn3>%F(@AZcZd@J zyKZDG&OKS_MU3>j3*d*Y;(zH^)}de7bP$AuIgpUv9~t4cwFe|}-=J;XHm0E=)erY@ ztl+o968rKJwGL?kr4Ehn>tUj|v0>v-)>A&KeHv^+9H-h%@X`0(_Q+j|eVg@M)uo0ung#k@J54yv{2806D2*XYp9 zRvq)S4#_Jz7T{LE3Rc|b4@a55m)*(L(sZF{!p>n?!gB2VJ8$SSfS_URQ$&)g_AX0o z{e@-q8P39W2TNI9J^*%47=W_+6gLaXiY#c-@?}L1%pR(gvO3J?M=7hXv^+9H-W3B9 z^Y|!|y85#G#9h%vy!<3ce&6kzm3YOJ!meu8l?Br@`x~w!| zXYq{&<;xP5LzmSMg3gzfcUfXtsW{c6rHa(M+>Npt3c)iPR`!M6U-XR`se3{~`Y2>X zq(-yPHS4S*^=Y_gkJNdJiqzDLhtIy+Lznl{e?8t0ab{LOMrsJp3cqVUAOkHa5w#Vo%ihHZikCA00314Z`q=hS9ynFuLD=+ zbcIZQOC5v=gryJz*F7sp@CUCkR(=hD+E5)Jn`;+u z#U0-PJr#{InW1Y^Wl)~nk{G>`!Ujym80Gx}iEAOTv0+}nMD8yTNvzlRQ##sqgbw<| z=m?7U-mvw*mK3lC!=BZ33ADl0b%NnlV30mttdto3I&K-6E-M1LQ9J!D@eML*Qw@{L zx+BY?7-=S(q)fwolk6IGo}Km0#=Z*dnKS8kG)nm`tLk3|G1B^8pnuPYycrF1Sz;ft zvM?i!HSc$I^F9VO03A|8Wsb9a{MSoXLNJfy zJ*=Z3uq2Yu^L&Z3ZyVEYW9RWujn;G3aAfB5*SLlamBYp*HdNLZkg>kBv2)!prY`ZZ z#d!gQK=W5bY_6mgUkTiq(JThTiS%ehc`uA?jZtCx zLm1{#mkKhUqlz^)EJ3_Kl~D%%`L2&Y))a{2VDXpz<>pO!9oO$VkM%3J07v!Ug98W( zzGzjz>`AEaYTC2c_^yXEdUadRt8!@>|HK+q%4%(QEdEL(>;nh5H$(i4h6xO-kH#8R zW^N%Ml&}1n{IwKP_Q1@Wo6faQDQGf9b*n%d&jCNCsLV*M1DMkP0xf;j=1$j9gPITZ zW){DY>ALqYU3Z$AuDfm!r|Yg8#8K340?(yx-m19+f9O7-BT;b@H+?(qqQzi>3cxXq zi&``p6RGc!w2~>5$_E_Z|20u(ab6ns%cT3<`RNrfM_fqc(b6llC|be zf=TZ^5oM|Yf@%7ogg2)?oihfUQ~hOEkCjybHtj*&;|d)4cB%88KD#_eu7)FJ@ArxD zqs+h#!wd)YOIVf&*$JxUcn*OshYMBX7H8C@w-onE$FwJI8{gH+TxI4q+6x0ZQ%b7Z zyDTx-8=_z24+39XDhxOuT-j%YS3Q}0v zQ*M6p-7EV5e^}WkU?H9kr0kiYsO-Dng}b^UCc$kWHrY`@Owmi22Fu({)@px-3XuNn z9U$c?I+h<5;-q=*DTd9vY8O;ZLoS5P+iDW&3~Jcsw>+OStSt{V-mR@Wk$0n0?hJ?qz zYx{D)F_tSblW7#JsYGUUiId^@{s;x$?Gi)5Kv}3gQ#!_55DwjYAsnMqE(v~{MHsjl zH&qxo>o(NF2S86>eFc)Ou9R`cjkSr~^eQ;<7QN&p3#78-mGUomdCSd|-`H>sC;P7% z&d163v8vVBa1%~{Jgz;Qaaq#|2i*@IG&|e_*G)a@(>pdaDWo9WJa7GK^4gM&_NXbLoX0Hb9_D!y0k?%ChkNzHo04!wy7(w>uSlHxew~$-?QOU@6WP) zdXo5bB7OQG1S+3?4WBA^o-Ft21`fuLz#QwUs{BqF56VLxl#zhq{aF^2K>~%t2KV7S z6m|iJaM?j4Q;*lrJV>wMO6x;B znK|G|h?GBO;}6O5^-kvb5nu28Lt1^k^ISGe9-4Vn8$NB0*{y4Eo6^hyfddf@hY=3A zGY7!GGY4=;H*-KLNbwd6tI|tgY>#mHs%S#33cXxM6MUPQ3<^M zfKML8oE|%xDw>{p)qzjIXw>S72QqfJ2QnZ2&UHZWNbiC$Suv^0NpnG83A6 zmazqvU_Lb6Xpx0zbhSvF28l8N?5LvArw8^yzS|G1uk+09(>sx>p7uL?z1Bz?s!huggB)qb4;5__cshz9i*3N|k zLu;oe9B>y7gvS>SWbIrykhRlC(Y5oBFg8d*&G-hZTvE*61Z!s-8}me|oeKvha{t~` z?VJyzBWov%Bxdc*%PPHgE*z+8r&l22D%MW;%3eFA)NQqM4y#DMc6yg3*3NG}k@e>L zP{ASTUi?Vx<25>wgZS*X5Ng6pCU&@$ zxx6Wh860&pH~QpZ_}`@vHhfr*)?dqcjm*=^s0SbvP0qV4(J1w%*Y!9`Ryu@9tMED1 zXT*%j`@)P5_JtXD;%2OwpBo@1eLJ|lshtmZ#O1wjDv6B^*A0inC-zm;CqPwmI`U$N zs3ntLOu51Qb))>n*I<6wU#4ih48+9=8}Ah;Z^mYka>|W>0;kBOWyU7fij{KCDXo-q z#FWK(=fISBGh(MgLi$-`Ob>otJ7)*Zdp$yTQ=)RtYC5Okmf_eRPVb0!aSyroDud3jRt3w)wl|Mz%}+ zlAfwj5>SG;5Y>>{e;?=$tB-gyA>|^YLQrOY8b4ReA6ra%DlQiqv3k0y=gFO z!*zobxpsIJqrU59O|KrDe$~#7=z7CojwYB%I)&|-=V<1UNvwUhL`cy9sHXKESkA3v z7moGhF}tzk_bcStp_qqG%DhPD!|U=ZyTi2PTAF5?ii}kd!8y`4H1#DZhCApFH{KlS z%L<(Qn*0EEhZR^Up}@q+V_pNaR|MMfeE{u>Zitgd<7WIg`6qCDak7$e^3+$AL`*I+ zPOjcZQCII!5GSdYOgc{f%lvh_Jx&r=VVqn^C!xqyoRmvT^C`tSCQgbeujZWtQ%Z=F zuOnl+6;M~_*p37MlrlE#jt|@crsp`{6K+| zUy~oeR#<_R5(-S5+=D^ya5-~PnoV>cL zqHbLnC#jZ9I!;bCe@(N;N#ZJulONGZ`8X+;mgZB6b4;8RQl15-+flb;}C`neah zbJC2HUFdE~RL*hfoQAs*C%e--h+^OGWsQ@cQkX4Hehz{!PPWd+$vj2HNdhVRbp%A6vswtbz!}$t%%V+^?h#EX;b6gc@c`2p-_ zE3i^Rfr*oEEC;l&1=^Io01an-WS!S>Gk%nS$4R-gG@nwOW8$Qk@=e}3Fr|bzxd9o| zaq>F~v&G5pLGZ;%-*_@lQE`%hN{W*| z7}+lMN5siIr!P+a*JO_oC-cl9aq?S8^TkQIv=nr#=2;jgzdfy_uBx zS%H&ZlOMotvH~k56qq=9!%{%|MW8M30%$m@GwWQBoAKl1L~wg?@~Us8&L3aT3<E+#*2uK^Ti~dg@8;`R{^c+%!O6S%)*W#OQ@*{ZgRwV)FnF`3 z755oDd~a8s>D4jYv0EA*fvT(X!AU_jb0-3CH7-{*u9R8@k{4}s4KLwvq1 z{!l(Y^pxg3=yOer^trdSRdUnk^_gub2tJoz<155m9GFq+-Wqw@-TLJtN zD>&Y&j#a^P=R$&iM7w6_$kaDOR}IzC)!V>E$#|E5$7gJix7F7SO=PyCH3*siga{ZV zmzIhYD`cv-K=;Dy+ESVL>bToZ?Ab_r@J@KvISV&89Xo-jE5u;?!rB9Ngant_c!5Ry zwFj8ns0?clQ2QNDN%YRih6gW)kWjLp9)Q1Op?t#u7-Dc&(1u;;uHNUM)9HOqy>E95 z*R%G4+RXO!3fv*T<+?-Opt-oIa)!JSvy(VO-k`x7F9b zJ0TPj^-c)o@r@6ZGv1q{VE%z{q+eQdsi)wcZ0Z~hotfV$+vT^^3N1Eor)`$^z;+g! zOM4xp9gY7zGP=yo7d&*(ebD^%2w#MJR9=MK9_%jJ8yg-LI$v*W?1$1{T^G2|2?}-J z{}s($kd=*K2gpIG%VoKxE=~FkY;ct(z;{-%P7Z0TI{zl}adq{VS|o`~mBO_Ow}DG8 z%f+R(&U4$HAmiCP?ru<^w$9@i9lfbiwr>4dMt$6|g;C$Ha3~B_1-i@Np)fUR+L|7x zcR-eZ`b?3c;Pyzy$y5tZ9UXyU=l(Mo$yYHpzsD+4U+{_w;^1_>QQrTK#~!p_0lE`_ zHh*h(5t6{}(~x&OCPB6AlNUU)Pku6QH66M|wG`3NCh*u4-l~Y&IuE9)V3OVJ6`9>> zoXU4XwZ57LhD=A2P`Tx|)Ntc%0zX(PG|vKZJ3*S-u#A&@bcN2!eZ5O~FoM9-{Sh3- z_r+rcj{2#UG*j(?>_w7BIJWV&A)J=k;#V zMgHd2PW*Lt!t5FDoasz&z!mcAE0dK9p@gL_}yF5(V(io&+ntTP!mok>jY zL?S*(Pa324PO3dIYiyf=jU?}B2`y@^>~~#r5RO8}?p2pU)$<9b5@sHho?M1p^q6nU zM*Vm6M*VkWYb*sO`^$Js&Mm|6vct#Im`}$BDg^!8*zoCr z7!hDUFV)=$Ss6zavHZ%^hQ?Vdf;YF+xu?|KOG;fHJh7cL>uiIYPHQHukc5|d(I#6X z$$P*oE_Djsbg6GjZfT`XX`!XAP4@t&Yk;rJQr{g}#eQyN1;RB0IRCX?@8w<3Qm11B zrB44^N_}rt>hde4u5qH&A=p>yu}1yg9@h(`oy*&dU8TfjM=N?d9fL1C<{4AFcO&NBkdR)&O_$8w z7}#uzqPR;|JnxoeQf|WBgH!qFQ6_gwWcKxJ$aRGX*ddqYj^C6$S(g@>CGN5o$!Z`nEc40Vg`t_|#p!33bp}LZ=JTipJ37j@VCOqzLVI8$A*HJ2(o!j6 z^|Pu{?1?>?QpsgsXm_aQ&Q3%KZ0w9TgRnOwpwuYHWqwri!TOPFbWa@EfX{`XulljF zeut_~U$z{3t z3WJI4E$ktFmaUxFTNu;N3?>cSnaJG19hnFwuS+m_LxKr+DvnUWWI2wL?Wych!9*@M z)1HuE!d<3W=SZZ^5lluPiB%F3OlpDCWfnGKX)nz}f(beEEuH$zRmYk>G}j+Y0(7s4 zdnuQgU?Q3P!G!pYP*;m^_3eBxsq?9mV4`__Emx~E!9+4e2b12AtAdGETByA!nB?=Q zU_wXPgNcTuf{9#ODn(hrL^e+z4AtEJh+u-&;^B8^pr3xmleUQO#uocUlPm*wIs3?{Mx?@;lx z?03WlyqJDwFzLnZd(0i&wuoRdPWBj#myHSB&Np5KlkfLRWcn+6R4|dt&9o;Zm~bm* z)@g^-*^WtDB(X|Dg2@2jbeY8jlU5klRYx>v;Y$|WY4NG5+U zA$}v&)goMdJ0DC2`_xG=(Y(H3qScvTBAKFt$w0_e!9*)9)Ls-!@_AG+p`+}!mSxhxk~VGxnsX~V_8vKbJ&(_;FULF6ay zZDa1>o<0PTJ0ytQDM5sL-R@LDWQvo>j8OKdAR?EWX-`NH;XcKzvl6NE3X_+S#3}&^ zB1ZzJ%Pb~{gpEkZnQ!6LXRbQd97S{eK_o!0l^OdZluJwykxc#|Li|Rkt3|l_c0Pz4 z?NcW~MDzNBh*oEUh-8WmB7cHh6-2bsLhVICB%enG5jx5qL^LE7MC8&^Dar~WvicK5l-?IunpO*D|>VNi5{j_)Y{)msw2X z3+utjnQs}?XRbQdoJ@25jW0m2mBx31a*1htlF8rrh~EfxwFp<=&Nsf1K6TRgG_SAm zX?3RYNv7z=cM{~P#;27QYA5Y&18?nz%H@?|bXngpH5*pvvXnd!F%*H3bu2zP|hYf!gJ7P6HwH7f8Gv2H}-VFLE zu|w7(Fn6AH9>WZ|^C%L%{63qL?SBPV`dXZt;gZC;RM`E19KCV>fr;E+Tn+&8`w!#{ z*%QohO#$;vVcrPlJ;9tl4FXa8xJLPHJg~m&xTakuNbV<*+a)T_>(e`2!oH;gyt4|k za7?LVP9awnxV}k)>ki?%L%8M^a&@wC%_rUqpiz~@xS7KZ04SU}K$bXgtTLV8@nKCG zwX@;A;hcTGABRK8B9w#O@#f1gxdnyFJwwt9uag(gQP#O`+)i)z)MT8dL{Hr&j=8A7 zU2xhoK0iVT{`|VqWwBw-JN@|vj9*wR7v^5bX|ojHTt<(>-!r{vX4qG7|3$XeNRN>Q~alKB2SZgFWl^B3wyz>?omS568eldSSw28mpU0b;E0WSx#! z#c_5+5{OJ!fXjStVlyh@lE~!eV%;y|lE`!` zH0sDSd$_AJq0TNGs3Oy~bb`mHB9kkT=}8@#GN_sbkx9$R8)A=4MV<;qrhgTF{t)IenNqul`q(S2Q+o(>-G=)9hcOg8WMA`@biiA;WBJC-C&MJ6T8 zM5YG_x7rU{BGbLNZ7MX{`9fV^YXR6LV1H!NmB))rJm*isAW@shB#MHO>2m5uWRl-f zBa^JhoUiw#%HrpPkjK?d;KgERypi7p1^ZGbcN>}dbl;o11$Ifel-$^GJr7pAez;yb zeTeX3;)UM6RJkm71Q@hNR$m?#YhI@{SZyiKn&n+brY3ZIrfbj|O2)yfwB|OkhHE#E z1g(+FU&k7m{(V%e8OKLrO!t;&&G&naOwH~3)m}ksC>bv{(wZq^4JVHu3tA(Wzm7FB z5B0cMa|f-#yik_Ma>*NFq_}zS~#%AB~tGhxMR9AI+!p{=v$}vhOEPA zhr^iNy|efzf`KBPc|!h7Rm<<@8+-=DxlbbD^8o(WGUtie@-&H2X4ZKaP@RXE zJcvXO+#W$5m#nmn;}35r?UGTC4vxTh=(9n1ZkdkXS znm3jXNc(eaX^%l#X1;Qe{Fd5f?7dNry5p(D;ut>fWt{~`o%u}WA<>@T`M>F>p-nc? z-3{HnFoENeg%4+Fo_J2iSnpR=NS-j7NU_(V=E31<4MZ z?V!`8M&>rYQ|IuusY;m7RugkOVs4TV7}X*}aPL4F+H}N2I3}}@8jxj2W=U0hmnCk# zl8>;DLAgp*XoXLfXPuTvV@(@2sC;7OSX{Ww%FQPzx<$kJn1Z)BfEH>3UwC^o z>h|YBZ_8!5P=ns)r|PrL1#!U@dz)Fg&&T5JwGrMHTDc}fd3&@NbV*!;#M|V?K0U_m zI}o?m1-&hon+5f@=F-L7iXZ7>c#SS*sz9BL)R`0)@9oH%{=MTJRFTD8f~;pX@eaPF zsK$o3+oLT0-G|>id9gh|VfSKtm-5Y`m<*J><+Sz6)H@&+U6fq@7N*XG{;V?tsdG1y zSaH;DYIDz2io!73Vk+g^Ox+kXRW5%EQy+%@tn(mJ=K&;}Zz@IEO{ILBsXqoymCN74 z)F+@n>&!yxJdR}ZO{J*DhAR&&uE3OUGd1z7Hu zHBALZ@$YHrLTsZ%zmK~d_*OTg_JZU5-rqveKBO2N znjx3vjQ6|9;26H?0ufnfPo&x{dnuAwzBh-%q~g;*J@B9p!}+M2Qg|EzfcL*SGS(yd zKky<|?a}h!c8v2Gd9}MCxs|vefggdvYki$}!;P2bR}%l*i;IR6ki;L>U0Fv@=1>@1mBDd+@v@HjgdHJpVGz z-1EK01FCRI|3jSHE6qZXzl66bc{59ts{(@8cUA({{4fO3d7tJ@I0b8Qs;3bx;;ynI}o~ElE(G!fG{Vo zF-n;0Nl^YU$E>V2nD=07N2TlPGB+|wB(sG%(uIgHC!$T5JBZ@*`FnRjm=l%NJxI}E zj!LOcg_Q#oO@%q{G9O7|P5u>n=lApIot=?7ze5u6PH*UQNy4;^p2QOG984g7?=Y*+ zJK*o?GB^I<4_`~$m4`X4GD?UiOB$Y1#`@*ksj!P2O;G+Y$E<~6j=6nZWKozS zU5B|~7kLTAyC%PMk)pCXM~V(}RO$Gv?&cPGz0Il9NdR%+}+`rtg}B-je8hz z(;N@-pV-Dp_u%rZtz06JyQD)cwnQZ|mnlTUJw)DRIf!^HwRp0ZAnM^mbbtjB=>>>7 zdWc+w=s*vVcUcZ1Q?`pBG3z{yRQpKE_Bq^0{~L)nN%tw%6kRfL4hPUaM%i*EBhihi zDO={^4Vlj~?*X)^MfFc)7K7+3U+=OU?52E=7jGWt^QM$9P4ZwL#quTHgUnWj^5ws; zbs5i9s8ktym*t=`Wqhij8tFqNWn6%YbPFm~&R-~0s+_&ca!{Fa{vHyu&UZ)y<@^(F zq}wdj4wG^wQ*=2qS7$nQswMj=268O6RXn z715<4XcZ?#6}*1eY6@$kYVE$>pyD?ymxFR7v2- z-Pkae;2Hof69gxh7I3lRf$SpvJ1Q^g@M+R6@CUCkl3N0`?txG?qhU-x#D*z6>2y&n z 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 z zk_WBj!P)X)xIDN-9$YF9E|UkB%Y!TAL54iIQXXW=gKOo%e0i`y9xRjxi{!y#d9Xwt zER_e#c&*#+_{hesa_EdeBWKdAvN)fR%UOWT=ifsru^KOD;2;zXiEdC#+A zB(j_XSYi!eu_b^T*mtEh6USL$#VCN2n_{(lUj3$O({@TzwP|b66gO?SbvUspZu(6h z3ONCgt~mvPkF35*>+rgO48_{epB8~C!y9W2A-%^)_?|3Wc%Z#R1KLH5p&&4`OM%cU zdkWomQy)@?wf&oD_b3W_U5GU>saXnuqm^7YK?SrvoJS4_q5T1+jnaNlIAD-GLhE(vI6p3y;*G z-$)QfUq6gN6o!{J*#A33{Vg+;!|RPI+2ivIrs$@ECRCv~Zab?F z>gH)V$nrLhcU`kU(}NzozeZL41|}_}dx2yzT)103usact-e-rC30j6$R|Le{P{22V=n0z-{@`cjf$->J(pkEQpJ)*wg z1v(J+9d`H4;Eoqtws5^)XO+3jBEuI`ws9<5EmR12JCp8?kl>9rsyXf>lIPyfVeM$v z2&xUPD;EZO>%9>TZqmJ+(Q^?}6P?jZenu~IMlYB%deN@&3TL#>PWqBbUqnb3>1e)Y z(i<_o;VZkqA-_1^adEye7w22M#t$6C_jZzVmO9NkPU5Wapc<@;lS(AdO*>1^Io?^u zR!p⋘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

KjYPLSko(^X(vrEj7~axd@P*257{gk+=Y@mr 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�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 Bp4R{X literal 0 HcmV?d00001 diff --git a/x64/Release/HPCS2.pdb b/x64/Release/HPCS2.pdb new file mode 100644 index 0000000000000000000000000000000000000000..e0fe5c26e1e383f87e7247a56ada7456c3dc0644 GIT binary patch literal 2404352 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%0ACI`%g@RQcg4w%*sI@_DbKZa`whOOANNDfXrX5& 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 z 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
8Pr%^AQv7@0jf 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

h!ituL^Py;G1-7HPtRbHRe|)lf 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
z
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≶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
%#`GPaq5uJP?!#bR4
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%0A@bt5X?ejV(XlGt0hwuPp8uST
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
Gf!_g{@d2R#

literal 0
HcmV?d00001

o21M^Ga#ZWMbWI|BMGlv0CBmSwjy?cRM8W_8rild~@c&LfS`NPXi zw5~{6&KFu^o-07fx@ zmy8~7zg5*mAdy+YVC?#wK3sX6#h16b_z5))P4g3LZf-KA-qXAVEnwv>&WHTEk9mW+ zXbeoQhFL^30h z?z#R7cngC@By(iWAvyiBG9%d`wz58WRo@~{O6eu$?T4Bk&AAI{EIm!5WN`GuvTE7* zhkX5sCOFLqM`2=CF4J_OWMHT4M$QYD7p^NhtM{t@m&rs0M)LYbGWPKwnrS~;U-@R? z)-}r}&6Y=rksHhS?c{FmjwD0)yq$~k@Gkz`{0*f9X$G627Kn7~>`#}QR7Scrck$QBRcOvxU5WZbnjNNrdAX(T z9L=2l;Y;}znXw&SiTtJ6h$a+_Z9!?em=5EQ_X+AH(mD1N14>(3Ody$fleP5H5B6$~wKH1$(Zo!Q7E;KCX0$jM ze}{vF_)|5bg{10-&4AGwHe-gs{>CQ5#`#IZkPI8=XL>!vPc_!Tn?0 zq*gz{&DuP1PaK*C?Oq5}trKoiwioSwqXZ^l7w2JShyFUH-1o3w>AiCzD3+#KTg zA#-u}!rdEpAKc?`vs-(i3!%445O1{MXFWgQqXfJT{i?czJ@|NNrhnr35SGXU* z{cGG0;wH6!2=_+Z@8kXu_eZ!7?hTs&+=t*U!aWXmC2msvD%=gYlQ%m*^vGcti1PDe zC<%#`W2GWsq`g+ znZJ|;uj~Z6il_M&zZMD}l-0Q&E|o|(zkeg&s*SPf;hGVE)`5e0-{*@DO@U+ zZh}h%5?R%I;F2o-0`8{>e>42&XB>;Bl(?8bFBHXh#bz4$3yTXpiSB>Gskf@plOq2o zoMH{AR7&aw!CdMBc{l0_r%5~f4K}3D*Vz2t^SeoRF|%X;Yp=UQ3-rJC+G^$1F16R9 zoocUx(29Ft&=eCU`ohkYptpi?%SORy+#?t%vtUr{TkJu_{-D^O75hxFFBIz;^y2Pk zeOQ;G80{VbD4aNSX*!zlwLSA~=))#hqDArT4qZKPv zY^-7@DpsplgJL%;cDrKh6nj9i`I%l>>Z~v9EK`j0F;Xv&DaP{~1Uo&;i@VVJuvF2(LqY@=e2Di+0n%iMCD0_(%3NYHQzw%+=}&LfIFq1aKdzmsqytS{^w zuh=-n>J?k0*!hZGpxBLy-KrRxugxQ5eb~ZJu^x&YqSz3{j!|rsVsjOnuh?_6orPvLa0>7;{zsD`shaSXp<;s+djh@zU_^7AXRI&mECHAGR+QK>>oeQ10+DT4-Ij~gj}PmtGxG`H*v-~@ zAZgZNLIy+gXe0|AcjG7=!r9DcyQ7LV=!{{Yd@* zf+LqS6MLcu8bd1o!uDaNmnLKP_NCq?fz(wsqF&J+Wc`k(iC2q< z00G1$d#7;aj9ffJ?f+x%O8}%OuKs&ZmY#v#MZ{G!%q~a}L03WK5_dUt7MIJDc(AUp z90>w0i&ribjp9h6iAHmu<}}g#WBkkwVgxmb8qav=6r)MhT$s!M?^mztO;1nH>@l;7 z-$!fFZ+}x=U0uhkSFc{Z(gbIB*!a||NpqGRk~Hj-YZx?(X^qo&5}4~&4vGzgI;E;A zDy1Zz9Bm$rA;t8QAFoGVO7U#GY9K$!Dl=zc&t*Ex($1^FJY-=Zw?`%(7Bd6Zrr^{@ zyD|bSVidw?ghLR~k9LCdIy`*mo3rP_ai8`;}t9Q*3yNd+!KK`QFKjEmkan zb}xAuWhvX8#Ek^@;WPy|PU1KS^sE+GRivJ%K5c7tEi49F#cZK<)EKcdnf5@}LCMrZ z$<+PQ{Wk4LBx%%;+_W7Ap3iLfO)~YE{zx|xp_3sN(q8mzS_ZUjhjz^xsm}!^EB-4$ z4MRbe8|NLj;IDKy=BZ_G3mw#xLJUOr)*#$akAKXS(T$5SwF~osVx);_JI_WDPEwQv z$I9aLpTV+qaXM&oHcPeOvrIA3ZPR{cxckArIk}fSL?bkLC;`cU9B4+ZeMmVPmyShZ zXg3@#&Cx~$<10r?b1-=acQ?vA#$c2gf)(>LZ#n?XpzLt0*d2_O%b{2yhz+FvnOWed znr6FXt8X`7_YSkfJ^e(pP&X3}Kh|!L6?3Yns}QBdMB_%(S!U&o*l`Bqn#inLa$I8d z2Ac#fyFUs{wv7f?*N#Mlc=h4rh(Y)W!m+cRDtg%nSqckAIT2qK9}3z1^jf^j3$B)h zwbsmtTs&E0CirSK{&ZUF4}*{1iGHvh;U@?;C7^^v7>GO^jL?X{{4lF5O1?OFq6Ycw zLZrv06X3Ip0kMcP`0UwfQ2Ff2G?wPGVabwxm24K>*tQd4tB2!nvQ_qBvej2`XWJNG z(hCjhTi_I~Vt4ioWnW(9i94c04x0KN8jDDAq}JJoRqO|fZB^_k#UN+e^j=czWyOvtb@_t>7#nY~VrMG0TCsJCZB&eQ!;F*WYz*4J#2aU+qD=FSL}KsD z)2-HxL{80>(XG^WlU~fjf?mdtL4hsf2fO}aJKg6o9nah8Y=jco>U6M0H6)~bj}tz@zG^Ao`-x)rD8>n&#QUXUe^cx= z#VXK=B;G(v`QEXLaU_@ba;%nk9IFLOqJIe1YNTj^bE0aMNQ9UVR|+?a(ea(vKJqgH9dQoaO_++_iBrno{eoll%We`1L1Up^AI`_!qYQ;_z9SvhNfpM;talbHsV=O z`5vcdtl=Qv3(wBjNAk_i*mvCQjJq}-?alFo!P!}Nt^bYgWPO-MQSo=2a(YrYc2_Z$ ztYH6DjQb%4Yp_(z8?6{!VMuzD6gyEd?g5Zz&rxi-Vqa72n~FWC*dvPlPO%phdrh(b zC^i}VQ}Qz1QoeT$sHYPYD6g|r_Uxz=y@RW1+qReEt2u}NC_+<+6Z1D-NXGkof)p>| z#BHanS>C>8=|yHu#_~YXXj$i23+MHFbA;ZM$s!D|qEjH{drOdc!OpRi&ts`9_7%l~W%5Cwlk=1br)6@5 z%EYYN(TJZDs)CBd&d7?>P9`T@nUM0~bPC^Ruy#vHnFz)*k$Ax}Ay=N6r%Wg<%M~h< zjQNQ)7%Tkuy}?+~*_BQq?d1g2rL-4PzS(9Y*t_sKg57MXn8!XOSg>r+FTMNnl+8p8 z>2ih2#)xf2+l(gTRiO+2m|L2SB@aUbTTl~b0>NG#ePmWodEGSa*Q9*!WfZ7jf3=iv zR+R;tjvA48!Fp;0`b3_3n)(LS)4474Tc%FMKl9qx6=zQ%D$Q2g7n%#KHYO0LwnF;W zB&{=2zV|w6N-#QN6>PSpVjfihf(7gB0X%bYo;u?~gIrO4tKiOHx`JI_>N~%(OBco9 zS0B|fCFL7$<$`?y#UR*kEfq7{(*+Bb>9_Fv8F|X|cL_u=S5%pHCpO!LXeV-gFEl$( zaD|5a6w(&QsH{Xvj+7MaGNdfnPD{b6OEI1jQhobC@c^)C_v_WyZ^feVnC$}*<39-L zRpE#6S6FJOGco9}#`AtL9RHY0OBME7OU0hrtV>QBYWnWXi@L&ARy>7cM(u$$=J(@P z1x`$r6bBiDoiR53%p1)g+=(-M13I^P1F^}7%2a{bRHxJqu#bNW{M*^@GzOC7H|;FX zlu$2$=nTla6nB2>CfqqU*_?2rD=Cr21fw)2*!wgdp0*f!y~JawO1xc)y`-4>uZ zqo?IVf0;}@2%8*T`VW}pB*ir+sy}3wb0;`Y*equvV$m$;5QOg}@Q=B)=2op))wQa9 zHTKrQ|B71RglCLmrDGOA;z$U?X?lG)J$ImQ$r-gaf+|YF3n1K5DOYZ@9MmMPks-xO zO~#fjTD6qbKuI#VtQ*@J8s_Ksf>i5G!uoF<@8tS#KAW1bJq?X#*r@o`rt!fsv}vVm zkrq^~K@+gx5`}Zn^6+f)aI-zZ)bIyB?=IHiE;MJhOtwZ|=V4u!#q@sMQ4-!p+*!vd z+!^OomY;s2H`XlHRWr`<-I@m$+vSvXt*Vt{7J* zHwoOfw^Ds`kx0ST1S%+S>FlbYACejj{ znsHzO9J!(BIK$MyKfT)BH=kp=7i5!l9t z*~MET*Az6#IPPrD$_=df*-$r!i-Q_QVDmM3Vu!?)zp4qt4v!y`}3&<Qxmu%~;HKA!gku{oaXQ_ln0t`j2DjQj$T&3%u@M~Xdf?#TKJ=*# z?x!HyLNsoPu{UH+=Up1geXhkQ^PilgpnCn$@1cRz8>GJ_Gj;;Lc~Rz@6{n-(63!Pp-0L2s7N*;xd!C3 zb9WmP_tyW^sm0S#_0Ld>K`EpDCn(o0y#6T_zOGtAQrM$~W+d27OZmo6gJ6{1B;Ia~ z_ix3jO5L+@OJR?ZVl+gNXD2H*U9r;@TcX%I6lM)Dc?I6`fS0#K@Ej?pf=T;c$PxEDuCA$O=8p($wyH^1R#X9z>o``j99~A3otV6NxY}_fTHhAZo6>Vv#f9=CHU}hecAd#Zs^;l&oMwEfw?X6q~FV z7iuIP)&KG=O@stnsn}}8E>!G2ihW$MPb)@q1WAwP2$J3diao3tMSF?&FU4XQAO)+o z6pocvY@}j5zFp$2wv_KZ2kO}bhsEDo%J+VTfmE;uEtPGykT&X06s*wvDZV6Z*G*-Z zQ)tr8Sgzb-5pKBMvdP{WWINR+zdVCA zPDYViP+4OWuY1b3@+%6b#~7FntLK+AJRUYTYoJRnXol;T7R8;BD3ST-cDrlSvSk((>&JAEv8B` zt(%bpTv67|xi_D_g6fUfd@9z>XFD}_ZtG^Ld|S-psi*SZuYh_kLF{Hr!2%T15W(6ll|3O5 zJL;Ac4wk;R`m!rgR;^o_C%2|{wjO%VoC&|E9^W8leRg&qmY&vX=R3F85SHuK`!+j_1;w0+kBXGhbn%4Km&octRqvguymIrWurB zAhQ#VrYwOK*Q%w#b=*k}7~hsAg3$2-1w9|fhT`D`mF4l#gM;uDgwH~nHN%1nycZK* zUwL3zIi9E(z{S~M`cLBL_^`9w+HLTs4bZ#A2QLV^MScblUcK>y=AeV}ieU5#c#Mfx zEO05gdoYV8=LzJaVNeh@IUkRl*JdnDo1D*ZImePlM9yo+yY~dMVsbtxk(KiVb6$oQ zRb=P9Ea6g$x>Havb(!@K{VLxJjpq^g#c4e0Q~#naA+YeD zMxamS-y>9^c)1y(3xVHo1A_Ch{AJKzLAVux)xhE&im)%ju?Y0NOe63M5$GcBUkDXw zW+M?MAsme`8R2e(9SCfKe?mA44UFxM4ecBR3M*{7>^T|23cufiDy-B2vo_eObp_<@ zNIGG~ES$dz2#8+SgQ9*FYdYR^i^8#?*?6)Y_c$>AoxuGr+$rJ{zYh1ExKl3}JBY(g zqosWBOC=7YR*t{=-tCHgPq8Nyg99)d@1KhOS26n0l6MTYl<(0wgJ5*dAn%x?7!Ml} z>|~4?5^u4kF!YIG)oL7;w7F}P(ZBV@y6Th(f3%xVjbYX1!;_oWVl``RU3E=ab?t!a zniFcOYZm}{S50!qtU3;GcbDPNrMyO0-|pV%YBh|mV0m?+SYGXiWaY@+4}f|W(m=V{ z@gnwCw*k8aA#JyMI*K7|Z$+PIBN4uiP+5Yv3EA-9Ad-v zRwv<@KG8YZha!epIhT{Fc3MAr-lxrw`vrMP#E=`dw^|Hyr+s>5ZzWIUwzneVfa`i) zxepBGL3^vwCfXXO(XrVC9G%Rd}$ato-{^xbMK7JedP+G3=81 zV+PbeZ1641yd(4-dyZY&-ukx(7mVwlR*S(qqy8uB=oX>x8iS54SKbA9XP3zFvPuPQ zQeu}T*v=C9RqWCPdt5OtI0#0&GmqE=@4nr3ps6G{I<>CK&C~1X~B0RIn~f`Q9#2ze+%O_g=D;?_H0HieMkJ6ykx} zT5sZ63h@Ry>|>Vdon2bfN!W0KQ%fJGiP=Kv!Eh|?cAVrqXTm+^AllZ=vH6=@z1{OS z$Eo~k+Era!W;9yWwI@IcmJI2$wkM#^NPAj4R67;TiVIEE$+^~6ENY`vSd}yzo(n{k zWFLx!jfVg`q_zny8X^>=&_w!4^U69)!o!^41Zk zl6Y*1lM2T}F$@rhteRnXMOgRqe)$3dp7$yU%D;}kT}s-;?V zYH^+%e6^7&<9QS`5vrx!3L46jQaq-NOmPX-h<%B-L!KlbE0#Rj4&_T<6*SyQ`~U)r z{!7U6HxLG*b`C~pL||poZ7FNat!%U1Whi23rC~u;#54g5o4)}Hn7^qaCMYMeZ%4_A zU|>cb9E^KV5p#;gm*7r0kvzdEWGZx=ASH%cf>o736=g84atKzZ*kr|Ms3q|hD|V)0 zD;1-mmc;vzVjofL3yOVNv6sQuN&h+0P_En!Fc-8paJG9SCS^;3f9-FjZ5do}Ll(>LO)@Dbi9i(iVB2a=cJ zPW(#T+1}S_eUS3KWs0q|l<$2-v6~eOmdi(g9vfP3F9*hp?|KI9SgxpYp?Q}r7TO=d za;4A3V(ph~u|)3D?rFKa7kL)NAt~QmiVqNMg{7oi1Y@~KykNO}3TR87a=C0IBA6?x zTrzBXTnSlIoIaP3wQF%D6upzZr)5-T*7w-*NWtdbQZes5#i-?zcy}lkETfMC&F9T! zeh>PTE1aWi3Tr-m9z0YFhx6sW_N#H)uSogca-<~~_nr#IRwLN0iUrH27Jc}KdD_qG z2|Q-5sP<#l|Jqttt?z2%QP$$#qiE}P)*>x^PKZ6`ea5)+!SqlgiLtI)7Pl5wEqp#$ zEd}-KAzCk_eD7B%Kf!)yDeQqkxeGSVQkmmG1<-Hhsh8X9rB=XVr4lm60fA2L?C1#B zOWM#?42lXCWV7p{>4d`Sg3lMNE~RXp3fJl?3=XgN%`={3R%)%_gTvK;wXE;Xz?TQf@Oa& z&HFkMfhwg&Lh@*6jAmw|1L!k=xnx%Ymez{;x zs1=D9tSee&J(s7ho=Hee5b z1GGI)xzbOwTsh0NTf<&kaMonK&jn}gqiw+2irlnNXqyjkl=V%83156Z%~1-eyLV{ak@7u`27*!I5{#pP zU<(xs*4>S$(b;+G?x4JNw{BtQ+NB-q*E??ee0^bM!{>`rHm7LWkn%lh{RCTWDe>Ga z81)nqFIYB|OYhH9HZkN@F5wC7%a(PbFxD;)4uN~hh$wRk@jUyUg{GR^fu?iuopN=j zr*%%YnE>jE2^h_KG!F`Up2c{#k?+|Dcj`}}4>!8n66N2dux$&!3AWo(B9{tAxm4l> z>*_~{xiU{(ePv%nFjsV4oz&I2YR!tabZwm!6kY5Zc7~_&ZHE+Ch)f`(5TkfOPs?zy z>UBx^-WGhTVAom->(q)pu2@nI_t?(*_|fE`)gnFrZx5Ad6);`{5X!n~{YDd%E>H7k z4tcQnN(%C8*WzM^J zHO9VoA0|+&vOP}AmK3%ppqvEznx%X*4-@QV#e!wa6}BaL%CNdrzV41bfa>zBdYGF4!1L zWv+6;x(hpCjyD3BDSG@993#J7@6hNvd4pFQr5`b|L16^VGv(`FU+Wtu#t;x649f-v>4(5Gd|K_;a)JXHq`+33gB$ zjP6VX`?q3XpcV_3HD|Y<&QsP)dQjFy5y3@zh*)Kma$f??cR?cn6DU%-AEf0@%E!Fa z^90*rDbaojM(vlx3zqx)O5x0~G&iq#svb$1E1K6N+t;tOik(x=ZC}^c)!DwP%dTn^ zD9B~if#@*XPFaa};`D=a*R^+ALzhC|WLgfBl}{-!xx@^~X~%gR+E=%Atu0cbF4^|g ztJf|~FEJHu3Y*i&2QO~qq(yqbd4=`>CJ^WWg~>phl+Tm$y?JQQf-SO?@6qO8up1Q% z_JL#3GhWEUdyZ(x-v^8g^j28`lu8`lS|A%^0>MfwWc)Z*>yVW14Mu$k#s~{Nu+SwoYp%8>z!--c9>{)Ai0$EprOhbuocJwG=d0Ytnil<$J$I9SHV&ONn);VB=5&5-(UU zv=Pc@A@?t&ELU`!?tzZFU};2$?yH*$>=aBOSo(#H-KT5$lM)?{VC)Toag9JQt`P_p zEdL)O=88N#<+c3fFJ-$NC!3wKVYz6Q-)v7&zB2spJueXzfesr6DVG}&e3uu<$Iq+84319 zOJT>SVlOEcEZ3vZVxP@Zu3t&uF>^)o25UJ}j9G2JS${~MsBS8duP}k))!kCn!I2Wn zK*4AWA{Z?|1mh~BV8Ob(4)ro4Pu<;-Km>Dz>&{t!NYPXksup7cfuboy4q2q-LP~Zy z3AO@XBG^|f1+RUIB{!8M)c4(56xY^J!Bm)n5GCc!3HyiL4$;2se4J@+=jm;BxC|6xD6M#T2K2H(ZXavD#dMy6xw4k)s7!|s zjt56^F145mRIg;ht-8ZK7{LY0my01uxYAkPH=-Vx=qLnU`(f)P@B8CUWpN|!<8W`o z3uS8?Dc^fuu@^1ndzT?CiFc)?e6Km>Z7$VXCo5YQs`W}d&x^Sk9-1QKD6Qq~8&-F< zsj|Y2riPs8`nJXyc2{*ePX3xX05!wxyM4giyZEVu=bePl;i+Ft$Da1swtQ{pxv=bE9n}D~ zhea}9!vNI*VqO-Mr1KIm0vf}V?8S292HR5HG2b=U_EM?6pW@D1J58s=q~J(Ev5#5G z_r9yx4;3R@lV{1+q2Kz4al2z9-z3FXj4@a{Rj!R1VsbK7LWfda!^GG_;C4yZRUX0{(I>)Ph4~J373MA6Rl;16ZLhmAZjSa7Qoi>Ce2`#UEd?Wc#U4=X zWySug7#;k`vsCs=di1VYWzV$vCw=Io?r%vwunReZpNCnAw7Z$-Jq5n z{f?)ZH`nrTlR>5u>EvfdZQIQ3en$^Hl=xsM84@qypd;XQ=VG*nc&sMaH90?E_e_|_ z<)1306YxY6?w;IH+l9cy-i_e8=aVzDx+mw&R&Kdi?;=Gxm&u`ki7GrQ@ht2&l; zT(D|=2Nv4btncE?tj!(FHCnoI*9PojEY8}tn;`@f2A495!B7uoZyac9Q+i{1LO9U$ z;9nbsi=BiWArrzyct)Bdka0UAJWxo-=x$^yHC~$|P`pk9KE#4{^r-O%OkFhA0ZM`Z=-^+0R*muAhHQ z$6->wN6*)S(et%n^n5KCJzooUm|{mN#>03dUcyo^ZPRhMCH0!=+7Gy{Jz;BdGe_cC zjR=#gYX(%;&Pr6*EP%i26963#f7Qnuf7MqG$U9Vj9CGl1AuE_>8k0RTlg0T~%W4WPGQ&yi!4GaanjY7unQ=YMNkj&h6^V3@ z6o-9iP39VIxXq(x)gqJIq-Ba(Cfzjm$@J3q%LL?wNg47&(7~SZyEmM^oU@N~I0Sz8 z23KeKa-MAc?v+OSa;`qa=_`X`i}AZRczBjC=i&6_T!|M&_;Ris?otZgb4xn(x%Y8Q zL=HyLxrxY|bsz$do_zp;#s35X{b)FLZO7Msh`cFE{35S%Y3>r~<%b1>^Aog3-oFFgVw?*apQeQtV@jeM+&fD)tS< zZUrBe^lr11uy33l&}!#W!o!oBPaf5X*_31C*Ce-`fZ5bzyYKWc_*j#-P+=^xwR~%0Ee~D{bajrN8=VZfNEF2vUmz+(R zX5sr9_AJ|f(!Dg3g&&+9#|n&O;Z(9gaTa3XL%gAZDPMU5r+f#*S=BlQM98q4OdcoDj0#MR6qdLvo~7a6c0t zIJxvVBYxsfbH(i)>luM-5*whP^kNTyxS9 z$0d38Y;P`nU8$21Qoc7IZBDQgE#-Uk^)1*rie0MM2Ne5~Vqa72cE!G@*wq+^B)w}a zg?&4qmSX(DX?>RB9-XTik;NC-&^c8+AG3;bk8_yP0Rnd4vcl}+h2_g66( zj}8r#XD}DIPDkKbO>*rWD7pKk+bFo24u(~EI=LgxG=QtjxW{`VN)|6_H7tT3e?M}(dJ|3sS zhzu?@chAisy@wKsc8MX}{5@E~_yTprPd>f6wCstypFq)wY)#t}VjBF~Ew zQpf|{v}u|SAf$Zn1h9F*a15cLd~dB{>lLf2aPi`nikSNBhWaXc>a*pvM4q|N;mF{# z$WHq7vlSRsP7bkjl!2N1OvHU^1O74Bo6FMs%>_cx-#bVdM4p{ zQ;;6hT!!HI$hKMJ4jF6HRLk%yLyKShk}N(F*1oWxMX?d~J2%(4q7?GqTVbx#KkcZ0 zHO&2z=eJ4+?fJAQc;eF0I;@fMJ?i!Zd#|N@*lRj$i(=I6NxW|<_Cv+CDfS+WM-p$N zrC@vkY8g5*_9R&<*Br8~jQgTno@6(pYiv-mz7zD#UIs;1%ky+Zkfsxw1 zvSHEMz0uuh_l7w=T()*^V3u}oU_R~MK$lYRPVF8ivf0<3q}`(s!9%TC{7Vt?2o&TR zp;`GtK&)gH98|lPWvs@hqvqx0L2h3Dfl~O8*eg4{^r`5l81+t#s3JkL#6F zbY4!%_bx>H6pT`?V4qa%vx;4b!Byg2Z7JV-9Mu09S>P#48Cf8K*W_Gt+%eOvE$T+i z8F)kZL=#ct!6OS2dIZvrTzwhK3zYz))Jg@XX(n~{BwlCRmmX$@WQ-BjFwHP4K=F#; z&~Y*0ipm4yRpsQ*L2iFO6sK4b2tv=T3PCEbc&2r4%xcK2_Z?uT3L0~2? zL}0F-M))1V?-8o--qR77rH>(e9N|_3=I2=iW`d`Z?u)Pp;Y$hpj^G&fiYB8k4O+Kx zImVtF%c6^3c47O8;>&DLZrSB>m8VJh^k(k~wx6YZtamtUv8C9)?}ZteY2KX3W*Ug? zi)a%=mi;lr;zjHJpZsrY%te}KiQ#;xOYl4cOgnH@g%$zIj3ky{&k;kN_H@fxcvm&G z5;rBJJ@&jU(t3%#Bdm>(Hku_ouw6toQhu^)q}OXBCFOhEJuBE*mh!z-ik++27R9br zY#iFAP0v!@G-jC0dQ=KJ-G=QsZ=q)F3QkL>kp2)%F883uVy z9)1-Kbqs>LdeWdjqz#&s@6o%yU`s89#csvcEA|n^ZcwZd?NgqeXeqx}woNL6j7685 z5Nhb-?N?D`dT?(;k80?VOgk;dj5ka=W4{4fPNqTY_zYQxb~Gv6%16;q)8p+sKqDC_I9XFC~){aj~4#*RX2jmI%9!tf%jfyp)Z%Vw`mdYBn z68N;Voyw2!=+hww6G0K|^akY0Tz#2OSQl4x`C@E9((GUS!bI+L>h2*)s=HX31Iv=x z83q&G$x7#%=$Qr+X#vwxXpkBg_6euO;PsrDz9&Ra#0;Y7~qoHA=im8gHs%4=eV#V%4{oURe@!xb-@+ zzaZ4mxJ!{&6#{#uT++~t$+Fp&+8#L0!quud3wwrPnafaC@C4dQpUJD%t}!e#eYTfu z8l40-5!OPcS?|ESb$Bh_BL1DYNz~21D7`Ys z8@`(tXKg2im_SC|s6VGbomi(%S}GjI(sfd0>MhE%Q@T#7dQm6NtCOn}>$*wb?&>7c ze^aD_PjiGLbpe9 zMf4X}C(iEw{I#o=NpI;%&CoAW?%vXynxTIt)=qad!#8I2mTc#vy{Vh`X@4Q*dl#Uv z1bero#7~o8pHYncMKJakc{bc%=$a*bY-+H-&`ptC5p~l8?@EE5WL+$2TaM~UQGS;C z){`zl#_3Noq-)3T z1)rObOfEohwZpeZjXiP*QTmMmjY_a~`2G1f9m~aWy0Hhj+94&qNig;%!9HQBn8)5E z7<-e%V{Z~HyLQU(+esl_7p$FmJ+GZ?j@Oeqnv%%J@p@B7t;j0tsk=Jj8?!iGcr5Bo z4UN|tBISGUMI8usiKTq+bBf)h80$si9cZbj{__|7HY+se57y9s6G+fp5&cK@3ch*% zkjBc4LCyeJgA>w{a!ywIjfQI!(jxcK7D>wYsBabQJWKf=^{s+kuNd|aSuAd;s22Ge;3h3moBSy%sk?T`H)e6lY}v3kymE`m z8l-%Wic`TZu#^vPiw^sQVl`-w5|2Kx`BBwG*8Q1($HMOzp-GRxUaT6QoeTz+KOOYs}k%Y#onvf z%ZmL~vFw)jEBtmuo|gBW`n@gBjKT$VjD}Qwu?JIO75A9{?Fs_ z|Ad5n&X>914>`d&F2xO3u7TUw8bQV32c zFQmqdnWxpRW z*2kkZnoKQLjcM%jP$xB}j1Dl3y=`VTw`B(rcdoVOnRMeHl+pMvMsddn*2K#P_r3Ac z<)ib|%0|w{Z{4x#ceuvSyk_xf&Yhaf2gyHd4^fSuAI-+jcEZLEb*1_HVEZ?<|E~>q z`WI5ZcPt7*uvwP!kpYLDq!=YziFbiw1tVKWIQKc5w7s<4Y4aTyJ_mc=H{g1{8@=9fXZNZpv!k&}a}h9VE&V zYI>2f*4r=O(}R9Y<7JicipqFZRqzKoHPs)&ou&KH;z*1ZWY+oor?MjjeW&K@O#Iv^ zPpM77d*dlJ-1pc9qxzm3c&O{-z{B!pUu0W#15dLKJfvhTUa&J!LxQceRLong*wu<% zqu7n5@%o!I&x)zQI;bY$?@Wfkhgxt)-vM>TQZkYN-Q*nKJ^VUtNW z-SH!wkT&LbLb`9X6Vj2`QxoBY^hmp>CYKY^kSr2?91eB z=;nG_6nPn&9eEl1xZ`D$R3}RcE(P$MV6=f1>|=_3O0gd*woNf=8|2yFDfWtDe^cx^ zWK81y)>6>tg6Gv(o`-`QUZelfMk8dv)93<-+z;75Qab|9M$?nYk@%)e$>Yo5r{{*a z+$6*zm!sr0okM`R{%>(Pr|Kx;)FQY78pZR{mL6frKEflXHF8YzJdyr0OnWWQOH2Q< zlRwDwvb=Uy>>H0)_TFn}aQYkc*x6kN4x9YC4xEA84s52y!5++Zny&}5{jvwYg8OID zuijJA3n!h~3m-+B0`5`6dH*%^jICphc^2%0jxLWqeyj(WJr~gbixon10|GDsS*+S2kjfiP{TwV!h zn5k`QH$Dn#rBxvgy%;T;7Y^+5&UuS+=sm7GrLDd4bLYio8X4s+GR=(_XY7ol1Hkyn zSyt#}hj3SRwztTmqIYG_>1J2R}aI+?~0G+$RCGT3ID2-}^S|R4_6~!L}>5L$T)- zdr`4}DE2SKsNj_JK5Hr8`zxs5B*>z7TPl|@S_}n2Chz?|-uT`S?+q#lo<_dpdQ0=( z!nLCP(4PWI(%$h~Q5ZyRT~CXsqA-YZ(U<1Q`4t9Fq3Yopi&f_lZYOP<1US-=o4nu&-N6#96^8&Pu!|HQuv| zQDGqQs4$RtG+PjCAH^O}>|w>mKy~n2H0YQ&&QiJfwplc8#3~l0W#h`OXDWqF+Y&G! zQh}P*Lyc!_Z}P$t^cV5|D?(hH3UDsuB@yVrO0Ksw7vIAr=x+Eq`7T#fJ#Ths(Mz^t zMmdE`^YddfR1Wk?7N4Yc9AwH_llZ|#sIP%DGSjC{hVf907 za6YGSgI!9&I~TBmayO^Pa&ZA`PnpDX_;OC+oGv?Rdci&y<^C-^iO;o2#b(0U1=De} zi|?WNeDwdoX!VxprZM3YgYvkOwb_bt?^VBfKn?{O(nu%9T#r9{DAQ0xxye8GNT zDc`Gsn&x+CqcLx&rOb!~BXUqI-peJwog)mE{N%La#NS zo<_D>9%$mE&Gq}fIpxlJ2u5fIPJhX_hczoyjPQ-!YF5~`qBJXj4ew){a|%p)l#p$( zq^yY7w6(&x8?L-C2wWp5tf{sS0OP~j`T-8sU94M?q2sDc^uDEe$J+N7T zIT%A+{zM}o-YI{L!+p6n2U5QG7sdWzDc{=m2an7kIruVj)v}-dVh2aQk z2=*UK`QAaOXTj<%;%&0Kq?AP5)|@XVVXp+-cfTD;hfzmXutYfo-OJs$sZ zdxlHTnR9rC%bpaQa}XmY#c$%uc5Vk+jf=1KK8PW<0aY0sV&6>9aNTvY42w1-}XQH%s~0eB`kGE#-T6p`S>+ot6p=-HAld4IDS$TpQ|A z!J+#+R)M*4b*b+BvB`p3cd;S_f9tv}hj1uEaFoBcbmvHOR!YdZn;W;k1&3hzYNMYv zSLN0ro94s~!O>pXvi$z_WC$)*@t>6MeII2m*pDscd(SHN8^xBP{v;lEBFM9jw^qSU z3wwCdhFG^C%I`y!U5li6QKYErX=N8f+>&;Yb_`gIG|j9xJvRUO*nCsR+6;B$r%~+j zOcVOoA&G^c+eR2DtkyFnnDtKrT+AKh#8o0r5cnFV%Y=T2uz#SLF}qoUepsKz`pU;Y zSdZ6Qx$bmrRHUFgLH!Fx_dJ5#rPxlzs!!WGVJocwYmH4{hB4pmNdLG{8{*W0*FFdb z=4(Ui7Iv;(+Od9pU}5nD3~vgtE!V z#{3>vmZxf2lJdQE_)V}bOW|BS#U4=1tY;@TuO3x*>S@i!@Vzy4aa}U?&t$5zrZx3o zEBvHydcCHztTp9N_+!f*2ajyH?6;qM^}f_2$;==aef>|8Dg3{B)Ix4SYHn*=vi*PX+&8hIG3{uy6pr&o zg$^P5Gh(4Lc#j}#hw&MEUc&fCzwx~*$%krH*uhPZIi^wV}!&nk8*CmZdV5gXQY zO&69u2u{0@NW6SNe8hnG(8l1R&(6?q!M&8<<3Qmb z7O#lMhYkxq^d#6)ykcr)sX3=;V2ocl60e2Z(o=2TxR-&ZS~xk+e9^+d7mbEi+C5U` zwY4m}P(Np(d8Elaazfydf!-8gvueq@cuh6`4#Q^>!@F?Fv!8+Y)wtJ!_--@{eo_T^ zBa342;CN|W@RP2RA7V3N+$L65$r67@4U=s~vZd8x>oC_f}L^R>sTy*s98*WrtT*l~u$>RSt}ol~yA+ zr=kfVH>a)a=F@(y4eb zWg;DKTGlc0of65!;EtD-CI%$&KxX%^XT@*4CO&##EmF^Dl1G{+*(N_`o*W1{lRm!E zEqNfa$x;fYxFDTk5dJxvp1ddsmnRe+63EuROr&<>H-p%7P#ngqHh$Zcd$_VI%gQ!> zK5u2S5NJ*y~xAY18>CGScQA51#d3*Hga722JXXf=ig*h{2Mbs z^LN7jy$ttn0p}R{ZQMC=yb;-#MFdhl4%l_rJWJth48_h;Y?Wf?D)u48KBCxX6#If= zheBGC_a1I3->S0`DAuXi2Nb(Xv5zbEX~jy)-Fqu6<$H8sB6-snLIyJ1Z8_Lf6;Cby8>J>r6f zmefuo&D}k#%1iE;W%>s039~K)vF(iQucPt9CEIlT(}_^-or!;&4TY~ZT8BTN*pCdY zoVMdPTHo;gF#3aBR*0M3vAi9FL7Pez8DgBGR?d549grEpV_64|T3dUOWWWeKMRzP@ z4@$HSe|QWNMV7RU%wmkhB{~>L@eRyyXELn;ym{Kdc;%wtHpeP3EkWNF;O!RyjSa+D z=;OGn^6`}i#VZfU9%cuUcLoRgXP8*|KJn25;+0JtJ~_xiKAE)^f|+LS0FyiCd!@vi zX8x}5f*JS(no;GzvIAm=U~I0at3-k$+!Dy8SS+I?Q-%hE#9di%eMv zL(X5*)xK&?htvlJu(zA!r=aX5c?x0f6NjcBp4qh zs=MKd9A7Rfo@QcrVqfI&#OzbY$svlhJP?7WU$AajQ9Lm0S`;&jdK#voY#(zGs=W$4 z&8ucq>->pFLvp}bXSg1kW9GrZlffu#T3=4AhQZ#H+S3^oR|%>ioDY^h=^6uVNfs}-X?x}^76#hzE}MaBN5*z1bbgYU_+2V2Vbz7DFqf!}tErF`%A z8jqY(^31}LXUi>>$;9gn6CamM#k%9+^~%G`$ij^jN>-l5!r5kpg|i}>5d!mYWMXcJ zg|{IFSvc?iNZ=oH^@)YQd0u{Vu=8T*3-Zig4Lh^mdmKAUv-VTH`Q5PgZT0AeQ^496 zWU+RG203d6YcCr|*1msFS$i2+du6=x*qp3gCcvUm?lpIAS*!mJIBN&X{#ss@U zu>=^aVDvjC@fsDIsMxy|d%t32-tz1h6}wHbI}{`HmUv}g#qy4QEEV(iQ*4T2$0)WP z)T{=w_8pe;z5i;wQgBd7ug+32??Aw2B`CAbuQg#gF5yW#O5l8pQ#bokl`@^7}t^yXS>*kwkt3i^SPj7cp|!j4ZF5wAQsTk;_qmVC-a*h#HO zK5xsGd`3i0YRe8WlF#g%lF#9$Ri!1Lh34-_$>;EZwP4dT}?A<2Fbn^KnpIPR~NvP3<rKNmtm|_Pg)~;BGVjC2@NU={S_8G;F0dM9$teDqq zDc`#gl)RUmTfXBO#jaCKyvT~aQpcJ%W~%#He85W~8-?Ih_r(P2&Rl&NQi>oUg;;*U zDH@h+Em7IdGxdz!Pe$*k-#ZyKr|kSMo{Y`_3m%L{-&+>Uwy_H#lkHASv)vU6zpKd4pHn*#qL(@7m7Wq*g;^nl3u-~d~c>= z$0>HIVy7$iImK>L>^q8mSFtA*dsZ>B?Bg29cFD3y!PXv>k z-plXlnvqPMSd%>T!Q`f2|2ywO(Qqf_(|oWjxp@}M2WQn#wAU4)8E8Ht#-9eN86hpk zABY@$GsJVxL=37IdH;O^|Cp;UJhxl((QGAP_m3E^N!!lAiUd`7ag)u3*j651or!1o z*8YF>hzsA^v!GvV39hNEfxcURI5@C8u~L4BRmSF2mX{q7I~b-6<>jzksPu!f@H^0& z<74aMmB$2SVY|L^U_cbD%Oi@)UaAuB81pq1=)a-06}4(N%BaDo^?j2N2Qy~M}EKe8bO#LQFp9k_yGW>O&Y@0s|Q zVkY~?bc=J+&%Y^FvLN_38zcW-fIG!brt8GcwQ;eJ!UE2dtR{@75iL? zi+7Wye2+X)o+VF|^!5cu5^R4<`Q9OljaO`eVkara)fst~t22@w#aJ#^#XO3!q{eZd1d@)EZEMg4{$3kJH*Q?V*@b% zuFSWnTp2n4-n*#G3h0kT<$TQUTCcBy9v76^Co>t}#EE7bL?b>Wd;(DJrQ;x@WB&*< zx)~+H=;q)~JsrA$KBgwc`my&o#J%~F_iEB1(DOG@0c=UB@3 z)+pAg*mo5({?5%io>A=A8t+xb{;t?DU}ciOW=r|rBE?Qo>;lEOx*^~38YrqYV%~o& z<$Dd_HIg2=j>Ma;Sd(JP5MfL%3=vDo1H04Z7G){`#jQSFuvCGD)w+QZbL_r-GfOSi54I6uUyP3h)@efvj<$ zrF`!&P?BeIAW1K&SgT?$;49Iy!|Sk90R1e)wqTH{*WLAw>}R%Byk$%>x%|GqE4tZ1 zz0?GxjhwXO~G|bE?LOc->s>?*7?}D?rb*dkpN?Bt_@Bk z++v?hHqP}r(C>n(3^Tbfi+w>=24@y~m-U9A5cZ^Hz1}S8T?>WLO5=wls8i{Q-KtyC zqud*@oY$z+4K}^t9!`#_;l(?2u&^RIYW;F2GP$bw<6_xl_d~x z4dz=4Yio)fpcoY?67MF(zNOfA6#KVgP+*xSe6QY8G4Ei-j#6xjVjC5^OtI?}yHT<4 zDfT19P6m&vZr~ug*iydtUQm)}axnSc8x^CPS+F;8ei1_^-V7jP(t9lt7L)kHDcmG7FX}!_tz3(aZBgMcvZ9MMFkY{PxFVE7lU$D^jIv<(qpka zI~oj3u(6i%y{U@LQ0#2QmMQiOs6h?%meN8Jb<{(zfOpnyk5;hGjW7s^3;uRYa#VM{+QM_V8PQ3aen}|mhGAZA?!csA_yIQbM zDE1kRHwhd;o}Fqb*+nE6d5t{#HI4U8#eSq1SGFYHZx!36*lxurq)EJYqCe92RLomr zDI6#SO5V%fD)DYs>{i9dF1Gy>o;U8)^Unq%;dh6+H&-Khu_8ZOZ%F)OyZ5T~UF~a@ z7RM1qV(bjF^!tN-%|!0FRh{c)TVHw>7elX~QEMZ#w%gyy-sLLGt3s&7lChli#1tT~ z%PWQetikgZG|2|^2y6`QVp)XUuuQD`(Go*iW==o(B_l?JQo=XjtgPgU)Qm&z5Ys`TbjTi(MF6Ltl;%iBgMpuCwvR(V@6 zP~Mat`dZw_C0x%X<$EiTmSFF)l=No7Qi}an<57Pj&qfsY?(jQ_|K!&znxKQBNR|YOd+d^ESR&3_`UfU5zE0bqT{uSNZ~+b z{3h5IOZnbc75j!_(`}mD zVe>_l03V{S4MyjCP_2B=Ag`*n8Bp8FYftQ0hZ?Yd&N>k~mIW|24|hP8)dMJCi2L3s z1YTPqsqp@D+*yWC;Lc$t0oE!K3n`qnqS*H>g}uC}4~aM1QoaYzX{^X(_1IEVi{*&@ z3c^Ih_++T=+~;!_@2UM-cWrGLo+eGqS-q|nyC&wS#hQp(jP<-0KNqS+zNcrk7_LK> zSyUaePJfEJV_CX79HDhc3a1X>H^F{lDTn~57r|OB1?-M*U-#(fU9rPzlm8eCZh3%m z%Lh=m$<4JY*p0(8*M(};Rb)NhQRe=zJTu(w^7Y8*I%7|a{>AmxM(vY1Yctc!;fbi6 zc-h-}UYmS?HR}3gs5aS+0)5i_Y5QcjHd#DTwF%gJ2(`&FbhX*0wMokNzKh=k`=Oy-wdT&s)ei?}^uy1Z znj6sbnmY*(@F7=od{3Ys_M+xkR=H}9yp(0=YVJo`bEKr^1Y^w!MqVlyYfiB2^E-~h zZ=VYFH%<|~3JdkXU}&nZ5`$Gw2SYy4w~mLh3HLpgTdo=; zCuMoM8eF6`ND8*1_)RcQummIj6pYKdf}!s<&8+r9eeZDmenY4hgMIJZkkDT^*GyMY zzFO4o_u*W^Oo82x^>-dV&UHV&r)S+StM+=+|4ur{$ugvT?+2(e!M0k;_t@(MA7OJ`l`0*2=s-vLFiw)}JH?ae1^^MELJ!9G3udKXx-LE8(u0Fn}kJZOA%hmbF zK3SHo^VMtTBjtNr@ta_GSxUqh!PpHY9(RBzPJz?elbcUzKGnFMZE8uq+?x7BE2WrL zY}-z)ffv|ETT{#HS~mULID;LQ{IPRDJK>(><$vrts3q-y_V)7HTV)wjHsd>xKw zf7bcOWNJst$fm|*+18d+5_X7ZZmVk9vJe|bP9BwLO-*f?_H5T;c%I!>J)#LV9O82} zx#{9M=Xmz#?!AMP({|DE>`#oj2OQ7F=y-OhIG%0Ue3sXI_na#4g@^HVt*L({Q%FB~ z$A?F?@c(jpplwV}nNzc2aB>Sr9?xz?H~C2Jm_2F?!SB*a-=yD~dO5inC_X;9C0S#z zYm%w?iI&atQ7WgvKknQTit?A=bK!u$K$ze5;=UC99^AF*S0%~VHbPtfQoR_m{=CW6 zr=g&1ynC|a?L@qL{!+bUTlL{{yy_daUbeORvOAEGWa?+;y(q%u$T=)RyqHCJXBASd zN>2Obh5_a%#TVDLrl#N7l3J6Pms&n%`SR)!m+@;N%Clw5{2EiB-e<EG@)1KFil(s!6ZmrP3!r`qPFL;?MC?pw#7BT}UK?^oyaTa@A`RYGHh?gf$bEaA z5l@|(cGkCaWqT)PAQ(iA(&vAjGvW@M)Yk6w?nU#flG{kxo+cwIltnW+`L>>qXVx~N z6-r~gsWfv@?jWqfH`mTbEB~`;sXr|F4OR)8OMIhxq4b5uk4ro#&&Sp)u2Xn$#LDNw z{)MOFDJ~ASnb%LJU*h#`_KX@1Cj0SG@0%tMOk1w~;Iv>y?RVzWeQDdt?VT$+=n`*M zEmwkhJ!$@}z#EAP_?*F>F8Py3ugo)R6Zm_+$=O91m}k^Jjin=`HoxP7HEWmAbMLI$ zQ}JXKqP@+eP=Qa7$EZ4kO0r}tq~`-m;@rBkSD8itx;f3ImgN?6YX$R>f7uY0&uQASs@tPo3o{(1uF?!1FUpK@2inN>I4`2`D z0r2WI7%gjnnNST26b^m-mTkO|-l_*=`x?$y9+VBELeRj`_zXX|A->PyLDYB)H)wEQ zsQ3w=L_gvCR0sVmi=XhBvBP6;udIkyl{=^3P?9@8;q<7|Wa@B=>5KEUU)Pz2$w^bd zM>tpa7MbYvrY8+CG}PDTUTr$&5bzsbF5X~R^t#UtevI)2UNbsgdO+BVGkimjwvINl zOV%lZ4>2z}F+=#KpfJZHeefbX?#HCFl0b{ShraR>g}DK?H8H1l4WfuWiF1kf4lLh42@77 zueYpO-_Z$o!OL-=s^j2+9bZhaz`h*gh%hR4 zaBKx!)K-<34Z)~zgmoWZTULspqGD*yVc~nG>^^03L-+A{h6NTq4G=hl)5?ad>N)fG zyYbPpb95ze33=LxS9q3>=*1 zl2=W8FVAu00L%RE=5zK#8HdY!xcL;O9_)K&Xt-n-8gag%A*xVZKErp%5q^x0!zHdJ z)}6g3JHl&(Tl%pjD{EVT(2R%2*KiCFzLNFIAe52n`4$5#}SXiy0rX_0Uov#1L51Y>4Ez%?R@m*o3wrxII;k4W9Q-gf0Z~d$J;O z_lpq7(cg_wli}a^$fJ)oI<$=*zH%m&Fh*+T?v-l*QIh4+yiSs(Q-0*lqqGWrjg?mE zvyUjHPM}Weqz%-+0rUDUN-YJsA$!N=sJ!s40(7t1;peN;fw}Vd$#w|I5-K`j8d5b-& z*b|EVNwHTI`>$ej`6uZOwp7d;qS#c$W+*mSvH6OvQ>;s|%M`m(F>VTy@8G5&dGC)E zqpM`W?pN#~#m2+%MV>vvQocuLf`T}=cB^7PP;9GW&nWh5#p=JrGXR{=M-yIY!|3Q z&9g6A%J*)AWcT|7)4Rh`cy`NGK)e?aGH5DAZ#QckmBd1g&=$4u*}xf$y=Ni17O1!ImT-T1?R-os2RqN$18&H#ekuAI1mYN?iftue9SlE6@!A% zGucoD=5>e_o_M;y-30Ve1u3fu&glTRK|%ZziP$(%loz(Z$#k5GlY zaI(p4y2<9Ppqa;K5ty-|2>T*%^2y@*FnYj85Vj*XETbK`eZ;Hv!?vw|u87N?#tG)pgzWwLvH(@~07A zc>5X+9cR?ukG5Ij8GQg3w)j|jZ_5O4IFMimeG27Wwhw!F-1Q}=NOphUZTnWjyjlKX zYnF@tu7i8DsN7+qt}on)r`aEVf^btp`ULv}+i9RbP(eYB5wmaA8O*-vCa(fth~O@^ z7j_cJ1>S56vXih4v6IlUkDcW0xU-Xt$DN&o?Tdf&J+9MSnsA+l6wVMtw-Ag9R>96v ztX;8r4;KZSzD0Hk9hgflcMfe*6hkyqVCL;H& zHCEFT2u~t#C}{Gq@f$7BYPLBP;IHsdK$xQdTa+6i(4qo@RB(*wLd>W!g3Xv?1WS!$ z#AOlZTMV*+^~|6XhVreM{AJd0pO%J+@{cNgp^OZi^2VsjK*sn}}8KBU-36#If= zUsh}v__Vy^B}-v?1pBp`B+j?5OAjg7ynhjfl#6P*j!tfV53L;U--RrD*YNNgSp3;P zjLeq2Fu55=sHV;wH92XHw&x(CL&#&HAIwlP21$u1cNC~+F|w3oct;98W(6X@q%tmE;8flBZ7sPlp~xc{;Q7 z4}{$aWQ)n(tnmd^Fnf3>+{-vRr#lPU(c}7sab&Dt9GOS| z<6R|daU9HNqJhd_PRjR|pbZLkj-`CBQ?c_EyI!%6DfR=!wkr03Vh=0!62?b)$IF)T zy=55ImxCq5yp@*10H3<55m_`NFIm9($YHrxL|x1WGlp$SFJtrQVxHTpi=q9uTlzKQ z6jc`1ZrP1f-DzYV0&DDrM&?)DYh-?kYRo-kL}_H0sME+$8*?wheF)T0ehtA56%iU4 zX5WnoP9q~5?1J+4F=(z)!$MzlGVeu(q>GaB@pjJ>>?BM1-crR@DE0xxu2QTOZCsv( z0g9oDAV)(5Q;-}j5;f)MD-H}QXKn*`*guaPeL_7RF;{=e(M3^D{NGm2Se8*76-@^J z3215@|LIOn&dYz&a&jEzjlIPinl+Dt4=4w<)$0 zW1BqtQ%k{v1ti}U=!`LMwxx2(z*yvHP2Hml{!`Km{+nmkHCNYo)wQL#C9!NWx29!t zQ%%c`CbMkPd?lo6XA96`Z2{(@cV7vnkX{zK0C^f25{2iRkrrw=-2c2+6s9PgwJMpZ zmk~|Mq7qro#oXQ~V1i2kcB@@_MKWxIa6*Rq|7FU;HBkSL%ToV8i293tE$6ODIL<~2+yre=Fs?cYwpg(<6??a0?^i6P z*oPFm8hk?1yT(#@$Cl=O)k)H|$js3pqauC?FYq|;Ad%KUi3s1ZW|>iwj5`vt1UKVM z#_A0=!ZqubqPcjvT-_aR;XG3^2^jfH5`p!RMwbxo%+rlX8DHUzviS7_yp1G3iaYaq z1MXCrdU#cozCnHrKzVe5R_h17+3<4;1R<0C$=f&8bQ|M0S< zb0JhnYgSm_plz*i723w_vVn8viXxbZh@EYsJMR3otCqp1Xkx64+G{qfUcIiXv#m=Q z;c4?sUAaw*>6)VJn;Eq)OI2dCMceu9vcoCJ_!#BXnf%zc1*?~76gF8lb+(t>{D5xb zTt8zrP~Xf3g;e$rzFPKqm~`0)*v*11faU&Ns0A!XcLMCK!kzW;F5KAyXgMV}QJ37KGCGE7d zI3n1LZd%993kq!=r_JFP7T7wNjs9&NSE)Ej%7;;<=Lz;}OZgsl_F1gLQa@~$s zMqSFY6cHu8>>57+zpcnq<1~_&E2_r3HmqCSG2Mt2W7^u5F6&sjdh8)%`1c{Xq>L+0 zEVMf3FJguY97mXqo>XTcwYgdQFDc)<8rc@?8cRtH3&t9jc&uT;Si^!*_7IG+hhW*Y zNpJP1=BdpSVb3I2RBg5$2M0P`Ft%UckwZlM^VmWw?+=i;3a&h6qbHSDP+uIZQX(lI zrvPAYx53_TDc}3FVxL!Rn_@pvEP;BFXDKB}ddW>MRkfym0o~7`4^kVn>COSkZGR|h znRaio`uGQum;a*cSR9pI+Bu~q1;<+3b|<&QADlOB=LHol({`>OmE1giRC3d=|JwpH z+$}>N!JD8Nx;MG)g|fdSzusDQZ!$G~)Vyi;cGaoRF(lKnxuj*&wkqHoUV({imCo~S zDTO^;NCLSGNpjxAubmBjvs}_{makg9T4pUWi`lSd>B^3!@9J3AwhBHV+Pl_v27kqL zA^7L|RdChR(bjd*x{md4)YOOC9{guVn73A@WhPA@9Xb52H(GYOczMMXIg0_qnGRuB;znC_-#bGg56~) z-+Mr@hZUo2CGq~M7;HK%hD}3;^1Ts?jZ};_m+~xaF6F&o)6OABG> zX-{=6NT$Z^tRAruMF(E>?lEw}C=Me#%gi8kzvLsCs!mROnZ6?L-o>c&6`7p&bXSe| zicDVqWLHJY=C{3AHgEH2dNYL2%e!gEnWTZ|!X#W6F6Pbv<6`j4?K_Y{riZ{S|DU}p z0j#3B+7t2!VO}H&f`S__7!d^(#08LQ!lEw{1O;3w8Uh4}0>Kd6s`Xj48Y5P#R%_k0 zEwNt^D72&z&>(P2PJ1UQo1Nn9P~)-MMq;+;h)8 zcRPc!-#Iel%qFofV*VA!zbOkQh#LFS$-@7VlZDxh7@eeTD#Km$KB7MR++6~@8}-O8 z7R(HUlg+My@#ynkZ>}5BDL=sIM44o+8{cqRFd{YqckOCoJ#SJ8wdk&Ci}&f2rKB+R z$CARd4TkjZV&Pz5J>jh0d?bONd$yGH*tW1Y2Ijkt#Gfw3?VRVe7+*Wxy2VGq$CL4( zcVe0cy{ul6E;c!zmEFbBVR*gonn>f#>(N2sYv#H*i;E+UBA#ku^hjes-wM1+*VOeT z1G;nMFpZOYYXRJ1?(D9P@2)r3EP(FT@tvQRs&R27sk&1s#>G*4IF`^nw0CiodeFsQ zK^L;5IJF`u6?eA8x;RSRDc;m_xH!7oWPclVaTL6cc);_~QXE$9PUM#vxwmh>~8rx_5{- zyfH;x3OPsBJ)XfE9_@xPh7-pbP8{yktU)k2N20+EZgafiu_{eBw^f?*Whp z-bTNZa}ke$?K~^vP6iWjy1{P2{;(2nHtsnc_XPZL-_3ZVRqle}3I$^IX?KO2Ve}4<-YjCEScC4Cdq%d~{ zBS|o>GZE})#il7XSFw4DU8LBz6@yDXo8FCz@tgJb8J6{7+9Q0ykfeyG^Z5C%zanWeaL;vwyxUWc--i41Gtg-rm1 zyay6O2Lt4@o0?ClZ>kBj9(@bwh#Wk+ zCV>bh*e<-~5$BQY*!r8OgJ!aJQ+dJ!I*TVKDo;qsG_7DW@D_sIY^k`JuocYZ$+z+Q zs2n_*7#R)=9S&Gr$5Vi>!3*NRQ0CUUOUOGwYUAS{l=6@FD(;NzV{M%C)g{N zlIcOgI6Wxw+%kcU;Qcs9nH<;O6bSxgDwEH4Hg40)!A_cWQaNmcVRjj|A%!6ta7(af zEaiKBz-PgBuvB_m!zq_za+JfuT;-5^J|vJ{I|Z`oT(grG$~6v!ZED-oRe44V-lmY2 zVBfHm@2ym9jbg6sUJEptgJ)-E(X*mY+*yZ!MRuZL(^+Jv2$V&6>D*(LN2Fly;e7== z$x`qDr5M|1iRbcY2&C=B96TD4ORl!?-GM==t**|qrDOt5OPP;c57#my<$LQLdC6}UW1;;|{6Pyj13|DfW0VK+;V4ekC zCGTem{4pUXxAp_KHoW?d>Fkouj;OTo*|~Z(%u~>-Ia;|v%J(kDZ-QNBDXumR-~617 zdh@#yNW_GkZ@zzr-+Z^ud-J38%}L3d3&uAW%&imO0UG^sIqgpd$^^Z#Nyz%HR$J`X zE6?h{1l;P7SAC$T4AB>)e2+a8!5S^)d+ebI#+o7VT;5y`^q?I2VpnK)3F*8E*GF2` z9E6DZb>omg8f)_6&HjmiH>9wG8ZRN(TuTXW1S4-Gp358R-(2G&XYY&%CZzKw(-+t+ zmp(i)PcAV5mrGF%vN8Rt9l&vsA5t7i z=CdC&Nh_AqCgoWyOu#9Yykzzwm0420_kZA@V1Ka`JpY34f(^D*dVihXK<~&=E_dZD zmrr}#B&{rNo0w-=FoDi0iyO5pNcrA#C;`Dd3r?MTst*9Gfk zsdWCcZH+EVc4hv)3gLdnvF(M84Ko`~XT>SccEpAO~5bYAwO&|5OYea)l-+apP zJ6evU#MiiB^ffLRH&zJ7y|;q7<+!1~$Jesh)5c~DJpt3ajh_qY~^J-f)zIV52ORZY%ge@5)h5?Y7oP5iJ33OU{ zY_Ii(l<&O&z6tgROZgsqa)MP_D!n{t?=|Nrj|UToV8VvW!#X^Lj+UNFSgnlO<_?`S zdtlPRc`6|$;BYe^9h6jFlJe1q!%T?5IHM)lONzasn5%=>r%vVIC0%<-$iT~d=M&R7 zYu8(Ex}{~;dIpwOe)hw~Iin+Y|7SLR42R}$4f(hxon?0|o z-Z~F?qB75_$^<%#Cw;Z9l9IK9g3Z8N2zIljWbL3}E>GgnhIi+Xrw1#9BN_XwpXD04 zG-ocGUcsX)QZcv8XthkvQD$osh+sknT~+thhUTWa zmbncJ;Owfov3^$L%)0vKIg0`}T`7!J<~8)g1RMcJKJw8+!&MKF^37&H!OlR+f-Sd{ zjCTs=@{6s&`8oK-PeMpY=htQtO0zv=_v$>E%mmVyoDYxphgB?N@T7e2HZVi5J1pgU zA1L;rVlIz|K~n#agU6@k(j#KeY}vjYMEw`m> zZN+LsY$NtQ@e@@N((6WKtWU;}g-6(wn4bn=0-eR9QK~;k$r>NQn(r5!8QDvi@AKlki%Ckw=1&M}oOL zdIf0IwO0%n1J@X?N|0j6$)ip&rvul!bE@*>G81sPoKIb?QaL0gj+q4e8F(TXb*y02 zv4XigehTPmIdtsP(B2X<@HpQ-iq!4SUM`-O++LvV7AbL;B-o8$gJA5V2*y5&U@lKN z&Q_g+rw>#hf(aRTD*JH)aXX@Cp5n#?9C6EwH&^Wt)M-*awxfHVU?*5g)_)3iyJ9YH z{seSs4&L0qVcv8~eGW#)tUdpJz7{GI=qx^ePx(v=d!fNI!G3Nj-(zhS>|@1TK3@j( zz#M$OBY_Aeq|0E#g2nR_Gny7OERxFkHk?7{Wx6u~hcWr+yRWLgBZW`UApe5Rv6Sp1 z6^tu5B%aHci+~Q#!I#BZ^xcf6rg_4V*DCYm2orEPl3!ouX4O}ueD65CpJ4Tt^1YiC zTc()H6UO{X4xYS|Km-%gWTmbi9X#VraYH*b9KQ-ff~0Vc;rOs1eZToP3%wMhoQE^p z`15fdjB`INds5P86YLE8E9}zNa`&~kLB2KeTHNfxP=w>{1Sy6ruhprF297=gpE0Aj zvuP2(uFdUHp-1X&a40>YT(Sh`%N6jX!cYB%&>raUM4&o>q7FEMMAFanS-l+`aC8Oy zD8z-2V48>FU_#qi=hZS(5@u7%FIsiU%Us1r9tXvj(BdQIdo)l4<0Ob+(@|c6&9YSb zv>qFjLn7r#5n`aI?1DFtAmuryp=Hz%aS)`#D$O&kTkYg4V~wT0$$=r1PQjMJCewtv+8>Y_gl=l{amrMr-e zt4y$CgirMZ1(Cy z`tWw#Sz3nYlpm|vT?zphUON>aVEO0!P3%BQL@1#JSIKpDQx;U zQ?Wz8kD-p8q@K|xp*%cqHAboKN9EU>i~~o0*^6Tv15KQNV3q$?MnQzW(FWS<0&g3{ zTMFdQ|(+-T-YtXM^U1rVr z=$)YzU!9n1ag%H7jdC@zbs_L^<@+rzFx&ElIZt@!dfOs9W6P^>x9ePNBpwGhU#naX zRL=sVi?`G&x<||4vz(shu4O*(4SPD7ng9n9!GjJ1whCMf8Zy_1-0euXFm)cjLbC(d z(A&6*D~bi5ZQB$5Dsl7989xzyf^+2PK9DL8g-pgV2Hx#&H0SgK->+<5(QiaFlsn%kdfrWtFvu z4c&Kd6ll3Yno#i8trwf+Wr)Ihh-NwT(0Y3anhNe%q(?JN8;pJiU5umFVjsbC7s*d> z-UVk~vqt|HXG-sSoZqs)bJae)S*5t%mN?skTS1>+aInoh0E7}b8INL?#3?o1D8nxs zgpqlF>Md*#Hv0Q)UzQntVcWrXx}g5_8}YO<8=AunfcstPgS011%J;5Ey%X$aOZndI ziruByGm5QMY@K3nDaNjjr1!C6+jR-Boh*fK>M1r>v1=5&L9x3PyH~L%6#I>01JJjT z=k9JP-`h{Ik&1msv8xoD*%cN}e~#MCu@qKngOc=?TgvxFp|3W#g7K;><$Hfe|8B6s zKCl$JV@oecKvBI;o#oQhm(Lo@7%hkQoT1PSX&DoGem)A$<6)S?$uoK#@0RxSYL||I z6Xhpq)hE`O1lzVx9`MJ-e|6j^FIhRHZUqhfxJfcFv9AR2PQ+<4=D<8Yoack^$`Yg} z_@&e2|0So%Zf_&Hv&anlZpj}1rF&LaW4}pYzHGrxlriqJ`hVWh^hRo-mtdJ83^3P+ z!oE(L>jKj)dIJ}*kTZ3Q651_Fm>YJ3iLwI{Ik4Q`q(1p+#BXcj47FV#bAdnG+UxM4 zG|PE^*d^kCR}E5tcUOc;)Y#DU9-V+;REYok(6V*My~dhfhDPCWgkuT9fn7WoHJ|n{ zE#4p$2ZTq*{yV`Q=E&4n66iGHVA@Qm3U|)Ik-=FktxCQHUnR||r1@t-wJP5OW?mU* z2I?a^kL5E*5kP<|)fCS^#F;va*9n}L;XKshBXIr^t_S11H?*HDrXYolT~P3XZEGpt z+gY()6~jo9jkmvIQxrQ|u~~}ERSY9{_TCE>yHc^M6+@nFyjvA}RIw)&qYGHc^X-=6 zfbFzkY>KVJ1p5D9TiaG!IlZQBZE{fGWZQca+8(ZH`(3i_qjlf|9QFU{l_bWZ3i~Bn zcVasM5Bn{~!@g}Nra}J0p_txy`tgyW7)(c)Pe2@q^Y36NNRW2IuBq;fA&HE`EP2nD zMh8>sj%=6-Yb~nKEE;~qWOBRjmvll_jAdx_62CK=(J%dAqY|hxD8~G{B!_4A8g2B@ zQF9xbW!yC!R_SeSn2a0H9h zejg||;BSE$(wGj4WAa}q;}3NvH%+r=oAjunM3WY#si?cr*)53;Eh*~es;3!s(U(N7Z_(nbBDi=Y~evujS8GNET6lmEfNNBsmT1p3JNmMirURS)?HeI$G&$gV73 zJxxhX4?$H@fT*W14yu9mf**ZF<+O!`4^yBE%W~KYXX>RPIJ4di#hC?q9`Y%AiIndx z0ow#S&r-g3sbW_sM&n!J-J{q_#nveHXT@Gu>>rAKq!|2=+w^v{l<)D2B=U?J#Rfwk z2!=6tLqP|vuiz`Q*Y^_~(KR`Ur(xIr0V(RDaly$=CuaMWn5h_jCmTthIO7B(R-BQN zP?)1r!&Zu=UW}+r0HrAjj3^Iop9?CSlnEtUCPL`#4DXCbNElM&rAQ6MnZ;JC%?T-4 zn#F9J`_vF)qas^Dx%sbwxph zihVI&@72gu&{q+QjqDU0t09gOq@?E8pV&~h2z!znX2~e@=RniL<|~1Ex{nppt2^RU zNYH3Al85m`gwbiknYSdUm<}x}EGg_pJv6|vtA2>z3i}k5m2~M=RF2PMmlYP_90L&V z;eK-BUKnMCdt#iin@Peo%`UG%@?H9s#CPNvb7@sOsooPgqTXarE$xFYkf0_^sx9Q3}qOVbZ|zhjMo`Ygxq_fVizkG z)>5kcbvV*$De5RHYL;4BT3%3EUR{P-n%H119h+85n~~3`k3hGU{uS>kp?xh~IH|d5 zCfw^tCHOCyx4}wqZvsM;r4sytzjZ?`DD)xxT{fi>TwOsK?Ozh#j+LMo3x3dbTT>MwrZF5vIGFo;aPSS8jUD>KKEdIN=*KFe(Jn}5NNAHv zC@Jy%C)ix%Td)r;756??Yyo6I;!zqT-ua4MsF)cjGGj!r^^>i&m5F|mqRZjboD0SrHyi>;8qc{fn`V4ig8MBAB!Ee zm6w82_m0LH>3hfEysN$DNFlGOQtv>u5tT~H_r9mtb(ZqsygrEcQ^o$E*sF^D0>vQd zQNkp>rxoJ>vS9A&qib+?uGK07n0XVdEH<4SH6;TXlfj=ICmYe&^zD&M0JbC(aGEl= zm|2gau5y2h=`3dRcARMp-+?pvJ3;wN%J=3ew$M`IU|izeqnOJhADqkOIAKC29?2Y8 zZR4Vr==bG2qu(AZOHfB6b#+**u-`t;x8?)a;hq0Q2g?7Zmd7qy9;C!^f?$+r!4lxN zV3n3iUt#qXpnr|%Ps#)X%f5C42v*BoN@q*wx*nxEKm@ki*Kxgr&Qh7v5Rx=9L zjCT_3E=!4HWWik7z7)UbTBy7(fe0ozvK{m!!mlIs&6h7sptJb0i}Hn(Z@z~t*lfIs zV9P8OH?GG8bNR9pBx+3#y}i0ZxYEAPZ*e=~2Z*uL*<0c}w#Yu4t#hgBWm3NPHrOfH zyOxqo@q!IUX-GV`jP?Nfe2y~u^`}rqn`QHHplv#ROMHH1c8Qi5Dc^KS1w#kR6Kt%d zD^d*uC3ydxHtMnkPRVjnz&)DY4-N zqYW<@b+TZz;RSPf)E7KlkwdPlv)YUyk3MUY{=h(ne?L0U@?ip0sjTt$5QDwJ*|y@<|v=h8&^J`7ZYELw7fRYB4q+jk>+D3?xp2P%J;TM*$CFp zQoc7`u~~|__3dSpd@jcmAEPEq$gYz*rK7AIo>P@4hnaxG;rw*kF{;x@iQ@^u?f_c^ z`@m9hvyD){s?xxrQ{=8f^ooB z;<-E>18IIc2T$!dC+>~Pt<2liEo^E29L?PYElR99&&t6B+{%%U{+X)fNDAK`N0|u5 zO)P?OR6($5in--@BTA??M>&3olqKXS$DmK9I;88^JlVtqTsC!RqkA@c|2X9nDIaqR zo+sF1OW{M-ians1%coa?w&mc{qO9$%OhR;uj@Di7R1|G6rc zq7%1^+ax}JHmhY6&yColcDr}BrC zk3EIh4`wjV0tv>tEEwyuV96y9W2w+XSogDnRg{A#DKPZs5jMqvGjQ7WsYr9Opy5=z zk@PcO`-tT^T+3)z8iq>~!%5zF+LZ0B2`)}ZgO0<1Uj+KQK<>P3u8&}HPvhKj@{(!s z<~_hKK8ni$%YdgX2jr?UVEEBU!$hoh9lCNq#M zD8rKA^~U;6wyjAnHI%&$eqWpA_qK_}wM&s$^}Wo066q#Px^2&`|6LnbtYO{p@Z_*y zd-=4=>0Dbp7i$fw>Q2@Z57P<$ISXcDZ6VDE58D?ojM* z#U4_O(l77vl47qY_NBT&5u~e&C&8TP7cgCQ@orXiq1Fby2!1+xV==Oib?%>Qy}@_b z%zA?@^5#|>b5w1Rk}r%3b|RiG*eRBZdtXzGhONZAMzLEIyG^lmioK=S1&~#__aaOA z-c^cStJsee`-x)rDfXaZk1EDmAbEaGv2}`lsWwmq>1yLCFelnSan;5&Hku|xtqfHg z^O_dS`IPjAbe29{y>Uz@+Z%j`&8s&)4YhHKstr=o_Y-U$-cPVoEfx39Q0ywju2t+u ziv2{f*A;tPu{Ox6JmXuI!g@}{u2byCiv3iv`xX0@Vvi}tS|E9*+K^{ZZ3wnOwSk56 zcB9Mt^n-;y#OCOoyl>oKb+CW3E4U{8j{QJMzoQD2^iK{3bv%xkHvxYo9_&mTZ#pRH zpK$Go#QP4Ybj`6E{5c@fWoJo39N^j$BZ4GMh-wb!<14h%JJdrte}g@geYA(Nk9q1s z(?h8;^hRlnDdv{(8G0y{g=L>b4~6fLrZMCN!yd|5lVeQ4gPZKJ$Qy*e&x-thuD#YC z3N;2hO+jEevVYPIN02!CA(gmhKV%Tj?58jzygmVE_Djygnf(%$f6y0WI<8lw8% zGNeLhd}*T>+!-;q2I!KNL#mIjJATD>h$VHKTT(;^3Hx-(crj2Mtm6Pqw5xFuaK7Z3INsk0e@uwh{4sS?r_|ORId069iAQX}WGFM$nL`wO zSr1JJ#}#Oeqz_SWNP^vE&zoiL2saV$wt3Hv#p`LGB*gLJB4>9S>pFT=+qgiw$ zBFpH*blk+OhocXyrtGyd1Oo}96l^x}3PDp7F#n7<183HLmVHp`8*qcvdQ#G@5RBal z!Pu=3jBg?syA^`5TOk;`6@uNS*i(xAPBG?J;&FAf+&f({uA>lap<*qHr4&0yv5OU> z#LKxHGIzQ~~pt`s2-g-iDzLkCK(g`K3>hOb!L30dJIyL;bV^?gAx0kxR z3n;1Mdx4TV&auhkam37)M2W|-Nr^WRl(h34o0ND#9ls547hPj}24ZngnDd~2MyX1O z)^YJVFl++89CU?LvWS1T# zMcsoTNVnpnme|0G-xEWStOvmmB=2SApAL*hjWhJP5K#NdPlO?;{2bzA2r9Q^Km2{N z{H(vvv)4i8$0h6kbPMyu@?yR2jw3J$SpUg!w%)A!tiP=9yxtLK{?4osKL%&k>jgNo zRcEeSuom+f;DTrlNGy6u`3n3S+Qk`J*wD~iZwzetZwD0Yitly=GUO2yVFW?FSraW?8S_1iuwE$?D0IjVPQ`RKA_+Z#Ax zXYA-9S>_!&FfUPkZx!CPw(XG&?RpX@+V#5Qk6Y0Pk)$e9Jf$j+1SM6z3Y1jkLqJKq zNuVSiiqls4>7XQDP~|yX8yyPx7Gjm)I19($P|y;hRsQ70hEp(m-qPH7YVfV6tcJaK z>X?9M^)!i{o}=RTGcguKDt^BWRQ$utU76bT-i3X&;z!*Bk*g9Clk#lW_p}KGRr^4D z9aL?}U|6+T3=F~VY)2U)RU1`O1IvX~yBJ5UMOk&pQPI3s=vTFF#ta*{Z+Mtl~| zkcAY>HK@{!C|{}4q@+tP7z7^nzWb*tHsu9SFJiCyG6-*fWaJgNwwQYAN5V zSFAy?lN4L57$+a(UQRwpUO4$67^PV-Hq?UMuGj{<^sIucUTVANW3bx^M;2DJYMar5 z4$V03fxD$T?*~e%a}_A5_8Z@$za01e6h}DY_*<~&;7E_2wil!Ueu441a!Qp6Q3ar5 zfx$M(jhjX|FN+Qsj|@qOcJ7-@=U&>-P3YVon!zgA{j-^V^>?1Kkin4=#qoW_0tc~39V=2um=IMQ;rCRs8Vu333QIPqEQT0^fdd0ZgL|SZgx)A+ zG0EgPld>4_*(eLXLz=RXmkLdZDwE^Tl#n+Ff1e)t{cL+3ni}r`ag_zjF_*F!An{Xd zo~SICBPtJe1889^!I_;0%0Zwk=0YCC(jet~b@)xNnU?ZVXaTlJF-o4qW8)?F-k=zB zD%dNEy{6bVAP#cxH!bCRR2zbQM=`1m!G53^)rMd{SBz>yFiJlu-{X*=V6P}fWnsR) z0oOS#m3`QWm{hu3OJ!t@6Gsb!oAT5){in8Vd9v|g@6oFcNb<6#ajl^X*CyM# zC6|0ya7JaaagBlQ!>2D8&PujDoE-E}@_@Bxc1;$(@Ma;Lr{EhM`+^f*@3Jb3DdmcV1yb5&LN)b+{6kL0Nz!ZUBnoHH71)DzdtGX0?y$w8~% zOP21we0J$xt4{6?*NnAGV?*DJ;cr2*a1Hw||9U;S6y98t5B+;P=I^0(2PF%iwvT9q z>))}1mXGBpK_unZ=io&+(=jBn5^Ek-VqrPf!qS1{;F6V->Q?N4_mVYP6v6*sz%}O4 zLV6uX4Bt9{cc<-1-K4+Xs=q!D>Qx*uZzu{Zfg|Q|heEn~TUkUAKBOEGHPA>Mh^vt} zzmCF}AZv@c;0m9?3{Gzw6fR} zctitM^fu0qeu!p}QEBWoap;}>u|dxIsrwUf%#gYPUq#rX$S?7`#kT^vYkXh)tw4vT zYY~0QG#$hn>!!?UF)Ouj3)WMI-e;cM&ZH6F&GQc}1*Jt%HnW^OvTx#1+u0d0FO z9CLo3RNvf!x2P^pB8Mx@@7KT)Y@IO!Z5m@7XEwK+C|!&ZXMa9wZj=4|4&U-I6QL06 zrw%K3zmo7aSY6UB^`wivWwBtj9zF*4xht zm)sSah;i^I-Zgk~G_^wJtozwsNsk`U z4D^>wf7~v)Sn6XpIrsN#O)gUZ=VG48aO(fudnz2pzX4$>9E5L(>=CblQ0x%j88T4V zWqT)zsR@HNP!Vbh0$)V!D*~N9QG%qOzg4zMFcRX!6@pwp+^!NZ{i!B`R07wLQytmd z9UhU=-6Na2(e+d}rl}fTPYsyi{&ZggiELZ%Lf2HZgG~9S$1-J~4w-T!NJFsgE#-UrD|UclUsddQ#lEK4S&Dt4 zSeGurGoVcDGq?*#p34t0$aDKEc8Fr*6-&f|c$JpIryCR-t5}_4GZjlIc8+2TVJpaU zTPy|Nj*6Y5*u{!nrr7n0-K^N{iruBya>Zzw$osBU>?Oq_rf0JCjLL+Wn$Bo|s*Tw8 zZt|CbnOO5+U?$>I4S}WT+NX}CXpKagsmZpTl7+@toOQ+wd)uHt(pH4YNK0`=U@86q zHsWr^Qj8}HALHCsCtHfiwlgYERdccW_!a#jn_@5S4N7doBS4Aecr2*Ua(oq6G4B=p zO+fBqW+WxuHtd1=b7jOf+y-$u(8_eEKO|(e4dJn;ah~kqnmM<*X+aZ=#unI)r`64z z*EI7)u@{41W-T_BWHm4 zi7jNw_C;(zcXDh&wH4WfaSDmb#rZwWRy^JOel@nDOv~0x)|n_-nn~J4r8Uw7jgfm||?VCGrw%oK6o~qIO1PQR=*SNxX6+j7Yve`=k^cnglc= zZ!y=Q5lLa{kP&&OiI~xdyuy7wwm&c;(=cm9UJ<+-&+a|eh`iLrtPy!>aF6?&H6qW8 zrelrB8;QHtq8O2>$1)m`26j^yBQo_|@Z@M}g?z*Ash?&yB7fX2xmfDQZgTGLY}88% zQ%hY;WFfUQxF?56g4LnlhDowBiiajiCR1cXW=LRy@Tmnj0`r4r2Xoh1CI=M(H~$5S zfYa4@oX5%zoE<}29f9o?SQ%17Ah10>#=CgnDis^3ShB54ZCgRI zwV<}O%L?3W7JJRdD@C1iZiU|%N^to74T(R}z%4o@*hMWL-C58y%X-z_{9B2|H}CET zCU&PkUbZ>bIcIIdYzlXE`Js3l30s+dm;L>S#yN8(0!uoGz=44yNAs#~%KU|@!(m?` zbi?RL&oV={`@;_`WB#<9Y0-IUPt>$x(0m$dn#oPDGt**{182L~a3@vr`xPX{GNF(& z%mKrBZp67e&X}A@u{=)1nQ^9}qay}8Dc^fhF;*YJ{-fA>#kRw9zxU)FPIR{65OXP2*c@|7<-V-4iXx*<)IFN=lp^&W~k zU*S4Vg^QH$ZH00dj506So{H_Q7|k__cerAADRz%y8HI~u^ih|lu5dNb;$D$8P_NJ*2QuTb^Iz=CKjQohG=Q^C4f z%J(W28>kou>?Ix>Y`OPV#kl4}u#7_01wYqB`fsjK&B!WL?fk6<1!(=PW-UPbd-ei+ z7M4q11^BvCfYy0ynoh7-XBS`}EkIH-g(n!N@C3WqQgQDx#n=gwct2CD56VTb9V|t^ z8ZcEbiPeVh#lTGI&5IQryt*Hv7sIr0Kn1o72gIU_Sj}C)d*P_hRJg%r`p}55j$$(u zXm8VL{c8o%3M(8<2%iX~xnnlMxv6zIR|F z^wk0*<$E*vEQ7(iFqH3oL$Plv_LgFQS1e=g`WQb)mlV3S>yL(Wh~yfN(ZxhTy|Ug< zG8BW@a`yM^^@^P|r<~Xy-#A-tjMLUyS1MXgls=1v<O@^cdD# zVb*ukxx@rqE=g0oseBr!vPR1H7UFFLYq6AgJQM5z#aupJ3^ckJ$d#cJ6Nq3!J3grc zf|A|xWD65;*piRzw5aTmlEo^5&BR*>cC)48-ZI5po?HcVY!2BmOYRY8L$V`PYks~$ z!vq}e$`s?3lQ{UjLmlVGe-g59MUXD4J$OgJ%-sA+pwJ`Pwa$**0y4$$+XJhoHW3i5G<&{Vi>FmNnntF5FT?+7g_}ry?1e( zfva~SMQ|K&wwq&dJb-pjf)&f=`UQ)yY-7HR%-2oE>h=Y5qMz8bXqHcG>etg{3_s5_ zrmNp>dFoV58;l&;(p1}YN<%ZhmA*IrjG9+Jf5xo(I%_C`C0qaHh%WgIn_sT^Rqu`_<>Ry<88?F+z|R7E(zq`~G?0@Kv^V;dI9(h&Ce zB#cGc+neVcuFu&YyHt9cAsNn~p(&keZseE^Cnx%tJ4dAX&3X<`FX=vjgS2c>5+;iL zVf!J0dv$_u{qlxi;?;kJV>yl+67W!pgF`VirN}B&i-1+-p>wEGZ17#9~8K;v;H`)hF?h4UnwDWiwu z%(0zoka;l)NcmoGa7eJemh!#b6x&0w5sL8>FLLj3ig7wvFpl|2dM7EiRIy7GyFoF! z^^tqI8cyz|R}R6j0KsCcg@W;`bQ13}#gYd++Opm3*|SUgorAaJMp=BHt{}POphCu>o}uE)2%7Bsdr*3WA^9c~_HH_o%uZPCwyH`>o_+bVB9 zE)-U6bGfM9Cv-ReuqLPS@NajkMNB?EFC%5*9*=ueVCIDG@xpP~GNTCijq);6f@P5B zu10~_n^fV1N-ANxT{}pkf$bFPp9Ivzf#thT;@XkA(e*P=Y+6heG{%hnQZ;O6p41hK zF^CnIB_{6E-Fd+_$Wn={!ExubK1{&!q&I+AQJ{cKqV4}c0S&-dFrPaPX|>|G00-0k zBNAak4_C;FT`D4@y6|RcipXS6K*J8&$W)1Bfzy!F%t_)1LIT9PZt35od|9Mbqy)s<05&%xJX{GmlgXz#k!zYOFS^h#;Z_l7sZl_ z)haekvFVBpL}n#De!f?p8=4SYRtp1w%GB{1`0lXZa@DC_RC;mnJJy*dl5M6R8Z2q} zFxhr6l+3Ap7L_L3lGx6-!$-+;f4_L{n_Y(eK6PrP*V4l&A)}0=4U!;r z0Ji6vMXomLk`LFn93j8L)WHJZ$JUwbwP8i>W9uj3E4RF{6-FiU9A=Xrzm57JJemg1 zbl5iVL1+@WxF>FsRSdg>`Ult)^Y#Yyw4n|J^^&33Y?OjwF>e8=Hw^Y&PaFGG^dV2nny>>DNZLqMm(OoP=-tpb87LThPv7H zGaIbe&Y74Mnt5`|C|XE^&7ZmnGZwYfw=}eH-2!J`Zbwqk8MRGpPu-cD3ZpS-6;zl9 zyy!iNemp;t`)fWOpG};Nnk|OT1t!Kx$kz5=71qp(0aPGW0OKK8>|^e1TV<_&0gEyIr< z^3of3E@sIgx4g4%&f@y!S?2yB0C#p4EIf?|7mmkT#h&r~v3%7pEQ$|+-YG7kKLq>q zgX?F)FS>m@u`QTLH&`B--k9dut(I3U&Eb;QW@ZRHk(Im!W|0>igY@zCKuYP02KLwn zda-M2nLBS@Z?RzByodKy?b{Pt(g(s9{u#{jU*Nb0 z$DeWh1qYva1P(ssOdPJ)$5O9rxg=IrS$o*9{nQO4r3f05Qp8yjmKsY^pc9ShmjFgS z0yAad^+iOM0t+YrZ2{4;V;T%MBOP9kmP_wyq`~WX_WC#W`U-pf)UNXT{r37L`}?*wAWy7M^fOE~eIWq^3~;9?{}|!~RqT7Hhrj91ce~C~n5aTqD9`9-Dc{>#v27LGS+QLe8>ZO) zij7h15XB}d#+Fy!ZJuHa6&s8O`mYJYdrQG1t74Zc_H)JVQ|wj6{;XIWCY7XDYAN3v z3u=!FJ|k%<-@8Sz+Z20JvEM58kz)TCXj4q?@#-#}P9lP7?1>jW-3t7&#FkTeg!=G5jye`7Q zF(HPDo)`g>a2{x{nGar*VTa>PnK%MxD&=OVVo}PZWGGv(nf6ziv=wZTVpPw9U9Q*- zihWzP zh@1OnnED%PhWG|GLmzVoyHXsfK%0f@1Iq^^?}26r26x47Jl@2gg!mFT?wrYye4r7= zn`ql-&W$2(0yB=1^7Cy76_6Lv;b=*Lr}~2l}ptE`khQ)y&eRIb2d~K_Y5~eXpamAH79b_F{({XxEWud!1v^DC)_uV^ zfFSW$_XWE}u}2i6K9G3NDn@-E*nbqGJ`n6;6u+c*nWaQC2u95y@u(RDqh=6{nn5sX z2EnKq1Y->mY@K3nDONQZ14tMYdSM;1;tgA#Y#mdDBZ*@Y2V^j-bnFURBfDcb(w5smaQn(jK3;f|%A0s{`q_Fd>8uqgulNT6U4foC5B33!%w9umks*Rvf45xOE~ zSx@+8Lu{tc1nMAX8J2K|CzuqL0}oq?Z$TvJttm+LS!TQ5K@vxl$7tq z5lJxii3Q_cH^KTTwpOv16r(NMht311R8OrwvihiG+gr)A-%8;rwQX|gr(CllX_ON z=76&%wNxfs&slB{~ObVA$X$+qWfmQJiPaB|72s+uM5 z6fFKpb=x?vb=>vXy7hkPS>u-7I~;j4QRtYU6~=fKoEwZ=W`DmYxq93h#K6qWxFNuw z#(6l-Yiru3CTa#v?SuXQg~_E8?lDQ!w4I4T(0=qO&>wR?$baq9F=ff6Q`aHN^^y?| zmaa`6uzK-p$))42uRY+ymao^?7ik-JeRXTM8hp?t**0z&*n*r)ScdB|T;Gms%q~y3 z9oKzueGjht;QAh1qn?i=I}^BGj_ZNAUW4m_xL#A!cGQq$+k~fUS|{QSrs55b8jkC= zxW=1IU8`BUxTbA&vhC{1r}4VUvsb2Ys;;X(zWTW8Y4p-Y5fWvw5Yz&QO3ZYEg}Myb zc~A~9?-!tG+r`WV^LwF@W8RJskhuAE1gL@LUJSf=GZXwZX!GAh)r)@a`}c@N%YwS_ z&?uh1SQFzAbH@}-^SpvMzAo+R z#1oOpl9J(6d@ei$vQg4wcNc1gXhfhJ1ah_K*3M{heFg4Fop<)&Z5(h8z{0Z!V^sO; z-QDli=W&rm`m}=2Gmq*MKNOn=CWEbU5_7sz>yhWB|XJ$%vX6|I?M3QCF zt^h2kAd^spS&DA5lYFG;$P89U4o^pO{3?dYTeUjPUDs_juDflYr?V=t;-Au<}EfNc)VH)~RZf2t|-a;kYHFc|- z#tMr?@8fkpM`(D;)u1U^zn7tAe3U(@?B z1~p#9K_-^spy}NUM{gY81-r@e!!dq)Hw=@Hwnw9h_TvK_|G+`X>V|_7$o6f29F&G? z94vhn;iEYA0dv{dk@2VDU@LbE4l?~K3Am%j!J5WewE)NOalD6v%q9;hfqY3ee^eE- zaj?~!i-WD)i8$Dfv9+KwBy(THLCx_J4z^)zEvV60t5`!>lUOUsa<&@OY@={|1qW*e zRY(;Mt{UeqtqC|9aIl8V!EquEc1f0d$bYqVNjS7X8=BV4!~(HqbXt(MWDscUv6I39 znpqaS&XbQcT#qwL>js?1;(Q~{H8}Hknld-zOoQe7IMXco0nS(A%y>9BPo3iA$SpX( zi)(J-dOkAU$AK;eWWfokaG4_eqMc(McCxVwp!UC{8+h8_uy1rF6s1=!UT<&1m zm$7q(PlV)rV>)=l#FYsH>W?D;N1dcU`n?`=~UVB1*=Zm<+< zRqQ3jUQujVEVy@nOTqi7V&74W6YugKuPb&{*8scLQdsegMpxqXwG;-Y@n5i*rF`#7 zQ0o#bkE<=^d-Krf2)58ta8ae$If^|4YR?MZyVg>^w+zZxuv;zVdk-kKT(L4tiQj1M z?PV$7drh%*ihZcq$BNZrGUFk0?<7n4UZOO>DlO%E`zSVCvGYMaX70VvQoc706<4t7 zmcqs+#aa|gwp}nC0{S`*&(c_WUKL!=)!&w0kYE%nOPAmDx{tXo#*ecQBW5PPxC~I{ z_)dnc8Z&GCziX(mh9 zwD|=YAxnc~gv@xL4EjXTPEW$}jVBhT1kM<`^9y_&(+@f$!Tf?_%&Xy^2ok}WWt44p zfzE(Ld6M$Iw-Hw`nv#P3SFr*xNH7i$OS}gZOSYC{6Iyb0wRr{IJy8ga_O;0F2~-vn zIFDFeVK3}P#=7cx@IzKNvuVMimgdDXTk5dXRP6eC{!ouKdhUja&&1)2ng05mWYo03 zk4)75M*0wUsrmW$qxmyls4g;+U7B`?F- z!PuwjduSs?@l(&7k*})`&nbSt8<(f}G5v`6G0jaCzga4Nq(?2Lhy!MagB%~yHd z)VX*j8i4r=>zl1JuRQCER3j$aNh3s(V8cm^>)}7Wsgn{-92l+chRdJEjz2iP;EImA zFH3u5CS_~N;R{yUMll~gS`{;=wiBrOfhCL%62f$IeJE6%gssdZrZ7`FuweQYZm|2?yCfRnz zPgy5zxQuV0d4*AFIWvSm zAL`D1u$+Q959W74LgqDCSS+1|IB4Hh;h7X2+vai(Aqj}$z#U8!hcaM*yg7nZJ8o6N zc^%JV+jAvaH?~iM86ROGHvJrdb2H9Ij^&h155cHR*qV%tEDhAq*!0Y=7QP_mSWt@ z{gA?kvoYK!*qN5XhFrxiQ4BL7c&anoq1Q6ofhiwP<})xdW9Ktugii;Yx!LNh$jBbY zPZ;nn-T*LBf*s;89&XHdbJX9~mgSNMrp@OitEMG>2Ymu(`$pJ_?3UIAlVyb%I}^uR zLE)sI>EpZydOKYJb7dEA3I?C~9A|?CtIR5`GNgR7$xpClkPg8jV)FrhSd>F-cF8C< zTeJ_SKw!4$Od3&nrjtdbCqxCqq()Q*px|6_;j<#*vRcK36y~uZ3xZv3sbC&Kwai>d z;{7?qg-?{=YMIcF))udCq(QH%u};eBFa+B$gkyvehhU%67cpY@Vs^2kgAXqL#kANY zPUb|$w{m&xaKFbuT@~mlKFtbV@HqxPfg>j72?QxJYfZemN%I=v%aC(t?*SYr!esuk zHM<9Ys0`T*GVF>;0ZROCI8y^Yq#{kqH_n;`dkrEjSOF3ctgEGb}O+8b}+8jVD*o5Qb=Lh7a|FU;ao%c^a^D$t{;(j8HIzB z^Oxrkj=ylw+XO2dlUkZh10^$YpN9`{uqFK*=GutbU#s#IH74MS8U@Xr<)EM)jaG&Y zS|tt!d}=Di^Vhq2DRf=Evv8*1ostLykCgA-2iXw}&c+OdxoxB+7~3w1mr?L;L4uPb zJM3Mp6bqW$V6l=GVelP?v~pF@um`bW<63j53at@12Tw7wim6!TpJ1 zD;1OFgTsDXeGe5u;KV@P7W72KJNj})2ZIh~&B3pDYlNxP?(B>sqBkI_>aCmW8I3Ji zaUjcMhLW!tal_h%iD|6mNpe5H4h1 zKB*X158Nw_)vmF@DdA%<6Gxl5{gm*gn9O{bEe1|9B5jWk2qqbOTZ{Q*2put5P-Sf9 z_H~0iej0yVrE)6V&I0yM!0Ad=FWk&@4u3HCB#3HEPG#l24yI~8Rs@y@VR zyN=@k{BTQ-;@>k%@kh+ijV}02yWbS~!v|$8a(4=wf?FcKi?h$DL} zc^G`1`7v1OR#i58byc4N6r9|&R8H_loJbCPT;eWSIeY~xuK2ry0C*1$4_3I#8n;o3 zp>?#sP6G8)9AO)D6>9h2A{ON_h_N+}LvS34SCwD|feR(=y0S&=rc zVbLPvCoejC5-$Ae^p&IGeAO5I712itH^#q%0xs#gP05a1xy~e}L!y9Ulm0I8osElt zq8LYhKB7#xBR}E#p?+z}UMmS;v$VUz+%6%)1#8d-EB^+q=-b zL_26qg@Jf;a8L`Qwqyti_$NF9W26*+Zm4F)GHs%s46aSVLGCdd}yyZ4yEUv zfipXRyx!SfSK)jnuBpI|MFvHIk@7uydKU~^&JE>zw?iKYc9*5vHPjp@n-ftPR7DK5 z)5d})5*(Ew`xc_}NM_Y_*jAX!ET4AR4D~%BYdg(TGn#*&efCUCxfGQy;|NCje9=Vk zeWT3`-W0T!e2&vvQe;k0ks;-K7ozM1yVz3g#N#FWaBL3oI3S~VM69sSp7XF}OeVIt zj2V%*v6Dr@ofl&Lb;W|uiipKL6$?_>w}>(q>>Nu`ENUx@1Al((>e&rY#_+KQ57zVt zUj250w29#obdT?ZQfi0@61qKjoEgpc-m3s%f~#j*8s;xFyG-iLS}!qG!ew95b2KIU zDQ`tF&)hO|XGH3@!_%}3hYDnbry?>`AWNOu2+?Ch);%iy;Y2DlGyaRhGOnL`6ua%U zF%$eg8I~FQecX7)K=AwIvJTwn+@w@exK+?;NQju2zr{*(p>Xg?n4qn99i=dD%r+CF zisT!UNwzK!q7f0@P-8}i88--&Sze<()j>OKVosIe8eYlGC#L$~{4TEVFMttHkiLYs z1UN%CIoZF#65cIXtO6CfWeR=TQYBd;=~RJWsZv;wxrS-H3#_LRwwd!W7Aj^IDSQw+oUH!A_QBqiefk=YU+!SmzZ-k}` z722;L20M32-^fXek%3MO;xsf(unO&ecUL9k=zsU+jY55Ue45Q0&e`~|_(J2AJ>HU{ zG-!UpK<F`F54t;7cnnG=k=t=)Qa8Z!81VS2p@Y-K#!8_}-bIHSL&SC#L`@0Yut z>B2*&CO_L<&(sZH7O;AiFarLC+URWb-*FSN=)Ypj0_ryADaP?eWT9tq2TTC!4?e=` zwqEElv(sz0!`fuUFleXqcyB7A^M+ZSccleU zL&?^|i?vTQ5lZrrh(Q=fb{MFN`OR1ffeDfJVdEL{sarcq7FiV>8BR36hIX8}%rXGp z89Fv$hPg9t*5Y7zVt1}4nfk?f8zba>CuI@xI7Iru@^?n_=Q{n)`FLYevV3#-$D|Xg zp!wzltcVATF_O%i(5i25yuc~bbJ-lG%~A_QHrwO zUafW@*KJEFxT& zqqtAm8L67Ek;Sbx+q|X)b2hHvqqiCn_y@cpXPoL15$L}G5m;nySASg_F9LjiLmn<@eev|CHc_f~@Mf~~O>d^9SyPO(Cip~UNEDfmxRtVOXbHGV!+!X1%D&8_jn zEAS)}Hc|vkyVPmEcsgYfiD}ESHf0%<&=&g+rc(SXeP$-?rAnoE=Ahhqadk3Jy~yWB zDg~bztrUEYTPfPFlc&5z8@)g?{!Oa|Dc^ez0xj5!mh!!SD)w*1dPA-yUSCW3-Z_e$ zuUM99(S`_5<){|>R@hn*4E}YrUF&3#+ANLWRB49htxir;DDmJ9hkR!fe+$H69h_WBGZCb*E&*h+VJIIrX)*jXO!~_^^oBSwnbph}}d?2gwXP zDSYSzvLe`YOUc?5!BUE`lP1{5ibceZ7S5m?Vs{m+DG7Ga&X#v%mdT>IOqfn7=}_Q4 zqYM~PE6*-!?xGG>*^S;V!JC3n$Y%CjTtk3`a+q%mg-_$+Yi8S&@#OZ(eVv10dSRVYcx zaHL=~_5~XVITLKKrE&=69*FXM4ox_rV&gSo)Tv;^uG+$u56J?6+^willb^fSG6K6( zZJs)m3Aj3R;{^64*niS=lkz?G8U*8Dl3-&k6*udE1(QAn)`MV8NKLo|hC}vg{5m zvomWM_R$uby;h`R#`&30G2HPkjt_ABGNP<7#%BUD<9%-v%KzksnOtzcp=rMkG-n-2 zsRPTU`8F>eqV=6c6t%MX&e_W6?^-^j#21lZB`6EQ-0_ARkkvLDAa-hSrlrl0}S980u#vHMlz4lRYW5SW#(i);c7GzFY^iCI??i(fUe|9&N}Mj-|M4;kDt)R1Az{oaF5&SD1jym8e|g;>lr&fG4DU zZviqdShJI$rLTpi9OZipbb*A7b+pr1-DwM-H=i_gS{9A$%+FVLn82pX&i|>kM9TNj z?ePS=(o(+nl47qY=E}~WfG*7;J9mCsva^{6>NcY&ZKfO>$+{t5$zlSoWNnPK^@7S3 zDc`#jG9uW|E#-Th`4x;~I1I$&vHcK??T27)x%?S1zm=n0W@POd7;|dF-Nbf`-|#Jlv%fhwPtGy{ zm$Mt!4*w1EDD5yQ=}id6-h^NuTPn_+TFiJ%9};~3eZA>#UTn?jWNYE7F=u$I#+(Fm z>@oR`!$V6_NGRE6T$3eR$G0R~$IKNcazlt_AqO0Co%fXX*w>UKi+ho?cI^jvE^0xrJv)h;v2|wVZV4~d~DGUh27)3@$1j= zz!TaKrej0U6M+X7Y-SBUBF5Xdhc(4P#45yOuB>GA@J5t#b11`icjcF^N0ejfq6xR) zTE>*9EZxVDpKHKy8q1X?uIJt8c`53!n{Y<@-px3(JpPO0+g`f+v*3yBFonUoKidc% zZ&ZO~a1Q1aPv9IZq50{C(W`Og6sIZ&%kJ%)4#UX4;H9on_8EB{tQCrs%+d?Sj=EsW zEfqIA2n8F73`o2KE#-UME+!bWC-G(}#sNFQ9su=bf)#nWrF?HZMrH-$o_JEeSEtxa z#ab0xs#x&F!u7i#qqq+xYieP#by{WFQE-Y~m2CTnP9g`c9$Sf&QLC+^Yd9u3`=Q$b zSdGBnktO_IS2k|gug5_RwEZsG_EexS+PWoYCS!VcY(!F!rI$=vzkYq|lo22Enb0#< zjpR}>$<<3zcoc)HWLA%vE70m>+qBA~lS@`s)vcg%cm(eo^Y#FBxp_Ox@OYOR>R3>R z8S3kxL@RM1LA26UphPR(3MySI{RA(2ZbU0Ridf{~uW;NQX=bDnG|q;X|AzYc9aBpk zi*5AMomFXiX&`ctu7~7X5)+VXqm{h}j9!|AczqnbL|t0a{j|6bg|wH?$q}bUQISz; zB%B+JB1W<D^{ya31n7EL#2B%R|`ig?z~A zDAUSAyLOLO8YgkYj3kAwlVU%&6qXJtwo0+nQOV@quUkr-ZVGmhVpnNAI^C3K{75ls zUBOl=wni~7N_s27{FPbC_pVXw2F31B>~6(=uh<_I>xGtKNCne_>sLeh-uD%|MX`Go z`=w%kQtYpa?EqbKj!7?JDc`$Iu{#udNU=v0dsDH$DONQVEp#H;_D0*d#FAGE&RyQp zdr3p$lVsb3foY91TEfI}E6~&inuPX85Qsgz}(FQ-?P}H%ZMbPKS zqpFX@BPS)>-m`YW5VZ@IoZhFbxiHzbx3=-L5SAf<_7*~Mb_=0)>Atwdt8LvUv=EMV zECd)N8*3qSWrFB}v?Q&CP<>B-B5ltht##(dbC)m1r&q*8DSQgXOZC!8UDR|bP0l<# zh8&Gdwi$Bl(r++JV_V0L{5aVLYvbz56cb#sa#Hp2b;qxurSW}8Wz72uD6u)Ffx67_ z^h8jcjE$M^Es4$X9bjT}{0NlT91nmJo8tvgucBd$dH(=40!P?8x);(KwL=CYb++=` z*Y)Yh#zt4%yn|YTE+FTL{`Xsz&z`+i&q9 z8xt*b^Hc5hcdU-tuogr49rK!pk9s<0cqbn(Ma_$J2@4T~1flT|9UV1WTq zOsJ>j9y2S7jAKLGdmR6gdbU>Z4+$&MmpStizwVu$fmK)=H+*eOar z>t`(h1De3k#YV76%}vbni1GsvhaoV*zABgAMLUZLcA>ovOfc4d2AW{J|9!dixTsq? zqGpJPYAFbmUD{+2YnUt&-i1w;0Qr7?wpqu-IB1JI7CX&06Pv`T0zq3m#J&hk#{gr= zNXTiM**+*07DH#)W*vL8JovD8R22m89P%Nw%|brpw9PCZ0^966fdplxtMIMX>p-uXv+N7k! zCKZe}sbCLlJldp!y{_2XigBt@?)|l;d~Y$7kzl7;%JYj-sOsYSF!Iac8g-P zIwd`}-g58LiqR3QUaZp9u^?AMC@O)+Rqd+$K#)kc%vU`zSl zy^8%(u_qM!jbi^&>_3VPfn{}tNpBxZ`QAf{J)+pNioKxNdc_LSrDiIa8U}T)NpF;; zeDBwaJ)zhi6nj;%?6&ZbG&59fVd^5-!eyZ?Tty_^GG6jfF@?m8iH5fEh2Ut+3vFXI zgV#gy=(vAcWuIhgOJ%|ip8Y%7_HOp^vy9g9@ve3Jq#B_`>EmZZlWhiBdWl%aLpOE& z4CR2=&R`us?^?&(Cfj->XV%1$g-^mdc8%jz9BiAOY-_2UD*6%k#iS>ICD6xKT1SQt*U7*DJ{S7Fwe%}I>Zv7sFx)Qa1V+G>p;seB{StQ}J zuzqRRq+7qe%{5Iw7+?sm>nL1LYb3(@Js49L3+m@Ln7E+{%t4y!a$3$Z{_<`n6Zh=w zCN2fOy@`8y78BPsr8#s|#q8Qp91vzwVnf4tj`_I_%+I57v;7RJzG%eW%xQxTvkwn! z&?D@1V1u4xuLB$OdV3w%pl{e~wL#wlP-Q`$C_l77Suysp`0KDd`-6TH=ao3Wh4YIz zzilm2Xxn^74L5rWET2xv&;p01cW9YTvM)_*HOHvo=g~6FYN3aG2rZG24_`RTG^<4x z@*%WLLq2@rEYqw#m5>jcA`fbrj#tZ+lvt*M(J~e6VN1omRf@f%7`2nc`$VxW&`^T? z$5L@`y<(VsF~7#WQcL;X_KNjWY>;AmDRzKjY+2mjinnlW+u{OoNrPxYPbV(QY)>z8-ra}h`c8sNbuTio2ie0MM6^cC$>YFCL zr!D1s$3dYBR&OcaJ4vy{ihWP9>lAwi)CnfNwU+X|2H2j0HCoE|PE+hm#j;zb9Hm`` zQWYCdEmO)~x@F3yJG4yg?;CHKni*XT-kKTRaOBpV(G9b6u`{FVTBIGA(am$bmP41Y zNU>}reMXn|sU5zMi=uhpHJJ2wO&GKn@ta({~_Bf=nFc_zJtrDR4|FwW?b!l;r=gf_6Am1bH`?%-f z<^G?&Zvm{MsQTaZ-lWOi+a_sCA3WOI2lNS~v_M}#(ib<7(n5I@D5RlHX`!?wO$!A+ zNhu;RR#6mD5fOZV;wQdAL0c*mKR{4GK}A7CK~Q;WL8brSZ_dowxtp7tl%|0GyX|Jr z{q5}R?97}qXU?3NN%g{*Uhm%i=;B3y6Z^oCGg*>M_rOHy+`++L<952Y+2=NXYc1ZK z?iK9q4ORXYP%0>C`Ea5bFG?nJh8g=Kcrk{?j>Fn2a(3*!ScN^!F2jf+xXg?g{tBap z+@ZHO&I+6yLA(%2W9s=~AIJF!PA2zBoX_I?BhFGJh$D>6IGNs0;&eOkei`)5IB&zr zgcl=${c!Gu^C+ChX>>U zCJa$WJQ&x}438`8UXuzkQnE*fV2|3nVZdP$!CqHvHR`lr&6Wy->iH+pf}5cmf6`oRg4J!BRRrJbY#VH}_QBS3k*2NL)-~{BFe&J& ztU=UQ<4nRcJ_u?IMdwDrZUy!ALA?7DP#-ZAB$COidUSW<{QgtiV~O%wff^#mdz0V$ zz+}o@vQgP_`~Y)ki()3(zD5RcKpdu5sfzvaP-J&~5DUKT7hE5Vf!&pO5ojJ`P{m4v zDIV`$fy_wklR6ZPTbwK@O@t*CiIUWe)Jdtu_|*gOl!1w*&wB-ZoYJ!)vD=%NPo4wOht6YK?!t=w4_&(nEnqb8(pUM}G;rn@E87vLM&ypbna z!9RqPU-uYJR#v}hV@@&g*Wh$bTcIYcA}F?eRxzUPxbano=tPWIBbP-2t*edGE+$uQ zvR_eznqnF~wt15*$P48v+dRr(wrf1DE(==r!SxzkZ^QLkT<^2L8D^!neWaxA6YNoY z*KSy3!m(A5aK$K730G#RFxXGAp^9x(>;sD3s@QFcZB~rxyu9O4#U59TTVBX}x#fj~ zJ6SPmnS!lUtVyw#6njmv{h%O7d_yf21_vrOUa>mG<|(#Nu||wOdmFTFltZ>{dPVKj%}t|f$8N5jx}~ms z`h7;jpf6>g+Qh?i+P1K`5N<0igsw?H5)gH}WKaj{!NH_hVP3}hb$mv=(LNqHOp*|9 zScWR^sOa0)v7M*T+m0Zvq`OAD3~9xOqp65D+GXtC^CtXjI%G_{m!a?FFfW^WU5PUFRhqcx%CK_wlGVXp#NK8O*Ipsop5nny zI&XlSp(I6}iP}P@iP1@~X|J3P1_f2(K*-0AoCf`mp^WsKkS9^9>2SCYnI@p;0Zyv+ z_flO zVv?QmI!Cf|2)h~}s}B1#tX}NrWFt&;p$dS&f_srX1gu#RH3HSd?Lj_eBLE4aqtJIi z==a9&J8|6`*Sm0?j_Z$bJ=XqaW6)C@15(l$2==JGD~*9*lr9pEje%fn3hI=ZZ{biU><5B5Tod#6=`sODG~I;OvEpCC7WSUqdOvevOF8gN>x4YAQ#W zk*Et%6`_JVRW$0+RH0T!@~Z`(n(n{169N=k{_U%IyK-;GyIqtE>rlIQgIqWVasmC* z9J$a78lThroLt~HG2y;!aB_i3i_3-I0rQO)&TtXqeA+U|`OI1HE^}7Q7RHU)*Wp-~ z;yT=8mVF<$?E3_+e8I1AWer`eY)eYmRgXE66C<_)W5BRVdI``YFqY4Oa-TDPjCID33)O~UEFYT|!1D17EFUwrzc9$Ne1w*zAAbRg(XX3mw74bFCzILTtpP3Aai@4GefK&44h+dsmu7(qppGi|C}r zS_~!%9z!*!gPN5nb&X4#>sQ+zZloF=W}f3B`iGh4o(g_}yrk*E>Qm-9wQ-z`fHI`| zX7C~`8*~z%3v85mn170lcU%i7Mq*zsmJ+_5irGncfbu#Bo(X=5;4TvKl^hZYE3>lz zI6F^d0XPM*9AJXK1P%)|mWZPz7V<}btI)w{LsQJ+hSd#=mp89BsiBob1~p#@eh(`N z^Nina!|JCWhj2%m_dSHw%8HD%Ud^UQr1jobxX&;_9toBrNtdGtT7#KJ(APqxeaPG! zZ(c#m5FVY~uyXNwS1fECwwW+J^qB|D?};#QMABb6?fa&C?w3yXZr^F&H?bf3?CE5J zopu=aqX(tazHd6QpKBU;^@pB~O=v>P73n?`)5RyZGbs$lSF+MwU{ZBGx>ZS-c(Fh-K@_$+yfH%TH;` zwJya4Ekva)Kgt)51>_H0Bq6I4^Duj=FKm+K#`0%t>zsx)=Qhf6xcr`zO#(;d=mlSa za7&jry2AID6gB~b{zZXK}K1qU%IO4 zyoMDR>=FIn_8#W1THCa^v3}K3?05{>BGa?1exY)90Pq&XZaWu|9OVs)Hv2#%8wcVB zrImfcGcVKe;#;`G!pWaf$F&*Pg}Ab!pNT7l*>YTej_cXD{=)u#0@r2u{iOZ< zEUxF^_iMPGi|ck=&%?C>>1BN5@cReo%E<&}Qldo(_NcupT9jbaq9j}?;t(utsW2F* z*uIL@C^k#6Qx!Wyu`3k&pkf>Vmv`K#*aM0^tk@qEdrmQ0%;Z^G%p}d+C`+(v#p)H~ z(jOA;V#O|1>~o6Uq}bOL`<7y}(EXBk)LIIzZ;CBf46e~O9Gs!;duc_JXK6)~v~UuN zV4Q>^*wKm|tJo=uovzq(ioK}VWb}|Fz9TFZ2LA?i@i5kdBDAWcu%av|2}f;B-utj( zk1CeOKo>1Ec^8T!uIQ0Tc=W?r&Ohe(Pf+x7jZenPQ=HezBfYsC@h?`M97wD@My9(~ zq44nZY3R){_k1f4ho)UGZdZG6rHI=T$X-{iN(#yRWeOd*>BgSjoD1<_N#UL7* z;QxRc7a1xBs|J9i;}AP88z~(t6q~Kw<_PBQHaIv%>3zt^xU#_tBnQ14&qQ^FK9Eyg z#h|vDyQzRyL7NDYj&{)tJ1c zSz#+gxf!M+I<9UfAU4?3o?# zP0AQ!_CfrvTL*WPvtyY~M_sHPCV{x$iH3>zrjX;VzhNO$V)=&M9Tp5DHY|cIUrfyG zIFWbk4Si$YVq-p4p|$tuk z+F&ao{K$_X)yPYpyrX*Ipj5u%c+8g@Doi5((%9W(T;40*+U>~kE6f{EW}v+7VRzYozMTlz zt?x6HuWEL|%C~4%7i5bKq*dYVRX(O9R{0ol-pXfh=o?MtYrh6>A?fm0t$w7!;2_iu z!49!h7|d6UR%r=$fnpac_L5?+DVC@DorjyBEg)U$yHx!;U*b5A*fABU^CwM}c(QPn z=+l)dVFPIay}c^Il*Fn8BhFhT>OFB&;aCuFl3`bU;jF@CFY*}MNG`_%&C>Mb9 z{SLBtI$heQuQ!^*QJ<3D0R3<>Fw)0$88UJz;SX~u9yI425^1_9Czx84`3GXL-^M9IQgEH8E`I6_A;sv2Xog79OoN!wt<{) z&?^YUfbJmw-QF|TU^NPp9N9-6jVpB7U<|IbhJOn$7i&1FFv#?9*a%C7L6u??6{Fv! zJWIbzd6pAw1-sT#;!^+-vcj!;qrL?jUTneZIa1#?b3`WFia&Lm_6LNe9hZ#A%$o3* zx>n-?hYL*sHJj#SMJ%`z+V(GT(fkj1i#ESWFc|~Grw)}ltmzJ-2yp+^E*{M&K zU;abfs{PT2pP9t}iKR=ImJhj{!Qseoe;tPZH=Q_QnTfr;0@E{Qj;Ma6yrR0|6_Sfu zE*Y^XSld)L`3Rs@f9SO>;-J9-YZarjX3s)VCAhLzkkxHR~ve{d`;MmwLx zh7~Rx+Y|{$%gsvE%VaPf)E`YaZn7ZnSPAN*8NW$bgsQhC)+DS!C`1wPx+JDioY$~A z+P`lXRaO!CD;n3VF&)^BTY%l5DreAN{_pt~BiN5&y%FOWohjIlnLs3{E}B$Czk%tM z8T_Ikfx|)(hw!HuMXkP;?VpkUYz>B)04K+c0K;-xgOgyrOAlO=Zn@>abaBgr{%C#` zs!n1J2IrIM5=^hdT)ITMSIc#1HHydco&D!9{`!-sXTh)_(_=0(?|eD<6$B{M zklS)q{NpY(q5c^>1v~QoUQ_am3|`rC170>9b4Pln4lK!}ht4b+o-RJ2cW@eJOa#II z4h@3oI61516UUpmH+8EP!zehT^3x_(NJDdNg~P%!iz72|++hAbh;)4j_^isq))ocT zia&xSs|G-Wnprsym_Kkn1+PmNZ|LtgO^*R%PHgDU2J{s9%DF3+)UU&UF;!eTo&43j z@Ho7Tzl&@F9tn=azX#CKcdeQ~(f>9?oM`!FNiwl7vSBayNc2dTBwahoiCxTAz7U3< zIqOY>&CI9Y&T{jZ0AJmLmm}Gm5a)j~R zE-6}8Sq;P=(@R4$;j~kyC2{I$De6}lPLB1h$N5{F^vd`sbUdd;eFii&si|mD<|B(w z#7Qy2Qg{L9i#VC}2jO!lL&oFer!nuDd;F%yaFW@7iSu!sf5JH#A4XQ2hLa!3x=@Sr z6r2lio{6&_=PfwDj+317C{D5>YdC8&>(^Mwy>U3F;+&217@Vi$T!=H~Nj`a!(f9E3 zfI`>mdmP@m9T0^oI+!9<*@>jeHwmXZ*semaKpX9(F(wcc1ud)b8%Bf{3gLrsWpAIq zUj|OIz{5qk`?REi^FR~s9dl~K>{i8YQ!I_f zP~K5tsW4bj?68HF3WGz?*xf&z`Er=0!k`(HJbR&~!r)O*f6Fl3j_fA0&qh1C6!%_0sU*!{{bQz|odNa>Ly4WX4U4Tj z0W-MOQw^Y)Z$$w<5i{=NOO16FdXZ5|aKRzg+1)dWG-b-}iP!YJ z(x$(u{u@+u#P&GAbbfr>qgy78n)X@JZK-cw)(~IQr4oE`S|#E!i&qr3^En$GQ{m}s zRL%GX=xp+a4h;V+i>L4=z6`ppIUYq}kW~*vu?wq`3WK*4>w(~c^|lnoTNOK8F%BF{ zxEmDvf?}NQQ)=e;7$e*p#`2VHn~~vq%~e_2uV9wKl$iRhm3Vb-#rg)Kc{x_G#v&A5 z3kKo5Xc+#O!>d@k)!1(<*=~J@sc^k&bBx_l1*_2Bc7^%!y-gRs3N$NR{dCh$jw&2$ zYA+Lz`!@Ouiu8IL6_BZlRY1P6vkJ&E>!KvJQZs3h3lNV;GLSSl5aQH*nR zB;0((>J?k87(HVo+yjb5&b6JbIn`PNqj3%DY0aeais_m1%9;#Tr>es0RKTWJVRfoW zG{9du9o0DU&wUK7!sly?ppRxFQ%+&qmGG`q+i5 zf?a{Zs|;}8MB}dt#&2~l*zd&3V60u9Y-7qd(1YjX*e4Zx5%NRAy<{ma1%`#ds?7L#-3TrSW`@x#AejoUnzwOF26|k^w7XY{5{KQ7 ztC8y8Ax+T`J10||8|=~@(s(VGZ{iY%O^wFxq7S! zdhX8HPrI+_-Yxb1JvSS18I%2Hu4SF!nu z`St`d-nt=dG0XxE+)b!mzYe=)&!s`BtS!w8D)-i-j2+xXD56K{MDM=0vn z%%s{qjZf_y*ps`Z-w6w4yzyb96Lm3Vdms+zV&n_Q(3~#jjWv0?m~{G~??tZK&AozT z6r1C?PMl{nYv6+xX zf@Lig1|I_Ta)v_mDocey0_IP_dRodDVEIkP=o$%3Y*mK&W}I!2g=Lj9&!)p!jlVDj zqeorq^k^1FGot@wObZ{57`5jZ3%+ipU1*=iD7~BCl7|E}Ir) zeB?he*+yu-S*;p-uFxEAY!KVc?YxV4569q1bNt_SxSA-nMU&-@F9rdfYDQ$vJx`Mo>E!?h{=RBmDNDqNIx(=Sm(IU4paeM z_wC@4poNy#DqIKRIv!WPj=xzq`J0XPVf-}XDoQF0?gVQIw%Jl)Kz0-CX~nL@`vfDq z$+NDX3tj=wU}dJ{OFQ5!9%rMiZYbi5crwmEqmU*ZBXQmcks-$({xL$LeR~jtyF--7 zuxMfa8D;qA-_=IBnA^O}E_58t_8OJ5U{Db&Sy^fh_@lJMXPY0I8)TcD0E2!i>}_$MO@kB3-E1AzBes6;rA6RA$#uWTfEDU)Bj$T0RCH-yAO# zOG9vB##K^MQb`44B^7KGo)v7IrNUq*^d(MMJ1I6o=<7?TcdRe1#(wgP;lhp44o@9X z)MWDZ83kMWH_h!XwDuFouAz}t9kljIqt)(YYtM(aV?qU^cjd(-$69+PGpDtO{~!vg z8mBvkgLu2`{mCkeNQGuydcod@SOxoxrBcD?6w9LQBpm%uC7jpZN5g49$0PAV_GM9` z<3?SJ^X(LJE+<7Lv=f}fhw_w+v;grQY$0AcE#r8Jlw`7C%w)lyvs4NT89L0VN>OfJ zip+jB#xhjvc(AG2wvQq4MthtRpOWvua%x&iX!_c)M0`VF-o<#wW`XjDXt3Q@;HGq_?3MSaTC{e*C zTPhVCp%{C`5{{-t3D>?>a7ORn3e<`>T(Y`aE7qf4ocH!?MQ3%QJEAu=;-JDcV%)CR z2)-d!BN*$h*N9K5;3X9X{ZNL24YX7k9I6=WhJ>TVM8dId20*qjnxHquy`bJ zej9qP93ml_*REdCI1TNnB}~4~>C*wHCA-K-jKF4_Tf=a!f$H5FhWYdnrgJ;K3jb9f zdBSqgZ5hWwq{3hk!U(p+QqWNp+pJi7ZaEjxKN8C!Uxq$E6c3xj&!KMVO35_j12nh0 zHBwV@FV5|t`=?sW8~C*uN|l27^$35^g_BVcAB-IDuWB?p%cYejD<6@K9k1oYf2%a48LcryX-fkGcpD_v7N!hmfne5p41G8J+Ow_d< z?R+fPz_u|sJN38CL(7NE#0<_&Gb%V|a}*Y^X6qhg+fsA^nEKPTf1uwSeCQT&qb)8f zU0uJGpMN#ZBvx_>f;*rYCWB3&QpkvCr2i=Rl^&Wnx)L|^_&TU^oYcdak74^-lx;4_sVq&tQ+lE`+nkwxU z7!Z@`o>G9@J+mTjzxtgi1tT64=uO!*i+rDrj)%`aWrok@84f$La*TQ0>od~X1MM0P zS&1OBc=f>+FOkLg*I>)U-ia!#WROKaF}+uM-%95xaR^x5pH_I(Fj#4d*QLf_3TsM3 zEd$EQlz-0hZElV#)m)}w9l_wBoSC3AGl-|8<)gHT`O_L_5l^mtN+B`8A)=L4;3+zT*yR{T-8w|MSMs4w0PWy6HYGmxxxz^iYR!9q3>E~mZlhGm!_aIV24Xnh@EgSTFt0J z$kG&}^32RE9p#6Ur71?ax{_~ZrXSoaO%V?EA+s(;IN1L>(j1bgMxAj-sUyr3%>RWk zX$%mzI0ctfbyF|h)JjgP{0@`>mJ}DNU^%dOm|rzG^DSI)LEX7yV?U+G`8kg1&EsRYFuB&^>Ya%I*~gQvOZHlqq{k;oUEV z9Cw28@n*QaPgb-;J2_g8LJK{*NvpvgKCRz{h5X({)oc%+>J-#>u@rLn^pM@ir|jw8 zkA_w{`lQ0(EVQqJEwvOp?iE|7*k=@Di!9H6RWa^bDcF#ti*LB4U><^zR^GAMQeki+ z+I_(mSSk#@0BRzXk5q88rNZD@SS$QM&1rist|XX5Im86lNVt@9q)`(BW}acS!tC)mH25z{k` zi*97B=w*x()!;0D*&ytjjWrV!2c=5I)==U)k2Ey+J;P;?AnDYhKJ;p)9VESDog6JfTr+Hpw@L_bCDIUAhX=Wj@(;VVV;biA|0#4U~=8OGKG|TE7 zoc=11=Vhb={Wz}dM6>W-!^sj`jgy_?>L906oPX?^GMXJ=R5TrTff0I7$9M4_g}P~) zbBT)Ew)fcmVbShrVPP7(a}?^G>iCjt6nE@Trkg@&2<@?z+sU zJJs>6c5I5iV#hxIf#Xwle8->>myRzf>G%r9j;~#69#o?21Yc1X7EoYK0fua{rmhTN+i z``7I4W~=BOJC4e>{X4s5N002(?d2c195=I@rrpH?$!^$zp|YT96o&CfW~V;1?i|yR z(b#D0^YLIM_9*>CaHM(o*rKA~TJ!K!sHFYO-aqNl1mxirT#}b>Jq~X%IGohw zcTr#p6iMX9%l<=4mt)@^6aC3}YJU^`x3SAz0wE*qz8ble?$IZm%2}zsucA)v_lNs_ z56v6HrZ=V2Im3P5$p~ybfs>`Zk)CESSXod%v(cuXKCyS0lq601xoxkcpF2~}sO)F% zITc%$0q$p%?jYD;?kzxFsmyT!|MXCsn$plEme-NqM-JxagombUDihPO3U38g3Mfrr zC+3o#>EbbaA)R(_JZv?sJ54itIY)H5d99l>S_Ho+9wla^*=9E$LlrU~#EpfeB*&n9 zqikNKDM(jLPZu9M+`DJCSw02*!;#!&c@&6LaY?Uq@$AuFAPyxa7TGP9_m6L}e1hx1 zcD%*1tF%i@`a_diZu~6YQ{4G>%PY-;(RR!7nLQ12tZrSCE-*+^f(_-vN zD=UThol}1}-ULgvY|0nTcMIUKD~dT$SrVp8%lyi~mM3EpB!31f&3y(whFEo%10EtD zeKvz3Vw~T_$(sBboco}Q9NYW2O1r9*L*Dpp7U`y((eYdEJiGxQ54ZEM@rPd~nE6XN zc@=n*X2*pV$4Z1|o*O2sw@_MO!-5vdnnQ3s1lI|;-h?ac94)ul-(R!8$-`5CvobLp zoAFG>HRGg0B@#a8ghoEENV9D8@~ICEN!TYg6nN#lEH(*JPCVjY33s_-S1HDABjmlb@JqOFDfT19wkq~Y66-n-=Xdp1ACCDcJC{MslZFH;3+9Yo!OItuj<=qcHa|4x=)wgJWGsVCG+K1irr^^&yH zOR}xURZur+yI<6sO}uklLA}HTd;q2$tDRg9ss?A$)L+q9zKP$WonR#-tDXEB)SscQ zMt+D}kXvy*fgOk?^NCP><53w^XWLNc+!A2LLo&vFh<8JK1CVI;8kRMomUKYmQ zJ4a9XU9bx6*fr2ooWFQm(R`Uclw7EbjGGs7h2~Y#_5Qf>XlK z8skWr`*9_Q*5~h=`=aEqm6dPkpQGeRBecluY2cKc%gl3Uwo`I`g)&Pg@JXqje!J$Y z5d-mgi6cr%)06t9_nDkd4o(*z$oy90_Spz9!YeJK6-}C#nCz)UDL!!^z3B4mHd69q za>~N!Hk0P1D<9-}t{D=)v2$ex&PzBVWk$YhzmAldOHA-c znQ__BUYR*3pOTVCnfY+OaK1I4N(c3rd4732+E*>%rv?qae>#!ERQhzX)W0Wse00w} zUqBy%mHsQxhuHG_`cN;3Eq`}`xK6}W^uftD_QSasPKpCEDr@E-oK9aNf07x8j=b>Cb09T3z{w90#_fY$Lg#Aqs$NOXL?}P2{3HJ97 zamBRJ7WRDkJawr#8K+B;5?x9#>QaK;sNtwf2}WH?!cmtJ>>0)Wq!_1DNw^wIg~9QP zout?n#qLq;S;d}L3{wbgd{D#fd-qaokYb}1J5aGB6su9}NyVO4>_TWVl4h<8CExZ% z#comTJBr<**rSR)uGk+Gdrq+?wBZR9Tq;;+sW7+;l)RTMyu9~u#eSpM9vvy4j`S_` zeIgwRQ>kGDIl2-RQIDrUIUVWv;SSExk#wA8#j2HO$L*OpH!;SbdQ;Ag&Ym(Y!Rsee zJ@+#s6$<9 z7zC?tFzPN{YJjKrT#U3sDJiT?EkU4y+EgO~_}bJ`=17Oy)OpApD7!IBky9i5)SWBw z?9rx>oyG6GHdW8;??9Vc9J|*AZ3@<t^JJV0aGr|uG@MKw1;bf5nHtto zR=l%uvf`}7Np>dJl110xY{t13=Q^Ah;JgSYS>O_!|AX^=I5*(D3}=Vh6eVHI>O@J` zPMhNT-vDbm(57Ai6TI8H)N4AtL@G30HNmKP3HE=MN(Dbv>~D&_s#ppdk37r$f#umo z#g;3!Ua|jCjM|bs`xnJ}LAw!*o8w7*)QkihuNZYC!KfoixZ@Q&NwG%7mMhjX;hs%d z3U)ZfzNFYgiany(?-YARv9}cKk#uS4Z7DdaD|Q{)`iF*7m%71HVeltV@*UI!w%C!p*u~a6 zZ&lmHINS5vE=IV!5^3t|-;U~_zRJp%|1h_`bpaw@m{B^v7c8<=Hzkf45Pf$H@?2AV1xXN~qC%JxIvXqn5^E^Hek7E`R zj=l3fj%Rzqqa@YA`RJ$MX@RrpgcR#QU#QU zay%9n27b@r`aQxRXT5Zz%kQFqp~NaI405&F9pu|wt(N5r$Z>gLM)9>;#>I#4!kLFD z-nLdtW|N9eN-DZwtmuM`KwT4z)mt!{|KXsyV#Gk}xd~55GFp(G@Z)Uj%n{Y)r)++; z{89r=*pY2D!{PLz$hPgBZF?{~_WtbcU;T)=L-KIlLJc)