---

#include <Windows.h>
#include <d3d11.h>
#include <imgui.h>
#include <imgui_impl_dx11.h>
#include <imgui_impl_win32.h>
#include <MinHook.h>
#include <psapi.h>
#include <vector>
#include <string>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <chrono>
#include <random>
#include <atomic>

#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "dxgi.lib")
#pragma comment(lib, "psapi.lib")

using namespace std::chrono;

struct Vector3 {
    float x, y, z;
    inline Vector3 operator+(const Vector3& o) const { return { x + o.x, y + o.y, z + o.z }; }
    inline Vector3 operator-(const Vector3& o) const { return { x - o.x, y - o.y, z - o.z }; }
    inline Vector3 operator*(float s) const { return { x * s, y * s, z * s }; }
    inline float Length() const { return sqrtf(x * x + y * y + z * z); }
    inline bool IsZero() const { return fabsf(x) < 0.0001f && fabsf(y) < 0.0001f && fabsf(z) < 0.0001f; }
};

struct Settings {
    bool aimbot = false;
    bool trigger = false;
    bool esp = true;
    bool bunnyhop = false;
    bool anti_aim = false;
    bool psilent = false;
    bool glow = false;
    bool chams = false;
    bool no_recoil = false;
    bool no_flash = false;
    bool auto_pistol = false;
    bool hit_marker = false;
    bool spectator_list = false;
    bool watermark = true;
    bool logging = false;

    int anti_aim_type = 0;
    float smooth = 5.0f;
    float fov = 120.0f;
    int trigger_delay = 50;

    bool draw_boxes = true;
    bool draw_health = true;
    bool draw_distance = true;
    bool draw_name = true;
    bool draw_skeleton = false;

    int menu_key = VK_INSERT;
};

Settings g_settings;

HMODULE g_module = nullptr;
std::atomic<bool> g_running{ true };
bool g_menu_open = false;
bool g_imgui_init = false;

ID3D11Device* g_device = nullptr;
ID3D11DeviceContext* g_context = nullptr;
IDXGISwapChain* g_swapchain = nullptr;
float g_view_matrix[16] = {};
HWND g_hwnd = nullptr;
HANDLE g_main_thread = nullptr;

uintptr_t g_client_base = 0;
uintptr_t g_engine_base = 0;

std::mt19937 g_rng(std::random_device{}());
steady_clock::time_point g_last_shot = steady_clock::now();

typedef HRESULT(__stdcall* PresentFn)(IDXGISwapChain*, UINT, UINT);
PresentFn oPresent = nullptr;
WNDPROC oWndProc = nullptr;

// OFFSETS - UPDATE THESE
#define OFFSET_VIEW_MATRIX     0xDEADBEEF
#define OFFSET_ENTITY_LIST     0xDEADBEEF
#define OFFSET_ENTITY_COUNT    0xDEADBEEF
#define OFFSET_LOCAL_PLAYER    0xDEADBEEF
#define OFFSET_VIEW_ANGLES     0xDEADBEEF
#define OFFSET_BONE_MATRIX     0xDEADBEEF
#define OFFSET_SET_VIEW_ANGLES 0xDEADBEEF
#define OFFSET_PAWN            0xDEADBEEF
#define OFFSET_ENTITY_POS      0xDEADBEEF
#define OFFSET_ENTITY_TEAM     0xDEADBEEF
#define OFFSET_ENTITY_HEALTH   0xDEADBEEF
#define OFFSET_ENTITY_LIFE     0xDEADBEEF

uintptr_t FindPattern(uintptr_t base, size_t size, const char* pattern) {
    std::string pat = pattern;
    pat.erase(std::remove(pat.begin(), pat.end(), ' '), pat.end());

    if (pat.length() % 2 != 0) return 0;

    std::vector<uint8_t> bytes;
    std::vector<bool> mask;
    for (size_t i = 0; i < pat.length(); i += 2) {
        if (pat[i] == '?' && pat[i + 1] == '?') {
            bytes.push_back(0);
            mask.push_back(false);
        }
        else {
            char hex[3] = { pat[i], pat[i + 1], 0 };
            bytes.push_back((uint8_t)strtol(hex, nullptr, 16));
            mask.push_back(true);
        }
    }

    if (bytes.empty()) return 0;

    for (size_t i = 0; i + bytes.size() < size; i++) {
        bool found = true;
        for (size_t j = 0; j < bytes.size(); j++) {
            if (mask[j] && bytes[j] != *(uint8_t*)(base + i + j)) {
                found = false;
                break;
            }
        }
        if (found) return base + i;
    }
    return 0;
}

uintptr_t FindPatternModule(const char* module, const char* pattern) {
    HMODULE mod = GetModuleHandleA(module);
    if (!mod) return 0;
    MODULEINFO info = {};
    if (!GetModuleInformation(GetCurrentProcess(), mod, &info, sizeof(info))) return 0;
    if (!info.SizeOfImage) return 0;
    return FindPattern((uintptr_t)mod, info.SizeOfImage, pattern);
}

bool IsAddressReadable(uintptr_t addr, size_t size) {
    if (!addr) return false;
    MEMORY_BASIC_INFORMATION mbi = {};
    if (VirtualQuery((LPCVOID)addr, &mbi, sizeof(mbi)) == 0) return false;
    if (mbi.State != MEM_COMMIT) return false;
    if (mbi.Protect & (PAGE_GUARD | PAGE_NOACCESS)) return false;
    if ((uintptr_t)mbi.BaseAddress + mbi.RegionSize < addr + size) return false;
    return true;
}

uintptr_t GetClient() {
    if (!g_client_base) g_client_base = (uintptr_t)GetModuleHandleA("client.dll");
    return g_client_base;
}

uintptr_t GetEngine() {
    if (!g_engine_base) g_engine_base = (uintptr_t)GetModuleHandleA("engine2.dll");
    return g_engine_base;
}

uintptr_t GetLocalPlayer() {
    uintptr_t client = GetClient();
    if (!client) return 0;
    if (!IsAddressReadable(client + OFFSET_LOCAL_PLAYER, 8)) return 0;
    uintptr_t local = *(uintptr_t*)(client + OFFSET_LOCAL_PLAYER);
    if (!local) return 0;
    if (!IsAddressReadable(local + OFFSET_PAWN, 8)) return 0;
    return *(uintptr_t*)(local + OFFSET_PAWN);
}

Vector3 GetViewAngles() {
    uintptr_t engine = GetEngine();
    if (!engine) return { 0, 0, 0 };
    if (!IsAddressReadable(engine + OFFSET_VIEW_ANGLES, sizeof(Vector3))) return { 0, 0, 0 };
    return *(Vector3*)(engine + OFFSET_VIEW_ANGLES);
}

void SetViewAngles(Vector3 angles) {
    uintptr_t engine = GetEngine();
    if (!engine) return;
    uintptr_t addr = engine + OFFSET_SET_VIEW_ANGLES;
    if (!IsAddressReadable(addr, 16)) return;
    typedef void(__cdecl* SetViewAnglesFn)(const Vector3&);
    SetViewAnglesFn fn = (SetViewAnglesFn)addr;
    if (!fn) return;
    fn(angles);
}

uintptr_t GetEntityFromList(int index) {
    uintptr_t client = GetClient();
    if (!client) return 0;
    if (!IsAddressReadable(client + OFFSET_ENTITY_LIST, 8)) return 0;
    uintptr_t list = *(uintptr_t*)(client + OFFSET_ENTITY_LIST);
    if (!list) return 0;
    uintptr_t entry = list + index * 0x10;
    if (!IsAddressReadable(entry, 8)) return 0;
    return *(uintptr_t*)entry;
}

Vector3 GetEntityPos(uintptr_t entity) {
    if (!entity) return { 0, 0, 0 };
    if (!IsAddressReadable(entity + OFFSET_ENTITY_POS, sizeof(Vector3))) return { 0, 0, 0 };
    return *(Vector3*)(entity + OFFSET_ENTITY_POS);
}

Vector3 GetBonePos(uintptr_t entity, int bone) {
    if (!entity) return { 0, 0, 0 };
    if (!IsAddressReadable(entity + OFFSET_BONE_MATRIX, 8)) return { 0, 0, 0 };
    uintptr_t bone_matrix = *(uintptr_t*)(entity + OFFSET_BONE_MATRIX);
    if (!bone_matrix) return { 0, 0, 0 };
    if (!IsAddressReadable(bone_matrix + bone * 0x30 + 0x0C, 12)) return { 0, 0, 0 };
    float* mat = (float*)(bone_matrix + bone * 0x30);
    return { mat[3], mat[7], mat[11] };
}

int GetEntityHealth(uintptr_t entity) {
    if (!entity) return 0;
    if (!IsAddressReadable(entity + OFFSET_ENTITY_HEALTH, 4)) return 0;
    return *(int*)(entity + OFFSET_ENTITY_HEALTH);
}

int GetEntityTeam(uintptr_t entity) {
    if (!entity) return -1;
    if (!IsAddressReadable(entity + OFFSET_ENTITY_TEAM, 4)) return -1;
    return *(int*)(entity + OFFSET_ENTITY_TEAM);
}

bool IsAlive(uintptr_t entity) {
    if (!entity) return false;
    if (!IsAddressReadable(entity + OFFSET_ENTITY_LIFE, 1)) return false;
    return *(unsigned char*)(entity + OFFSET_ENTITY_LIFE) == 0;
}

bool IsValidEntity(uintptr_t entity) {
    if (!entity) return false;
    if (entity < 0x10000) return false;
    if (!IsAddressReadable(entity, 0x100)) return false;
    if (!IsAlive(entity)) return false;
    if (GetEntityHealth(entity) < 1) return false;
    return true;
}

void NormalizeAngles(Vector3& angles) {
    angles.x = fmodf(angles.x, 360.0f);
    angles.y = fmodf(angles.y, 360.0f);
    if (angles.x < 0) angles.x += 360.0f;
    if (angles.y < 0) angles.y += 360.0f;
    if (angles.x > 180.0f) angles.x -= 360.0f;
    if (angles.y > 180.0f) angles.y -= 360.0f;
    if (angles.x > 89.0f) angles.x = 89.0f;
    if (angles.x < -89.0f) angles.x = -89.0f;
    angles.z = 0;
}

void ClampAngles(Vector3& angles) {
    angles.x = (std::max)(-89.0f, (std::min)(89.0f, angles.x));
    angles.y = (std::max)(-180.0f, (std::min)(180.0f, angles.y));
    angles.z = 0;
}

bool WorldToScreen(Vector3 world, Vector3& screen) {
    if (!g_imgui_init) return false;
    if (ImGui::GetIO().DisplaySize.x <= 0) return false;

    float w = g_view_matrix[12] * world.x + g_view_matrix[13] * world.y + g_view_matrix[14] * world.z + g_view_matrix[15];
    if (w < 0.001f) return false;

    float width = ImGui::GetIO().DisplaySize.x;
    float height = ImGui::GetIO().DisplaySize.y;

    float x = g_view_matrix[0] * world.x + g_view_matrix[1] * world.y + g_view_matrix[2] * world.z + g_view_matrix[3];
    float y = g_view_matrix[4] * world.x + g_view_matrix[5] * world.y + g_view_matrix[6] * world.z + g_view_matrix[7];

    screen.x = (x / w + 1.0f) * 0.5f * width;
    screen.y = (1.0f - y / w) * 0.5f * height;
    return true;
}

Vector3 CalcAngle(Vector3 src, Vector3 dst) {
    Vector3 delta = dst - src;
    float dist = delta.Length();
    if (dist < 0.001f) return { 0, 0, 0 };
    Vector3 angles;
    angles.x = -atan2f(delta.z, sqrtf(delta.x * delta.x + delta.y * delta.y)) * (180.0f / 3.14159f);
    angles.y = atan2f(delta.y, delta.x) * (180.0f / 3.14159f);
    angles.z = 0;
    return angles;
}

float GetFov(Vector3 view_angle, Vector3 aim_angle) {
    Vector3 delta = aim_angle - view_angle;
    NormalizeAngles(delta);
    return sqrtf(delta.x * delta.x + delta.y * delta.y);
}

Vector3 GetBestTarget() {
    uintptr_t local = GetLocalPlayer();
    if (!local) return { 0, 0, 0 };

    Vector3 local_pos = GetEntityPos(local);
    if (local_pos.IsZero()) return { 0, 0, 0 };

    Vector3 local_angles = GetViewAngles();
    int local_team = GetEntityTeam(local);
    if (local_team < 0) return { 0, 0, 0 };

    uintptr_t client = GetClient();
    if (!client) return { 0, 0, 0 };
    if (!IsAddressReadable(client + OFFSET_ENTITY_COUNT, 4)) return { 0, 0, 0 };

    int entity_count = *(int*)(client + OFFSET_ENTITY_COUNT);
    if (entity_count < 1 || entity_count > 64) entity_count = 64;

    Vector3 best_angles = { 0, 0, 0 };
    float best_fov = g_settings.fov;
    bool found = false;

    for (int i = 1; i < entity_count; i++) {
        uintptr_t entity = GetEntityFromList(i);
        if (!IsValidEntity(entity)) continue;
        if (entity == local) continue;
        if (GetEntityTeam(entity) == local_team) continue;

        Vector3 head = GetBonePos(entity, 8);
        if (head.IsZero()) continue;

        Vector3 angles = CalcAngle(local_pos, head);
        float fov = GetFov(local_angles, angles);
        if (fov < best_fov) {
            best_fov = fov;
            best_angles = angles;
            found = true;
        }
    }
    return found ? best_angles : Vector3{ 0, 0, 0 };
}

void RunAimbot() {
    if (!g_settings.aimbot) return;

    Vector3 target_angle = GetBestTarget();
    if (target_angle.IsZero()) return;

    Vector3 local_angle = GetViewAngles();
    Vector3 delta = target_angle - local_angle;
    NormalizeAngles(delta);

    if (g_settings.smooth > 1.0f) {
        delta.x /= g_settings.smooth;
        delta.y /= g_settings.smooth;
    }

    Vector3 new_angle = local_angle + delta;
    NormalizeAngles(new_angle);
    ClampAngles(new_angle);

    if (g_settings.psilent) {
        SetViewAngles(new_angle);
    } else {
        SetViewAngles(new_angle);
    }
}

void RunTriggerbot() {
    if (!g_settings.trigger) return;

    auto now = steady_clock::now();
    auto elapsed = duration_cast<milliseconds>(now - g_last_shot).count();
    if (elapsed < g_settings.trigger_delay) return;

    uintptr_t local = GetLocalPlayer();
    if (!local) return;

    Vector3 local_angles = GetViewAngles();
    int local_team = GetEntityTeam(local);
    if (local_team < 0) return;

    uintptr_t client = GetClient();
    if (!client) return;
    if (!IsAddressReadable(client + OFFSET_ENTITY_COUNT, 4)) return;

    int entity_count = *(int*)(client + OFFSET_ENTITY_COUNT);
    if (entity_count < 1 || entity_count > 64) entity_count = 64;

    for (int i = 1; i < entity_count; i++) {
        uintptr_t entity = GetEntityFromList(i);
        if (!IsValidEntity(entity)) continue;
        if (entity == local) continue;
        if (GetEntityTeam(entity) == local_team) continue;

        Vector3 head = GetBonePos(entity, 8);
        if (head.IsZero()) continue;

        Vector3 angles = CalcAngle(GetEntityPos(local), head);
        float fov = GetFov(local_angles, angles);
        if (fov < 3.0f) {
            g_last_shot = now;
            return;
        }
    }
}

void RunAntiAim() {
    if (!g_settings.anti_aim) return;

    Vector3 angles = GetViewAngles();
    static float phase = 0.0f;

    if (g_settings.anti_aim_type == 0) {
        phase += 0.8f;
        if (phase > 180.0f) phase -= 360.0f;
        angles.x = 89.0f;
        angles.y += sinf(phase) * 30.0f;
    } else if (g_settings.anti_aim_type == 1) {
        phase += 6.0f;
        if (phase > 360.0f) phase -= 360.0f;
        angles.y = phase;
        angles.x = 89.0f;
    }

    SetViewAngles(angles);
}

void DrawESP() {
    if (!g_settings.esp) return;
    if (!g_imgui_init) return;
    if (ImGui::GetIO().DisplaySize.x <= 0) return;

    ImDrawList* draw = ImGui::GetBackgroundDrawList();
    if (!draw) return;

    uintptr_t local = GetLocalPlayer();
    if (!local) return;

    int local_team = GetEntityTeam(local);
    if (local_team < 0) return;

    uintptr_t client = GetClient();
    if (!client) return;
    if (!IsAddressReadable(client + OFFSET_ENTITY_COUNT, 4)) return;

    int entity_count = *(int*)(client + OFFSET_ENTITY_COUNT);
    if (entity_count < 1 || entity_count > 64) entity_count = 64;

    for (int i = 1; i < entity_count; i++) {
        uintptr_t entity = GetEntityFromList(i);
        if (!IsValidEntity(entity)) continue;
        if (entity == local) continue;
        if (GetEntityTeam(entity) == local_team) continue;

        Vector3 head = GetBonePos(entity, 8);
        Vector3 feet = GetEntityPos(entity);
        if (head.IsZero() || feet.IsZero()) continue;

        Vector3 screen_head, screen_feet;
        if (!WorldToScreen(head, screen_head)) continue;
        if (!WorldToScreen(feet, screen_feet)) continue;

        float height = screen_feet.y - screen_head.y;
        if (height < 1.0f) continue;
        float width = height * 0.6f;
        float x = screen_head.x - width * 0.5f;
        float y = screen_head.y;

        int health = GetEntityHealth(entity);
        float health_ratio = (float)health / 100.0f;
        if (health_ratio > 1.0f) health_ratio = 1.0f;
        if (health_ratio < 0.0f) health_ratio = 0.0f;
        ImColor color = ImColor((int)(255 * (1.0f - health_ratio)), (int)(255 * health_ratio), 0);

        if (g_settings.draw_boxes) {
            draw->AddRect(ImVec2(x, y), ImVec2(x + width, y + height), color);
            draw->AddRect(ImVec2(x - 1, y - 1), ImVec2(x + width + 1, y + height + 1), IM_COL32(0, 0, 0, 255));
        }

        if (g_settings.draw_health) {
            char text[64];
            sprintf_s(text, "%d HP", health);
            draw->AddText(ImVec2(x, y - 20), IM_COL32(255, 255, 255, 255), text);
        }

        if (g_settings.draw_distance) {
            float dist = (GetEntityPos(local) - feet).Length();
            char text[64];
            sprintf_s(text, "%.0fm", dist);
            draw->AddText(ImVec2(x + width + 5, y + height / 2), IM_COL32(200, 200, 200, 255), text);
        }

        if (g_settings.draw_name) {
            draw->AddText(ImVec2(x, y - 35), IM_COL32(255, 255, 255, 255), "Enemy");
        }
    }
}

void DrawWatermark() {
    if (!g_settings.watermark) return;
    if (!g_imgui_init) return;

    ImDrawList* draw = ImGui::GetBackgroundDrawList();
    if (!draw) return;

    char text[128];
    sprintf_s(text, "Internal | FPS: %.0f", ImGui::GetIO().Framerate);
    draw->AddText(ImVec2(10, 10), IM_COL32(0, 255, 0, 255), text);
}

void DrawMenu() {
    if (!g_menu_open) return;
    if (!g_imgui_init) return;

    ImGui::Begin("Internal", &g_menu_open, ImGuiWindowFlags_NoCollapse);

    if (ImGui::BeginTabBar("Tabs")) {
        if (ImGui::BeginTabItem("Rage")) {
            ImGui::Checkbox("Anti-Aim", &g_settings.anti_aim);
            ImGui::Combo("AA Type", &g_settings.anti_aim_type, "Jitter\0Spin\0");
            ImGui::Checkbox("PSilent", &g_settings.psilent);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Legit")) {
            ImGui::Checkbox("Aimbot", &g_settings.aimbot);
            ImGui::SliderFloat("Smooth", &g_settings.smooth, 1.0f, 30.0f);
            ImGui::SliderFloat("FOV", &g_settings.fov, 0.0f, 180.0f);
            ImGui::Checkbox("Triggerbot", &g_settings.trigger);
            ImGui::SliderInt("Trigger Delay", &g_settings.trigger_delay, 0, 200);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Visuals")) {
            ImGui::Checkbox("ESP", &g_settings.esp);
            ImGui::Checkbox("Boxes", &g_settings.draw_boxes);
            ImGui::Checkbox("Health", &g_settings.draw_health);
            ImGui::Checkbox("Distance", &g_settings.draw_distance);
            ImGui::Checkbox("Name", &g_settings.draw_name);
            ImGui::Checkbox("Watermark", &g_settings.watermark);
            ImGui::EndTabItem();
        }
        if (ImGui::BeginTabItem("Misc")) {
            ImGui::Checkbox("Bunnyhop", &g_settings.bunnyhop);
            ImGui::Checkbox("Logging", &g_settings.logging);
            ImGui::EndTabItem();
        }
        ImGui::EndTabBar();
    }

    ImGui::End();
}

HRESULT __stdcall hkPresent(IDXGISwapChain* pSwapChain, UINT Sync, UINT Flags) {
    __try {
        if (!g_device) {
            if (FAILED(pSwapChain->GetDevice(__uuidof(ID3D11Device), (void**)&g_device)))
                return oPresent(pSwapChain, Sync, Flags);
        }
        if (!g_context && g_device) g_device->GetImmediateContext(&g_context);
        if (!g_swapchain) g_swapchain = pSwapChain;

        if (g_device && g_context && !g_imgui_init && g_hwnd) {
            ImGui::CreateContext();
            ImGui::StyleColorsDark();
            ImGui_ImplWin32_Init(g_hwnd);
            ImGui_ImplDX11_Init(g_device, g_context);
            g_imgui_init = true;
        }

        if (g_imgui_init) {
            ImGui_ImplDX11_NewFrame();
            ImGui_ImplWin32_NewFrame();
            ImGui::NewFrame();

            DrawMenu();
            DrawESP();
            DrawWatermark();

            ImGui::Render();
            ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        return oPresent(pSwapChain, Sync, Flags);
    }

    return oPresent(pSwapChain, Sync, Flags);
}

LRESULT CALLBACK hkWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    if (msg == WM_KEYDOWN && wParam == g_settings.menu_key) {
        g_menu_open = !g_menu_open;
    }
    if (g_imgui_init) ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam);
    return CallWindowProc(oWndProc, hWnd, msg, wParam, lParam);
}

DWORD WINAPI MainThread(LPVOID) {
    AllocConsole();
    FILE* f;
    freopen_s(&f, "CONOUT$", "w", stdout);
    printf("[+] Loaded\n");
    printf("[!] Update offsets before use\n");

    g_hwnd = GetForegroundWindow();
    if (!g_hwnd) {
        FreeConsole();
        return 1;
    }

    if (!FindPatternModule("client.dll", "48 8B 05 ?? ?? ?? ?? 48 85 C0 74 ?? 48 8B 40 ??")) {
        printf("[-] client.dll not loaded\n");
        FreeConsole();
        return 1;
    }

    IDXGISwapChain* tmp_chain = nullptr;
    ID3D11Device* tmp_dev = nullptr;
    ID3D11DeviceContext* tmp_ctx = nullptr;
    DXGI_SWAP_CHAIN_DESC scd = {};
    scd.BufferCount = 1;
    scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    scd.BufferDesc.Width = 100;
    scd.BufferDesc.Height = 100;
    scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    scd.OutputWindow = g_hwnd;
    scd.SampleDesc.Count = 1;
    scd.Windowed = TRUE;
    scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

    if (FAILED(D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, 0, nullptr, 0, D3D11_SDK_VERSION, &scd, &tmp_chain, &tmp_dev, &tmp_ctx))) {
        printf("[-] Failed to create swapchain\n");
        FreeConsole();
        return 1;
    }

    void** vtable = *(void***)tmp_chain;
    oPresent = (PresentFn)vtable[8];
    tmp_chain->Release();
    tmp_dev->Release();
    if (tmp_ctx) tmp_ctx->Release();

    if (!oPresent) {
        printf("[-] Present is null\n");
        FreeConsole();
        return 1;
    }

    MH_Initialize();
    if (MH_CreateHook((LPVOID)oPresent, hkPresent, (LPVOID*)&oPresent) != MH_OK) {
        printf("[-] Hook failed\n");
        FreeConsole();
        return 1;
    }
    MH_EnableHook(MH_ALL_HOOKS);

    oWndProc = (WNDPROC)SetWindowLongPtr(g_hwnd, GWLP_WNDPROC, (LONG_PTR)hkWndProc);
    printf("[+] Ready\n");

    MSG msg;
    while (g_running) {
        while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
            if (msg.message == WM_QUIT) {
                g_running = false;
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        uintptr_t engine = GetEngine();
        if (engine && IsAddressReadable(engine + OFFSET_VIEW_MATRIX, sizeof(g_view_matrix))) {
            memcpy(g_view_matrix, (void*)(engine + OFFSET_VIEW_MATRIX), sizeof(g_view_matrix));
        }

        __try {
            RunAimbot();
            RunTriggerbot();
            RunAntiAim();
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
        }

        Sleep(5);
    }

    SetWindowLongPtr(g_hwnd, GWLP_WNDPROC, (LONG_PTR)oWndProc);
    MH_DisableHook(MH_ALL_HOOKS);
    MH_Uninitialize();
    if (g_imgui_init) {
        ImGui_ImplDX11_Shutdown();
        ImGui_ImplWin32_Shutdown();
        ImGui::DestroyContext();
    }
    FreeConsole();
    return 0;
}

BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID) {
    if (reason == DLL_PROCESS_ATTACH) {
        g_module = hModule;
        DisableThreadLibraryCalls(hModule);
        g_main_thread = CreateThread(nullptr, 0, MainThread, nullptr, 0, nullptr);
        if (g_main_thread) CloseHandle(g_main_thread);
    } else if (reason == DLL_PROCESS_DETACH) {
        g_running = false;
        Sleep(200);
    }
    return TRUE;
}