Crack Lua [NL] Ataraxia.pub [BETA] source leak

Начинающий
Статус
Оффлайн
Регистрация
29 Июн 2020
Сообщения
54
Реакции[?]
4
Поинты[?]
1K

Данный скрипт не проверялся модераторами, так как в нём присутствует обфускация. Даже известные пользователи могут внедрить вредоносы в скрипт, поэтому любое использование исключительно на свой страх и риск. Рекомендуем доверять проверенным скриптам с открытым исходным кодом.

if u need lite or live vers. source leak dm me: @keqx1
Код:
local AntiAim_GetCurrentRealRotation, AntiAim_GetInverterState, AntiAim_GetMaxDesyncDelta, AntiAim_GetMinDesyncDelta, AntiAim_OverrideInverter, AntiAim_OverrideLimit, AntiAim_OverrideYawOffset, bit_band, bit_bnot, bit_bor, bit_lshift, cheat_AddEvent, Cheat_AddNotify, cheat_AngleToForward, Cheat_AngleToForward, cheat_FireBullet, Cheat_GetBinds, Cheat_GetCheatUserName, Cheat_GetMousePos, Cheat_IsKeyDown, Cheat_IsMenuVisible, cheat_RegisterCallback, cheat_SetThirdPersonAnim, cheat_VectorToAngle, Cheat_VectorToAngle, Color_new, Color_RGBA, CVar_FindVar, EngineClient_GetScreenSize, EntityList_GetClientEntity, EntityList_GetLocalPlayer, EntityList_GetPlayer, EntityList_GetPlayerResource, ffi_cast, ffi_cdef, ffi_new, ffi_typeof, math_abs, math_ceil, math_clamp, math_cos, math_floor, math_lerp, math_max, math_min, math_normalize, math_rad, math_round, Menu_Combo, Menu_FindVar, Menu_SliderInt, Menu_Switch, print, pairs, RageBot_OverrideHitchance, Render_InitFont, string_format, table_insert, table_reference_condition, Utils_CreateInterface, Utils_CreateInterface, Utils_PatternScan, utils_RandomFloat, Vector_new, Vector2_new, fn, type, tonumber, error, condition, EngineClient_GetLocalPlayer, EngineClient_GetViewAngles, EngineClient_IsConnected, EngineClient_IsInGame, EngineTrace_TraceRay, EntityList_GetEntitiesByName, EntityList_GetPlayerForUserID, exploits_GetCharge, Exploits_OverrideDoubleTapSpeed, math_closest_point_on_ray, math_percent_to_pix, math_sin, math_vector_lerp, MatSystem_FirstMaterial, MatSystem_GetMaterial, MatSystem_NextMaterial, Menu_Button, Menu_ColorEdit, Menu_ComboColor, Menu_DestroyItem, Menu_MultiCombo, menu_SliderInt, menu_SwitchColor, Menu_SwitchColor, QAngle_new, Render_BoxFilled, Render_CalcTextSize, Render_Circle, Render_CircleFilled, Render_GradientBoxFilled, Render_Line, Render_PolyFilled, Render_Text, Render_WorldToScreen, table_remove, table_sort, unpack, Utils_RandomFloat, Utils_RandomInt, ipairs, pcall, tostring = AntiAim.GetCurrentRealRotation, AntiAim.GetInverterState, AntiAim.GetMaxDesyncDelta, AntiAim.GetMinDesyncDelta, AntiAim.OverrideInverter, AntiAim.OverrideLimit, AntiAim.OverrideYawOffset, bit.band, bit.bnot, bit.bor, bit.lshift, Cheat.AddEvent, Cheat.AddNotify, Cheat.AngleToForward, Cheat.AngleToForward, Cheat.FireBullet, Cheat.GetBinds, Cheat.GetCheatUserName, Cheat.GetMousePos, Cheat.IsKeyDown, Cheat.IsMenuVisible, Cheat.RegisterCallback, Cheat.SetThirdPersonAnim, Cheat.VectorToAngle, Cheat.VectorToAngle, Color.new, Color.RGBA, CVar.FindVar, EngineClient.GetScreenSize, EntityList.GetClientEntity, EntityList.GetLocalPlayer, EntityList.GetPlayer, EntityList.GetPlayerResource, ffi.cast, ffi.cdef, ffi.new, ffi.typeof, math.abs, math.ceil, math.clamp, math.cos, math.floor, math.lerp, math.max, math.min, math.normalize, math.rad, math.round, Menu.Combo, Menu.FindVar, Menu.SliderInt, Menu.Switch, print, pairs, RageBot.OverrideHitchance, Render.InitFont, string.format, table.insert, table.reference_condition, Utils.CreateInterface, Utils.CreateInterface, Utils.PatternScan, Utils.RandomFloat, Vector.new, Vector2.new, fn, type, tonumber, error, condition, EngineClient.GetLocalPlayer, EngineClient.GetViewAngles, EngineClient.IsConnected, EngineClient.IsInGame, EngineTrace.TraceRay, EntityList.GetEntitiesByName, EntityList.GetPlayerForUserID, Exploits.GetCharge, Exploits.OverrideDoubleTapSpeed, math.closest_point_on_ray, math.percent_to_pix, math.sin, math.vector_lerp, MatSystem.FirstMaterial, MatSystem.GetMaterial, MatSystem.NextMaterial, Menu.Button, Menu.ColorEdit, Menu.ComboColor, Menu.DestroyItem, Menu.MultiCombo, Menu.SliderInt, Menu.SwitchColor, Menu.SwitchColor, QAngle.new, Render.BoxFilled, Render.CalcTextSize, Render.Circle, Render.CircleFilled, Render.GradientBoxFilled, Render.Line, Render.PolyFilled, Render.Text, Render.WorldToScreen, table.remove, table.sort, unpack, Utils.RandomFloat, Utils.RandomInt, ipairs, pcall, tostring
local Render_GetMenuPos = Render.GetMenuPos
local Render_GetMenuSize = Render.GetMenuSize
--[[
    @module Ataraxia
    @build alpha
    @author Aslier
    @lastupdatetime 2022/5/5
]]
local cat = [[
        $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%$$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$'''''')$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$C''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''#$$$$$$$$$$$$$$$$$$$$$''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$'''''''''''''''''!pU/))))/Ym)'''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$o''''''''''''''''''''''''''''''''''''''''''''''j$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''w$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
        $$!'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$
        $$$$$$$$$t'''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
        $$$$$$$www''''''''''''''''''''''''''''''''''''''''''''''''''www8$$$$$$$$$$$$$$$$
        $$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$/'''''''''''''''''''''''''''''''''''''''''''':$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$$$i'''''''''''''''''''''''''''''''''''''''''$$$$qf!:!?L$$$$$$$$$$$$$
        $$$$$$$$$$$$$$$$$W''''''''''''''''''''''''''''''''''Z$$@''''''''''''''''$$$$$$$$
        $$$$$$$$$$$$$$$$$$$$$$$U''''''''''''''''''''''x@$$$$$$'''''''$$$$$$$$$''''$$$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$$a''''''''''''''|$$$$$$$$$$'''''$$$$$$$$$$$$''''''$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''$$$$$$$$$;''''$$$$$$$$$$$$$$d''''$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$p''''''''''''''''{$$$$$$$$-''''B$$$$$$Y''`$$$$'''''8$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$''''''''''''''''''Q$$$$$$$$''''''''''''''''$$$n''''{$$
        $$$$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''''''''$$$$$$$$f''''''''''''/$$$$+'''']$$
        $$$$$$$$$$$$$$$$$$$$$$$o''''''''''''''''''''''/$$$$$$$$$$$t<;?w$$$$$$$$$'''''0$$
        $$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$$,'''''$$$
        $$$$$$$$$$$$$$$$$$$$$h''''''''''''''''''''''''''|$$$$$$$$$$$$$$$$$$$$$''''''$$$$
        $$$$$$$$$$$$$$$$$$$$L''''''''''''''''''''''''''''~$$$$$$$$$$$$$$$$$&'''''''B$$$$
        $$$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''$$$$$$$$$$$$$$C''''''''-$$$$$$
        $$$$$$$$$$$$$$$$$$$<'''''''''''''''''''''''''''''''$$$$$$$$$<''''''''''>$$$$$$$$
        $$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''B$$$$$$$$$$
        $$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''|$$$$$$$$$$$$$$
        $$$$$$$$$$$$$$$$$$$8''''''''''''''''''''''''''''''''''''''\#$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%$$$$$$$$$$$$$$$$$$$$$$$

]]

local _ataraxia_ = function()
    local userdata = {
        username = Cheat_GetCheatUserName(),
        build = "beta",
        last_updatetime = "22/5/29"
    }
    local ffi = require('ffi')
    local bit = require "bit"

    ffi_cdef [[
        typedef struct {
            uint8_t r;
            uint8_t g;
            uint8_t b;
            uint8_t a;
        } color_struct_t;
    
        typedef void (__cdecl* console_color_print)(void*,const color_struct_t&, const char*, ...);

        typedef float*(__thiscall* bound)(void*);

        typedef int(__thiscall* get_clipboard_text_count)(void*);
        typedef void(__thiscall* set_clipboard_text)(void*, const char*, int);
        typedef void(__thiscall* get_clipboard_text)(void*, int, const char*, int);
        typedef int(__fastcall* clantag_t)(const char*, const char*);
    ]]

    ffi_cdef[[

    void* GetProcAddress(void* hModule, const char* lpProcName);
    void* GetModuleHandleA(const char* lpModuleName);

    typedef uintptr_t (__thiscall* GetClientEntity_4242425_t)(void*, int);
    struct Animstate_t
    {
            char pad[3];
            char m_bForceWeaponUpdate;
            char pad1[91];
            void* m_pBaseEntity;
            void* m_pActiveWeapon;
            void* m_pLastActiveWeapon;
            float m_flLastClientSideAnimationUpdateTime;
            int m_iLastClientSideAnimationUpdateFramecount;
            float m_flAnimUpdateDelta;
            float m_flEyeYaw;
            float m_flPitch;
            float m_flGoalFeetYaw;
            float m_flCurrentFeetYaw;
            float m_flCurrentTorsoYaw;
            float m_flUnknownVelocityLean;
            float m_flLeanAmount;
            char pad2[4];
            float m_flFeetCycle;
            float m_flFeetYawRate;
            char pad3[4];
            float m_fDuckAmount;
            float m_fLandingDuckAdditiveSomething;
            char pad4[4];
            float m_vOriginX;
            float m_vOriginY;
            float m_vOriginZ;
            float m_vLastOriginX;
            float m_vLastOriginY;
            float m_vLastOriginZ;
            float m_vVelocityX;
            float m_vVelocityY;
            char pad5[4];
            float m_flUnknownFloat1;
            char pad6[8];
            float m_flUnknownFloat2;
            float m_flUnknownFloat3;
            float m_flUnknown;
            float m_flSpeed2D;
            float m_flUpVelocity;
            float m_flSpeedNormalized;
            float m_flFeetSpeedForwardsOrSideWays;
            float m_flFeetSpeedUnknownForwardOrSideways;
            float m_flTimeSinceStartedMoving;
            float m_flTimeSinceStoppedMoving;
            bool m_bOnGround;
            bool m_bInHitGroundAnimation;
            float m_flTimeSinceInAir;
            float m_flLastOriginZ;
            float m_flHeadHeightOrOffsetFromHittingGroundAnimation;
            float m_flStopToFullRunningFraction;
            char pad7[4];
            float m_flMagicFraction;
            char pad8[60];
            float m_flWorldForce;
            char pad9[462];
            float m_flMaxYaw;
        };

        int VirtualProtect(void* lpAddress, unsigned long dwSize, unsigned long flNewProtect, unsigned long* lpflOldProtect);
        void* VirtualAlloc(void* lpAddress, unsigned long dwSize, unsigned long  flAllocationType, unsigned long flProtect);
        int VirtualFree(void* lpAddress, unsigned long dwSize, unsigned long dwFreeType);

        typedef uintptr_t (__thiscall* GetClientEntity_4242425_t)(void*, int);
        typedef struct
        {
            float x;
            float y;
            float z;
        } Vector_t;

        typedef struct
        {
            char    pad0[0x60]; // 0x00
            void* pEntity; // 0x60
            void* pActiveWeapon; // 0x64
            void* pLastActiveWeapon; // 0x68
            float        flLastUpdateTime; // 0x6C
            int            iLastUpdateFrame; // 0x70
            float        flLastUpdateIncrement; // 0x74
            float        flEyeYaw; // 0x78
            float        flEyePitch; // 0x7C
            float        flGoalFeetYaw; // 0x80
            float        flLastFeetYaw; // 0x84
            float        flMoveYaw; // 0x88
            float        flLastMoveYaw; // 0x8C // changes when moving/jumping/hitting ground
            float        flLeanAmount; // 0x90
            char    pad1[0x4]; // 0x94
            float        flFeetCycle; // 0x98 0 to 1
            float        flMoveWeight; // 0x9C 0 to 1
            float        flMoveWeightSmoothed; // 0xA0
            float        flDuckAmount; // 0xA4
            float        flHitGroundCycle; // 0xA8
            float        flRecrouchWeight; // 0xAC
            Vector_t        vecOrigin; // 0xB0
            Vector_t        vecLastOrigin;// 0xBC
            Vector_t        vecVelocity; // 0xC8
            Vector_t        vecVelocityNormalized; // 0xD4
            Vector_t        vecVelocityNormalizedNonZero; // 0xE0
            float        flVelocityLenght2D; // 0xEC
            float        flJumpFallVelocity; // 0xF0
            float        flSpeedNormalized; // 0xF4 // clamped velocity from 0 to 1
            float        flRunningSpeed; // 0xF8
            float        flDuckingSpeed; // 0xFC
            float        flDurationMoving; // 0x100
            float        flDurationStill; // 0x104
            bool        bOnGround; // 0x108
            bool        bHitGroundAnimation; // 0x109
            char    pad2[0x2]; // 0x10A
            float        flNextLowerBodyYawUpdateTime; // 0x10C
            float        flDurationInAir; // 0x110
            float        flLeftGroundHeight; // 0x114
            float        flHitGroundWeight; // 0x118 // from 0 to 1, is 1 when standing
            float        flWalkToRunTransition; // 0x11C // from 0 to 1, doesnt change when walking or crouching, only running
            char    pad3[0x4]; // 0x120
            float        flAffectedFraction; // 0x124 // affected while jumping and running, or when just jumping, 0 to 1
            char    pad4[0x208]; // 0x128
            float        flMinBodyYaw; // 0x330
            float        flMaxBodyYaw; // 0x334
            float        flMinPitch; //0x338
            float        flMaxPitch; // 0x33C
            int            iAnimsetVersion; // 0x340
        } CCSGOPlayerAnimationState_534535_t;

        typedef struct {
            char  pad_0000[20];
            int m_nOrder; //0x0014
            int m_nSequence; //0x0018
            float m_flPrevCycle; //0x001C
            float m_flWeight; //0x0020
            float m_flWeightDeltaRate; //0x0024
            float m_flPlaybackRate; //0x0028
            float m_flCycle; //0x002C
            void *m_pOwner; //0x0030
            char  pad_0038[4]; //0x0034
        } CAnimationLayer_t;
    ]]

    ffi_cdef([[
        typedef struct
        {
            void* steam_client;
            void* steam_user;
            void* steam_friends;
            void* steam_utils;
            void* steam_matchmaking;
            void* steam_user_stats;
            void* steam_apps;
            void* steam_matchmakingservers;
            void* steam_networking;
            void* steam_remotestorage;
            void* steam_screenshots;
            void* steam_http;
            void* steam_unidentifiedmessages;
            void* steam_controller;
            void* steam_ugc;
            void* steam_applist;
            void* steam_music;
            void* steam_musicremote;
            void* steam_htmlsurface;
            void* steam_inventory;
            void* steam_video;
        } S_steamApiCtx_t;
    ]])

    ffi_cdef[[
        void* CreateFileA(
            const char*                lpFileName,
            unsigned long                 dwDesiredAccess,
            unsigned long                 dwShareMode,
            unsigned long lpSecurityAttributes,
            unsigned long                 dwCreationDisposition,
            unsigned long                 dwFlagsAndAttributes,
            void*                hTemplateFile
            );
        bool ReadFile(
                void*       hFile,
                char*       lpBuffer,
                unsigned long        nNumberOfBytesToRead,
                unsigned long*      lpNumberOfBytesRead,
                int lpOverlapped
                );
        bool WriteFile(
                void*       hFile,
                char*      lpBuffer,
                unsigned long        nNumberOfBytesToWrite,
                unsigned long*      lpNumberOfBytesWritten,
                void* lpOverlapped
            );
        bool DeleteFileA(
            const char* lpFileName
        );

        unsigned long GetFileSize(
            void*  hFile,
            unsigned long* lpFileSizeHigh
        );
        bool CreateDirectoryA(
            const char*                lpPathName,
            void* lpSecurityAttributes
        );
        void* CloseHandle(void *hFile);
        typedef int(__fastcall* clantag_t)(const char*, const char*);

        typedef struct _OVERLAPPED {
            unsigned long* Internal;
            unsigned long* InternalHigh;
            union {
                struct {
                unsigned long Offset;
                unsigned long OffsetHigh;
                } DUMMYSTRUCTNAME;
                void* Pointer;
            } DUMMYUNIONNAME;
            void*    hEvent;
            } OVERLAPPED, *LPOVERLAPPED;

        typedef struct _class
        {
            void** this;
        }aclass;
    ]]

    ffi.C.CreateDirectoryA("nl\\ataraxia", nil)

    local pS_SteamApiCtx = ffi.cast(
        "S_steamApiCtx_t**", ffi.cast(
            "char*",
            Utils.PatternScan(
                "client.dll",
                "FF 15 ?? ?? ?? ?? B9 ?? ?? ?? ?? E8 ?? ?? ?? ?? 6A"
            )
        ) + 7
    )[0] or error("invalid interface", 2)

    local Png = {}
Png.__index = Png
local png_ihdr_t = ffi.typeof([[
struct {
    char type[4];
    uint32_t width;
    uint32_t height;
    char bitDepth;
    char colorType;
    char compression;
    char filter;
    char interlace;
} *
]])

local jpg_segment_t = ffi.typeof([[
struct {
    char type[2];
    uint16_t size;
} *
]])

local jpg_segment_sof0_t = ffi.typeof([[
struct {
    uint16_t size;
    char precision;
    uint16_t height;
    uint16_t width;
} __attribute__((packed)) *
]])

local uint16_t_ptr = ffi.typeof("uint16_t*")
local charbuffer = ffi.typeof("unsigned char[?]")
local uintbuffer = ffi.typeof("unsigned int[?]")

--
-- constants
--

local INVALID_TEXTURE = -1
local PNG_MAGIC = "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"

local JPG_MAGIC_1 = "\xFF\xD8\xFF\xDB"
local JPG_MAGIC_2 = "\xFF\xD8\xFF\xE0\x00\x10\x4A\x46\x49\x46\x00\x01"

local JPG_SEGMENT_SOI = "\xFF\xD8"
local JPG_SEGMENT_SOF0 = "\xFF\xC0"
local JPG_SEGMENT_SOS = "\xFF\xDA"
local JPG_SEGMENT_EOI = "\xFF\xD9"



local DEFLATE_MAX_BLOCK_SIZE = 65535

local function putBigUint32(val, tbl, index)
    for i=0,3 do
        tbl[index + i] = bit.band(bit.rshift(val, (3 - i) * 8), 0xFF)
    end
end

function Png:writeBytes(data, index, len)
    index = index or 1
    len = len or #data
    for i=index,index+len-1 do
        table.insert(self.output, string.char(data[i]))
    end
end

function Png:write(pixels)
    local count = #pixels  -- Byte count
    local pixelPointer = 1
    while count > 0 do
        if self.positionY >= self.height then
            error("All image pixels already written")
        end

        if self.deflateFilled == 0 then -- Start DEFLATE block
            local size = DEFLATE_MAX_BLOCK_SIZE;
            if (self.uncompRemain < size) then
                size = self.uncompRemain
            end
            local header = {  -- 5 bytes long
                bit.band((self.uncompRemain <= DEFLATE_MAX_BLOCK_SIZE and 1 or 0), 0xFF),
                bit.band(bit.rshift(size, 0), 0xFF),
                bit.band(bit.rshift(size, 8), 0xFF),
                bit.band(bit.bxor(bit.rshift(size, 0), 0xFF), 0xFF),
                bit.band(bit.bxor(bit.rshift(size, 8), 0xFF), 0xFF),
            }
            self:writeBytes(header)
            self:crc32(header, 1, #header)
        end
        assert(self.positionX < self.lineSize and self.deflateFilled < DEFLATE_MAX_BLOCK_SIZE);

        if (self.positionX == 0) then  -- Beginning of line - write filter method byte
            local b = {0}
            self:writeBytes(b)
            self:crc32(b, 1, 1)
            self:adler32(b, 1, 1)
            self.positionX = self.positionX + 1
            self.uncompRemain = self.uncompRemain - 1
            self.deflateFilled = self.deflateFilled + 1
        else -- Write some pixel bytes for current line
            local n = DEFLATE_MAX_BLOCK_SIZE - self.deflateFilled;
            if (self.lineSize - self.positionX < n) then
                n = self.lineSize - self.positionX
            end
            if (count < n) then
                n = count;
            end
            assert(n > 0);

            self:writeBytes(pixels, pixelPointer, n)

            -- Update checksums
            self:crc32(pixels, pixelPointer, n);
            self:adler32(pixels, pixelPointer, n);

            -- Increment positions
            count = count - n;
            pixelPointer = pixelPointer + n;
            self.positionX = self.positionX + n;
            self.uncompRemain = self.uncompRemain - n;
            self.deflateFilled = self.deflateFilled + n;
        end

        if (self.deflateFilled >= DEFLATE_MAX_BLOCK_SIZE) then
            self.deflateFilled = 0; -- End current block
        end

        if (self.positionX == self.lineSize) then  -- Increment line
            self.positionX = 0;
            self.positionY = self.positionY + 1;
            if (self.positionY == self.height) then -- Reached end of pixels
                local footer = {  -- 20 bytes long
                    0, 0, 0, 0,  -- DEFLATE Adler-32 placeholder
                    0, 0, 0, 0,  -- IDAT CRC-32 placeholder
                    -- IEND chunk
                    0x00, 0x00, 0x00, 0x00,
                    0x49, 0x45, 0x4E, 0x44,
                    0xAE, 0x42, 0x60, 0x82,
                }
                putBigUint32(self.adler, footer, 1)
                self:crc32(footer, 1, 4)
                putBigUint32(self.crc, footer, 5)
                self:writeBytes(footer)
                self.done = true
            end
        end
    end
end

function Png:crc32(data, index, len)
    self.crc = bit.bnot(self.crc)
    for i=index,index+len-1 do
        local byte = data[i]
        for j=0,7 do  -- Inefficient bitwise implementation, instead of table-based
            local nbit = bit.band(bit.bxor(self.crc, bit.rshift(byte, j)), 1);
            self.crc = bit.bxor(bit.rshift(self.crc, 1), bit.band((-nbit), 0xEDB88320));
        end
    end
    self.crc = bit.bnot(self.crc)
end
function Png:adler32(data, index, len)
    local s1 = bit.band(self.adler, 0xFFFF)
    local s2 = bit.rshift(self.adler, 16)
    for i=index,index+len-1 do
        s1 = (s1 + data[i]) % 65521
        s2 = (s2 + s1) % 65521
    end
    self.adler = bit.bor(bit.lshift(s2, 16), s1)
end

local function begin(width, height, colorMode)
    -- Default to rgb
    colorMode = colorMode or "rgb"

    -- Determine bytes per pixel and the PNG internal color type
    local bytesPerPixel, colorType
    if colorMode == "rgb" then
        bytesPerPixel, colorType = 3, 2
    elseif colorMode == "rgba" then
        bytesPerPixel, colorType = 4, 6
    else
        error("Invalid colorMode")
    end

    local state = setmetatable({ width = width, height = height, done = false, output = {} }, Png)

    -- Compute and check data siezs
    state.lineSize = width * bytesPerPixel + 1
    -- TODO: check if lineSize too big

    state.uncompRemain = state.lineSize * height

    local numBlocks = math.ceil(state.uncompRemain / DEFLATE_MAX_BLOCK_SIZE)

    -- 5 bytes per DEFLATE uncompressed block header, 2 bytes for zlib header, 4 bytes for zlib Adler-32 footer
    local idatSize = numBlocks * 5 + 6
    idatSize = idatSize + state.uncompRemain;

    -- TODO check if idatSize too big

    local header = {  -- 43 bytes long
        -- PNG header
        0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
        -- IHDR chunk
        0x00, 0x00, 0x00, 0x0D,
        0x49, 0x48, 0x44, 0x52,
        0, 0, 0, 0,  -- 'width' placeholder
        0, 0, 0, 0,  -- 'height' placeholder
        0x08, colorType, 0x00, 0x00, 0x00,
        0, 0, 0, 0,  -- IHDR CRC-32 placeholder
        -- IDAT chunk
        0, 0, 0, 0,  -- 'idatSize' placeholder
        0x49, 0x44, 0x41, 0x54,
        -- DEFLATE data
        0x08, 0x1D,
    }
    putBigUint32(width, header, 17)
    putBigUint32(height, header, 21)
    putBigUint32(idatSize, header, 34)

    state.crc = 0
    state:crc32(header, 13, 17)
    putBigUint32(state.crc, header, 30)
    state:writeBytes(header)

    state.crc = 0
    state:crc32(header, 38, 6);  -- 0xD7245B6B
    state.adler = 1

    state.positionX = 0
    state.positionY = 0
    state.deflateFilled = 0

    return state
end


    local native_ISteamFriends = ffi.cast("void***", pS_SteamApiCtx.steam_friends)
    
    local native_ISteamUtils = ffi.cast("void***", pS_SteamApiCtx.steam_utils)

    local native_ISteamFriends_GetSmallFriendAvatar = ffi.cast("int(__thiscall*)(void*, uint64_t)" ,native_ISteamFriends[0][34] )

    local native_ISteamUtils_GetImageSize = ffi.cast("bool(__thiscall*)(void*, int, uint32_t*, uint32_t*)" , native_ISteamUtils[0][5])

    local native_ISteamUtils_GetImageRGBA =  ffi.cast("bool(__thiscall*)(void*, int, unsigned char*, int)" , native_ISteamUtils[0][6])
    
    local VGUI_System010 = Utils_CreateInterface("vgui2.dll", "VGUI_System010") or print("Error finding VGUI_System010")

    local VGUI_System = ffi.cast(ffi.typeof('void***'), VGUI_System010)

    local cvar_interface = ffi_cast(ffi.typeof("uintptr_t**"), Utils_CreateInterface("vstdlib.dll", "VEngineCvar007")) or error ("Fail")

    local color_print_fn = ffi.cast("console_color_print", cvar_interface[0][25]) or error ("Fail")
    
    local function vtable_thunk(index, typedef)
        return function(v0, ...)
            local instance = ffi.cast(ffi.typeof('void***'), v0)
    
            local tdef = nil
    
            if seen[typedef] then
                tdef = seen[typedef]
            else
                tdef = ffi.typeof(typedef)
    
                seen[typedef] = tdef
            end
    
            return ffi.cast(tdef, instance[0][index])(instance, ...)
        end
    end
    
    local function vtable_bind(interface, index, typedef)
        local instance = ffi.cast('void***', interface);
    
        return function(...)
            return ffi.cast(typedef, instance[0][index])(instance, ...)
        end
    end
    local entity_list_pointer = ffi.cast("void***", Utils.CreateInterface("client.dll", "VClientEntityList003"))
    local get_client_entity_fn = ffi.cast("GetClientEntity_4242425_t", entity_list_pointer[0][3])
    local get_entity_address = function(ent_index)
        local addr = get_client_entity_fn(entity_list_pointer, ent_index)
        return addr
    end

    local hook_helpers = {
        copy = function(dst, src, len)
            return ffi.copy(ffi.cast('void*', dst), ffi.cast('const void*', src), len)
        end,

        virtual_protect = function(lpAddress, dwSize, flNewProtect, lpflOldProtect)
            return ffi.C.VirtualProtect(ffi.cast('void*', lpAddress), dwSize, flNewProtect, lpflOldProtect)
        end,

        virtual_alloc = function(lpAddress, dwSize, flAllocationType, flProtect, blFree)
            local alloc = ffi.C.VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
            if blFree then
                table.insert(buff.free, function()
                    ffi.C.VirtualFree(alloc, 0, 0x8000)
                end)
            end
            return ffi.cast('intptr_t', alloc)
        end
    }
    local buff = {free = {}}
    local vmt_hook = {hooks = {}}


    function vmt_hook.new(vt)
        local new_hook = {}
        local org_func = {}
        local old_prot = ffi.new('unsigned long[1]')
        local virtual_table = ffi.cast('intptr_t**', vt)[0]

        new_hook.this = virtual_table
        new_hook.hookMethod = function(cast, func, method)
            org_func[method] = virtual_table[method]
            hook_helpers.virtual_protect(virtual_table + method, 4, 0x4, old_prot)

            virtual_table[method] = ffi.cast('intptr_t', ffi.cast(cast, func))
            hook_helpers.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)

            return ffi.cast(cast, org_func[method])
        end

        new_hook.unHookMethod = function(method)
            hook_helpers.virtual_protect(virtual_table + method, 4, 0x4, old_prot)
            local alloc_addr = hook_helpers.virtual_alloc(nil, 5, 0x1000, 0x40, false)
            local trampoline_bytes = ffi.new('uint8_t[?]', 5, 0x90)

            trampoline_bytes[0] = 0xE9
            ffi.cast('int32_t*', trampoline_bytes + 1)[0] = org_func[method] - tonumber(alloc_addr) - 5

            hook_helpers.copy(alloc_addr, trampoline_bytes, 5)
            virtual_table[method] = ffi.cast('intptr_t', alloc_addr)

            hook_helpers.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)
            org_func[method] = nil
        end

        new_hook.unHookAll = function()
            for method, func in pairs(org_func) do
                new_hook.unHookMethod(method)
            end
        end

        table.insert(vmt_hook.hooks, new_hook.unHookAll)
        return new_hook
    end


    local hooked_function = nil
    local is_jumping = false
    local display_duration = 2
    local speed = 1
    local check_headshot = false
    local get_fake_amount = 0
    local noti_table = {}
    local sc_x,sc_y = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
    local M = {}
    
    local JSON = Panorama.LoadString([[
        return {
            stringify: JSON.stringify,
            parse: JSON.parse
        };
    ]])()

    local shl, shr, band = bit.lshift, bit.rshift, bit.band
    local char, byte, gsub, sub, format, concat, tostring, error, pairs = string.char, string.byte, string.gsub, string.sub, string.format, table.concat, tostring, error, pairs

    local extract = function(v, from, width)
        return band(shr(v, from), shl(1, width) - 1)
    end

    local function makeencoder(alphabet)
        local encoder, decoder = {}, {}
        for i=1, 65 do
            local chr = byte(sub(alphabet, i, i)) or 32 -- or " "
            if decoder[chr] ~= nil then
                error("invalid alphabet: duplicate character " .. tostring(chr), 3)
            end
            encoder[i-1] = chr
            decoder[chr] = i-1
        end
        return encoder, decoder
    end

    local encoders, decoders = {}, {}

    encoders["base64"], decoders["base64"] = makeencoder("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=")
    encoders["base64url"], decoders["base64url"] = makeencoder("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")

    local alphabet_mt = {
        __index = function(tbl, key)
            if type(key) == "string" and key:len() == 64 or key:len() == 65 then
                -- if key is a valid looking base64 alphabet, try to make an encoder/decoder pair from it
                encoders[key], decoders[key] = makeencoder(key)
                return tbl[key]
            end
        end
    }

    setmetatable(encoders, alphabet_mt)
    setmetatable(decoders, alphabet_mt)

    function M.encode(str, encoder)
        encoder = encoders[encoder or "base64"] or error("invalid alphabet specified", 2)

        str = tostring(str)

        local t, k, n = {}, 1, #str
        local lastn = n % 3
        local cache = {}

        for i = 1, n-lastn, 3 do
            local a, b, c = byte(str, i, i+2)
            local v = a*0x10000 + b*0x100 + c
            local s = cache[v]

            if not s then
                s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)])
                cache[v] = s
            end

            t[k] = s
            k = k + 1
        end

        if lastn == 2 then
            local a, b = byte(str, n-1, n)
            local v = a*0x10000 + b*0x100
            t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[64])
        elseif lastn == 1 then
            local v = byte(str, n)*0x10000
            t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[64], encoder[64])
        end

        return concat(t)
    end

    function M.decode(b64, decoder)
        decoder = decoders[decoder or "base64"] or error("invalid alphabet specified", 2)

        local pattern = "[^%w%+%/%=]"
        if decoder then
            local s62, s63
            for charcode, b64code in pairs(decoder) do
                if b64code == 62 then s62 = charcode
                elseif b64code == 63 then s63 = charcode
                end
            end
            pattern = format("[^%%w%%%s%%%s%%=]", char(s62), char(s63))
        end

        b64 = gsub(tostring(b64), pattern, '')

        local cache = {}
        local t, k = {}, 1
        local n = #b64
        local padding = sub(b64, -2) == "==" and 2 or sub(b64, -1) == "=" and 1 or 0

        for i = 1, padding > 0 and n-4 or n, 4 do
            local a, b, c, d = byte(b64, i, i+3)

            local v0 = a*0x1000000 + b*0x10000 + c*0x100 + d
            local s = cache[v0]
            if not s then
                local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d]
                s = char(extract(v,16,8), extract(v,8,8), extract(v,0,8))
                cache[v0] = s
            end

            t[k] = s
            k = k + 1
        end

        if padding == 1 then
            local a, b, c = byte(b64, n-3, n-1)
            local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40
            t[k] = char(extract(v,16,8), extract(v,8,8))
        elseif padding == 2 then
            local a, b = byte(b64, n-3, n-2)
            local v = decoder[a]*0x40000 + decoder[b]*0x1000
            t[k] = char(extract(v,16,8))
        end
        return concat(t)
    end

    local get_clipboard_text_count = ffi.cast("get_clipboard_text_count", VGUI_System[0][7]) or print("get_clipboard_text_count Invalid")

    local set_clipboard_text = ffi.cast("set_clipboard_text", VGUI_System[0][9]) or print("set_clipboard_text Invalid")

    local get_clipboard_text = ffi.cast("get_clipboard_text", VGUI_System[0][11]) or print("get_clipboard_text Invalid")

    local function str_to_sub(input, sep)
        local t = {}
    
        for str in string.gmatch(input, "([^" .. sep .. "]+)") do
            t[#t + 1] = string.gsub(str, "\n", "")
        end
    
        return t
    end

    local ffi_handler = {}
    ffi_handler.bind_argument = function(fn, arg)
        return function(...)
            return fn(arg, ...)
        end
    end

    ffi_handler.interface_type = ffi_typeof("uintptr_t**")

    ffi_handler.vgui_system = ffi_cast(ffi_handler.interface_type, Utils.CreateInterface("vgui2.dll", "VGUI_System010"))

    ffi_handler.get_clipboard_text_count = ffi_handler.bind_argument(ffi.cast("int(__thiscall*)(void*)", ffi_handler.vgui_system[0][7]), ffi_handler.vgui_system)
    ffi_handler.set_clipboard_text = ffi_handler.bind_argument(ffi.cast("void(__thiscall*)(void*, const char*, int)", ffi_handler.vgui_system[0][9]), ffi_handler.vgui_system)
    ffi_handler.get_clipboard_text_fn = ffi_handler.bind_argument(ffi.cast("void(__thiscall*)(void*, int, const char*, int)", ffi_handler.vgui_system[0][11]), ffi_handler.vgui_system)

    ffi_handler.clipboard_import = function()
        local clipboard_text_length = ffi_handler.get_clipboard_text_count()
    
        if clipboard_text_length > 0 then
            local buffer = ffi.new("char[?]", clipboard_text_length)
            local size = clipboard_text_length * ffi.sizeof("char[?]", clipboard_text_length)
        
            ffi_handler.get_clipboard_text_fn(0, buffer, size )
        
            return ffi.string( buffer, clipboard_text_length-1)
        end
    
        return ""
    end

    local function clipboard_export(string)
        if string then
            set_clipboard_text(VGUI_System, string, string:len())
        end
    end

    local debugger = function(...)
        local color_print = function(color,tel)
            if color == nil then
                return
            end
    
            local col = ffi.new("color_struct_t")
            col.r = color.r * 255
            col.g = color.g * 255
            col.b = color.b * 255
            col.a = color.a * 255
            color_print_fn(cvar_interface, col, tel)
        end
        local r,g,b,a = 224/255,159/255,154/255,1

        color_print(Color_new(r,g,b,a),"[Ataraxia] ")
        print(...)
    end
    local ui_reference = function(tab1,tab2,tab3,tab4)
        return Menu_FindVar(tab1,tab2,tab3,tab4)
    end

    local ui_set = function(type,elements,val,state)
        if type == "value" then
            return elements:Set(val)
        elseif type == "bool" then
            return elements:SetBool(val,state)
        end
    end

    local ui_get = function(type,elements,val)
        if type == "value" then
            return elements:Get()
        elseif type == "color" then
            local r,g,b,a = elements:GetColor().r,elements:GetColor().g,elements:GetColor().b,elements:GetColor().a
            
            return {r = r ,g = g,b = b,a = a }
        elseif type == "bool" then
            return elements:GetBool(val)
        end
    end
    
    local ui_set_visible = function(elements,val)
        return elements:SetVisible(val)
    end

    local ui_set_callback = function(elements,val)
        return elements:RegisterCallback(val)
    end

    local ui_new_multiselect = function(tab1,tab2,elements,combo,val,tooltips)
        return Menu_MultiCombo(tab1,tab2,elements,combo,val,tooltips)
    end

    local ui_new_combobox = function(tab1,tab2,elements,combo,val,tooltips)
        return Menu_Combo(tab1,tab2,elements,combo,val,tooltips)
    end

    local ui_new_colorpicker = function(tab1,tab2,elements,r,g,b,a,tooltips)
        return Menu_ColorEdit(tab1,tab2,elements,Color_RGBA(r,g,b,a),tooltips)
    end

    local ui_new_textbox = function(tab1,tab2,elements,max_size,val,tooltips)
        return Menu.TextBox(tab1,tab2,elements,max_size,val,tooltips)
    end
    
    local ui_new_label = function(tab1,tab2,elements)
        return Menu.Text(tab1,tab2,elements)
    end
    
    local ui_new_checkbox = function(type,tab1,tab2,elements,states,tooltips,r,g,b,a)
        if type == "bool" then
            return Menu_Switch(tab1,tab2,elements,states,tooltips)
        elseif type == "color" then
            return Menu_SwitchColor(tab1,tab2,elements,states,Color_RGBA(r,g,b,a),tooltips)
        end
    end

    local ui_new_slider = function(type,tab1,tab2,elements,min,max,val,tooltips)
        if type == "int" then
            return Menu_SliderInt(tab1,tab2,elements,val,min,max,tooltips)
        elseif type == "float" then
            return Menu.SliderFloat(tab1,tab2,elements,val,min,max,tooltips)
        end
    end

    local client_set_event_callback = function(events,func)
        return cheat_RegisterCallback(events,func)
    end

    local entity_get_prop = function(inx,prop)
        return inx:GetProp(prop)
    end

    local entity_get_localplayer = function()
        return EntityList_GetLocalPlayer()
    end
    
    Render.Texts = function(text, pos, col, size, font, bool)
        if font == nil then
            Render.Text(text, pos + Vector2.new(1, 1), Color.new(0, 0, 0, col.a), size, false , bool)
            Render.Text(text, pos, col, size, false , bool)
        else
            Render.Text(text, pos + Vector2.new(1, 1), Color.new(0, 0, 0, col.a), size, font, false , bool and bool or false)
            Render.Text(text, pos, col, size, font, false , bool and bool or false )
        end
    end
      
    
    local noscope_weapons = {
        [261] = true,
        [242] = true,
        [233] = true,
        [267] = true
    }

    local reference = {
        enable = ui_reference("Aimbot","Anti Aim","Main","Enable Anti Aim"),
        pitch = ui_reference("Aimbot","Anti Aim","Main","Pitch"),
        yaw_base = ui_reference("Aimbot","Anti Aim","Main","Yaw Base"),
        yaw_add = ui_reference("Aimbot","Anti Aim","Main","Yaw Add"),
        yaw_jitter_mode = ui_reference("Aimbot","Anti Aim","Main","Yaw Modifier"),
        yaw_jitter_slider = ui_reference("Aimbot","Anti Aim","Main","Modifier Degree"),
        fake_angle = ui_reference("Aimbot","Anti Aim","Fake Angle", "Enable Fake Angle"),
        inverter = ui_reference("Aimbot","Anti Aim","Fake Angle", "Inverter"),
        left_limit = ui_reference("Aimbot","Anti Aim", "Fake Angle", "Left Limit"),
        right_limit = ui_reference("Aimbot","Anti Aim","Fake Angle", "Right Limit"),
        fake_option = ui_reference("Aimbot","Anti Aim","Fake Angle", "Fake Options"),
        lby = ui_reference("Aimbot","Anti Aim", "Fake Angle", "LBY Mode"),
        freestanding_yaw = ui_reference("Aimbot","Anti Aim", "Fake Angle", "Freestanding Desync"),
        desync_shot = ui_reference("Aimbot","Anti Aim","Fake Angle", "Desync On Shot"),
        slow_motion = ui_reference("Aimbot","Anti Aim", "Misc", "Slow Walk"),
        leg_movement = ui_reference("Aimbot","Anti Aim","Misc", "Leg Movement"),
        autopeek = ui_reference("Miscellaneous", 'Main',  'Movement', 'Auto Peek'),
        windows = ui_reference("Miscellaneous", 'Main',  'Other', 'Windows'),

        auto_starfe = ui_reference("Miscellaneous", 'Main',  'Movement', 'Auto Strafe'),
        dmg = ui_reference("Aimbot", 'Ragebot', 'Accuracy', 'Minimum Damage'),
        ragebot = ui_reference("Aimbot", "Ragebot", "Main", "Enable Ragebot"),

        dt = ui_reference("Aimbot", "Ragebot", "Exploits", "Double Tap"),
        fl_main = ui_reference("Aimbot", "Anti Aim", "Fake Lag", "Enable Fake Lag"),
        fl_limit = ui_reference("Aimbot","Anti Aim", "Fake Lag", "Limit"),
        fl_jitter = ui_reference("Aimbot","Anti Aim","Fake Lag", "Randomization"),
        hs = ui_reference("Aimbot", "Ragebot", "Exploits", "Hide Shots"),

        hitchance = ui_reference("Aimbot", "Ragebot", "Accuracy", "Hit Chance"),
        body_aim = ui_reference("Aimbot", "Ragebot", "Misc", "Body Aim"),
        safe_point = ui_reference("Aimbot", "Ragebot", "Misc", "Safe Points"),
        tb = CVar.FindVar("sv_maxusrcmdprocessticks"),
        clock = CVar.FindVar("cl_clock_correction"),
        fakeduck = ui_reference("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
        lagCompensation = CVar.FindVar("cl_lagcompensation"),
        remove_scope = ui_reference("Visuals", "View", "Camera", "Remove Scope"),



    }

    
    local doubletap_charged = function()
        if not ui_get("value",reference.dt) or ui_get("value",reference.fakeduck) then
            return false
        end
    
        if entity_get_localplayer() == nil then
            return
        end
    
        local weap = entity_get_localplayer():GetActiveWeapon()
        if weap == nil then
            return
        end
    
        local next_attack = entity_get_prop(entity_get_localplayer(), "m_flNextAttack") + 0.25
        local jewfag = entity_get_prop(weap, "m_flNextPrimaryAttack")
    
        if jewfag == nil then
            return
        end
        local next_primary_attack = jewfag + 0.5
        if next_attack == nil or next_primary_attack == nil then
            return false
        end
        return next_attack - GlobalVars.curtime < 0 and next_primary_attack -GlobalVars.curtime < 0
    end

    table.insert(noti_table, {
        text = "Welcome to Ataraxia , "..userdata.username.." Current build: "..userdata.build.." Last update time: "..userdata.last_updatetime,
        timer = GlobalVars.realtime,
        smooth_y = sc_y + 100,
        alpha = 0,
    })

    local menu = {}
    menu.ui_data = {
        bool = {},
        int = {},
        float = {},
        str = {},
        color = {}
    }

    menu.callback_data = {}

    menu.new_elements = function(type,cheatVar)
        if type == "bool" then
           table_insert(menu.ui_data.bool,cheatVar)
        end
        if type == "int" then
            table_insert(menu.ui_data.int,cheatVar)
        end
        if type == "float" then
            table_insert(menu.ui_data.float,cheatVar)
        end
        if type == "str" then
            table_insert(menu.ui_data.str,cheatVar)
        end
        if type == "color" then
            table_insert(menu.ui_data.color,cheatVar)
        end
        if type == "button" then
            debugger("invoked button")
        end
        table_insert(menu.callback_data,cheatVar)
        return cheatVar
    end

    menu.interface = {}
    menu.interface.type = {"[Ataraxia] Info","[Ataraxia] Visuals","[Ataraxia] Antiaim","[Ataraxia] Misc"}
    menu.interface.info = {}
    menu.interface.antiaim = {}
    menu.interface.visuals = {}
    menu.interface.misc = {}

    local t1 = menu.interface.type[1]
    local t2 = menu.interface.type[2]
    local t3 = menu.interface.type[3]
    local t4 = menu.interface.type[4]

    local info = menu.interface.info
    local antiaim = menu.interface.antiaim
    local visuals = menu.interface.visuals
    local misc = menu.interface.misc

    local _state = {"Stand","Move","Slow walk","Duck","Air","Air + D"}
    local __state = {"1","2","3","4","5","6"}

  
    local g_config = {

        export_process = function(self)
            local data = {{},{},{},{},{}}
            for k, v in pairs(menu.ui_data.bool) do
                table_insert(data[1],v:GetBool())
            end
            for k, v in pairs(menu.ui_data.int) do
                table_insert(data[2],ui_get("value",v))
            end
            for k, v in pairs(menu.ui_data.float) do
                table_insert(data[3],ui_get("value",v))
            end
            for k, v in pairs(menu.ui_data.str) do
                table_insert(data[4],ui_get("value",v))
            end
            for _, colors in pairs(menu.ui_data.color) do
                local clr = colors:GetColor()
                table_insert(data[5], string.format("%02X%02X%02X%02X", math.floor(clr.r * 255), math.floor(clr.g * 255), math.floor(clr.b * 255), math.floor(clr.a * 255)))
            end

            clipboard_export(M.encode(JSON.stringify(data)))
        end,

        load_process = function(self,text)

            local protected = function()
                local clipboard = text == nil and ffi_handler.clipboard_import() or text
                local json_config = M.decode(clipboard)
                json_config = JSON.parse(json_config)

                if json_config == nil then
                    error("wrong_json")
                    return
                end
                for k, v in pairs(json_config) do
                        k = ({[1] = "bool", [2] = "int", [3] = "float", [4] = "str", [5] = "color"})[k]
                        for k2, v2 in pairs(v) do
                            if (k == "bool") then
                            if type(v2) == "boolean" then
                                menu.ui_data[k][k2]:SetBool(v2)
                            else
                                return debugger("Fail to load due to incorrect data type, expect boolean received "..type(v2))
                            end
                            end
                            if (k == "int") then
                                if type(v2) == "number" then
                                    menu.ui_data[k][k2]:SetInt(v2)
                                else
                                    return debugger("Fail to load due to incorrect data type, expect number received "..type(v2))
                                end
                            end
                            if (k == "float") then
                                if type(v2) == "number" then
                                    menu.ui_data[k][k2]:SetFloat(v2)
                                else
                                    return debugger("Fail to load due to incorrect data type, expect number received "..type(v2))
                                end
                        end
                        if (k == "string") then
                            menu.ui_data[k][k2]:SetString(v2)
                        end
                        if (k == "color") then
                            menu.ui_data[k][k2]:SetColor(Color.new(tonumber("0x"..v2:sub(1, 2))/255, tonumber("0x"..v2:sub(3, 4))/255, tonumber("0x"..v2:sub(5, 6))/255, tonumber("0x"..v2:sub(7, 8))/255))
                        end
                    end
                end
                Cheat_AddNotify("Ataraxia", "Config loaded!")
                debugger("Loaded config from clipboard")
                table.insert(noti_table, {
                    text = "Loaded config from clipboard",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
                table.insert(noti_table, {
                    text = "Reload lua to use config",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
        
            end
            local status, message = pcall(protected)

            if not status then
                debugger("Fail to load config "..message)
                table.insert(noti_table, {
                    text = "Failed to load config,check error message and send it to support",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
                Cheat_AddNotify("Ataraxia", "Failed to load config due to "..message)
                return
            end
        end,

        menu = function(self)

            
        
        end,

    }

    local clamp = function(num, min, max)
        if num < min then
            num = min
        elseif num > max then
            num = max
        end
        return num
    end
  

    local get_icon_size = Vector2.new(32,28)

    local bytes = Http.Get("https://i.imgur.com/WEZaLSo.png")
    local pfile = ffi.cast("void*", ffi.C.CreateFileA(ffi.cast("const char *", "nl\\ataraxia\\icon.png"), 0xC0000000, 0x00000003, 0, 0x4, 0x80, nil))
    if (not pfile) then
        debugger("Failed to create file, please restart the script or create a ticket.")
        return
    end



    local overlapped = ffi.new("OVERLAPPED")
    overlapped.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Offset = 0xFFFFFFFF
    overlapped.DUMMYUNIONNAME.DUMMYSTRUCTNAME.OffsetHigh = 0xFFFFFFFF

    ffi.C.WriteFile(pfile, ffi.cast("char*" , bytes) , 25600 , nil ,  ffi.cast("void*", overlapped))
    ffi.C.CloseHandle(pfile)
    local icon = Render.LoadImageFromFile("nl\\ataraxia\\icon.png", get_icon_size)
 
    
 
    local g_menu = {
        
        create_data = function(self)
            info.announcement = ui_new_label(t1,"[Announcement]","Thanks for all small8-yaw user's long waiting.")
            info.user = ui_new_label(t1,"[Userdata]","Welcome! "..userdata.username)
            info.build = ui_new_label(t1,"[Userdata]","Current build: "..userdata.build)
            info.last_updatetime = ui_new_label(t1,"[Userdata]","Last update time: "..userdata.last_updatetime)
            info.master_switch = menu.new_elements("bool",ui_new_checkbox("bool",t1,"[Announcement]","Enable Ataraxia",false,"[~] All features master switch"))
            info.feature_list = menu.new_elements("int",ui_new_multiselect(t1,"[Announcement]","Features list",{"Indicators","Built-in presets","Extra antiaim settings","Misc features"},0,"[~] Features list"))

            antiaim.import = menu.new_elements("button",Menu_Button(t1,"[Config]","                  Load config from clipboard              ","[~] Check here to load config",function()
                g_config:load_process()
            end))
        
            antiaim.export = menu.new_elements("button",Menu_Button(t1,"[Config]","                   Export config to clipboard               ","[~] Check here to export config",function()
                g_config:export_process()
                Cheat_AddNotify("Ataraxia", "Config Copied!")
                table.insert(noti_table, {
                    text = "Exported config!",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
                debugger("Exported config")
            end))
            info.download = menu.new_elements("button",Menu_Button(t1,"[Userdata]","Download userdata from clipboard ","[~] Check here to download userdata",function()
            
            end))
    

            visuals.info = ui_new_label(t2,"[Notice]","Enable in the main interface")
            antiaim.info = ui_new_label(t3,"[Notice]","Enable in the main interface")
            misc.info = ui_new_label(t4,"[Notice]","Enable in the main interface")

            visuals.indicator_settings = menu.new_elements("int",ui_new_multiselect(t2,"[Indicator settings]","Features list",{"Manual Arrows","Center","Watermark","Menu effect","Damage marker","Scope line","Solus render","Damage indicator"},0,"[~] Indicator features list"))
            visuals.disable_glow = menu.new_elements("bool",ui_new_checkbox("bool",t2,"[Indicator settings]","Disable glow",false,"[~] Disable all cointainer's glow"))
            visuals.indicator_color = menu.new_elements("color",ui_new_colorpicker(t2,"[Indicator settings]","Main color",224,159,154,255,"[~] Center & Arrows & Effect & Scopeline color"))
            visuals.watermark_color = menu.new_elements("color",ui_new_colorpicker(t2,"[Indicator settings]","Watermark color",224,159,154,255,"[~] Watermark color"))

            visuals.arrows_mode = menu.new_elements("int",ui_new_combobox(t2,"[Manual Arrows]","Arrows mode",{"+","-"},0,"[~] Arrows mode"))
            visuals.arrows_background = menu.new_elements("bool",ui_new_checkbox("bool",t2,"[Manual Arrows]","Background shadow",false,"[~] Arrows background shadow"))
            visuals.arrows_distance = menu.new_elements("int",ui_new_slider("int",t2,"[Manual Arrows]","Arrows distance",10,100,15,"[~] Distance between arrows"))

            visuals.center_mode = menu.new_elements("int",ui_new_combobox(t2,"[Center]","Center mode",{"Text","Gradient","Pixel","Icon"},0,"[~] Arrows mode"))
            visuals.center_scoped_anim = menu.new_elements("int",ui_new_multiselect(t2,"[Center]","Scoped animations",{"Alpha","Postion"},0,"[~] Scoped animations"))
            visuals.center_color_2 = menu.new_elements("color",ui_new_colorpicker(t2,"[Center]","Gradient color",170,170,170,255,"[~] Second color"))

            visuals.temp_keybind_x = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","TEMP_X",0,sc_x,500,"[~]"))
            visuals.temp_keybind_y = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","TEMP_Y",0,sc_y,500,"[~]"))
            visuals.temp_spec_x = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","STEMP_X",0,sc_x,500,"[~]"))
            visuals.temp_spec_y = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","STEMP_Y",0,sc_y,500,"[~]"))

            visuals.dmgmarker_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage marker]","Display mode",{"-","+","++"},0,"[~] Display mode"))
            visuals.dmgmarker_display_time = menu.new_elements("int",ui_new_slider("int",t2,"[Damage marker]","Display Duration",1,10,4,"[~] Maker's display time"))
            visuals.dmgmarker_speed = menu.new_elements("int",ui_new_slider("int",t2,"[Damage marker]","Speed",1,8,2,"[~] Maker's speed"))
            visuals.dmgmarker_color_2 = menu.new_elements("color",ui_new_colorpicker(t2,"[Damage marker]","Normal color",255,255,255,255,"[~] Second color"))

            visuals.scopeline_origin = menu.new_elements("int",ui_new_slider("int",t2,"[Scope line]","Scope origin",0,500,100,"[~] Scope origin"))
            visuals.scopeline_width = menu.new_elements("int",ui_new_slider("int",t2,"[Scope line]","Scope width",0,500,100,"[~] Scope origin"))

            visuals.solus_select = menu.new_elements("int",ui_new_multiselect(t2,"[Solus render]","Solus feature",{"Watermark","Keybind","Spectator"},0,"[~] Solus features"))
            visuals.solus_watermark_name = menu.new_elements("str",ui_new_textbox(t2,"[Solus render]","User name",30,userdata.username,"[~] Watermark main text"))

            visuals.dmgind_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display mode",{"-","+"},0,"[~] Display mode"))
            visuals.dmgind_pos = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display postion",{"Top left","Top right","Bottom left","Bottom Right"},0,"[~] Display mode"))

            antiaim.preset_mode = menu.new_elements("int",ui_new_combobox(t3,"[Built-in presets]","Presets manager",{"#1","Custom"},0,"[~] ."))
            antiaim.preset_static = menu.new_elements("int",ui_new_multiselect(t3,"[Built-in presets]","Suppress jitter select",_state,0,"[~] Disable jitter when choking commands"))

            antiaim.custom_states = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","Condition selection",_state,0,"[~] Select for custom states"))

            antiaim.ex_info = ui_new_label(t3,"[Extra-Notice]","Enable in the main interface")

            antiaim.ex_select = menu.new_elements("int",ui_new_multiselect(t3,"[Extra antiaim settings]","Extra settings",{"Manual antiaim","Antiaim on use","Edge yaw","Roll"},0,"[~] Select for extra antiaim settings"))
            antiaim.ex_manual_yawbase = menu.new_elements("int",ui_new_combobox(t3,"[Extra antiaim settings]","Manual Yawbase",{"At Target", "Forward", "Backward", "Right", "Left", "Freestanding"},0,"[~] Manual yaw base"))
            antiaim.on_use_select = menu.new_elements("int",ui_new_multiselect(t3,"[Extra antiaim settings]","Antiaim on use",{"Disable use to plant"},0,"[~] Antiaim on use setting"))
            antiaim.ex_prevent_jitter = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Extra antiaim settings]","Prevent sideways jitter",false,"[~] Prevent jitter on sideways"))
            antiaim.ex_edge_yaw = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Extra antiaim settings]","Edge yaw",false,"[~] Edge yaw"))

            antiaim.ex_roll_states = menu.new_elements("int",ui_new_multiselect(t3,"[Roll settings]","Roll states",{"Stand","Slow walk","Duck","Manual","Use"},0,"[~] Force roll states"))
            antiaim.ex_roll_options = menu.new_elements("int",ui_new_multiselect(t3,"[Roll settings]","Extra roll options",{"Jitter","Disable roll when peeking","Unsafe"},0,"[~] Force roll states"))
            antiaim.ex_roll_key = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Roll settings]","Roll key",false,"[~] Force roll"))
            -- antiaim.ex_roll_inverter = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Roll settings]","Roll inverter",false,"[~] only work on Stand"))

            antiaim.custom_data = {}


            for k, v in pairs(_state) do
                antiaim.custom_data[k] = {
                    enable = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Custom modifier]","Enable ".._state[k].." setting",false,"[~] Switch states")),
                    extra_options = menu.new_elements("int",ui_new_multiselect(t3,"[Custom modifier]","["..__state[k].."] Extra options",{"Suppress jitter","Freestand yaw","Desync on shot","Lby modifier","Avert concide","Anti bruteforce"},0,"[~] Extra antiaim options")),
                    lby_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] LBY mode",{"Opposite","Sway"},0,"[~] LBY modifier funtions")),
                    desync_on_shot = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Desync on shot",{"Opposite","Freestanding","Switch"},0,"[~] Desync on shot")),
                    freestanding_bodyyaw = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Freestand yaw",{"Peek fake","Peek real"},0,"[~] Freestanding bodyyaw")),
                    yaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Yaw built-in funcs",{"Static","Period jitter [Tick]","Period jitter [Choke]","Period jitter [Desync]"},0,"[~] Yaw modifier funtions")),
                    static_yaw = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw",-90,90,0,"[~] Yaw modifier")),
                    tick_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Tick]",-90,90,0,"[~] Yaw left will jitter by tick")),
                    tick_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Tick]",-90,90,0,"[~] Yaw right will jitter by tick")),
                    choke_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Choke]",-90,90,0,"[~] Yaw left will jitter by choke")),
                    choke_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Choke]",-90,90,0,"[~] Yaw right will jitter by choke")),
                    desync_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Desync]",-90,90,0,"[~] Yaw left will jitter by desync side")),
                    desync_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Desync]",-90,90,0,"[~] Yaw right will jitter by desync side")),
                    yaw_jitter = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Native yaw mode",{"Disabled","Center","Offset","Random","Spin"},0,"[~] Yaw native funtions")),
                    yaw_jitter_degree = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Native yaw degree",0,120,0,"[~] Yaw native degree")),
                    self_bodyyaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Body yaw mode",{"Disabled","Static","Jitter"},0,"[~] Bodyyaw native funtions")),
                    bodyyaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Body built-in funcs",{"Static","Period jitter","Recursion"},0,"[~] Bodyyaw modifier funtions")),
                    bodyyaw_degree = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw modifier",-180,180,0,"[~] Body yaw degree modifier")),
                    jitter_bodyyaw_degree_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw left",-180,180,0,"[~] Body yaw will jitter by your desync side")),
                    jitter_bodyyaw_degree_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw right",-180,180,0,"[~] Body yaw will jitter by your desync side")),
                    body_yaw_step_ticks = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Recursion ticks",1,15,0,"[~] Recursion ticks")),
                    body_yaw_step_value = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Recursion value",0,180,0,"[~] Recursion value")),
                    step_bodyyaw_degree_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw min",-180,180,0,"[~] Body yaw recursion min")),
                    step_bodyyaw_degree_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw max",-180,180,0,"[~] Body yaw recursion max")),
                    fake_yaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Fake built-in funcs",{"Static","Period tick jitter","Progressive"},0,"[~] Bodyyaw modifier funtions")),
                    static_fakeyaw = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit",0,60,0,"[~] Fake yaw limit")),
                    jitter_fakeyaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake left [Period]",0,60,0,"[~] Fake yaw will jitter by period")),
                    jitter_fakeyaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake right [Period]",0,60,0,"[~] Fake yaw will jitter by period")),
                    step_ticks = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Progressive ticks",1,15,7,"[~] Progressive ticks")),
                    step_value = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Progressive value",1,60,10,"[~] Progressive value")),
                    step_abs = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Custom modifier]","["..__state[k].."] Increment absolute value",false,"[~] Progressive will only progress abs value")),
                    step_fake_min = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit min",0,60,0,"[~] Fake yaw limit min ")),
                    step_fake_max = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit max",0,60,0,"[~] Fake yaw limit max ")),                   
                }
            end


          
            misc.select = menu.new_elements("int",ui_new_multiselect(t4,"[Misc features]","Misc settings",{"Anti knife","Animation breaker","Jump scout fix","Trash talk","Hit sound","Extra ragebot settings"},0,"[~] Misc list"))
            misc.hitsound_vol = menu.new_elements("int",ui_new_slider("int",t4,"[Hit sound]","Vol",0,100,100,"[~] Hitsound vol"))
            misc.antiknife_pitch = menu.new_elements("bool",ui_new_checkbox("bool",t4,"[Anti knife]","Reset pitch on knife",false,"[~] Disable pitch when knife"))
            misc.antiknife_distance = menu.new_elements("int",ui_new_slider("int",t4,"[Anti knife]","Anti knife radius",0,1000,280,"[~] Antiknife radius"))
            
            misc.anim_list = menu.new_elements("int",ui_new_multiselect(t4,"[Animation breaker]","Break anims",{"Pitch 0 on land","Static legs in air","Leg fucker"},0,"[~] Break anims list"))

            misc.dormant_aimbot = menu.new_elements("int",ui_new_checkbox("bool",t4,"[Dormant aimbot]","Dormant aimbot",false,"[~] Dormant Aimbot"))
            misc.dormant_aimbot_dmg = menu.new_elements("int",ui_new_slider("int",t4,"[Dormant aimbot]","Dormant aimbot damage",1,100,10,"[~] Dormant Aimbot damage"))

            misc.hitchance_noscope = menu.new_elements("int",ui_new_slider("int",t4,"[Hitchance modifier]","Noscope hitchance",0,100,50,"[~] Noscoped hitchance"))
            misc.hitchance_inair = menu.new_elements("int",ui_new_slider("int",t4,"[Hitchance modifier]","In air hitchance",0,100,50,"[~] Noscoped hitchance"))
        end,

        visible_data = function(self)
            local master_switch = ui_get("value",info.master_switch)

            ui_set_visible(antiaim.import,master_switch)

            ui_set_visible(antiaim.export,master_switch)

            ui_set_visible(info.feature_list,master_switch)

            local e_ind = ui_get("bool",info.feature_list,1) == true and master_switch
            local e_antiaim = ui_get("bool",info.feature_list,2) == true and master_switch
            local e_ex_antiaim = ui_get("bool",info.feature_list,3) == true and master_switch
            local e_misc = ui_get("bool",info.feature_list,4) == true and master_switch

            ui_set_visible(visuals.info,ui_get("bool",info.feature_list,1) == false and master_switch == true and true or false)
            ui_set_visible(antiaim.info,ui_get("bool",info.feature_list,2) == false and master_switch == true and true or false)
            ui_set_visible(antiaim.ex_info,ui_get("bool",info.feature_list,3) == false and master_switch == true and true or false)
            ui_set_visible(misc.info,ui_get("bool",info.feature_list,4) == false and master_switch == true and true or false)

            ui_set_visible(visuals.indicator_settings,e_ind)

            local e_arrows = ui_get("bool",visuals.indicator_settings,1) == true and e_ind
            local e_center = ui_get("bool",visuals.indicator_settings,2) == true and e_ind
            local e_watermark = ui_get("bool",visuals.indicator_settings,3) == true and e_ind
            local e_menu_effect = ui_get("bool",visuals.indicator_settings,4) == true and e_ind
            local e_dmgmarker = ui_get("bool",visuals.indicator_settings,5) == true and e_ind
            local e_scopeline = ui_get("bool",visuals.indicator_settings,6) == true and e_ind
            local e_solus = ui_get("bool",visuals.indicator_settings,7) == true and e_ind
            local e_dmgind = ui_get("bool",visuals.indicator_settings,8) == true and e_ind
          
            ui_set_visible(visuals.dmgind_mode,e_dmgind)
            ui_set_visible(visuals.dmgind_pos,e_dmgind)
            
            ui_set_visible(visuals.indicator_color,e_arrows or e_center or e_menu_effect)
            ui_set_visible(visuals.disable_glow,e_arrows or e_center or e_menu_effect or e_solus or e_scopeline)

            
            ui_set_visible(visuals.watermark_color,e_watermark or e_solus)

            ui_set_visible(visuals.arrows_mode,e_arrows)
            ui_set_visible(visuals.arrows_background,e_arrows)
            ui_set_visible(visuals.arrows_distance,e_arrows)

            ui_set_visible(visuals.center_mode,e_center)
            ui_set_visible(visuals.center_scoped_anim,e_center)

            ui_set_visible(visuals.center_color_2,e_center and ui_get("value",visuals.center_mode) == 1)

            ui_set_visible(visuals.dmgmarker_mode,e_dmgmarker)
            ui_set_visible(visuals.dmgmarker_display_time,e_dmgmarker)
            ui_set_visible(visuals.dmgmarker_speed,e_dmgmarker)
            ui_set_visible(visuals.dmgmarker_color_2,e_dmgmarker)

            ui_set_visible(visuals.scopeline_origin,e_scopeline)
            ui_set_visible(visuals.scopeline_width,e_scopeline)

            ui_set_visible(visuals.solus_select,e_solus)
            ui_set_visible(visuals.temp_keybind_x,false)
            ui_set_visible(visuals.temp_keybind_y,false)
            ui_set_visible(visuals.temp_spec_x,false)
            ui_set_visible(visuals.temp_spec_y,false)
            ui_set_visible(visuals.solus_watermark_name,e_solus and ui_get("bool",visuals.solus_select,1) == true)

            
            ui_set_visible(antiaim.preset_mode,e_antiaim)
            ui_set_visible(antiaim.preset_static,e_antiaim and ui_get("value",antiaim.preset_mode) == 0)
            local custom = e_antiaim and ui_get("value",antiaim.preset_mode) == 1
            ui_set_visible(antiaim.custom_states,custom)
            local selection = ui_get("value",antiaim.custom_states) + 1

            for k, v in pairs(_state) do
                local switch = ui_get("value",antiaim.custom_data[selection].enable)

                local show = custom and switch
    
                for n, c in pairs(antiaim.custom_data[k]) do
    
                    ui_set_visible(c,selection == k and e_antiaim and custom)
    
                end
                local m = antiaim.custom_data[selection]
                ui_set_visible(m.extra_options,show)
                local lby = ui_get("bool",m.extra_options,4) == true
                local desync = ui_get("bool",m.extra_options,3) == true
                local freestand = ui_get("bool",m.extra_options,2) == true
                ui_set_visible(m.lby_mode,show and lby)
                ui_set_visible(m.desync_on_shot,show and desync)
                ui_set_visible(m.freestanding_bodyyaw,show and freestand)

                ui_set_visible(m.yaw_mode,show)
                local static = ui_get("value",m.yaw_mode) == 0
                local tick = ui_get("value",m.yaw_mode) == 1
                local choke = ui_get("value",m.yaw_mode) == 2
                local desync = ui_get("value",m.yaw_mode) == 3
                ui_set_visible(m.static_yaw,show and static)
                ui_set_visible(m.tick_yaw_left,show and tick)
                ui_set_visible(m.tick_yaw_right,show and tick)
                ui_set_visible(m.choke_yaw_left,show and choke)
                ui_set_visible(m.choke_yaw_right,show and choke)
                ui_set_visible(m.desync_yaw_left,show and desync)
                ui_set_visible(m.desync_yaw_right,show and desync)

                ui_set_visible(m.yaw_jitter,show)
                local yaw_jitter_c = ui_get("value",m.yaw_jitter) ~= 0
                ui_set_visible(m.yaw_jitter_degree,show and yaw_jitter_c)

                ui_set_visible(m.self_bodyyaw_mode,show)

                local bodyyaw_c = ui_get("value",m.self_bodyyaw_mode) ~= 0
                ui_set_visible(m.bodyyaw_mode,show and bodyyaw_c)

                local static_body = ui_get("value",m.bodyyaw_mode) == 0 and bodyyaw_c
                local jitter_body = ui_get("value",m.bodyyaw_mode) == 1 and bodyyaw_c
                local step = ui_get("value",m.bodyyaw_mode) == 2 and bodyyaw_c

                ui_set_visible(m.bodyyaw_degree,show and static_body)
                ui_set_visible(m.jitter_bodyyaw_degree_left,show and jitter_body)
                ui_set_visible(m.jitter_bodyyaw_degree_right,show and jitter_body)
                ui_set_visible(m.body_yaw_step_ticks,show and step)
                ui_set_visible(m.body_yaw_step_value,show and step)
                ui_set_visible(m.step_bodyyaw_degree_left,show and step)
                ui_set_visible(m.step_bodyyaw_degree_right,show and step)
                
                local fake_c = show and bodyyaw_c
                ui_set_visible(m.fake_yaw_mode,fake_c)

                local static_fake = ui_get("value",m.fake_yaw_mode) == 0 and fake_c
                local jitter_fake = ui_get("value",m.fake_yaw_mode) == 1 and fake_c
                local step_fake = ui_get("value",m.fake_yaw_mode) == 2 and fake_c

                ui_set_visible(m.static_fakeyaw,fake_c and static_fake)

                ui_set_visible(m.jitter_fakeyaw_left,fake_c and jitter_fake)
                ui_set_visible(m.jitter_fakeyaw_right,fake_c and jitter_fake)
                ui_set_visible(m.step_ticks,fake_c and step_fake)
                ui_set_visible(m.step_value,fake_c and step_fake)
                ui_set_visible(m.step_abs,fake_c and step_fake)
                ui_set_visible(m.step_fake_min,fake_c and step_fake)
                ui_set_visible(m.step_fake_max,fake_c and step_fake)

            end


            ui_set_visible(antiaim.ex_select,e_ex_antiaim)

            local e_manual = ui_get("bool",antiaim.ex_select,1) == true and master_switch and e_ex_antiaim
            local e_on_use = ui_get("bool",antiaim.ex_select,2) == true and master_switch and e_ex_antiaim
            local e_edge_yaw = ui_get("bool",antiaim.ex_select,3) == true and master_switch and e_ex_antiaim
            local e_roll = ui_get("bool",antiaim.ex_select,4) == true and master_switch and e_ex_antiaim

            ui_set_visible(antiaim.ex_manual_yawbase,e_manual)
            ui_set_visible(antiaim.on_use_select,e_on_use)
            ui_set_visible(antiaim.ex_prevent_jitter,e_manual)
            ui_set_visible(antiaim.ex_edge_yaw,e_edge_yaw)
            ui_set_visible(antiaim.ex_roll_states,e_roll)
            ui_set_visible(antiaim.ex_roll_options,e_roll)
            ui_set_visible(antiaim.ex_roll_key,e_roll)

              
            ui_set_visible(misc.select,e_misc)
            
            local knife = ui_get("bool",misc.select,1) == true and e_misc
            local anim = ui_get("bool",misc.select,2) == true and e_misc
            local sound = ui_get("bool",misc.select,5) == true and e_misc
            local hitchance = ui_get("bool",misc.select,6) == true and e_misc
            ui_set_visible(misc.hitsound_vol,sound)
            ui_set_visible(misc.antiknife_pitch,knife)
            ui_set_visible(misc.antiknife_distance,knife)
            ui_set_visible(misc.anim_list,anim)

            ui_set_visible(misc.dormant_aimbot,hitchance)
            ui_set_visible(misc.dormant_aimbot_dmg,hitchance)
            ui_set_visible(misc.hitchance_inair,hitchance)
            ui_set_visible(misc.hitchance_noscope,hitchance)
        end,

        register = function(self)
            self.create_data()
            self.visible_data()
        end
    }

    g_config:menu()

    g_menu:register()
    local desync = 0
    local   IN_FORWARD            = bit_lshift(1, 3) -- Walk forward
    local   IN_JUMP                = bit_lshift(1, 1) -- Jump
    local check_roll = false
    local g_antiaim = {
        value_table = {
            randomseed = 0,
            states = 1,
            choke = 0,
            antiaim = {
                pitch = 0, --0 Disabled --1 Down
                yaw_base = 0,
                yaw_add = 0,
                yaw_jitter = 0, --0 Disabled --1 Center --2 Offset --3 Random --4 Spin
                yaw_jitter_degree = 0,
                fake_angle = true,
                inverter = false,
                left_limit = 0,
                right_limit = 0,
                fake_options = {false,false,false,false}, -- avoid overlap -- jitter -- Randomize jitter -- Anti bruteforce
                lby_mode = 0, --0disabled --1 Opposite --2 sway
                freestanding_desync = 0, --0 off -- 1peek fake --2 peek real
                desync_onshot = 0,--0 disabled --1 Opposite --2 Freestanding --3 Switch
            },

            on_use = {
                using = false,
                in_use = bit_lshift(1, 5)
            },

            on_ground_ticks = 0
        },

        bodyyaw_jitter = function(c, d, e)
            local f = {}
            if e == -180 then
                f[1] = 0.0
            else
                if e ~= 0 then
                    if e == 180 then
                        f[0] = 0.0
                        f[1] = d
                    else
                        math.randomseed(e)
                        f[0] = math.random(-d, d)
                        f[1] = math.random(-d, d)
                    end
                    return f[c % 2]
                end
                f[1] = d
            end
            f[0] = -d
            return f[c % 2]
        end,

        override_limit = function(self,g, h, i, j, f )
            local b = 60
            local k = f
            local l = self.bodyyaw_jitter(self.value_table.randomseed, 60, k)
            self.value_table.antiaim.inverter = l < 0 and true
            b = math.abs(l)
            AntiAim_OverrideLimit(math.min(b, j))
        end,

        bodyyaw_jitter_funcs = function(self,f,j)
            local m = ClientState.m_choked_commands
            local g = EntityList.GetLocalPlayer()
            local h = g:GetPlayer():GetActiveWeapon()
            if g == nil or h == nil then
                return
            end
            if m == 1 then
                self.value_table.randomseed = self.value_table.randomseed + 1
            end
            self:override_limit(g, h, m, j, f)
        end,
    
        bodyyaw_static_funcs = function(self,a, b)
            if a > b and a > 0 then
                AntiAim_OverrideLimit(math.min(b, 60))
                self.value_table.antiaim.inverter = false
            elseif a < b and a > 0 then
                AntiAim_OverrideLimit(math.min(a, 60))
                self.value_table.antiaim.inverter = true
            elseif math.abs(a) > b and a < 0 then
                AntiAim_OverrideLimit(math.min(b, 60))
                self.value_table.antiaim.inverter = true
            elseif math.abs(a) < b and a < 0 then
                AntiAim_OverrideLimit(math.min(math.abs(a), 60))
                self.value_table.antiaim.inverter = true
            end
        end,

        clamp = function(num, min, max)
            if num < min then
                num = min
            elseif num > max then
                num = max
            end
            return num
        end,

        calculate_angles = function(from, to)
            local sub = to - from
        
            local pitch = -math.deg(math.atan2(sub.z, math.sqrt(sub.x ^ 2 + sub.y ^ 2)))
            local yaw = math.deg(math.atan2(sub.y, sub.x))
        
            return pitch, yaw
        end,
        
        normalize_yaw = function(yaw)
            while yaw > 180 do
                yaw = yaw - 360
            end
        
            while yaw < -180 do
                yaw = yaw + 360
            end
        
            return yaw
        end,

        run_onuse = function(self,cmd)
            local v = self.value_table.on_use
            v.using = false
            
            if ui_get("bool",antiaim.ex_select,2) == true and ui_get("bool",info.feature_list,3) == true then
                local is_holding_using = bit_band(cmd.buttons, v.in_use) > 0
                local me = entity_get_localplayer()
                local active_weapon = me:GetActiveWeapon() 
                if active_weapon == nil then
                    return
                end

                local is_bomb_in_hand = false       
                if active_weapon then
                    is_bomb_in_hand = active_weapon:GetClassName() == "CC4"
                end
                local is_in_bombzone = me:GetProp("m_bInBombZone")
                local is_planting = is_in_bombzone and is_bomb_in_hand       
                local planted_c4_table = EntityList_GetEntitiesByName("CPlantedC4")
                local is_c4_planted = #planted_c4_table > 0
                local bomb_distance = 100       
                if is_c4_planted then
                    local c4_entity = planted_c4_table[#planted_c4_table]       
                    local c4_origin = c4_entity:GetRenderOrigin()
                    local my_origin = me:GetRenderOrigin()       
                    bomb_distance = my_origin:DistTo(c4_origin)
                end       
                local is_defusing = bomb_distance < 62 and me:GetProp("m_iTeamNum") == 3       
                if is_defusing then
                    return
                end
                local camera_angles = EngineClient_GetViewAngles()
                local eye_position = me:GetEyePosition()
                local forward_vector = cheat_AngleToForward(camera_angles)
                local trace_end = eye_position + forward_vector * 8192
                local trace = EngineTrace_TraceRay(eye_position, trace_end, me, 0x4600400B)
                local is_using = is_holding_using
                if trace and trace.fraction < 1 and trace.hit_entity then
                    local class_name = trace.hit_entity:GetClassName()
                    is_using = class_name ~= "CWorld" and class_name ~= "CFuncBrush" and class_name ~= "CCSPlayer"
                end
                if not is_using and not is_planting then
                    cmd.buttons = bit_band(cmd.buttons, bit_bnot(v.in_use))
                    v.using = true
                end
            end
        end,

        get_distance = function(x1, y1, z1, x2, y2, z2)
            return math.sqrt((x2 - x1) ^ 2 + (y2 - y1) ^ 2 + (z2 - z1) ^ 2)
        end,

        run_antiknife = function(self)
            if ui_get("bool",misc.select,1) == true and ui_get("bool",info.feature_list,4) == true then
                local player = EntityList.GetPlayers()
                local entity_or = entity_get_prop(entity_get_localplayer(),"m_vecOrigin")
            
                for i = 1, #player do
                    if player[i] == entity_get_localplayer() or player[i]:IsTeamMate() then
                        goto skip
                    end
                    if Cheat.IsKeyDown(0x45) then
                        goto skip
                    end
                    local entity_e_or = entity_get_prop(player[i], "m_vecOrigin")

                    local active_weapon = player[i]:GetActiveWeapon()

                    local distance = self.get_distance(entity_or.x, entity_or.y, entity_or.z, entity_e_or.x, entity_e_or.y, entity_e_or.z)

                    if active_weapon == nil then
                        return
                    end
                    if active_weapon:IsKnife() and distance <= ui_get("value",misc.antiknife_distance) then
                      
                        if ui_get("value",misc.antiknife_pitch) then
                            self.value_table.antiaim.pitch = 0
                        end
                        AntiAim.OverrideYawOffset(180)
                    end
                    ::skip::
                end
            end
        end,

        
        run_direction = function(self)
            if ui_get("bool",antiaim.ex_select,1) == true then
                local antiaim_yawbase = ui_get("value",antiaim.ex_manual_yawbase)
                if antiaim_yawbase == 0 then
                    self.value_table.antiaim.yaw_base = 4
                elseif antiaim_yawbase == 1 then
                    self.value_table.antiaim.yaw_base = 0
                elseif antiaim_yawbase == 2 then
                    self.value_table.antiaim.yaw_base = 1
                elseif antiaim_yawbase == 3 then
                    self.value_table.antiaim.yaw_base = 2
                elseif antiaim_yawbase == 4 then
                    self.value_table.antiaim.yaw_base = 3
                elseif antiaim_yawbase == 5 then
                    self.value_table.antiaim.yaw_base = 5
                end
                if ui_get("value",antiaim.ex_prevent_jitter) and (self.value_table.antiaim.yaw_base == 2 or self.value_table.antiaim.yaw_base == 3) then
                    self.value_table.antiaim.yaw_add = 0
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    AntiAim_OverrideLimit(60)
                end
            end
        end,

        run_edge = function(self)
    
            if ui_get("value",antiaim.ex_edge_yaw) and ui_get("bool",antiaim.ex_select,3) == true then
                local entity = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
                local player = entity:GetPlayer()
                local eye_pos = player:GetEyePosition()
                local view_angles = EngineClient.GetViewAngles()
            
                local distance = 8192
                local closest_point = nil
            
                for i = view_angles.yaw - 180, view_angles.yaw + 180, 15 do
                    local rotation = math.rad(i)
                    local point = Vector.new(eye_pos.x + math.cos(rotation) * 100, eye_pos.y + math.sin(rotation) * 100, eye_pos.z)
            
                    local trace = EngineTrace.TraceRay(eye_pos, point, entity, 0x4600400b)
            
                    if trace.fraction * 100 < distance then
                        distance = trace.fraction * 100
                        closest_point = point
                    end
                end
            
                if distance > 30 then
                    return
                end
            
                local _, yaw = self.calculate_angles(eye_pos, closest_point)
                local delta = self.normalize_yaw(view_angles.yaw - 180)
                local final_yaw = self.normalize_yaw(yaw - delta)
            
                AntiAim.OverrideYawOffset(final_yaw)
            end
        end,

        run_aa_logic = (function()
            local aa = {}

            local choke_var = 0
            local choke_reverse = 0

            local clamp = function(num, min, max)
                if num < min then
                    num = min
                elseif num > max then
                    num = max
                end
                return num
            end
            
            aa.get_tick = function(a,b)
                return GlobalVars.tickcount % 4 >= 2 and a or b
            end

            aa.get_choke = function(a,b)
                if GlobalVars.tickcount - choke_var > 1  then
                    choke_reverse = choke_reverse == 1 and 0 or 1
                    choke_var = GlobalVars.tickcount
                end
                return choke_reverse >= 1 and a or b
            end

            aa.get_desync = function(a,b)
                return AntiAim_GetInverterState() and a or b
            end
            local return_value = 0


            aa.get_step = function(a,b,step_value,step_tick)
                local step_min = a
                local step_max = b
                local step_v = step_value
                local step_t = GlobalVars.tickcount % step_tick
                if step_t == step_tick - 1 then
                    if return_value < step_max then
                        return_value = return_value + step_v
                    elseif return_value >= step_max then
                        return_value = step_min
                    end
                end

                return clamp(return_value,step_min,step_max)
            end
            return aa
            
        end)(),

        run_custom = function(self,cmd)
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.value_table.on_ground_ticks = self.value_table.on_ground_ticks + 1
            else
                self.value_table.on_ground_ticks = 0
            end
            if ui_get("value",reference.slow_motion) and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[3].enable) then
                self.value_table.states = 3
            elseif in_air and duck and ui_get("value",antiaim.custom_data[6].enable) then
                self.value_table.states = 6
            elseif in_air and ui_get("value",antiaim.custom_data[5].enable) then
                self.value_table.states = 5
        
            elseif duck and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[4].enable) then
                self.value_table.states = 4
            elseif velocity > 10 and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[2].enable) and not ui_get("value",reference.slow_motion) then
                self.value_table.states = 2
            elseif velocity < 2 and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[1].enable) then
                self.value_table.states = 1
            end

            local m = antiaim.custom_data
            local s = self.value_table.states
            self.value_table.antiaim.pitch = 1

            self.value_table.antiaim.lby_mode = ui_get("bool",m[s].extra_options,4) == true and ui_get("value",m[s].lby_mode) + 1 or 0
            self.value_table.antiaim.freestanding_desync = ui_get("bool",m[s].extra_options,2) == true and ui_get("value",m[s].freestanding_bodyyaw) + 1 or 0
            self.value_table.antiaim.desync_onshot = ui_get("bool",m[s].extra_options,3) == true and ui_get("value",m[s].desync_on_shot) + 1 or 0

            self.value_table.antiaim.fake_options[1] = ui_get("bool",m[s].extra_options,5) == true and true or false
            self.value_table.antiaim.fake_options[4] = ui_get("bool",m[s].extra_options,6) == true and true or false


            if s == 1 and ui_get("bool",m[1].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 2 and ui_get("bool",m[2].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 3 and ui_get("bool",m[3].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 18
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 4 and ui_get("bool",m[4].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 24
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 5 and ui_get("bool",m[5].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 6 and ui_get("bool",m[5].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            else
                local static_yaw = ui_get("value",m[s].yaw_mode) == 0
                local tick_yaw = ui_get("value",m[s].yaw_mode) == 1
                local choke_yaw = ui_get("value",m[s].yaw_mode) == 2
                local desync_yaw = ui_get("value",m[s].yaw_mode) == 3
                
                local static_yaw_value = ui_get("value",m[s].static_yaw)
                local tick_yaw_value_left = ui_get("value",m[s].tick_yaw_left)
                local tick_yaw_value_right = ui_get("value",m[s].tick_yaw_right)
                local choke_yaw_value_left = ui_get("value",m[s].choke_yaw_left)
                local choke_yaw_value_right = ui_get("value",m[s].choke_yaw_right)
                local desync_yaw_value_left = ui_get("value",m[s].desync_yaw_left)
                local desync_yaw_value_right = ui_get("value",m[s].desync_yaw_right)

                local yaw_jitter = ui_get("value",m[s].yaw_jitter)
                local yaw_jitter_value = ui_get("value",m[s].yaw_jitter_degree)

                self.value_table.antiaim.yaw_jitter = yaw_jitter
                self.value_table.antiaim.yaw_jitter_degree = yaw_jitter_value

                if ui_get("value",m[s].yaw_mode) == 3 or ui_get("value",m[s].bodyyaw_mode) == 1 or ui_get("value",m[s].fake_yaw_mode) == 1 then
                    self.value_table.antiaim.fake_options[2] = true
                else
                    self.value_table.antiaim.fake_options[2] = false
                end


                if ui_get("value",m[s].yaw_mode) == 0 then
                    self.value_table.antiaim.yaw_add = static_yaw_value
                elseif ui_get("value",m[s].yaw_mode) == 1 then

                    self.value_table.antiaim.yaw_add = self.run_aa_logic.get_tick(tick_yaw_value_left,tick_yaw_value_right)
                elseif ui_get("value",m[s].yaw_mode) == 2 then
                    self.value_table.antiaim.yaw_add = self.run_aa_logic.get_choke(choke_yaw_value_left,choke_yaw_value_right)
                elseif ui_get("value",m[s].yaw_mode) == 3 then
                    self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(desync_yaw_value_left,desync_yaw_value_right)
                end


                local fake = ui_get("value",m[s].static_fakeyaw)
                if ui_get("value",m[s].fake_yaw_mode) == 0 then
                    desync = fake
                elseif ui_get("value",m[s].fake_yaw_mode) == 1 then
                    desync = self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_fakeyaw_left),ui_get("value",m[s].jitter_fakeyaw_right))
                elseif ui_get("value",m[s].fake_yaw_mode) == 2 then
                    if ui_get("value",m[s].step_abs) == true then
                        desync = math.abs(self.run_aa_logic.get_step(ui_get("value",m[s].step_fake_min),ui_get("value",m[s].step_fake_max),ui_get("value",m[s].step_value),ui_get("value",m[s].step_ticks)))
                    else
                        desync = self.run_aa_logic.get_step(ui_get("value",m[s].step_fake_min),ui_get("value",m[s].step_fake_max),ui_get("value",m[s].step_value),ui_get("value",m[s].step_ticks))
                    end
                end


                if ui_get("value",m[s].self_bodyyaw_mode) == 0 then
                    self:bodyyaw_static_funcs(0,0)
                elseif ui_get("value",m[s].self_bodyyaw_mode) == 1 then
                    if ui_get("value",m[s].bodyyaw_mode) == 0 then
                      
                        self:bodyyaw_static_funcs(ui_get("value",m[s].bodyyaw_degree),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 1 then

                        self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_bodyyaw_degree_left),ui_get("value",m[s].jitter_bodyyaw_degree_right)),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 2 then
                    
                        self:bodyyaw_static_funcs(self.run_aa_logic.get_step(ui_get("value",m[s].step_bodyyaw_degree_left),ui_get("value",m[s].step_bodyyaw_degree_right),ui_get("value",m[s].body_yaw_step_value),ui_get("value",m[s].body_yaw_step_ticks)),desync)
                    end

                elseif ui_get("value",m[s].self_bodyyaw_mode) == 2 then
                    if ui_get("value",m[s].bodyyaw_mode) == 0 then
                        self:bodyyaw_jitter_funcs(ui_get("value",m[s].bodyyaw_degree),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 1 then
                        self:bodyyaw_jitter_funcs(self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_bodyyaw_degree_left),ui_get("value",m[s].jitter_bodyyaw_degree_right)),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 2 then
                        self:bodyyaw_jitter_funcs(self.run_aa_logic.get_step(ui_get("value",m[s].step_bodyyaw_degree_left),ui_get("value",m[s].step_bodyyaw_degree_right),ui_get("value",m[s].body_yaw_step_value),ui_get("value",m[s].body_yaw_step_ticks)),desync)
                    end
                end

            end

      
            
        

    

        end,
        
        lean_body = function(self,cmd)
            if check_roll == false then
                return
            end
            local local_player = EntityList.GetLocalPlayer()
            if (math.abs(cmd.forwardmove) > 1) or (math.abs(cmd.sidemove) > 1) or bit_band(cmd.buttons, IN_JUMP) > 0 or entity_get_prop(local_player, "m_MoveType") == 9 then
                return
            end
            
 
            local desync_amount = cmd.viewangles.yaw - desync
            if desync_amount == nil then
                return
            end
            
            if math.abs(desync_amount) < 15 or cmd.chokedcommands == 0 then
                return
            end
        
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)
            local inair = bit.band(entity_get_prop(local_player, "m_fFlags" ), 1 ) == 0
        
            if velocity > 80 and not inair then return end

            cmd.forwardmove = 0
            cmd.buttons = bit.band(cmd.buttons, IN_FORWARD)
        end,

        roll_var = {
            ground_ticks = 0
        },

        get_roll_states = function(self)
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.roll_var.ground_ticks = self.roll_var.ground_ticks + 1
            else
                self.roll_var.ground_ticks = 0
            end
            
            if Cheat_IsKeyDown(0x45) then
                return "USE"
            elseif self.value_table.antiaim.yaw_base == 3 or self.value_table.antiaim.yaw_base == 2 then
                return "MANUAL"
            elseif in_air then
                return "IN_AIR"
            elseif ui_get("value",reference.slow_motion) and self.roll_var.ground_ticks > 8 then
                return "SLOW_WALK"
            elseif duck and self.roll_var.ground_ticks > 8 then
                return "DUCK"
            elseif velocity > 4 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "MOVE"
            elseif velocity < 2 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "STAND"
            else
                return "IN_AIR"
            end

        end,

        run_roll = function(self,cmd)
            if ui_get("bool",antiaim.ex_select,4) == true then
                self.value_table.antiaim.pitch = 1
                local states = self:get_roll_states()
                if ui_get("value",antiaim.ex_roll_key) then
                    check_roll = true
                elseif ui_get("value",reference.autopeek) == true and ui_get("bool",antiaim.ex_roll_options,2) == true then
                    check_roll = false
                elseif states == "USE" and ui_get("bool",antiaim.ex_roll_states,5) == true then
                    check_roll = true
                elseif states == "MANUAL" and ui_get("bool",antiaim.ex_roll_states,4) == true then
                    check_roll = true
                elseif states == "DUCK" and ui_get("bool",antiaim.ex_roll_states,3) == true then
                    check_roll = true
                elseif states == "SLOW_WALK" and ui_get("bool",antiaim.ex_roll_states,2) == true then
                    check_roll = true
                elseif states == "STAND" and ui_get("bool",antiaim.ex_roll_states,1) == true then
                    check_roll = true
                elseif states == "MOVE" then
                    check_roll = false
                elseif states == "IN_AIR" then
                    check_roll = false
                else
                    check_roll = false
                end
    
                local degree = 0
    
                if states == "USE" then
                    self.value_table.antiaim.yaw_add = 2
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.inverter = false
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
    
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = 90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                        
                        degree = 50
                    end
    
                end
    
                if states == "MANUAL" then
                    self.value_table.antiaim.inverter = false
    
                    self.value_table.antiaim.yaw_add = -2
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                        
                        degree = -50
                    end
                end
    
                if states == "SLOW_WALK" then
                    self.value_table.antiaim.inverter = false
    
                    self.value_table.antiaim.yaw_add = 51
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                        
                        degree = -50
                    end
                end
    
                if states == "STAND" then
                    self.value_table.antiaim.inverter = false
    
                    self.value_table.antiaim.yaw_add = 33
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    self.value_table.antiaim.inverter = false
    
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                        
                        degree = -50
                    end
                end
    
    
                if states == "DUCK" then
                    self.value_table.antiaim.yaw_add = 47
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                        
                        degree = -50
                    end
                end
    
                if check_roll == true then
                    AntiAim_OverrideLimit(58)
                    self.value_table.antiaim.lby_mode = 0
                    self:lean_body(cmd)
                    cmd.viewangles.roll = degree
    
                else
                    cmd.viewangles.roll = 0
                end
            else
                check_roll = false
                cmd.viewangles.roll = 0

            end



            

            -- antiaim.ex_roll_states = "[Roll settings]","Roll states",{"Stand","Slow walk","Duck","Manual","Use"}
            -- antiaim.ex_roll_options = "[Roll settings]","Extra roll options",{"Jitter","Disable roll when peeking","Unsafe"},
            -- antiaim.ex_roll_key = "[Roll settings]","Roll key",false,"[~] Force roll"))
            -- antiaim.ex_roll_inverter = "[Roll settings]","Roll inverter",false,"[~] only work on Stand"))



        end,

        run_presets_states = function(self,cmd)
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.roll_var.ground_ticks = self.roll_var.ground_ticks + 1
            else
                self.roll_var.ground_ticks = 0
            end
            
            if Cheat_IsKeyDown(0x45) then
                return "USE"
            elseif self.value_table.antiaim.yaw_base == 3 or self.value_table.antiaim.yaw_base == 2 then
                return "MANUAL"
            elseif in_air and duck then
                return "AIR_DUCK"
            elseif in_air then
                return "IN_AIR"
            elseif ui_get("value",reference.slow_motion) and self.roll_var.ground_ticks > 8 then
                return "SLOW_WALK"
            elseif duck and self.roll_var.ground_ticks > 8 then
                return "DUCK"
            elseif velocity > 4 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "MOVE"
            elseif velocity < 2 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "STAND"
            else
                return "AIR_DUCK"
            end

        end,

        run_presets_1 = function(self,cmd)
            local states = self:run_presets_states(cmd)
            self.value_table.antiaim.pitch = 1
            if states == "STAND" and ui_get("bool",antiaim.preset_static,1) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "STAND" then
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(5,18)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 60
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                st_deysnc = self.run_aa_logic.get_step(20,60,1,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_step(90,180,1,1),st_deysnc)
                self.value_table.antiaim.fake_options[2] = true

            end

            if states == "MOVE" and ui_get("bool",antiaim.preset_static,2) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "MOVE" then
                
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-14,26)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 40
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                mv_deysnc = self.run_aa_logic.get_step(20,60,5,3)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(180,180),mv_deysnc)
                self.value_table.antiaim.fake_options[2] = true

            end

            if states == "SLOW_WALK" and ui_get("bool",antiaim.preset_static,3) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 18
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "SLOW_WALK" then
                self.value_table.antiaim.fake_options[2] = true

                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-2,20)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 60
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
               sw_deysnc = self.run_aa_logic.get_step(20,60,1,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_step(90,180,1,1),sw_deysnc)

            end

                
            if states == "DUCK" and ui_get("bool",antiaim.preset_static,4) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "DUCK" then
                
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-5,35)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 40
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60

            end
            
            if states == "IN_AIR" and ui_get("bool",antiaim.preset_static,5) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "IN_AIR" then
                
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(2,16)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 51
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                local arid = self.run_aa_logic.get_step(30,60,5,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(180,180),arid)
                self.value_table.antiaim.fake_options[2] = true

            end

            if states == "AIR_DUCK" and ui_get("bool",antiaim.preset_static,6) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "AIR_DUCK" then
                
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-1,33)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 45
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                AIR_deysnc = self.run_aa_logic.get_step(30,60,5,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(-180,180),AIR_deysnc)
                self.value_table.antiaim.fake_options[2] = true

            end

            -- antiaim.preset_static = menu.new_elements("int",ui_new_multiselect(t3,
            -- "[Built-in presets]","Suppress jitter select",_state,0,"[~] Disable jitter when choking commands"))
            -- local _state = {"Stand","Move","Slow walk","Duck","Air","Air + D"}



        end,

        run_main = function(self,cmd)
            self.value_table.choke = cmd.chokedcommands
            self:run_roll(cmd)



            if check_roll == false then

                if ui_get("value",antiaim.preset_mode) == 0 then
                    self:run_presets_1(cmd)
                elseif ui_get("value",antiaim.preset_mode) == 1 then
                    self:run_custom(cmd)
                end
            end
          

                  
        

    
            self:run_direction()
            self:run_edge()
            self:run_antiknife()

            if Cheat.IsKeyDown(0x45) then
                self.value_table.antiaim.pitch = 0
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_base = 0
                self.value_table.antiaim.freestanding_desync = 1
            end
            ui_set("value",reference.pitch,self.value_table.antiaim.pitch)
            ui_set("value",reference.yaw_base,self.value_table.antiaim.yaw_base)
            ui_set("value",reference.yaw_add,self.value_table.antiaim.yaw_add)
            ui_set("value",reference.yaw_jitter_mode,self.value_table.antiaim.yaw_jitter)
            ui_set("value",reference.yaw_jitter_slider,self.value_table.antiaim.yaw_jitter_degree)
            ui_set("value",reference.fake_angle,self.value_table.antiaim.fake_angle)
            ui_set("value",reference.inverter,self.value_table.antiaim.inverter)
            ui_set("value",reference.left_limit,self.value_table.antiaim.left_limit)
            ui_set("value",reference.right_limit,self.value_table.antiaim.right_limit)
            ui_set("bool",reference.fake_option,1,self.value_table.antiaim.fake_options[1])
            ui_set("bool",reference.fake_option,2,self.value_table.antiaim.fake_options[2])
            ui_set("bool",reference.fake_option,3,self.value_table.antiaim.fake_options[3])
            ui_set("bool",reference.fake_option,4,self.value_table.antiaim.fake_options[4])
            ui_set("value",reference.lby,self.value_table.antiaim.lby_mode)
            ui_set("value",reference.freestanding_yaw,self.value_table.antiaim.freestanding_desync)
            ui_set("value",reference.desync_shot,self.value_table.antiaim.desync_onshot)
        end,

        run_jumpscout_fix = function()
            if ui_get("bool",misc.select,3) == true  then
                local me = EntityList.GetLocalPlayer()
                if me == nil then
                    return
                end
                local weap = me:GetActiveWeapon()
                if weap == nil then
                    return
                end
                local speed_x = me:GetProp("DT_BasePlayer", "m_vecVelocity[0]")
                local speed_y = me:GetProp("DT_BasePlayer", "m_vecVelocity[1]")
                local speed = math.sqrt(speed_x * speed_x + speed_y * speed_y)
                if weap:IsGrenade() then
                    ui_set("value",reference.auto_starfe,true)
                else
                    if speed < 5 then 
                        ui_set("value",reference.auto_starfe,false)
                    else
                        ui_set("value",reference.auto_starfe,true)
                    end   
                end
            else
                ui_set("value",reference.auto_starfe,ui_get("value",reference.auto_starfe))
            end

                

            
        end,

        load_antiaim = function(self,cmd)
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
          
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end

            if not ui_get("bool",info.feature_list,2) == true then return end
            if EngineClient.IsConnected() and my_index:IsAlive() then
                self:run_main(cmd)
            end
        end,

        load_pre_antiaim = function(self,cmd)
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
          
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end
            if not ui_get("bool",info.feature_list,2) == true then return end

            if EngineClient.IsConnected() and my_index:IsAlive() then
                self:run_jumpscout_fix()
                self:run_onuse(cmd)
            end
        end
            
    }
    local damage_indicator_displays = {}


    local g_misc = {

        phrases = {
            "by UNFAILEr hvh boss",
            "sleep",
            "GLhf.exe Activated",
            "what you do dog??",
            "1 week lou doggo ovnet",
            "l2p bot",
            "why you sleep dog???",
            "$$$ 1 TAP UFF YA $$$",
            "0 iq",
            "iq ? HAHAHA",
            "Best and cheap configurations for gamesense, ot and neverlose waiting for your order  at ---> shoppy.gg/@Xamidimura",
            "最好的AA -> Ataraxia.pub",
            "中国的科技?>Ataraxia.pub,最好的AA",
            "XAXAXAXAXAXA (◣_◢)",
        },
        
        get_phrase = function(self)
            return self.phrases[Utils.RandomInt(1, #self.phrases)]:gsub('\"', '')
        end,

        run_trashtalk = function(self,event)
            if event:GetName() ~= "player_death" then return end
        
            local me = EntityList.GetLocalPlayer()
            local victim = EntityList.GetPlayerForUserID(event:GetInt("userid"))
            local attacker = EntityList.GetPlayerForUserID(event:GetInt("attacker"))
        
            if victim == attacker or attacker ~= me then return end
            if ui_get("bool",misc.select,4) == true then
                EngineClient.ExecuteClientCmd('say "' .. self:get_phrase() .. '"')

            end
        end,
        clant_var = {
            _set_clantag = ffi.cast('int(__fastcall*)(const char*, const char*)', Utils.PatternScan('engine.dll', '53 56 57 8B DA 8B F9 FF 15')),
            _last_clantag = nil,
        },
      
        set_clantag = function(self,v)
            if v == self.clant_var._last_clantag then return end
            self.clant_var._set_clantag(v, v)
            self.clant_var._last_clantag = v
        end,

        set_callback_clantag = function(self)
          
        end,

        run_marker_hurt = function(self,e)
            if e:GetName() ~= "player_hurt" then return end
            if e:GetInt("userid") == nil or e:GetInt("attacker") == nil or e:GetInt("dmg_health",0) == nil then
                return
            end
            local player = EntityList.GetPlayerForUserID(e:GetInt("userid"))
            local get_player_origin = entity_get_prop(player,"m_vecOrigin")
            if get_player_origin.x == nil or get_player_origin.y == nil or get_player_origin.z == nil then
                return
            end

            local voZ = entity_get_prop(player,"m_vecViewOffset[2]")

            if e.hitgroup == 1 then
                check_headshot = true
            else
                check_headshot = false
            end

 
            table_insert(damage_indicator_displays,{e:GetInt("dmg_health",0),GlobalVars.realtime,get_player_origin.x,get_player_origin.y,get_player_origin.z + voZ,check_headshot})

        end,

        run_hitsound = function(self,e)
            if e:GetName() ~= "player_hurt" then return end
            local localplayer = entity_get_localplayer()
            local attacker = EntityList.GetPlayerForUserID(e:GetInt("attacker"))
            if attacker == localplayer then
              if ui_get("bool",misc.select,5) == true then
                 EngineClient.ExecuteClientCmd(string.format("playvol %s %s", "buttons/arena_switch_press_02",ui_get("value",misc.hitsound_vol)/100))
              end
            end
        end,

        run_autostop = function(self,cmd, goal_speed)
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
 
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end

            local minspeed = math.sqrt((cmd.forwardmove * cmd.forwardmove) + (cmd.sidemove * cmd.sidemove))
            if goal_speed <= 0 or minspeed <= 0 then return end

            local flags = my_index:GetProp("m_fFlags")
            if bit.band(flags, 4) == 4 then
                goal_speed = goal_speed * 2.94117647
            end

            if minspeed <= goal_speed then return end
            local speed_factor = goal_speed / minspeed

            cmd.forwardmove = cmd.forwardmove * speed_factor
            cmd.sidemove = cmd.sidemove * speed_factor
        end,

        vars = {
            player_info_prev = {},
            round_started = 0,
            is_dormant_flag = false,

            minimal_vector = Vector.new(),
            maximal_vector = Vector.new()
        },

        calculate_angles = function(self,source, point)
            local world_to_screen = function(x_position, y_position)
                if x_position == 0 and y_position == 0 then return 0 end
      
                local atan_position = math.atan2(y_position, x_position)
                local deg_position = math.deg(atan_position)
      
                return deg_position
            end

            local delta_of_vectors = point - source
            local hyp = math.sqrt(delta_of_vectors.x * delta_of_vectors.x + delta_of_vectors.y * delta_of_vectors.y)
 
            local yaw = world_to_screen(delta_of_vectors.x, delta_of_vectors.y)
            local pitch = world_to_screen(hyp, -delta_of_vectors.z)
 
            return Vector.new(pitch, yaw, 0)
        end,

        get_hittable_damage = function(self,my_index, enemy, start_point, end_point)
            if my_index ~= nil then
                if enemy ~= nil then
                    local bullet_data = Cheat.FireBullet(my_index, start_point, end_point)
                    local bullet_damage = bullet_data.damage

                    local minimum_damage = ui_get("value",misc.dormant_aimbot_dmg)
                    local enemy_health = enemy:GetProp("m_iHealth")

                    if bullet_damage < math.min(minimum_damage, enemy_health) then
                        return 0
                    end

                    if bullet_data.trace.hit_entity ~= nil then
                        if bullet_data.trace.hit_entity:EntIndex() ~= enemy:EntIndex() then
                            return 0
                        end
                    end

                    if enemy:IsVisible(end_point) then
                        return 0
                    end

                    return bullet_damage
                end
            end
        end,

        run_dormant_aimbot = function(self,cmd)
            if ui_get("value",misc.dormant_aimbot) then
                local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
                if not localplayer then return end
      
                local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
                if not my_index then return end
      
                local my_weapon = my_index:GetActiveWeapon()
                if not my_weapon then return end
      
                local weapon_id = my_weapon:GetWeaponID()
                if not weapon_id then return end

                if EngineClient.IsConnected() and my_index:IsAlive() then
                    local get_inaccuracy = my_weapon:GetInaccuracy(my_weapon)
                    local tickcount = GlobalVars.tickcount
      
                    local player_resource = EntityList.GetPlayerResource()
                    local eye_position = my_index:GetEyePosition()
      
                    local simulation_time = my_index:GetProp("m_flSimulationTime")
                    local on_ground = bit.band(my_index:GetProp("m_fFlags"), bit.lshift(1, 0)) == 1 and true or false

                    if tickcount < self.vars.round_started then
                        return
                    end

                    local primary_attack = my_weapon:GetProp("m_flNextPrimaryAttack")
                    local next_attack = my_index:GetProp("m_flNextAttack")
                    local secondary_attack = my_weapon:GetProp("m_flNextSecondaryAttack")

                    local can_shoot = false
                    if weapon_id == 64 then -- revolver
                        can_shoot = simulation_time > primary_attack
                    elseif my_weapon:IsKnife() or my_weapon:IsGrenade() or weapon_id == 31 then
                        can_shoot = false
                    else
                        can_shoot = simulation_time > math.max(next_attack, primary_attack, secondary_attack)
                    end

                    local player_info = {}
                    local players = EntityList.GetEntitiesByName("CCSPlayer")
                  
                    for i = 1, #players do
                        local enemy = players[i]:GetPlayer()
                        if enemy ~= my_index and not enemy:IsTeamMate() and enemy:IsAlive() then
                            local network_state = enemy:GetNetworkState()
                            if enemy:IsDormant() and network_state ~= -1 then
                                local can_hit = false
                                local origin = enemy:GetProp("m_vecOrigin")
                                local alpha_multiplier = enemy:GetESPAlpha()

                                if self.vars.player_info_prev[i] ~= nil and origin.x ~= 0 and alpha_multiplier > 0 then
                                    local is_dormant_accurate = alpha_multiplier > 0.2
                                    if is_dormant_accurate then
                                        local bounds = enemy:GetRenderBounds(self.vars.minimal_vector, self.vars.maximal_vector)
                                        local all_vector_points = {
                                            origin + Vector.new(0, 0, 38),
                                            origin + Vector.new(0, 0, 40),
                                            origin + Vector.new(0, 0, 42),
                                            origin + Vector.new(0, 0, 50)
                                        }

                                        local best_damage = 0
                                        local best_point = Vector.new()
                                        local my_eye_position = my_index:GetEyePosition()
                                      
                                        for point = 1, #all_vector_points do
                                            local current_point = all_vector_points[point]
                                            local start_position = self:calculate_angles(my_eye_position, current_point)
                                            local damage = self:get_hittable_damage(my_index, enemy, my_eye_position, current_point)

                                            if damage > best_damage then
                                                best_damage = damage
                                                best_point = start_position
                                                can_hit = true
                                            end
                                        end

                                        local get_max_speed = my_weapon:GetMaxSpeed()
                                        if can_shoot and can_hit then
                                            self.vars.is_dormant_flag = true
                                            self:run_autostop(cmd, get_max_speed * 0.33)

                                            if get_inaccuracy < 0.009 then
                                                cmd.viewangles.pitch = best_point.x
                                                cmd.viewangles.yaw = best_point.y
                                                cmd.viewangles.roll = 0.0

                                                cmd.buttons = bit.bor(cmd.buttons, 1)
                                                self.vars.is_dormant_flag = true

                                                can_shoot = false
                                            end
                                        elseif not can_hit then
                                            self.vars.is_dormant_flag = false
                                        end
                                    end
                                end
                                player_info[i] = {origin, alpha_multiplier, can_hit}
                            end
                        end
                    end
                    self.vars.player_info_prev = player_info
                end
            end
        end,

        reset_data = function(self, e)
            if ui_get("value",misc.dormant_aimbot) then
                local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
                if not localplayer then return end
      
                local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
                if not my_index then return end
      
                if EngineClient.IsConnected() and my_index:IsAlive() then
                    if e:GetName() == "round_prestart" then
                        local mp_freezetime = CVar.FindVar("mp_freezetime"):GetFloat()
                        local ticks = GlobalVars.interval_per_tick
              
                        local freezetime = (mp_freezetime + 1) / ticks
                        local tickcount = GlobalVars.tickcount
              
                        self.vars.round_started = tickcount + freezetime
                    end
                end
            end
        end,

        run_evets = function(self,e)
            if e:GetName() == "round_start" then
                table.insert(noti_table, {
                    text = "Reseted data due to round start",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
            end

            if e:GetName() == "player_death" then
                if EntityList.GetPlayerForUserID(e:GetInt("userid")) == EntityList.GetLocalPlayer() then
                    table.insert(noti_table, {
                        text = "Reseted data due to player death",
                        timer = GlobalVars.realtime,
                        smooth_y = sc_y + 100,
                        alpha = 0,
                    })
                end
            end

            if e:GetName() == "player_hurt" then
                if EntityList.GetPlayerForUserID(e:GetInt("userid")) == EntityList.GetLocalPlayer() and e:GetInt("hitgroup") ~= 0 then
                    table.insert(noti_table, {
                        text = "Received data due to player hurt",
                        timer = GlobalVars.realtime,
                        smooth_y = sc_y + 100,
                        alpha = 0,
                    })
                end
            end


        end,

        run_hitchance = function(self)
            if ui_get("bool",misc.select,6) == true then
                if entity_get_localplayer() == nil then
                    return
                end
                local is_scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
        
                local player = entity_get_localplayer()
                local weapon = player:GetActiveWeapon()
                
                
                local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
                if weapon ~= nil then
                    if weapon:GetWeaponID() == 38 or 11 or 9 or 40 then
                        if not is_scoped then
                            for i = 1, 64 do
                                RageBot.OverrideHitchance(i, ui_get("value",misc.hitchance_noscope))
                            end
                        end
                    end
                end

                if on_ground == 0 then
                    for i = 1, 64 do
                        RageBot.OverrideHitchance(i, ui_get("value",misc.hitchance_inair))
                    end
                end
            end
            
        end,

        hit_groups = {
            [0] = "body",
            [1] = "head",
            [2] = "chest",
            [3] = "stomach",
            [4] = "left arm",
            [5] = "right arm",
            [6] = "left leg",
            [7] = "right leg",
            [10] = "unknown"
        },

        get_round = function(self,num, numDecimalPlaces)
            return tonumber(string.format("%." .. (numDecimalPlaces or 0) .. "f", num))
        end,

        on_shot = function(self,e)
            local entity = EntityList.GetClientEntity(e.target_index)
            local player = entity:GetPlayer()
            local reason = ""
            if (e.reason == 0) then
                self:on_hurt(e)
                return
            elseif (e.reason == 1) then
        
                reason = "resolver"
                if (Menu.FindVar("Aimbot", "Ragebot", "Main", "Override Resolver"):GetBool()) then
                    reason = "resolver"
                end
            elseif (e.reason == 2) then
                reason = "spread degree (" .. tostring(self:get_round(e.spread_degree, 3)) .."°) safepoint (false)"
            elseif (e.reason == 3) then
                reason = "spread degree (" .. tostring(self:get_round(e.spread_degree, 3)) .."°) safepoint (true)"
            elseif (e.reason == 4) then
                reason = "prediction error"
            end
            local hitbox = ""
            if ((e.wanted_hitgroup > -1 and e.wanted_hitgroup < 8) or e.wanted_hitgroup == 10) then
                hitbox = self.hit_groups[e.wanted_hitgroup]
            else
                hitbox = "unknown"
            end
            debugger("Missed ["..player:GetName().."] hitbox: [".. hitbox.."] hitchance: ["..e.hitchance.."] reason: ["..reason.."] backtrack: ".. e.backtrack.."ticks health remain: ["..entity:GetProp('m_iHealth').."]")

        end,

        on_hurt = function(self,e)
            if e.reason > 0 and e.reason < 5 then
                self:on_shot(e)
                return
            end
            local entity = EntityList.GetClientEntity(e.target_index)
            local player = entity:GetPlayer()
            local hitbox = ""
            if ((e.hitgroup > -1 and e.hitgroup < 8) or e.hitgroup == 10) then
                hitbox = self.hit_groups[e.hitgroup]
            else
                hitbox = "unknown"
            end
            debugger("Hit ["..player:GetName().."] hitbox: ["..hitbox.."] hitchance: ["..e.hitchance.."] damage: ["..e.damage.."] backtrack: ".. e.backtrack.."ticks health remain: ["..entity:GetProp('m_iHealth').."]")
        end,
    
        run_hitlog = function(self,e)
            self:on_shot(e)

        end,

        load_events = function(self,event)
            self:run_trashtalk(event)
            self:run_marker_hurt(event)
            self:run_hitsound(event)
            self:run_evets(event)
            self:reset_data(event)
        end
        
    }

    local lerp = function(start, vend, time)
        return start + (vend - start) * time
    end
        
    local render_measure_text = function(size,fonts,text)
        local size = Render_CalcTextSize(text,size,fonts)
        return size
    end

    local render_text = function(x,y,fonts,size,outline,center,r,g,b,a,text)
        Render_Text(text,Vector2.new(x,y),Color_RGBA(math.floor(r),math.floor(g),math.floor(b),math.floor(a)),size,fonts,outline,center)
    end
    
    local render_rectangle = function(x,y,w,h,r,g,b,a,round)
        Render_BoxFilled(Vector2.new(x ,y ),Vector2.new(x + w,y + h),Color_new(r/255,g/255,b/255,a/255),round)
    end


    local render_Box = function(x,y,w,h,r,g,b,a,round)
        Render.Box(Vector2.new(x ,y ),Vector2.new(x + w,y + h),Color_new(r/255,g/255,b/255,a/255),round)
    end

    local render_gradient = function(x,y,w,h,r,g,b,a,r1,g1,b1,a1,type)
        local first_gradient = Color_new(r/255,g/255,b/255,a/255)
        local second_gradient = Color_new(r1/255,g1/255,b1/255,a1/255)

        if type == true then
            Render_GradientBoxFilled(Vector2.new(x, y), Vector2.new(x + w, y + h),first_gradient,second_gradient,first_gradient, second_gradient)
        elseif type == false then
            Render_GradientBoxFilled(Vector2.new(x, y), Vector2.new(x + w, y + h), first_gradient, first_gradient, second_gradient, second_gradient)
        end     
    end

    
    local render_circle_outline = function(x,y,radius,r,g,b,a,thickness,start,enddegree)
        Render.Circle(Vector2.new(x, y),radius, 32, Color.new(r/255, g/255, b/255, a/255),thickness,start,enddegree)
    end

    local render_circle = function(x,y,radius,r,g,b,a,start,enddegree)
        Render_CircleFilled(Vector2.new(x, y), radius, 30, Color.new(r/255, g/255, b/255, a/255))
    end

    local render_glow_rectangle = function(x,y,w,h,r,g,b,a,round,size,g_w)
        for i = 1 , size , 0.3 do
            local fixpositon = (i  - 1) * 2     
            local fixi = i  - 1
            render_Box(x - fixi, y - fixi, w + fixpositon , h + fixpositon , r , g ,b , (a -  i * g_w) , round)   
            
        end
    end

    local render_glow_rectangle_gradient = function(x,y,w,h,r,g,b,a,r1,g1,b1,a1,type,size,g_w,type)
        for i = 1 , size , 1.0 do
            local fixpositon = (i  - 1) * 2     
            local fixi = i  - 1
            render_gradient(x - fixi, y - fixi, w + fixpositon , h + fixpositon , r , g ,b , (a -  i * g_w) ,r1,g1,b1, (a1 -  i * g_w) , type)   
        end
    end

    local linear = function(check,val,value,speed)
        if check then
            return val + (value - val) * GlobalVars.frametime * speed
        else
            return val - (value + val) * GlobalVars.frametime * speed / 2;
        end
    end

    local entity_is_enemy = function(index)
        if index == nil then
            return false
        end

        return index:IsTeamMate() == false
    end

    local entity_is_alive = function(index)
        if index == nil then
            return false
        end

        return entity_get_prop(index,"m_lifeState") == false
    end

    local distance_3d = function(x1,y1,z1,x2,y2,z2)
        if x1 == nil or y1 == nil or z1 == nil or x2 == nil or y2 == nil or z2 == nil then
            return 0
        end
        return math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
    end

    local client_threat = function()
        local me = entity_get_localplayer()
        if entity_get_localplayer() == nil then
            return nil
        end
        local lm = entity_get_prop(entity_get_localplayer(),"m_vecOrigin")
        local lx,ly,lz = lm.x,lm.y,lm.z
        local view = EngineClient_GetViewAngles()
        local viewangle_x,viewangle_y,roll = view.pitch,view.yaw,view.roll
        local enemies = EntityList.GetPlayers()

        if #enemies == 0 then
            return nil
        end
        local data = {id = nil ,dis = 0 ,last_dmg = 0}
        for k, v in pairs(enemies) do
            if (not entity_is_enemy(enemies[k]) or (enemies[k] == me) or (not entity_is_alive(enemies[k])) or (enemies[k]:IsDormant())) then goto skip end
            local em = enemies[k]:GetProp("m_vecOrigin")
            local ex,ey,ez = em.x,em.y,em.z
            local trace = Cheat.FireBullet(me,Vector.new(ex,ey,ez),Vector.new(lx,ly,lz))

            if trace.damage > data.last_dmg then
                table_insert(data,{id = enemies[k],dis = distance_3d(lx,ly,lz,ex,ey,ez),last_dmg = trace.damage})
            end
            ::skip::
        end

        if data == nil then
            return
        end
        if data.id == nil then
            return
        end

        return data
    end


    local gradient_text = function(b, c, d, e, f, g, h, i, j, k, l, size, fonts, out)
        local m = ""
        local n = 0
        local o = #l - 1
        local p = (h - d) / o
        local q = (i - e) / o
        local r = (j - f) / o
        local s = (k - g) / o
        for t = 1, o + 1 do
            local u = string.sub(l, t, t)
            local v = Render.CalcTextSize(u, size, fonts)
            Render.Text(u .. "", Vector2.new(b + n, c), Color.new(d, e, f, g), size, fonts, out)
            d = d + p
            e = e + q
            f = f + r
            g = g + s
            n = n + v.x
        end
    end
    

    local FONTS = {
        PIXEL_10 = Render_InitFont("Smallest Pixel-7",10,{"","",""}),
        PIXEL_11 = Render_InitFont("Smallest Pixel-7",11,{"","",""}),

        PIXEL_12 = Render_InitFont("Smallest Pixel-7",12,{"","",""}),
        PIXEL_18 = Render_InitFont("Smallest Pixel-7",18,{"","",""}),
        TAHOMA_15 = Render_InitFont("Tahoma",15,{"","",""}),
        TAHOMA_15_BOLD = Render_InitFont("Tahoma",15,{"b","",""}),
        TAHOMA_12_BOLD = Render_InitFont("Tahoma",12,{"b","",""}),
        VERDANA_12 = Render_InitFont("Verdana",11,{"","",""}),
        VERDANA_12_BOLD = Render_InitFont("Verdana",11,{"b","",""}),
        VERDANA_12_R = Render_InitFont("Verdana",11,{"","","r"}),

        VERDANA_13 = Render_InitFont("Verdana",13,{"","",""}),
        VERDANA_13_BOLD = Render_InitFont("Verdana",13,{"b","",""}),
        VERDANA_36_BOLD = Render_InitFont("Verdana",36,{"b","",""}),

        VERDANA_40_BOLD = Render_InitFont("Verdana",40,{"b","",""}),
        ARROWS_12 = Render.InitFont("Acta Symbols W95 Arrows", 12),
        ARROWS_24 = Render.InitFont("Acta Symbols W95 Arrows", 20)

        
    }

    local svg = '<svg t="1650815150236" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="1757" width="200" height="200"><path d="M750.688207 480.651786c-40.458342 65.59852-115.105654 102.817686-205.927943 117.362627 2.382361 26.853806 0.292571 62.00408 20.897903 102.232546 40.77181 79.621013 76.486328 166.28462 88.356337 229.897839 69.819896 30.824408 215.958937-42.339153 257.671154-134.540705 44.721514-98.847085 0-202.082729-74.103967-210.755359-74.083069-8.651732-117.655198 31.555835-109.902076 78.65971 7.732224 47.103875 51.868597 47.918893 96.485622 16.822812 44.617024-31.075183 85.869486 32.517138 37.992389 60.562125-47.897995 28.044987-124.133548 44.867799-168.228125-5.642434-44.094577-50.489335-40.458342-228.205109 143.65219-211.716662 184.110532 16.509344 176.127533 261.683551 118.804583 344.042189C894.465785 956.497054 823.600993 1024.519731 616.37738 1023.997283h-167.18323V814.600288 1023.997283h-168.269921c-83.424432 0-24.743118-174.267619 51.826801-323.750324 20.584435-40.228465 18.494645-75.378739 20.897904-102.232546C262.784849 583.469472 188.137536 546.250306 147.679195 480.651786H93.867093A20.814312 20.814312 0 0 1 73.031883 459.753882c0-11.535643 9.46675-20.897904 20.83521-20.897903H127.993369a236.480679 236.480679 0 0 1-10.093687-41.795808H52.071285A20.814312 20.814312 0 0 1 31.236075 376.162267c0-11.535643 9.46675-20.897904 20.83521-20.897903H114.82769v-0.877712c0-57.009481 15.171878-103.131155 41.795808-139.514406V28.379353c0-11.535643 8.630834-17.136281 19.267867-12.517844l208.979037 90.864085c20.793414-2.08979 42.318255-3.113788 64.323748-3.113787s43.530333 1.044895 64.344646 3.134685l208.979037-90.884983c10.616135-4.618437 19.246969 0.982201 19.246969 12.538742v186.471995c26.623929 36.38325 41.795807 82.504924 41.795808 139.514406V355.264364h62.756405c11.493847 0 20.83521 9.278669 20.83521 20.897903 0 11.535643-9.46675 20.897904-20.83521 20.897904h-65.828397a236.480679 236.480679 0 0 1-10.093688 41.795808h34.126277c11.493847 0 20.83521 9.278669 20.83521 20.897903 0 11.535643-9.46675 20.897904-20.83521 20.897904h-53.833z" p-id="1758" fill="#ffffff"></path></svg>'
    local image_loaded = Render.LoadImage(svg, Vector2_new(32,32))

    local render_stringwithshadow = function(type,x,y,center,r,g,b,a,text)
        if type == "n" then
            render_text(x + 1,y + 1,FONTS.VERDANA_12,11,false,center,30,30,30,a,text)

            render_text(x,y,FONTS.VERDANA_12,11,false,center,r,g,b,a,text)

        elseif type == "b" then
            render_text(x + 1,y + 1,FONTS.VERDANA_12_BOLD,11,false,center,30,30,30,a,text)
            render_text(x,y,FONTS.VERDANA_12_BOLD,11,false,center,r,g,b,a,text)

        end
    end
    local is_breaking_lc = false
    local last_sent,current_choke = 0,0

  


    local g_visual = {
        g_vars = {
            check_show = false,
            check_show_time = GlobalVars.realtime,
            g_alpha = 0,
            arrows = {
                g_alpha = 0,
                l=0,
                r=0
            },
            menu_effect = {
                g_alpha = 0,
                o_alpha = 0,
                height = 0,
                cur_alpha = 200,
                min_alpha = 75,
                max_alpha = 200,
                target_alpha = 0,
                speed = 0.08,
                last_change = GlobalVars.realtime - 1,

                dots_alpha = 0,
                key_last_press = 0,
                dots = {},
                dot_size = 3,
                menu_open_prev = true,
            },
            watermark = {
                g_alpha = 0,
                cur_alpha = 1,
                min_alpha = 0.2,
                max_alpha = 1,
                target_alpha = 0,
                speed = 0.2,

            },
            center = {
                g_alpha = 0,
                o_alpha = 0,
                add_x = 0,
                cur_alpha = 22,
                min_alpha = 15,
                max_alpha = 22,
                target_alpha = 0,
                speed = 0.2,
                add_y = 0,
                width = 0,
                r_alpha = 0,

                desync_line = 0,

                left_r = 0,
                left_g = 0,
                left_b = 0,
                left_a = 0,

                right_r = 0,
                right_g = 0,
                right_b = 0,
                right_a = 0,

                rect_alpha = 0,
                rect_add_y = 0,
                rect_width = 0,

                dt_add_y = 0,
                dt_r = 0,
                dt_g = 0,
                dt_b = 0,
                dt_a = 0,

                hs_add_y = 0,

                ground_ticks = 0,




            },
            scopeline = {
                toleng = 0
            },
            s_watermark = {
                g_alpha = 0,
                current_time = GlobalVars.curtime,
                current_fps = 0,
                fps_counter = 0,       
                width = 0,

                --anti-aimbot & FL Text indicator
                add_x = 0,
                get_cmd_width = 0,
                get_fake_width = 0,
                get_circle_degree = 0,
                GET_FAKE_AMOUNT_LERP = 0
                
            },

            s_keybind = {
                g_alpha = 0,
                keybinds_alpha = {},
                keybinds_anime_posy = {},
                keybinds_y = {},

                width = 0,
                is_draggable = false,
                cursor_last_pos = Vector2.new(0, 0),
                container_alpha = 0,
                re_anim_width = 0,
                re_anim_x = 0,
                re_anim_y = 0,
                re_anim_add_y = 0,
                anims_add_y = 0,
                real_add_y = 0

            },
            s_spec = {
                g_alpha = 0,
                keybinds_alpha = {},
                keybinds_anime_posy = {},
                keybinds_y = {},

                width = 0,
                is_draggable = false,
                cursor_last_pos = Vector2.new(0, 0),
                container_alpha = 0,
                re_anim_width = 0,
                re_anim_x = 0,
                re_anim_y = 0,
                re_anim_add_y = 0,
                anims_add_y = 0,
                real_add_y = 0,
                binds = {},
                spec_offset = 0,
                size = Vector2.new(122 , 17)



            }
        },

        

        solus_render = (function()
            local solus_m = {}
            local rounding = 4;
            local rad = rounding + 2;
            local n = 45;
            local o = 20;

            local roundedrect = function(x, y, w, h, radius, r, g, b, a)
                Render.Blur(Vector2.new(x, y), Vector2.new(x + w, y + h),Color.new(255,255,255,a*255),radius)
                render_rectangle(x,y,w,h,r,g,b,a,radius)
            end

            local outline_glow = function(x,y,w,h,radius,r,g,b,a)
                render_rectangle(x + 2, y + radius + rad, 1, h - rad * 2 - radius * 2,r, g, b, a,0)
                render_rectangle(x + w - 3, y + radius + rad, 1,h - rad * 2 - radius * 2, r, g, b, a,0)
                render_rectangle(x + radius + rad, y + 2, w - rad * 2 - radius * 2, 1,r, g, b, a,0)
                render_rectangle(x + radius + rad, y + h - 3,w - rad * 2 - radius * 2, 1, r, g, b, a,0)
                render_circle_outline(x + radius + rad, y + radius + rad, radius + rounding,r,g,b,a,1,-90,-180)
                render_circle_outline(x + w - radius - rad, y + radius + rad, radius + rounding,r, g, b,a,1, -90, 0)

                render_circle_outline(x + radius + rad, y + h - radius - rad, radius + rounding,r, g, b,a,1, 90, 180)
                render_circle_outline(x + w - radius - rad, y + h - radius - rad, radius + rounding,r, g, b,a,1, 90, 0)
        
            end
            local FadedRoundedRect = function(x, y, w, h, radius, r, g, b, a, glow)
                local n = a / 255 * n;
                if not ui_get("value",visuals.disable_glow) then
                    for radius = 4, glow do
                        local radius = radius / 2;
                        outline_glow(x - radius, y - radius, w + radius * 2,h + radius * 2, radius, r, g, b, glow - radius * 2)
                    end
                end
        
                render_rectangle(x + radius, y, w - radius * 2, 1, r, g, b, a,0)
                render_circle_outline(x + radius, y + radius,radius,  r, g, b, a, 1,-90,-180)
                render_circle_outline(x + w - radius, y + radius,radius,  r, g, b, a, 1,-90,0)
                render_circle_outline(x + radius, y + h - radius,radius,  r, g, b, n, 1,90,180)
                render_circle_outline(x + w - radius, y + h - radius,radius,  r, g, b, n, 1,90,0)
            
                render_gradient(x, y + radius, 1, h - radius * 2, r, g, b, a, r, g, b,n, false)
                render_gradient(x + w - 1, y + radius, 1, h - radius * 2, r, g, b, a,r, g, b, n, false)

                render_rectangle(x + radius, y + h - 1, w - radius * 2, 1, r, g, b, n,0)
                
            end;

            solus_m.glow = function(x, y, w, h, radius, r, g, b, a, glow)
                for radius = 1, glow do
                    local radius = radius / 2;
                    render_rectangle(x - radius, y - radius, w + radius * 2,h + radius * 2,r, g, b, glow - radius * 2,radius)
                end
            end

            solus_m.glow_gradient = function(x, y, w, h, radius,r, g, b, a,r1,g1,b1,a1, glow)
                for radius = 1, glow do
                    local radius = radius / 2;
                    render_gradient(x - radius, y - radius, w + radius * 2,h + radius * 2,r, g, b, glow - radius * 2,r1,g1,b1,glow - radius * 2,true)
                end
            end


            solus_m.container = function(x, y, w, h, r, g, b, a, alpha)
                roundedrect(x, y, w, h, rounding, 17, 17, 17,a)
                FadedRoundedRect(x,y,w,h,rounding,r,g,b,alpha * 255, alpha * o)
            end
            solus_m.measure_multitext = function(fonts,size,_table)
                local x,y = 0,0
                for k, v in pairs(_table) do
                    local text_ = render_measure_text(size,fonts,v.text)
                    x = x + text_.x
                    y = y + text_.y
                end
                return {x = x ,y = y}
            end

            solus_m.multitext = function(x,y,fonts,size,outline,center,_table)
                for k, v in pairs(_table) do
                    v.color = v.color or {255,255,255,255}
                    v.color[4] = v.color[4] or 255

                    render_text(x,y,fonts,size,outline,center,v.color[1],v.color[2],v.color[3],v.color[4],v.text)
                    x = x + render_measure_text(size,fonts,v.text).x
                end
            end

            return solus_m
        end)(),

        on_script_start = function(self)

            if not self.g_vars.check_show then

                self.g_vars.g_alpha = lerp(self.g_vars.g_alpha,1,GlobalVars.frametime * 3.5)
            else
                self.g_vars.g_alpha = lerp(self.g_vars.g_alpha,0,GlobalVars.frametime * 3.5)
            end

      
            local screen = EngineClient_GetScreenSize()
            local cx , cy = screen.x /2,screen.y/2
            local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Welcome to Ataraxia , "..userdata.username..".")
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            Render.Blur(Vector2.new(0,0), Vector2.new(screen.x  , screen.y ),Color_RGBA(255,255,255,math_floor(255 * self.g_vars.g_alpha)))
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            render_gradient(cx - text_size.x/2 - 3,cy + text_size.y/2  ,text_size.x/2 +  6 ,2,r,g,b,0,r,g,b,255 * self.g_vars.g_alpha ,true)
            render_gradient(cx + 3,cy + text_size.y/2 ,text_size.x/2 +  5 + 2 ,2,r,g,b,255 * self.g_vars.g_alpha,r,g,b,0 ,true)


            render_stringwithshadow("b",cx,cy,true,255,255,255,255 * self.g_vars.g_alpha,"Welcome to Ataraxia , "..userdata.username..".")
            if self.g_vars.check_show_time + 3 < GlobalVars.realtime then
                self.g_vars.check_show_time = GlobalVars.realtime
                self.g_vars.check_show = true
            end
        end,

        get_center_states = function(self)
            
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.g_vars.center.ground_ticks = self.g_vars.center.ground_ticks + 1
            else
                self.g_vars.center.ground_ticks = 0
            end
            
            if Cheat_IsKeyDown(0x45) then
                return "USE"
            elseif check_roll == true then
                return "ROLL" 
            elseif g_antiaim.value_table.antiaim.yaw_base == 3 or g_antiaim.value_table.antiaim.yaw_base == 2 then
                return "MANUAL"
            elseif in_air and duck then
                return "AIR+D"
            elseif in_air then
                return "AIR"
            elseif ui_get("value",reference.slow_motion) and self.g_vars.center.ground_ticks > 8 then
                return "SLOWWALK"
            elseif duck and self.g_vars.center.ground_ticks > 8 then
                return "DUCK"
            elseif velocity > 4 and self.g_vars.center.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "MOVE"
            elseif velocity < 2 and self.g_vars.center.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "STAND"
            else
                return "AIR"
            end
        end,

        run_center = function(self)
            local v = self.g_vars.center
            if ui_get("bool",visuals.indicator_settings,2) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
            elseif ui_get("bool",visuals.indicator_settings,2) == false then
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
            end

            local cx ,cy = EngineClient_GetScreenSize().x /2,EngineClient_GetScreenSize().y/2
            local is_scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
            local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Ataraxia")
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            local r_td,g_td,b_td,a_td = ui_get("color",visuals.center_color_2).r,ui_get("color",visuals.center_color_2).g,ui_get("color",visuals.center_color_2).b,ui_get("color",visuals.center_color_2).a
            local r1,g1,b1,a1 = r_td*255,g_td*255,b_td *255 ,a_td *255
            local modifier = entity_get_prop(entity_get_localplayer(), "m_flVelocityModifier")

            local get_anims_alpha = ui_get("bool",visuals.center_scoped_anim,1)
            local get_anims_pos = ui_get("bool",visuals.center_scoped_anim,2)

            if is_scoped then
                if get_anims_pos == true then
                    v.add_x = lerp(v.add_x,30,GlobalVars.frametime * 8)
                end

                if get_anims_alpha == true then
                    v.o_alpha = lerp(v.o_alpha,0.3,GlobalVars.frametime * 8)
                end
            else
                if modifier ~= 1 then
                    v.add_y = lerp(v.add_y,1,GlobalVars.frametime * 8)
                else
                    v.add_y = lerp(v.add_y,0,GlobalVars.frametime * 8)
                end

                    v.o_alpha = lerp(v.o_alpha,1,GlobalVars.frametime * 8)
                

                if get_anims_pos == true then
                    v.add_x = lerp(v.add_x,0,GlobalVars.frametime * 8)
                end

            end

            if (v.cur_alpha < v.min_alpha + 1) then
                v.target_alpha = v.max_alpha
            elseif (v.cur_alpha > v.max_alpha - 1) then
                v.target_alpha = v.min_alpha
            end
            v.cur_alpha = v.cur_alpha + (v.target_alpha - v.cur_alpha)*v.speed*(GlobalVars.absoluteframetime*10)
            local inverted = AntiAim_GetInverterState()
            if inverted then
                v.left_r = lerp(v.left_r,r,GlobalVars.frametime * 12)
                v.left_g = lerp(v.left_g,g,GlobalVars.frametime * 12)
                v.left_b = lerp(v.left_b,b,GlobalVars.frametime * 12)
                v.left_a = lerp(v.left_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                v.right_r = lerp(v.right_r,255,GlobalVars.frametime * 12)
                v.right_g = lerp(v.right_g,255,GlobalVars.frametime * 12)
                v.right_b = lerp(v.right_b,255,GlobalVars.frametime * 12) 
                v.right_a = lerp(v.right_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
            else
                v.left_r = lerp(v.left_r,255,GlobalVars.frametime * 12)
                v.left_g = lerp(v.left_g,255,GlobalVars.frametime * 12)
                v.left_b = lerp(v.left_b,255,GlobalVars.frametime * 12)
                v.left_a = lerp(v.left_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                v.right_r = lerp(v.right_r,r,GlobalVars.frametime * 12)
                v.right_g = lerp(v.right_g,g,GlobalVars.frametime * 12)
                v.right_b = lerp(v.right_b,b,GlobalVars.frametime * 12) 
                v.right_a = lerp(v.right_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
            end

            if modifier ~= 1 then
                v.rect_add_y = lerp(v.rect_add_y,1,GlobalVars.frametime * 12)
                
            else
                v.rect_add_y = lerp(v.rect_add_y,0,GlobalVars.frametime * 12)
            end

            if ui_get("value",reference.dt) then

                if doubletap_charged() then
                    v.dt_r = lerp(v.dt_r,r,GlobalVars.frametime * 12)
                    v.dt_g = lerp(v.dt_g,g,GlobalVars.frametime * 12)
                    v.dt_b = lerp(v.dt_b,b,GlobalVars.frametime * 12)
                    v.dt_a = lerp(v.dt_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                else
                    v.dt_r = lerp(v.dt_r,255,GlobalVars.frametime * 12)
                    v.dt_g = lerp(v.dt_g,0,GlobalVars.frametime * 12)
                    v.dt_b = lerp(v.dt_b,0,GlobalVars.frametime * 12)
                    v.dt_a = lerp(v.dt_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                end
                v.dt_add_y = lerp(v.dt_add_y,1,GlobalVars.frametime * 12)

            else
                v.dt_add_y = lerp(v.dt_add_y,0,GlobalVars.frametime * 12)

            end

            if ui_get("value",reference.hs) then
                v.hs_add_y = lerp(v.hs_add_y,1,GlobalVars.frametime * 12)
            else
                v.hs_add_y = lerp(v.hs_add_y,0,GlobalVars.frametime * 12)
            end


            if ui_get("value",visuals.center_mode) == 0 then
                self.solus_render.glow(cx - text_size.x/2 - 1 + 4+ math_floor(v.add_x),cy + 25.5,text_size.x - 8,(text_size.y - 5)/2 - 4,5,r,g,b,math_floor(a*v.g_alpha),math_floor(v.cur_alpha *v.g_alpha)*v.o_alpha)
                render_rectangle(
                    cx - text_size.x/2 + math_floor(v.add_x),cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 *  v.add_y),text_size.x,3,25,25,25,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
                )
                render_rectangle(
                    cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18   + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y) + 1,math_floor(((text_size.x - 1) * modifier) * v.add_y),1,r,g,b,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
                )
                render_stringwithshadow("b",cx - text_size.x/2 + math_floor(v.add_x),cy + 18 -  math_floor(4 * v.add_y),false,r,g,b,math_floor(a*v.g_alpha)*v.o_alpha,"Ataraxia")
            elseif ui_get("value",visuals.center_mode) == 1 then

                self.solus_render.glow_gradient(cx - text_size.x/2 - 1 + 4+ math_floor(v.add_x) + 2,cy + 25.5,text_size.x - 8,(text_size.y - 5)/2 - 4,2,r,g,b,math_floor(a*v.g_alpha),r1,g1,b1,math_floor(a1*v.g_alpha),math_floor(v.cur_alpha *v.g_alpha)*v.o_alpha)
                render_rectangle(
                    cx - text_size.x/2 + math_floor(v.add_x),cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 *  v.add_y),text_size.x,3,25,25,25,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
                )
 
                render_gradient(cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18   + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y) + 1,math_floor(((text_size.x - 1) * modifier) * v.add_y),1,r,g,b,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,r1,g1,b1,math_floor((a1 * v.add_y)*v.g_alpha)*v.o_alpha,true)
                render_text(cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18 -  math_floor(4 * v.add_y) + 1,FONTS.VERDANA_12_BOLD,11,false,false,30,30,30,math_floor(a1*v.g_alpha)*v.o_alpha,"Ataraxia")
                gradient_text(cx - text_size.x/2 + math_floor(v.add_x),cy + 18 -  math_floor(4 * v.add_y),r/255,g/255,b/255,math_floor(a*v.g_alpha)*v.o_alpha/255,r1/255,g1/255,b1/255,math_floor(a1*v.g_alpha)*v.o_alpha/255,"Ataraxia",11,FONTS.VERDANA_12_BOLD,false,false)
            elseif ui_get("value",visuals.center_mode) == 2 then
                local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Atar")
                local text_size_2  = render_measure_text(11,FONTS.VERDANA_12_BOLD,"axia")
                local g_x = text_size.x + text_size_2.x
                local x,y = cx - g_x / 2 + math_floor(v.add_x ) ,cy + 18

                local modifier = entity_get_prop(entity_get_localplayer(), "m_flVelocityModifier")

                local alpha = math.floor(
                    math.sin(math.abs(-math.pi + (GlobalVars.curtime * (1.25 / .75)) % (math.pi * 2))) * 200
                )
                v.desync_line = lerp(v.desync_line,math_floor(get_fake_amount/100 ),GlobalVars.frametime * 12)

                local inverted = AntiAim_GetInverterState()


                local get_states = self:get_center_states()

                

                local dt_r,dt_g,dt_b,dt_a = math_floor(v.dt_r),math_floor(v.dt_g),math_floor(v.dt_b),math_floor(v.dt_a)
                local left_r,left_g,left_b,left_a = math_floor(v.left_r),math_floor(v.left_g),math_floor(v.left_b),math_floor(v.left_a)
                local right_r,right_g,right_b,right_a = math_floor(v.right_r),math_floor(v.right_g),math_floor(v.right_b),math_floor(v.right_a)

                render_text(x + 1,y + 1,FONTS.VERDANA_12_BOLD,11,false,false,0,0,0,left_a - 50,"Ataraxia")

                render_text(x + text_size.x - 1 , y  - 4 + 1,FONTS.PIXEL_10,10,true,true,r,g,b,math_floor(alpha * v.g_alpha * v.o_alpha),"|"..userdata.build.."|")
                render_text(x,y,FONTS.VERDANA_12_BOLD,11,false,false,left_r,left_g,left_b,left_a,"Atar")
                render_text(x + text_size.x,y,FONTS.VERDANA_12_BOLD,11,false,false,right_r,right_g,right_b,right_a,"axia")

                render_rectangle(x ,y + text_size.y  + math_floor( 3 * v.rect_add_y),g_x,3,25,25,25,math_floor(255 * v.g_alpha * v.o_alpha * v.rect_add_y),0)
                render_rectangle(x  + 1,y + text_size.y + 1  + math_floor( 3 * v.rect_add_y),math_floor((g_x - 2) * modifier),1,r,g,b,math_floor(255 * v.g_alpha * v.o_alpha * v.rect_add_y),0)

                render_text(x  + text_size.x/2 + 11,y + text_size.y + 5  + math_floor( 5 * v.rect_add_y) ,FONTS.PIXEL_10,10,true,true,255,255,255,math_floor(255 * v.g_alpha * v.o_alpha),get_states)
                render_text(x  + text_size.x/2 + 7,y + text_size.y + 7  + math_floor( 3 * v.dt_add_y) + math_floor( 4 * v.rect_add_y) ,FONTS.PIXEL_10,math_floor(10 * v.dt_add_y + 0.5),true,false,dt_r,dt_g,dt_b,dt_a,"DT")
                render_text(x  + text_size.x/2 + 7,y + text_size.y + 7   + math_floor( 3 * v.hs_add_y) + math_floor( 10 * v.dt_add_y) + math_floor( 4 * v.rect_add_y),FONTS.PIXEL_10,math_floor(10 * v.hs_add_y + 0.5),true,false,r,g,b,math_floor(255 * v.g_alpha * v.o_alpha),"HS")




            elseif ui_get("value",visuals.center_mode) == 3 then

                local x,y = (cx - 14)  + math_floor(v.add_x ) ,cy + 18
                local re_r,re_g,re_b = math_floor(r),math_floor(g),math_floor(b)
              
                Render.Image(icon,Vector2_new(x + 1,y + 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
                Render.Image(icon,Vector2_new(x - 1,y - 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
                Render.Image(icon,Vector2_new(x + 1,y - 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
                Render.Image(icon,Vector2_new(x - 1,y + 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))

                Render.Image(icon,Vector2_new(x,y),get_icon_size,Color_RGBA(re_r,re_g,re_b,math_floor(255 * v.g_alpha * v.o_alpha)))
            end


        
        end,

        run_arrows = function(self)
            local v = self.g_vars.arrows
            if ui_get("bool",visuals.indicator_settings,1) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
            elseif ui_get("bool",visuals.indicator_settings,1) == false then
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
            end

            local cx ,cy = EngineClient_GetScreenSize().x /2,EngineClient_GetScreenSize().y/2
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255           
            local ds = (EngineClient_GetScreenSize().x/2) / 210 * ui_get("value",visuals.arrows_distance)
            local mode = ui_get("value",visuals.arrows_mode)
            local check_back = ui_get("value",visuals.arrows_background)
          
            v.l =  linear(g_antiaim.value_table.antiaim.yaw_base == 3,v.l,math_floor(255* v.g_alpha),6)
            v.r =  linear(g_antiaim.value_table.antiaim.yaw_base == 2,v.r,math_floor(255* v.g_alpha),6)
            if mode == 0 then
                if check_back == true then
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(125 * v.g_alpha),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(125 * v.g_alpha),"w")
                    render_text(cx+ds,cy,FONTS.ARROWS_24,20,false,true,60,60,60,math_floor(125 * v.g_alpha),"x")
                    render_text(cx-ds,cy,FONTS.ARROWS_24,20,false,true,60,60,60,math_floor(125 * v.g_alpha),"w")
                else
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(v.r),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(v.l),"w")
                end
                render_text(cx+ds,cy,FONTS.ARROWS_24,20,false,true,r,g,b,math_floor(v.r),"x")

                render_text(cx-ds,cy,FONTS.ARROWS_24,20,false,true,r,g,b,math_floor(v.l),"w")


            elseif mode == 1 then
                if check_back == true then
                
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(125 * v.g_alpha),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(125 * v.g_alpha),"w")
                    render_text(cx+ds,cy,FONTS.ARROWS_12,12,false,true,60,60,60,math_floor(125 * v.g_alpha),"x")
                    render_text(cx-ds,cy,FONTS.ARROWS_12,12,false,true,60,60,60,math_floor(125 * v.g_alpha),"w")
                else
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(v.r),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(v.l),"w")
                end
                render_text(cx+ds,cy,FONTS.ARROWS_12,12,false,true,r,g,b,math_floor(v.r),"x")

                render_text(cx-ds,cy,FONTS.ARROWS_12,12,false,true,r,g,b,math_floor(v.l),"w")
            end
      

        end,

    

        distance = function(self,x1, y1, x2, y2)
            return math.sqrt((x2-x1)^2 + (y2-y1)^2)
        end,

        run_menueffect = function(self)
            if ui_get("bool",visuals.indicator_settings,4) == true then
                self.g_vars.menu_effect.g_alpha = lerp(self.g_vars.menu_effect.g_alpha,1,GlobalVars.frametime * 24)
            elseif ui_get("bool",visuals.indicator_settings,4) == false then
                self.g_vars.menu_effect.g_alpha = lerp(self.g_vars.menu_effect.g_alpha,0,GlobalVars.frametime * 24)
            end
            if self.g_vars.menu_effect.g_alpha <= 0.001 then
                self.g_vars.menu_effect.g_alpha = 0
            end
            if Cheat_IsMenuVisible() == true then
                self.g_vars.menu_effect.o_alpha = lerp(self.g_vars.menu_effect.o_alpha,self.g_vars.menu_effect.g_alpha,GlobalVars.frametime * 12)
            else
                self.g_vars.menu_effect.o_alpha = lerp(self.g_vars.menu_effect.o_alpha,0,GlobalVars.frametime * 12)
            end
            if self.g_vars.menu_effect.o_alpha <= 0.001 then
                self.g_vars.menu_effect.o_alpha = 0
            end
            local sx,sy = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            if (self.g_vars.menu_effect.cur_alpha < self.g_vars.menu_effect.min_alpha + 2) then
                self.g_vars.menu_effect.target_alpha = self.g_vars.menu_effect.max_alpha
            elseif (self.g_vars.menu_effect.cur_alpha > self.g_vars.menu_effect.max_alpha - 2) then
                self.g_vars.menu_effect.target_alpha = self.g_vars.menu_effect.min_alpha
            end
            self.g_vars.menu_effect.cur_alpha = self.g_vars.menu_effect.cur_alpha + (self.g_vars.menu_effect.target_alpha - self.g_vars.menu_effect.cur_alpha)*self.g_vars.menu_effect.speed*(GlobalVars.frametime*10)
            render_gradient(0,0,sx,600 ,r,g,b,self.g_vars.menu_effect.cur_alpha*self.g_vars.menu_effect.o_alpha,r,g,b,0,false)

            local v = self.g_vars.menu_effect
            local menu_open = Cheat_IsMenuVisible()
            local realtime = GlobalVars.realtime
            if menu_open and not v.menu_open_prev then
                v.last_change = realtime
            end
            if not menu_open then
                return
            end

            local opacity_multiplier = menu_open and 1 or 0
    
            local menu_fade_time = 0.2
        
            if realtime - v.last_change < menu_fade_time then
                opacity_multiplier = (realtime - v.last_change) / menu_fade_time
            end
        
            if opacity_multiplier ~= 1 then
                --client.log(opacity_multiplier)
            end
    
            local screen_width, screen_height = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
            if opacity_multiplier > 0 and v.o_alpha >= 0.5 then
                local r, g, b, a = 255,255,255,200
                a = a * opacity_multiplier
                local r_connect, g_connect, b_connect, a_connect = 255,255,255,255
                a_connect = a_connect * opacity_multiplier * 0.5
                local speed_multiplier = 61 / 100
                local dots_amount = 23
                local dots_connect_distance = 307
                local line_a = a/4

                while #v.dots > dots_amount do
                    table_remove(v.dots, #v.dots)
                end
                while #v.dots < dots_amount do
                    local x, y = Utils_RandomInt(-dots_connect_distance, screen_width+dots_connect_distance), Utils_RandomInt(-dots_connect_distance, screen_height+dots_connect_distance)
                    local max = 12
                    local min = 4

                    local velocity_x
                    if Utils_RandomInt(0, 1) == 1 then
                        velocity_x = Utils_RandomFloat(-max, -min)
                    else
                        velocity_x = Utils_RandomFloat(min, max)
                    end
    
                    local velocity_y
                    if Utils_RandomInt(0, 1) == 1 then
                        velocity_y = Utils_RandomFloat(-max, -min)
                    else
                        velocity_y = Utils_RandomFloat(min, max)
                    end
    
                    local size = Utils_RandomFloat(v.dot_size-1, v.dot_size+1)
                    table_insert(v.dots, {x, y, velocity_x, velocity_y, size})
                end

                local dots_new = {}
                for i=1, #v.dots do
                    local dot = v.dots[i]
                    local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
                    x = x + velocity_x*speed_multiplier*0.2
                    y = y + velocity_y*speed_multiplier*0.2
                    if x > -dots_connect_distance and x < screen_width+dots_connect_distance and y > -dots_connect_distance and y < screen_height+dots_connect_distance then
                        table_insert(dots_new, {x, y, velocity_x, velocity_y, size})
                    end
                end
                v.dots = dots_new
    
                for i=1, #v.dots do
                    local dot = v.dots[i]
                    local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
                    for i2=1, #v.dots do
                        local dot2 = v.dots[i2]
                        local x2, y2 = dot2[1], dot2[2]
                        local distance = self:distance(x, y, x2, y2)
                        if distance <= dots_connect_distance then
                            local a_connect_multiplier = 1
                            if distance > dots_connect_distance * 0.7 then
                                a_connect_multiplier = (dots_connect_distance - distance) / (dots_connect_distance * 0.3)
                                --distance - dots_connect_distance /
                            end
                            Render.Line(Vector2.new(x, y), Vector2.new(x2, y2), Color.RGBA(r_connect, g_connect, b_connect, math_floor(a_connect*a_connect_multiplier)))

                        end
                    end
                end
    
                for i=1, #v.dots do
                    local dot = v.dots[i]
                    local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
                    Render.CircleFilled(Vector2.new(x, y), math_floor(size), 32, Color.new(r, g, b, math_floor(a)))
                end
            end


        end,


        run_watermark = function(self)
            local v = self.g_vars.watermark
            if ui_get("bool",visuals.indicator_settings,3) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
            end

            -- solus_m.container = function(x, y, w, h, r, g, b, a, alpha)
            local screen = EngineClient_GetScreenSize()
            local cx , cy = screen.x /2,screen.y/2   
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.watermark_color).r,ui_get("color",visuals.watermark_color).g,ui_get("color",visuals.watermark_color).b,ui_get("color",visuals.watermark_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            local tabled = {
                {text = "ATARAXIA",color = {r,g,b,math_floor(255*v.g_alpha)}},
                {text = ".PUB",color = {255,255,255,math_floor(255*v.g_alpha)}},
                {text = "  ",color = {255,255,255,math_floor(255*v.g_alpha)}},
                {text = "@"..string.upper(userdata.username),color = {r,g,b,math_floor(255*v.g_alpha)}},
                {text = "  ",color = {255,255,255,math_floor(255*v.g_alpha)},flags = "-"},
                {text = string.upper(userdata.build),color = {159,227,255,math_floor(255*v.g_alpha)}},
                {text = "  ",color = {255,255,255,math_floor(255*v.g_alpha)}},
                {text = string.upper(userdata.last_updatetime),color = {255,255,255,math_floor(255*v.g_alpha)}},
            }

            if (v.cur_alpha < v.min_alpha + 0.02) then
                v.target_alpha = v.max_alpha
            elseif (v.cur_alpha > v.max_alpha - 0.02) then
                v.target_alpha = v.min_alpha
            end
            v.cur_alpha = v.cur_alpha + (v.target_alpha - v.cur_alpha)*v.speed*(GlobalVars.frametime*10)
            local lua = self.solus_render.measure_multitext(FONTS.PIXEL_10,10,tabled).x + 8
            local w,h = lua+ 12 ,18
            local sx,sy = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
            local x ,y = sx/ 2 -lua/2, sy - 30
            Render.Image(image_loaded, Vector2.new(500, 500), Vector2_new(32,32))

            self.solus_render.container(x, y, w, h, r, g, b, a*v.g_alpha,v.cur_alpha*v.g_alpha )
            self.solus_render.multitext(x + 11 , y + 3,FONTS.PIXEL_10,10,true,false, tabled)
        end,

        run_damage_maker = function(self)
            if ui_get("bool",visuals.indicator_settings,5) == true then
                local damage_indicator_displays_new = {}
                local max_time_delta = ui_get("value",visuals.dmgmarker_display_time) / 2
                local speed = ui_get("value",visuals.dmgmarker_speed) / 3
                local realtime = GlobalVars.realtime
                local max_time = realtime - max_time_delta / 2
                local aimbot_enabled = ui_get("value",reference.ragebot)
                local minimum_damage = 0
                if aimbot_enabled then
                    minimum_damage = ui_get("value",reference.dmg)
                end
                -- local r_t,g_t,b_t,a_t = ui_get("color",visuals.dmgmarker_color_1).r,ui_get("color",visuals.dmgmarker_color_1).g,ui_get("color",visuals.dmgmarker_color_1).b,ui_get("color",visuals.dmgmarker_color_1).a
                -- local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
                local r_td,g_td,b_td,a_td = ui_get("color",visuals.dmgmarker_color_2).r,ui_get("color",visuals.dmgmarker_color_2).g,ui_get("color",visuals.dmgmarker_color_2).b,ui_get("color",visuals.dmgmarker_color_2).a
                local r1,g1,b1,a1 = r_td*255,g_td*255,b_td *255 ,a_td *255

                for i=1, #damage_indicator_displays do
                    local damage_indicator_display = damage_indicator_displays[i]
                    local damage, time, x, y, z, e = damage_indicator_display[1], damage_indicator_display[2], damage_indicator_display[3], damage_indicator_display[4], damage_indicator_display[5], damage_indicator_display[6]
                    local r_s, g_s, b_s, a_s = r1,g1,b1,a1
                    if time > max_time then
                        local sx, sy = Render.WorldToScreen(Vector_new( x, y, z)).x,Render.WorldToScreen(Vector_new( x, y, z)).y
                
                
                        -- if damage < minimum_damage and e.health ~= 0 then
                        --     r, g, b = r1, g1,b1
                        -- end
            
                        if (time - max_time) < 0.7 then
                            a_s = math_floor((time - max_time) / 0.7 * 255)
                        end
            
                        if not (sx == nil or sy == nil) then
                            if ui_get("value",visuals.dmgmarker_mode) == 0 then
                        
                                render_text(math_floor(sx) + 1, math_floor(sy) + 1,FONTS.VERDANA_13, 13,false,false,30,30,30,a_s,tostring(damage))
                                render_text(math_floor(sx), math_floor(sy),FONTS.VERDANA_13, 13,false,false,r_s, g_s, b_s,a_s,tostring(damage))


                            elseif ui_get("value",visuals.dmgmarker_mode) == 1 then
                                render_text(sx + 1, sy + 1,FONTS.VERDANA_12_BOLD,11,false,false,30,30,30,a_s,tostring(damage))
                                render_text(sx, sy,FONTS.VERDANA_12_BOLD, 11,false,false,r_s, g_s, b_s,a_s,tostring(damage))

                            elseif ui_get("value",visuals.dmgmarker_mode) == 2 then
                                 render_text(sx + 1, sy + 1,FONTS.VERDANA_36_BOLD,36,false,false,30,30,30,a_s,tostring(damage))
                                 render_text(sx, sy,FONTS.VERDANA_36_BOLD,36,false,false,r_s, g_s, b_s,a_s,tostring(damage))

                                    
                            end
                        end
                        table_insert(damage_indicator_displays_new, {damage, time, x, y, z+0.4*speed, e})
                    end
                end
            
                damage_indicator_displays = damage_indicator_displays_new

            end
        end,
        
        run_scopeline = function(self)
            local v = self.g_vars.scopeline
            local scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
            local sc = EngineClient.GetScreenSize()
            local gui = CVar.FindVar("r_drawvgui")
            if ui_get("bool",visuals.indicator_settings,6) == true then
                ui_set("value",reference.remove_scope,2)
                local Scoped_color = ui_get("color",visuals.indicator_color)
                local r, g, b, a = Scoped_color.r, Scoped_color.g, Scoped_color.b, Scoped_color.a
                local org = ui_get("value",visuals.scopeline_origin)
                local width = ui_get("value",visuals.scopeline_width)
                if scoped then
                    if v.toleng < (org/ 2 + width) then
                        v.toleng = v.toleng + 2
                    else
                        v.toleng = (org/ 2 + width)
                    end
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 - 0.1,sc.y / 2 - math.min(org, v.toleng)),Vector2.new(sc.x / 2 + 1, sc.y / 2 - math.min(org, v.toleng) -math.min(width, v.toleng)),Color.new(r , g , b , a), Color.new(r , g , b , a),Color.new(r , g , b , 0), Color.new(r, g , b , 0))
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 - math.min(org, v.toleng),
                        sc.y / 2 - 0.1), Vector2.new(sc.x / 2 - math.min(org, v.toleng) -
                                                         math.min(width, v.toleng), sc.y / 2 + 1),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0))
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 - 0.1,
                        sc.y / 2 + math.min(org, v.toleng)),
                        Vector2.new(sc.x / 2 + 1, sc.y / 2 + math.min(org, v.toleng) +
                            math.min(width, v.toleng)),
                        Color.new(r , g , b , a), Color.new(r , g , b , a),
                        Color.new(r , g , b , 0), Color.new(r , g , b , 0))
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 + math.min(org, v.toleng),
                        sc.y / 2 - 0.1), Vector2.new(sc.x / 2 + math.min(org, v.toleng) +
                                                         math.min(width, v.toleng), sc.y / 2 + 1),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0))
                else
                    if v.toleng > 0 then
                        v.toleng = v.toleng - 2
                    else
                        v.toleng = 0
                    end
                end

            else
                ui_set("value",reference.remove_scope,1)
            end


        
        end,

        run_notifications = function(self)
            local y = sc_y - 100

            for i, info in pairs(noti_table) do
                if i > 5 then
                    table_remove(noti_table,i)
                end

                if info.text ~= nil and info.text ~= "" then
                

                    if info.timer + 3.8 < GlobalVars.realtime then
                        info.smooth_y = lerp(info.smooth_y,sc_y + 100,GlobalVars.frametime * 2)
                        info.alpha = lerp(info.alpha,0,GlobalVars.frametime * 4)
                    else
                        info.alpha = lerp(info.alpha,1,GlobalVars.frametime * 4)
                        info.smooth_y = lerp(info.smooth_y,y,GlobalVars.frametime * 4)
                    end

                    local add_y = math_floor(info.smooth_y)
                    local alpha = info.alpha
                
                    local get_color = ui_get("color",visuals.watermark_color)
                    local r,g,b,a = get_color.r * 255,get_color.g * 255,get_color.b * 255,get_color.a * 255
                    local tabled = {
                        {text = "[Ataraxia]",color = {r,g,b,math_floor(255*alpha)}},
                        {text = " ",color = {r,g,b,math_floor(255*alpha)}},
                        {text = info.text,color = {255,255,255,math_floor(255*alpha)}},
                    }
                    local text_size = self.solus_render.measure_multitext(FONTS.VERDANA_12,11,tabled).x + 8
                    local text_size_y = self.solus_render.measure_multitext(FONTS.VERDANA_12,11,tabled).y/2 + 4
                    -- solus_m.container = function(x, y, w, h, r, g, b, a, alpha)

                    self.solus_render.container(sc_x/2 - text_size/2,add_y - 26 - 7 + 2 + 31,text_size + 2,text_size_y,r,g,b,math_floor(a*alpha),1*alpha)
                    self.solus_render.multitext(sc_x/2 - text_size/2 + 5  ,add_y - 26 - 7 + 2 + 31 + 3,FONTS.VERDANA_12,11,true,false, tabled)
                    y = y - 45
                    if info.timer + 4 < GlobalVars.realtime then
                        table_remove(noti_table,i)
                    end
                end
            end
        end,
        
        get_ping = function(self)
            local netchann_info = EngineClient.GetNetChannelInfo()
            if not netchann_info then return "0" end

            local latency = netchann_info:GetLatency(0)
            return math_floor(latency * 1000.0 + 0.5).."ms"
        end,


        get_ticks = function(self)
            return math.floor(1.0 / GlobalVars.interval_per_tick)
        end,

        get_fps = function(self)
            local get_fps = function()
                self.g_vars.s_watermark.fps_counter = 0.9 * self.g_vars.s_watermark.fps_counter + (1.0 - 0.9) * GlobalVars.absoluteframetime
                return math.floor((1.0 / self.g_vars.s_watermark.fps_counter) + 0.5)
            end

            local current_fps = get_fps()
            if self.g_vars.s_watermark.current_time + 0.3 < GlobalVars.curtime then
                self.g_vars.s_watermark.current_fps = current_fps
                self.g_vars.s_watermark.current_time = GlobalVars.curtime
            end

            return self.g_vars.s_watermark.current_fps
        end,

        get_fl_amount = function(self,cmd)
            
            if doubletap_charged() then
                is_breaking_lc = true
            else
                is_breaking_lc = false
            end


            if ClientState.m_choked_commands == 0 then
            
        
                    last_sent = current_choke
                

            end
            current_choke = ClientState.m_choked_commands


            return last_sent
        end,

        normalize_yaw = function(self,ang)
            while (ang > 180.0) do
                ang = ang - 360.0
            end
            while (ang < -180.0) do
                ang = ang + 360.0
            end
            return ang
        end,

        get_desync = function(self,cmd)

            local ptr = entity_get_localplayer()
            local degree = self:normalize_yaw(AntiAim_GetCurrentRealRotation() - ptr:GetProp("m_angEyeAngles[1]"))

        
            

            get_fake_amount = math_abs(math_floor(tonumber(string_format("%.2f", (clamp(degree, AntiAim_GetMinDesyncDelta(), AntiAim_GetMaxDesyncDelta())))) + 0.5))
            return get_fake_amount
        end,

        run_solus_watermark = function(self)
            local v = self.g_vars.s_watermark
            if ui_get("bool",visuals.indicator_settings,7) == false then
                return
            end

            if ui_get("bool",visuals.solus_select,1) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
            end
            
            local get_n_watermark = ui_get("bool",reference.windows,3)
            
            if ui_get("bool",visuals.solus_select,1) == true then
                ui_set("bool",reference.windows,3,false)
            else
                ui_set("bool",reference.windows,3,get_n_watermark)
            end
            local r,g,b,a = ui_get("color",visuals.watermark_color).r * 255,ui_get("color",visuals.watermark_color).g * 255,ui_get("color",visuals.watermark_color).b * 255,math_floor((ui_get("color",visuals.watermark_color).a*255) * v.g_alpha)
            local rea = math_floor(255*v.g_alpha)
            local text_Table = {
                {text = "Ataraxia",color = {r,g,b,rea}},
                {text = ".pub",color = {255,255,255,rea}},
                {text = "[",color = {255,255,255,rea}},
                {text = userdata.build,color = {159,227,255,rea}},
                {text = "]",color = {255,255,255,rea}},
                {text = "  ",color = {255,255,255,rea}},
                {text = ui_get("value",visuals.solus_watermark_name),color = {255,255,255,rea}},
                {text = "  ",color = {255,255,255,rea}},
                {text = "delay:"..self:get_ping(),color = {255,255,255,rea}},
                {text = "  ",color = {255,255,255,rea}},
                {text = self:get_ticks().."tick",color = {255,255,255,rea}}
            }

            local get_text_size_x,get_text_size_y = self.solus_render.measure_multitext(FONTS.VERDANA_12_R,11,text_Table).x,self.solus_render.measure_multitext(FONTS.PIXEL_10,10,text_Table).y

            v.width = lerp(v.width,(get_text_size_x + 10) * v.g_alpha,GlobalVars.frametime * 12)
            local w,h = math_floor(v.width), math_floor(18 * v.g_alpha + 0.5)


            -- print(math.floor(ping * 1000 + 0.5))
            -- local text_size =
            -- local w,h =
            
            self.solus_render.container(sc_x - (w+8),h/2,w,h,r,g,b,a,1 * v.g_alpha)
            local reget_text = "Ataraxia.pub  "..userdata.build.."  "..ui_get("value",visuals.solus_watermark_name).."  ".."delay:"..self:get_ping().."  "..self:get_ticks().."tick"
            render_text(sc_x - (w+8) + 5 + 1,h/2 + 2 +1,FONTS.VERDANA_12_R,math_floor(11*v.g_alpha + 0.5),false,false,10,10,10,rea,reget_text)

            self.solus_render.multitext(sc_x - (w+8) + 5,h/2 + 2,FONTS.VERDANA_12_R,math_floor(11*v.g_alpha + 0.5),false,false, text_Table)
            
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
          
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end


            local text_fl = ("FL:%s"):format(
                    (function()
                        if tonumber(last_sent) < 10 then
                            return "\x20"..last_sent
                        end
                        return last_sent
                end)()
            )

            v.GET_FAKE_AMOUNT_LERP = lerp(v.GET_FAKE_AMOUNT_LERP,get_fake_amount + 0.5,GlobalVars.frametime * 3.5)

            local text_fake = ("FAKE:(%.1f°)"):format(v.GET_FAKE_AMOUNT_LERP + 0.5)
            local text_fake_size = render_measure_text(11,FONTS.VERDANA_12_R,text_fake)
            v.get_fake_width = lerp(v.get_fake_width,(text_fake_size.x + 10 + 10)*v.g_alpha,GlobalVars.frametime * 12)
            local w_f,h_f = v.get_fake_width,18
            local text_tick = ""
            if is_breaking_lc == true then
                text_tick = " | SHIFTING"
            elseif is_breaking_lc == false then

                text_tick = ""
            end

            local text_tick_size = render_measure_text(11,FONTS.VERDANA_12_R,text_tick)
            local text_fl_size = render_measure_text(11,FONTS.VERDANA_12_R,text_fl)

            local text_cmd = text_fl..text_tick
            local text_cmd_size = text_fl_size.x + text_tick_size.x
            v.get_cmd_width = lerp(v.get_cmd_width,(text_cmd_size + 10)*v.g_alpha,GlobalVars.frametime * 12)

            local w_cmd ,h_cmd = v.get_cmd_width,18
            self.solus_render.container(sc_x - (w_cmd+8) ,h_cmd/2 + h_cmd + 6,w_cmd,h_cmd,r,g,b,a,1 * v.g_alpha)


            self.solus_render.container(sc_x - (w_f + w_cmd +15) ,h_f/2 + h + 6,w_f,h_f,r,g,b,a,1 * v.g_alpha)
            render_text(sc_x - (w_cmd+8) + 5 + 1 ,h_cmd/2 + h + 6 + 1 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,10,10,10,rea,text_cmd)
            render_text(sc_x - (w_cmd+8) + 5 ,h_cmd/2 + h + 6 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,255,255,255,rea,text_cmd)

            render_text(sc_x - (w_f + w_cmd +15) + 6  + 1 + 10,h_f/2 + h + 6 + 1 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,10,10,10,rea,text_fake)
            render_text(sc_x - (w_f+ w_cmd + 15) + 6  + 10 ,h_f/2 + h + 6 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,255,255,255,rea,text_fake)
          
            v.get_circle_degree = lerp(v.get_circle_degree,((get_fake_amount + 0.5)*6)*v.g_alpha,GlobalVars.frametime * 12)

            render_circle_outline(sc_x - (w_f+ w_cmd + 15) + 6 + 3,h_f/2 + h + 6 + 1 + 8,4.5,r,g,b,rea,3,0,v.get_circle_degree)


    
        end,

        render_text_key = function(self,text, pos, color, size, text_font, outline, align)
            local text_size = Render.CalcTextSize(text, size, text_font)

            if align == 0 then -- To the left
                Render.Text(text, Vector2.new(pos.x - text_size.x, pos.y), color, size, text_font, outline)
            elseif align == 1 then -- To the center
                Render.Text(text, Vector2.new(pos.x - (text_size.x / 2), pos.y), color, size, text_font, outline)
            elseif align == 2 then -- To the right
                Render.Text(text, pos, color, size, text_font, outline)
            end
        end,

        run_solus_keybind = function(self)
            local v = self.g_vars.s_keybind
            if ui_get("bool",visuals.indicator_settings,7) == false then
                return
            end

            if ui_get("bool",visuals.solus_select,2) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
            end
                        
            local get_n_keybind = ui_get("bool",reference.windows,1)
            
            if ui_get("bool",visuals.solus_select,2) == true then
                ui_set("bool",reference.windows,1,false)
            else
                ui_set("bool",reference.windows,1,get_n_keybind)
            end

            if EngineClient.IsConnected() then
                local x = ui_get("value",visuals.temp_keybind_x)
                local y = ui_get("value",visuals.temp_keybind_y)

                local max_width = 0
                local g_res_alpha = math_floor(255 * v.g_alpha)

                local render_container = function(x, y, w,alpha)
                    local color = ui_get("color",visuals.watermark_color)
                    local name_size = Render.CalcTextSize("keybinds", 11, FONTS.VERDANA_12_R)

                    local height = 18
                    local line_height = 1.5
              


                    self.solus_render.container(x - 66,y , w  ,18,color.r * 255,color.g * 255,color.b * 255,math_floor((color.a * 255) * alpha),1 * alpha)
                    -- render_rounded_line()
                    render_text( x - 64  + w/2 - name_size.x /2 , y + 2 + 1,FONTS.VERDANA_12_R,11,false,false,30,30,30,255 * alpha - 50,"keybinds")

                    render_text( x  - 64 + w/2 - name_size.x /2, y + 2,FONTS.VERDANA_12_R,11,false,false,255,255,255, 255 * alpha,"keybinds")
    
                end

                local binds = Cheat.GetBinds()
                local add_y = 0
                local anim_y = math_floor(v.re_anim_add_y)
                v.re_anim_add_y = lerp(v.re_anim_add_y , y,GlobalVars.frametime * 24)

                v.re_anim_y = lerp(v.re_anim_y,y,GlobalVars.frametime * 24)

                local re_anim_width = math_floor(v.re_anim_width)
                local re_anim_y = math_floor(v.re_anim_y)
                for i = 1, #binds do
                    v.anims_add_y = lerp(v.anims_add_y,13,GlobalVars.frametime * 12)


                    local bind = binds[i]
                    
                    local yaw_base = Menu.FindVar("Aimbot", "Anti Aim", "Main", "Yaw Base"):Get()
                    local isFS = yaw_base == 5
                    
                    local bind_name = bind:GetName()
                    local stringname = tostring(bind_name)
                    table.insert(v.keybinds_alpha, bind_name)
                    if v.keybinds_alpha[stringname] == nil then
                        v.keybinds_alpha[stringname] = 0
                    end
                  
                  
                    bind_name = bind_name:gsub("Double Tap", "Double tap")
                    bind_name = bind_name:gsub("Fake Duck", "Duck peek assist")
                    bind_name = bind_name:gsub("Auto Peek", "Quick peek assist")
                    bind_name = isFS and bind_name:gsub("Yaw Base", "Freestanding") or bind_name:gsub("Yaw Base", "")
                    v.real_add_y = lerp(v.real_add_y,add_y,GlobalVars.frametime * 12)
                    local add_y_r = math_floor(v.real_add_y + 0.5)

                    add_y = add_y + v.keybinds_alpha[stringname] / 20
                    add_y_r = add_y_r + math_floor(v.anims_add_y)

                    if bind_name ~= "" then

                        if bind:IsActive() then
                            v.keybinds_alpha[stringname] = lerp(
                                v.keybinds_alpha[stringname],
                                255,
                                GlobalVars.frametime * 12
                            )
                        else
                            v.keybinds_alpha[stringname] = lerp(
                                v.keybinds_alpha[stringname],
                                0,
                                GlobalVars.frametime * 12
                            )
                        end

                
                        local render_binds = function(binds, name)
                            local x = ui_get("value",visuals.temp_keybind_x)

                            local bind_state = binds:GetMode() == 1 and "[holding]" or "[toggled]"
                            local bind_name = name

                            local bind_state_size = Render.CalcTextSize(bind_state, 11, FONTS.VERDANA_12_R)
                            local bind_name_size = Render.CalcTextSize(bind_name, 11, FONTS.VERDANA_12_R)

                            local smooth_alpha = math.floor(v.keybinds_alpha[stringname] * v.g_alpha)
                            local width = math.floor(v.width)

                            v.re_anim_x = lerp(v.re_anim_x,(width - bind_state_size.x) - 5 - 25 ,GlobalVars.frametime * 24)
                            local re_anim_x = math_floor(v.re_anim_x)

                            render_text(x - 63 + 1, re_anim_y + 7 + 1 + add_y,FONTS.VERDANA_12_R,11,false,false,0,0,0,smooth_alpha - 50,bind_name)
                            render_text(x - 63, re_anim_y + 7 + add_y,FONTS.VERDANA_12_R,11,false,false,255,255,255,smooth_alpha,bind_name)

                            render_text(x + re_anim_x + 1, re_anim_y + 7  + 1+ add_y,FONTS.VERDANA_12_R,11,false,false,30,30,30,smooth_alpha - 50,bind_state)
                            render_text(x + re_anim_x, re_anim_y + 7 + add_y,FONTS.VERDANA_12_R,11,false,false,255,255,255,smooth_alpha,bind_state)
            

                            local bind_width = bind_state_size.x + bind_name_size.x
                            local length = 40
 
                            if bind_width > length then
                                if bind_width > max_width then
                                    max_width = bind_width
                                end
                            end
                        end
                
                        render_binds(bind, bind_name)
                    else

                        add_y = add_y - v.keybinds_alpha[stringname] / 20
                    end
                    
                end

                v.width = math.max(40, max_width)
                if not Cheat.IsMenuVisible() then
                    v.is_draggable = false
                end

                local width = math.floor(v.width)
                if Cheat.IsMenuVisible() or #binds > 0 then
                    v.container_alpha = lerp(v.container_alpha,1 * v.g_alpha,GlobalVars.frametime * 12)
                else
                    v.container_alpha = lerp(v.container_alpha,0 * v.g_alpha,GlobalVars.frametime * 12)
                end
      
                v.re_anim_width = lerp(v.re_anim_width,width +  40,GlobalVars.frametime * 24)


                render_container(x, re_anim_y,re_anim_width,v.container_alpha)

                if Cheat.IsMenuVisible() or #binds > 0 then

                    local mouse = Cheat.GetMousePos()

                    if Cheat.IsKeyDown(0x1) then
                        if not v.is_draggable then
                            if mouse.x >= x - 70 and mouse.y >= y and mouse.x <= x + width and mouse.y <= y + 18 then
                                v.is_draggable = true
                            end
                        else
                            local x_pos = x + (mouse.x - v.cursor_last_pos.x)
                            local y_pos = y + (mouse.y - v.cursor_last_pos.y)

                            ui_set("value",visuals.temp_keybind_x, math.floor(x_pos))
                            ui_set("value",visuals.temp_keybind_y, math.floor(y_pos))

                        end
                    else
                        v.is_draggable = false
                    end

                    v.cursor_last_pos = mouse
                end
            end

        end,

       get_specs = function(self)
            if not EngineClient.IsConnected() or not EngineClient.IsInGame() then
                return
            end
            local spectators = {}
            local local_player = EntityList.GetLocalPlayer()
            if not local_player then
                return
            end
            local local_player_ent_index = local_player:EntIndex()
            local local_target = bit.band(local_player:GetProp("m_hObserverTarget"), 0xFFF)
            local is_local_alive = entity_is_alive(local_player)
            for i = 1, EngineClient.GetMaxClients() do
                local entity = EntityList.GetClientEntity(i)
                if not entity then
                    goto continue
                end
                local observer = bit.band(entity:GetProp("m_hObserverTarget"), 0xFFF)
                if not observer then
                    goto continue
                end
                if is_local_alive then
                    if observer ~= local_player_ent_index then
                        goto continue
                    end
                    local player = entity:GetPlayer()
                    if not player then
                        goto continue
                    end
                    if player:IsDormant() then
                        goto continue
                    end
                    local name = player:GetName()
                    if not name then
                        goto continue
                    end
    
                    spectators[#spectators+1] ={
                        name = name,
                        id = player:EntIndex(),
                    }
                else
                    if observer ~= local_target then
                        goto continue
                    end
                    local player = entity:GetPlayer()
                    if not player then
                        goto continue
                    end
                    if player:IsDormant() then
                        goto continue
                    end
                    local name = player:GetName()
                    if not name then
                        goto continue
                    end
    
                    spectators[#spectators+1] ={
                        name = name,
                        id = player:EntIndex(),
                    }
    
                end
    
                ::continue::
            end
    
            return spectators
        end,

        run_solus_spectators = function(self)
            local global_alpha = 0
            
            local function get_steam_id_fn(ent_idx)

                local panorama_handle = Panorama.Open()
                local huy = panorama_handle.GameStateAPI.GetPlayerXuidStringFromEntIndex(ent_idx)
                return huy
            
            end


        
        
            local spec = self:get_specs()
            if spec == nil then
                return
            end


            
            local v = self.g_vars.s_spec
            if ui_get("bool",visuals.indicator_settings,7) == false then
                return
            end

            
    
                        
            local get_n_keybind = ui_get("bool",reference.windows,2)
            
            if ui_get("bool",visuals.solus_select,3) == true then
                ui_set("bool",reference.windows,2,false)
            else
                ui_set("bool",reference.windows,2,get_n_keybind)
            end

            local should_work = true
    
    
            if not spec then should_work = false goto c end
    
        
    
            if  spec   then  if #spec==0 then should_work = false end end
            if not ui_get("bool",visuals.solus_select,3) then
                should_work = false
            end
    
            ::c::
    
            if should_work or (Cheat.IsMenuVisible() and ui_get("bool",visuals.solus_select,3)) then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
            end

    
        
            if v.g_alpha < 0.01  then return end

            local max_size = 75
            local clamp_alpha = visuals.watermark_color:GetColor().a
            local start = {x = ui_get("value",visuals.temp_spec_x),y = ui_get("value",visuals.temp_spec_y)}
            -- local colors = ui_get("color",visuals.watermark_color)

            -- local colors = {
            --     Color.new(colors[1].r, colors[1].g, colors[1].b, colors[1].a * (v.g_alpha )),
            --     Color.new(colors[2].r, colors[2].g, colors[2].b, colors[2].a * (v.g_alpha )),
            --     Color.new(colors[3].r, colors[3].g, colors[3].b, colors[3].a * (v.g_alpha ))
            -- }
            local offset = Vector2.new(v.size.x  / 2, 2)
    
            if start.x + v.size.x/2 < sc_x/2 then
                v.spec_offset = lerp(v.spec_offset,1,GlobalVars.frametime * 12)
            else
                v.spec_offset = lerp(v.spec_offset,0,GlobalVars.frametime * 12)
            end
    
            local y_off = 0

            if spec then
                
                for i = 1 , #spec do
                    local bind = spec[i]
                    local bind_name = bind.name
                    if not v.binds[bind_name] then
                        v.binds[bind_name] = 0
                    end
    
    
    
                    v.binds[bind_name]  =  lerp(v.binds[bind_name] ,  1  , GlobalVars.frametime * 12)
    
                    if v.binds[bind_name] <0.01 then goto skip end
    
    
                    local alpha = v.binds[bind_name]
    
                    local text_size = Vector2.new(11,11)
                    local text_size2 = Render.CalcTextSize(bind_name, 11, FONTS.VERDANA_12_R) + Vector2.new(11,11)
                    local off = start.y + (y_off ) + 20
    
                  
                        Render.Texts(bind_name, Vector2.new(start.x  + 5, off), Color.new(1.0, 1.0, 1.0, alpha*v.g_alpha ), 11,  FONTS.VERDANA_12_R)
                        -- Render.Image(val , Vector2.new(start.x + (size.x - 15)*(1-v.spec_offset) + 2*v.spec_offset , off) , Vector2.new(12,12) , Color.new(1,1,1,v.g_alpha) )
                
      
                
    
    
                    if max_size < (text_size2.x)+18 then max_size = (text_size2.x+18 ) end
    
                
                    y_off =   y_off + 14
                    ::skip::
                end
            end
            local r,g,b,a = ui_get("color",visuals.watermark_color).r * 255,ui_get("color",visuals.watermark_color).g * 255,ui_get("color",visuals.watermark_color).b * 255,math_floor((ui_get("color",visuals.watermark_color).a*255) * v.g_alpha)

            v.size.x = lerp(v.size.x,max_size,GlobalVars.frametime * 12)

            -- if box_alpha~=0 then
            --     Render.BoxFilled(start, start +  kbinds.size, color(17, 17, 17, g_alpha * accent_alpha*255 * box_alpha))
            -- end
            -- if blur_alpha~=0 then
            --     local blur_col = Color.new(ui.vis.blur_bg:GetColor().r , ui.vis.blur_bg:GetColor().g, ui.vis.blur_bg:GetColor().b, g_alpha*accent_alpha * blur_alpha* ui.vis.blur_bg:GetColor().a)
            --     Render.Blur(start, start +  kbinds.size, blur_col)
            -- end
    
            -- Render.GradientBoxFilled(start, start + offset, colors[1], colors[2], colors[1], colors[2])
            -- Render.GradientBoxFilled(start + offset, start + offset + Vector2.new(offset.x, -offset.y), colors[2], colors[3], colors[2], colors[3])
            self.solus_render.container(start.x, start.y,math_floor(v.size.x) ,18,r,g,b,a,1 * v.g_alpha)
            Render.Texts("spectators", Vector2.new(start.x+ v.size.x/2  , start.y + 8), Color.new(1.0, 1.0, 1.0, v.g_alpha ), 11, FONTS.VERDANA_12_R , true)
            if Cheat.IsMenuVisible() or #spec > 0 then

                local mouse = Cheat.GetMousePos()

                if Cheat.IsKeyDown(0x1) then
                    if not v.is_draggable then
                        if mouse.x >= start.x - 70 and mouse.y >= start.y and mouse.x <= start.x + v.size.x and mouse.y <= start.y + 18 then
                            v.is_draggable = true
                        end
                    else
                        local x_pos = start.x + (mouse.x - v.cursor_last_pos.x)
                        local y_pos = start.y + (mouse.y - v.cursor_last_pos.y)

                        ui_set("value",visuals.temp_spec_x, math.floor(x_pos))
                        ui_set("value",visuals.temp_spec_y, math.floor(y_pos))

                    end
                else
                    v.is_draggable = false
                end

                v.cursor_last_pos = mouse
            end
        end,

        -- PLAYERS_INFO = {},
        
        -- getsteam_id = function(self, steamid)
        --     return string.sub(tostring(ffi.new('uint64_t', 76561197960265728) + ffi.new('uint64_t', steamid)), 1, -4)
        -- end,

        -- get_spectators = function(self,player)
        --     local buffer = { }
        
        --     local players = EntityList.GetPlayers()
        --     for tbl_idx, player_pointer in pairs(players) do
        --         if player_pointer:EntIndex() ~= player:EntIndex() then
        --             if not player_pointer:IsAlive() then
        --                 local spectatingMode = player_pointer:GetProp('m_iObserverMode')
        --                 local spectatingPlayer = player_pointer:GetProp('m_hObserverTarget')
    
        --                 if spectatingPlayer then
        --                     if spectatingMode >= 4 or spectatingMode <= 5 then
        --                         local spectatingEntity = EntityList.GetClientEntityFromHandle(spectatingPlayer)
        --                         if spectatingEntity ~= nil and spectatingEntity:EntIndex() == player:EntIndex() then
        --                             local player_info = player_pointer:GetPlayerInfo()
    
        --                             table.insert(buffer, 1, {
        --                                 ['id'] = player_info.iSteamID,
        --                                 ['id64'] = self:getsteam_id(player_info.iSteamID),
        --                                 ['name'] = player_pointer:GetName()
        --                             })
        --                         end
        --                     end
        --                 end
        --             end
        --         end
        --     end

        --     return buffer
        -- end,

        -- getspectators = function(self)
        --     if not EngineClient.IsConnected() or EngineClient.GetLocalPlayer() == nil or EntityList.GetLocalPlayer() == nil then return end
        --     local local_player = EntityList.GetLocalPlayer()
        --     if local_player == nil then return end
    
        --     if local_player:IsAlive() then
        --         return self:get_spectators(local_player:GetPlayer())
        --     else
        --         local m_hObserverTarget = local_player:GetProp('m_hObserverTarget')
        --         if m_hObserverTarget then
        --             local targetEntity = EntityList.GetClientEntityFromHandle(m_hObserverTarget)
        --             if targetEntity ~= nil and targetEntity:IsPlayer() then
        --                 return self:get_spectators(targetEntity:GetPlayer())
        --             end
        --         end
        --     end
        -- end,

        -- run_solus_spectators = function(self)

        --     local spectators = self:getspectators()

        --     if spectators ~= nil then
        --         print(spectators[1]['name'])

        --     end
            
    
        -- end,

        run_dmgind = function(self)
            -- visuals.dmgind_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display mode",{"-","+"},0,"[~] Display mode"))
            -- visuals.dmgind_pos = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display postion",{"Top left","Top right","Bottom left","Bottom light"},0,"[~] Display mode"))
            if ui_get("bool",visuals.indicator_settings,8) == true then
                local font = FONTS.VERDANA_12_R
                local x , y = 0,0
                local damage = Menu.FindVar("Aimbot", "Ragebot", "Accuracy", "Minimum Damage"):GetInt()
                local dmg = '' .. damage
                -- {"Top left","Top right","Bottom left","Bottom light"}
                if ui_get("value",visuals.dmgind_pos) == 0 then
                    x = sc_x/2 - 30 
                    y = sc_y/2 - 20
                elseif ui_get("value",visuals.dmgind_pos) == 1 then
                    x = sc_x/2 + 20 
                    y = sc_y/2 - 20
                elseif ui_get("value",visuals.dmgind_pos) == 2 then
                    x = sc_x/2 - 30 
                    y = sc_y/2 + 20
                elseif ui_get("value",visuals.dmgind_pos) == 3 then
                    x = sc_x/2 + 20 
                    y = sc_y/2 + 20
                end

                if ui_get("value",visuals.dmgind_mode) == 0 then
                    render_text(x,y,FONTS.PIXEL_10,10,true,false,255,255,255,255,dmg)
                elseif ui_get("value",visuals.dmgind_mode) == 1 then
                    render_text(x + 1,y + 1,FONTS.VERDANA_12_R,11,false,false,0,0,0,205,dmg)
                    render_text(x,y,FONTS.VERDANA_12_R,11,false,false,255,255,255,255,dmg)

                end



            end

        end,

        load_indicators = function(self)
            self:on_script_start()
            self:run_menueffect()
            self:run_watermark()
            self:run_damage_maker()
            self:run_notifications()
            self:run_solus_watermark()
            self:run_solus_keybind()
            self:run_solus_spectators()
            -- self:run_solus_spectators()
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
          
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end

            if EngineClient.IsConnected() and my_index:IsAlive() then
                if ui_get("bool",info.feature_list,1) == true then
                    self:run_arrows()
                    self:run_center()
                    self:run_scopeline()
                    self:run_dmgind()

                end
            end
        end

    }


    local updateCSA = function(thisptr, edx)
        local is_localplayer = ffi.cast("uintptr_t", thisptr) == get_entity_address(EngineClient.GetLocalPlayer())
        hooked_function(thisptr, edx)
    
        if is_localplayer then
            local addons = misc.anim_list
            
            if  addons:GetBool(2) and misc.select:GetBool(2) then
                ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[6] = 0.5
            end
    
            if  addons:GetBool(3) and misc.select:GetBool(2) then
                ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[0] = 1
                Menu.FindVar("Aimbot", "Anti Aim", "Misc", "Leg Movement"):Set(1)
            end
    
            if  addons:GetBool(1) and misc.select:GetBool(2) then
                if ffi.cast("CCSGOPlayerAnimationState_534535_t**", ffi.cast("uintptr_t", thisptr) + 0x9960)[0].bHitGroundAnimation then
                    if not is_jumping then
                        ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[12] = 0.5
                    end
                end
            end
        end
    end


    ESP.CustomText("Dormant aimbot", "enemies", "DA", function(ent)
        if g_misc.vars.is_dormant_flag then
            return "DA"
        else
            return false
        end
    end)

    local all_callbacks = {

        on_draw = function()
            g_visual:load_indicators()
        end,
    
        on_prediction = function(cmd)
            g_antiaim:load_antiaim(cmd)
            g_visual:get_desync(cmd)
            g_visual:get_fl_amount(cmd)
            g_misc:run_hitchance()
            g_misc:run_dormant_aimbot(cmd)
        end,
    
        on_pre_prediction = function(cmd)
            is_jumping = bit.band(cmd.buttons, bit.lshift(1, 1)) ~= 0
            g_antiaim:load_pre_antiaim(cmd)

        end,

        register_shot = function(e)
            g_misc:run_hitlog(e)
        end,

        on_create_move = function()
            local local_player = EntityList.GetLocalPlayer()
            if not local_player then return end

            local local_player_ptr = get_entity_address(local_player:EntIndex())
            if not local_player_ptr or hooked_function then return end

            local C_CSPLAYER = vmt_hook.new(local_player_ptr)
            hooked_function = C_CSPLAYER.hookMethod("void(__fastcall*)(void*, void*)", updateCSA, 224)
        end,

        on_destory = function()
            for i, unHookFunc in ipairs(vmt_hook.hooks) do
                unHookFunc()
            end
            for i, free in ipairs(buff.free) do
                free()
            end
        end,

        on_event = function(events)
            g_misc:load_events(events)
            
        end,
    
        __call = function(self)
            EngineClient.ExecuteClientCmd("clear")
            print(cat)
            local d = 0
            for k, v in pairs(menu.callback_data) do
                ui_set_callback(v,g_menu.visible_data)
                d = k
            end
            debugger("invoked ui callback: "..d)
        end,
    

        load_callbacks = function(self)
            
            self:__call()
            if not ui_get("value",info.master_switch) then
                return
            end
            client_set_event_callback("draw",self.on_draw)
            client_set_event_callback("prediction",self.on_prediction)
            client_set_event_callback("pre_prediction",self.on_pre_prediction)
            client_set_event_callback("createmove",self.on_create_move)
            client_set_event_callback("destroy",self.on_destory)
            client_set_event_callback("events",self.on_event)
            client_set_event_callback("registered_shot",self.register_shot)

        end
    }
    
    all_callbacks:load_callbacks()
end

_ataraxia_()
 
Забаненный
Статус
Оффлайн
Регистрация
20 Фев 2022
Сообщения
149
Реакции[?]
41
Поинты[?]
0
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
аситеч лучше
 
Пользователь
Статус
Оффлайн
Регистрация
10 Янв 2020
Сообщения
429
Реакции[?]
67
Поинты[?]
1K
аситеч лучше
 
Эксперт
Статус
Оффлайн
Регистрация
24 Апр 2018
Сообщения
1,468
Реакции[?]
909
Поинты[?]
42K
когда слив аситеч
 
Начинающий
Статус
Оффлайн
Регистрация
19 Апр 2021
Сообщения
34
Реакции[?]
9
Поинты[?]
0
смысла нет, уже скоро апдейт который все поломает
 
Эксперт
Статус
Оффлайн
Регистрация
19 Дек 2018
Сообщения
2,961
Реакции[?]
493
Поинты[?]
0
if u need lite or live vers. source leak dm me: @keqx1
Код:
local AntiAim_GetCurrentRealRotation, AntiAim_GetInverterState, AntiAim_GetMaxDesyncDelta, AntiAim_GetMinDesyncDelta, AntiAim_OverrideInverter, AntiAim_OverrideLimit, AntiAim_OverrideYawOffset, bit_band, bit_bnot, bit_bor, bit_lshift, cheat_AddEvent, Cheat_AddNotify, cheat_AngleToForward, Cheat_AngleToForward, cheat_FireBullet, Cheat_GetBinds, Cheat_GetCheatUserName, Cheat_GetMousePos, Cheat_IsKeyDown, Cheat_IsMenuVisible, cheat_RegisterCallback, cheat_SetThirdPersonAnim, cheat_VectorToAngle, Cheat_VectorToAngle, Color_new, Color_RGBA, CVar_FindVar, EngineClient_GetScreenSize, EntityList_GetClientEntity, EntityList_GetLocalPlayer, EntityList_GetPlayer, EntityList_GetPlayerResource, ffi_cast, ffi_cdef, ffi_new, ffi_typeof, math_abs, math_ceil, math_clamp, math_cos, math_floor, math_lerp, math_max, math_min, math_normalize, math_rad, math_round, Menu_Combo, Menu_FindVar, Menu_SliderInt, Menu_Switch, print, pairs, RageBot_OverrideHitchance, Render_InitFont, string_format, table_insert, table_reference_condition, Utils_CreateInterface, Utils_CreateInterface, Utils_PatternScan, utils_RandomFloat, Vector_new, Vector2_new, fn, type, tonumber, error, condition, EngineClient_GetLocalPlayer, EngineClient_GetViewAngles, EngineClient_IsConnected, EngineClient_IsInGame, EngineTrace_TraceRay, EntityList_GetEntitiesByName, EntityList_GetPlayerForUserID, exploits_GetCharge, Exploits_OverrideDoubleTapSpeed, math_closest_point_on_ray, math_percent_to_pix, math_sin, math_vector_lerp, MatSystem_FirstMaterial, MatSystem_GetMaterial, MatSystem_NextMaterial, Menu_Button, Menu_ColorEdit, Menu_ComboColor, Menu_DestroyItem, Menu_MultiCombo, menu_SliderInt, menu_SwitchColor, Menu_SwitchColor, QAngle_new, Render_BoxFilled, Render_CalcTextSize, Render_Circle, Render_CircleFilled, Render_GradientBoxFilled, Render_Line, Render_PolyFilled, Render_Text, Render_WorldToScreen, table_remove, table_sort, unpack, Utils_RandomFloat, Utils_RandomInt, ipairs, pcall, tostring = AntiAim.GetCurrentRealRotation, AntiAim.GetInverterState, AntiAim.GetMaxDesyncDelta, AntiAim.GetMinDesyncDelta, AntiAim.OverrideInverter, AntiAim.OverrideLimit, AntiAim.OverrideYawOffset, bit.band, bit.bnot, bit.bor, bit.lshift, Cheat.AddEvent, Cheat.AddNotify, Cheat.AngleToForward, Cheat.AngleToForward, Cheat.FireBullet, Cheat.GetBinds, Cheat.GetCheatUserName, Cheat.GetMousePos, Cheat.IsKeyDown, Cheat.IsMenuVisible, Cheat.RegisterCallback, Cheat.SetThirdPersonAnim, Cheat.VectorToAngle, Cheat.VectorToAngle, Color.new, Color.RGBA, CVar.FindVar, EngineClient.GetScreenSize, EntityList.GetClientEntity, EntityList.GetLocalPlayer, EntityList.GetPlayer, EntityList.GetPlayerResource, ffi.cast, ffi.cdef, ffi.new, ffi.typeof, math.abs, math.ceil, math.clamp, math.cos, math.floor, math.lerp, math.max, math.min, math.normalize, math.rad, math.round, Menu.Combo, Menu.FindVar, Menu.SliderInt, Menu.Switch, print, pairs, RageBot.OverrideHitchance, Render.InitFont, string.format, table.insert, table.reference_condition, Utils.CreateInterface, Utils.CreateInterface, Utils.PatternScan, Utils.RandomFloat, Vector.new, Vector2.new, fn, type, tonumber, error, condition, EngineClient.GetLocalPlayer, EngineClient.GetViewAngles, EngineClient.IsConnected, EngineClient.IsInGame, EngineTrace.TraceRay, EntityList.GetEntitiesByName, EntityList.GetPlayerForUserID, Exploits.GetCharge, Exploits.OverrideDoubleTapSpeed, math.closest_point_on_ray, math.percent_to_pix, math.sin, math.vector_lerp, MatSystem.FirstMaterial, MatSystem.GetMaterial, MatSystem.NextMaterial, Menu.Button, Menu.ColorEdit, Menu.ComboColor, Menu.DestroyItem, Menu.MultiCombo, Menu.SliderInt, Menu.SwitchColor, Menu.SwitchColor, QAngle.new, Render.BoxFilled, Render.CalcTextSize, Render.Circle, Render.CircleFilled, Render.GradientBoxFilled, Render.Line, Render.PolyFilled, Render.Text, Render.WorldToScreen, table.remove, table.sort, unpack, Utils.RandomFloat, Utils.RandomInt, ipairs, pcall, tostring
local Render_GetMenuPos = Render.GetMenuPos
local Render_GetMenuSize = Render.GetMenuSize
--[[
    @module Ataraxia
    @build alpha
    @author Aslier
    @lastupdatetime 2022/5/5
]]
local cat = [[
        $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%$$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$'''''')$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$C''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''#$$$$$$$$$$$$$$$$$$$$$''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$'''''''''''''''''!pU/))))/Ym)'''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$o''''''''''''''''''''''''''''''''''''''''''''''j$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''w$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
        $$!'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$
        $$$$$$$$$t'''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
        $$$$$$$www''''''''''''''''''''''''''''''''''''''''''''''''''www8$$$$$$$$$$$$$$$$
        $$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$/'''''''''''''''''''''''''''''''''''''''''''':$$$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$$$i'''''''''''''''''''''''''''''''''''''''''$$$$qf!:!?L$$$$$$$$$$$$$
        $$$$$$$$$$$$$$$$$W''''''''''''''''''''''''''''''''''Z$$@''''''''''''''''$$$$$$$$
        $$$$$$$$$$$$$$$$$$$$$$$U''''''''''''''''''''''x@$$$$$$'''''''$$$$$$$$$''''$$$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$$a''''''''''''''|$$$$$$$$$$'''''$$$$$$$$$$$$''''''$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''$$$$$$$$$;''''$$$$$$$$$$$$$$d''''$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$p''''''''''''''''{$$$$$$$$-''''B$$$$$$Y''`$$$$'''''8$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$''''''''''''''''''Q$$$$$$$$''''''''''''''''$$$n''''{$$
        $$$$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''''''''$$$$$$$$f''''''''''''/$$$$+'''']$$
        $$$$$$$$$$$$$$$$$$$$$$$o''''''''''''''''''''''/$$$$$$$$$$$t<;?w$$$$$$$$$'''''0$$
        $$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$$,'''''$$$
        $$$$$$$$$$$$$$$$$$$$$h''''''''''''''''''''''''''|$$$$$$$$$$$$$$$$$$$$$''''''$$$$
        $$$$$$$$$$$$$$$$$$$$L''''''''''''''''''''''''''''~$$$$$$$$$$$$$$$$$&'''''''B$$$$
        $$$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''$$$$$$$$$$$$$$C''''''''-$$$$$$
        $$$$$$$$$$$$$$$$$$$<'''''''''''''''''''''''''''''''$$$$$$$$$<''''''''''>$$$$$$$$
        $$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''B$$$$$$$$$$
        $$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''|$$$$$$$$$$$$$$
        $$$$$$$$$$$$$$$$$$$8''''''''''''''''''''''''''''''''''''''\#$$$$$$$$$$$$$$$$$$$$
        $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%$$$$$$$$$$$$$$$$$$$$$$$

]]

local _ataraxia_ = function()
    local userdata = {
        username = Cheat_GetCheatUserName(),
        build = "beta",
        last_updatetime = "22/5/29"
    }
    local ffi = require('ffi')
    local bit = require "bit"

    ffi_cdef [[
        typedef struct {
            uint8_t r;
            uint8_t g;
            uint8_t b;
            uint8_t a;
        } color_struct_t;
   
        typedef void (__cdecl* console_color_print)(void*,const color_struct_t&, const char*, ...);

        typedef float*(__thiscall* bound)(void*);

        typedef int(__thiscall* get_clipboard_text_count)(void*);
        typedef void(__thiscall* set_clipboard_text)(void*, const char*, int);
        typedef void(__thiscall* get_clipboard_text)(void*, int, const char*, int);
        typedef int(__fastcall* clantag_t)(const char*, const char*);
    ]]

    ffi_cdef[[

    void* GetProcAddress(void* hModule, const char* lpProcName);
    void* GetModuleHandleA(const char* lpModuleName);

    typedef uintptr_t (__thiscall* GetClientEntity_4242425_t)(void*, int);
    struct Animstate_t
    {
            char pad[3];
            char m_bForceWeaponUpdate;
            char pad1[91];
            void* m_pBaseEntity;
            void* m_pActiveWeapon;
            void* m_pLastActiveWeapon;
            float m_flLastClientSideAnimationUpdateTime;
            int m_iLastClientSideAnimationUpdateFramecount;
            float m_flAnimUpdateDelta;
            float m_flEyeYaw;
            float m_flPitch;
            float m_flGoalFeetYaw;
            float m_flCurrentFeetYaw;
            float m_flCurrentTorsoYaw;
            float m_flUnknownVelocityLean;
            float m_flLeanAmount;
            char pad2[4];
            float m_flFeetCycle;
            float m_flFeetYawRate;
            char pad3[4];
            float m_fDuckAmount;
            float m_fLandingDuckAdditiveSomething;
            char pad4[4];
            float m_vOriginX;
            float m_vOriginY;
            float m_vOriginZ;
            float m_vLastOriginX;
            float m_vLastOriginY;
            float m_vLastOriginZ;
            float m_vVelocityX;
            float m_vVelocityY;
            char pad5[4];
            float m_flUnknownFloat1;
            char pad6[8];
            float m_flUnknownFloat2;
            float m_flUnknownFloat3;
            float m_flUnknown;
            float m_flSpeed2D;
            float m_flUpVelocity;
            float m_flSpeedNormalized;
            float m_flFeetSpeedForwardsOrSideWays;
            float m_flFeetSpeedUnknownForwardOrSideways;
            float m_flTimeSinceStartedMoving;
            float m_flTimeSinceStoppedMoving;
            bool m_bOnGround;
            bool m_bInHitGroundAnimation;
            float m_flTimeSinceInAir;
            float m_flLastOriginZ;
            float m_flHeadHeightOrOffsetFromHittingGroundAnimation;
            float m_flStopToFullRunningFraction;
            char pad7[4];
            float m_flMagicFraction;
            char pad8[60];
            float m_flWorldForce;
            char pad9[462];
            float m_flMaxYaw;
        };

        int VirtualProtect(void* lpAddress, unsigned long dwSize, unsigned long flNewProtect, unsigned long* lpflOldProtect);
        void* VirtualAlloc(void* lpAddress, unsigned long dwSize, unsigned long  flAllocationType, unsigned long flProtect);
        int VirtualFree(void* lpAddress, unsigned long dwSize, unsigned long dwFreeType);

        typedef uintptr_t (__thiscall* GetClientEntity_4242425_t)(void*, int);
        typedef struct
        {
            float x;
            float y;
            float z;
        } Vector_t;

        typedef struct
        {
            char    pad0[0x60]; // 0x00
            void* pEntity; // 0x60
            void* pActiveWeapon; // 0x64
            void* pLastActiveWeapon; // 0x68
            float        flLastUpdateTime; // 0x6C
            int            iLastUpdateFrame; // 0x70
            float        flLastUpdateIncrement; // 0x74
            float        flEyeYaw; // 0x78
            float        flEyePitch; // 0x7C
            float        flGoalFeetYaw; // 0x80
            float        flLastFeetYaw; // 0x84
            float        flMoveYaw; // 0x88
            float        flLastMoveYaw; // 0x8C // changes when moving/jumping/hitting ground
            float        flLeanAmount; // 0x90
            char    pad1[0x4]; // 0x94
            float        flFeetCycle; // 0x98 0 to 1
            float        flMoveWeight; // 0x9C 0 to 1
            float        flMoveWeightSmoothed; // 0xA0
            float        flDuckAmount; // 0xA4
            float        flHitGroundCycle; // 0xA8
            float        flRecrouchWeight; // 0xAC
            Vector_t        vecOrigin; // 0xB0
            Vector_t        vecLastOrigin;// 0xBC
            Vector_t        vecVelocity; // 0xC8
            Vector_t        vecVelocityNormalized; // 0xD4
            Vector_t        vecVelocityNormalizedNonZero; // 0xE0
            float        flVelocityLenght2D; // 0xEC
            float        flJumpFallVelocity; // 0xF0
            float        flSpeedNormalized; // 0xF4 // clamped velocity from 0 to 1
            float        flRunningSpeed; // 0xF8
            float        flDuckingSpeed; // 0xFC
            float        flDurationMoving; // 0x100
            float        flDurationStill; // 0x104
            bool        bOnGround; // 0x108
            bool        bHitGroundAnimation; // 0x109
            char    pad2[0x2]; // 0x10A
            float        flNextLowerBodyYawUpdateTime; // 0x10C
            float        flDurationInAir; // 0x110
            float        flLeftGroundHeight; // 0x114
            float        flHitGroundWeight; // 0x118 // from 0 to 1, is 1 when standing
            float        flWalkToRunTransition; // 0x11C // from 0 to 1, doesnt change when walking or crouching, only running
            char    pad3[0x4]; // 0x120
            float        flAffectedFraction; // 0x124 // affected while jumping and running, or when just jumping, 0 to 1
            char    pad4[0x208]; // 0x128
            float        flMinBodyYaw; // 0x330
            float        flMaxBodyYaw; // 0x334
            float        flMinPitch; //0x338
            float        flMaxPitch; // 0x33C
            int            iAnimsetVersion; // 0x340
        } CCSGOPlayerAnimationState_534535_t;

        typedef struct {
            char  pad_0000[20];
            int m_nOrder; //0x0014
            int m_nSequence; //0x0018
            float m_flPrevCycle; //0x001C
            float m_flWeight; //0x0020
            float m_flWeightDeltaRate; //0x0024
            float m_flPlaybackRate; //0x0028
            float m_flCycle; //0x002C
            void *m_pOwner; //0x0030
            char  pad_0038[4]; //0x0034
        } CAnimationLayer_t;
    ]]

    ffi_cdef([[
        typedef struct
        {
            void* steam_client;
            void* steam_user;
            void* steam_friends;
            void* steam_utils;
            void* steam_matchmaking;
            void* steam_user_stats;
            void* steam_apps;
            void* steam_matchmakingservers;
            void* steam_networking;
            void* steam_remotestorage;
            void* steam_screenshots;
            void* steam_http;
            void* steam_unidentifiedmessages;
            void* steam_controller;
            void* steam_ugc;
            void* steam_applist;
            void* steam_music;
            void* steam_musicremote;
            void* steam_htmlsurface;
            void* steam_inventory;
            void* steam_video;
        } S_steamApiCtx_t;
    ]])

    ffi_cdef[[
        void* CreateFileA(
            const char*                lpFileName,
            unsigned long                 dwDesiredAccess,
            unsigned long                 dwShareMode,
            unsigned long lpSecurityAttributes,
            unsigned long                 dwCreationDisposition,
            unsigned long                 dwFlagsAndAttributes,
            void*                hTemplateFile
            );
        bool ReadFile(
                void*       hFile,
                char*       lpBuffer,
                unsigned long        nNumberOfBytesToRead,
                unsigned long*      lpNumberOfBytesRead,
                int lpOverlapped
                );
        bool WriteFile(
                void*       hFile,
                char*      lpBuffer,
                unsigned long        nNumberOfBytesToWrite,
                unsigned long*      lpNumberOfBytesWritten,
                void* lpOverlapped
            );
        bool DeleteFileA(
            const char* lpFileName
        );

        unsigned long GetFileSize(
            void*  hFile,
            unsigned long* lpFileSizeHigh
        );
        bool CreateDirectoryA(
            const char*                lpPathName,
            void* lpSecurityAttributes
        );
        void* CloseHandle(void *hFile);
        typedef int(__fastcall* clantag_t)(const char*, const char*);

        typedef struct _OVERLAPPED {
            unsigned long* Internal;
            unsigned long* InternalHigh;
            union {
                struct {
                unsigned long Offset;
                unsigned long OffsetHigh;
                } DUMMYSTRUCTNAME;
                void* Pointer;
            } DUMMYUNIONNAME;
            void*    hEvent;
            } OVERLAPPED, *LPOVERLAPPED;

        typedef struct _class
        {
            void** this;
        }aclass;
    ]]

    ffi.C.CreateDirectoryA("nl\\ataraxia", nil)

    local pS_SteamApiCtx = ffi.cast(
        "S_steamApiCtx_t**", ffi.cast(
            "char*",
            Utils.PatternScan(
                "client.dll",
                "FF 15 ?? ?? ?? ?? B9 ?? ?? ?? ?? E8 ?? ?? ?? ?? 6A"
            )
        ) + 7
    )[0] or error("invalid interface", 2)

    local Png = {}
Png.__index = Png
local png_ihdr_t = ffi.typeof([[
struct {
    char type[4];
    uint32_t width;
    uint32_t height;
    char bitDepth;
    char colorType;
    char compression;
    char filter;
    char interlace;
} *
]])

local jpg_segment_t = ffi.typeof([[
struct {
    char type[2];
    uint16_t size;
} *
]])

local jpg_segment_sof0_t = ffi.typeof([[
struct {
    uint16_t size;
    char precision;
    uint16_t height;
    uint16_t width;
} __attribute__((packed)) *
]])

local uint16_t_ptr = ffi.typeof("uint16_t*")
local charbuffer = ffi.typeof("unsigned char[?]")
local uintbuffer = ffi.typeof("unsigned int[?]")

--
-- constants
--

local INVALID_TEXTURE = -1
local PNG_MAGIC = "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"

local JPG_MAGIC_1 = "\xFF\xD8\xFF\xDB"
local JPG_MAGIC_2 = "\xFF\xD8\xFF\xE0\x00\x10\x4A\x46\x49\x46\x00\x01"

local JPG_SEGMENT_SOI = "\xFF\xD8"
local JPG_SEGMENT_SOF0 = "\xFF\xC0"
local JPG_SEGMENT_SOS = "\xFF\xDA"
local JPG_SEGMENT_EOI = "\xFF\xD9"



local DEFLATE_MAX_BLOCK_SIZE = 65535

local function putBigUint32(val, tbl, index)
    for i=0,3 do
        tbl[index + i] = bit.band(bit.rshift(val, (3 - i) * 8), 0xFF)
    end
end

function Png:writeBytes(data, index, len)
    index = index or 1
    len = len or #data
    for i=index,index+len-1 do
        table.insert(self.output, string.char(data[i]))
    end
end

function Png:write(pixels)
    local count = #pixels  -- Byte count
    local pixelPointer = 1
    while count > 0 do
        if self.positionY >= self.height then
            error("All image pixels already written")
        end

        if self.deflateFilled == 0 then -- Start DEFLATE block
            local size = DEFLATE_MAX_BLOCK_SIZE;
            if (self.uncompRemain < size) then
                size = self.uncompRemain
            end
            local header = {  -- 5 bytes long
                bit.band((self.uncompRemain <= DEFLATE_MAX_BLOCK_SIZE and 1 or 0), 0xFF),
                bit.band(bit.rshift(size, 0), 0xFF),
                bit.band(bit.rshift(size, 8), 0xFF),
                bit.band(bit.bxor(bit.rshift(size, 0), 0xFF), 0xFF),
                bit.band(bit.bxor(bit.rshift(size, 8), 0xFF), 0xFF),
            }
            self:writeBytes(header)
            self:crc32(header, 1, #header)
        end
        assert(self.positionX < self.lineSize and self.deflateFilled < DEFLATE_MAX_BLOCK_SIZE);

        if (self.positionX == 0) then  -- Beginning of line - write filter method byte
            local b = {0}
            self:writeBytes(b)
            self:crc32(b, 1, 1)
            self:adler32(b, 1, 1)
            self.positionX = self.positionX + 1
            self.uncompRemain = self.uncompRemain - 1
            self.deflateFilled = self.deflateFilled + 1
        else -- Write some pixel bytes for current line
            local n = DEFLATE_MAX_BLOCK_SIZE - self.deflateFilled;
            if (self.lineSize - self.positionX < n) then
                n = self.lineSize - self.positionX
            end
            if (count < n) then
                n = count;
            end
            assert(n > 0);

            self:writeBytes(pixels, pixelPointer, n)

            -- Update checksums
            self:crc32(pixels, pixelPointer, n);
            self:adler32(pixels, pixelPointer, n);

            -- Increment positions
            count = count - n;
            pixelPointer = pixelPointer + n;
            self.positionX = self.positionX + n;
            self.uncompRemain = self.uncompRemain - n;
            self.deflateFilled = self.deflateFilled + n;
        end

        if (self.deflateFilled >= DEFLATE_MAX_BLOCK_SIZE) then
            self.deflateFilled = 0; -- End current block
        end

        if (self.positionX == self.lineSize) then  -- Increment line
            self.positionX = 0;
            self.positionY = self.positionY + 1;
            if (self.positionY == self.height) then -- Reached end of pixels
                local footer = {  -- 20 bytes long
                    0, 0, 0, 0,  -- DEFLATE Adler-32 placeholder
                    0, 0, 0, 0,  -- IDAT CRC-32 placeholder
                    -- IEND chunk
                    0x00, 0x00, 0x00, 0x00,
                    0x49, 0x45, 0x4E, 0x44,
                    0xAE, 0x42, 0x60, 0x82,
                }
                putBigUint32(self.adler, footer, 1)
                self:crc32(footer, 1, 4)
                putBigUint32(self.crc, footer, 5)
                self:writeBytes(footer)
                self.done = true
            end
        end
    end
end

function Png:crc32(data, index, len)
    self.crc = bit.bnot(self.crc)
    for i=index,index+len-1 do
        local byte = data[i]
        for j=0,7 do  -- Inefficient bitwise implementation, instead of table-based
            local nbit = bit.band(bit.bxor(self.crc, bit.rshift(byte, j)), 1);
            self.crc = bit.bxor(bit.rshift(self.crc, 1), bit.band((-nbit), 0xEDB88320));
        end
    end
    self.crc = bit.bnot(self.crc)
end
function Png:adler32(data, index, len)
    local s1 = bit.band(self.adler, 0xFFFF)
    local s2 = bit.rshift(self.adler, 16)
    for i=index,index+len-1 do
        s1 = (s1 + data[i]) % 65521
        s2 = (s2 + s1) % 65521
    end
    self.adler = bit.bor(bit.lshift(s2, 16), s1)
end

local function begin(width, height, colorMode)
    -- Default to rgb
    colorMode = colorMode or "rgb"

    -- Determine bytes per pixel and the PNG internal color type
    local bytesPerPixel, colorType
    if colorMode == "rgb" then
        bytesPerPixel, colorType = 3, 2
    elseif colorMode == "rgba" then
        bytesPerPixel, colorType = 4, 6
    else
        error("Invalid colorMode")
    end

    local state = setmetatable({ width = width, height = height, done = false, output = {} }, Png)

    -- Compute and check data siezs
    state.lineSize = width * bytesPerPixel + 1
    -- TODO: check if lineSize too big

    state.uncompRemain = state.lineSize * height

    local numBlocks = math.ceil(state.uncompRemain / DEFLATE_MAX_BLOCK_SIZE)

    -- 5 bytes per DEFLATE uncompressed block header, 2 bytes for zlib header, 4 bytes for zlib Adler-32 footer
    local idatSize = numBlocks * 5 + 6
    idatSize = idatSize + state.uncompRemain;

    -- TODO check if idatSize too big

    local header = {  -- 43 bytes long
        -- PNG header
        0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
        -- IHDR chunk
        0x00, 0x00, 0x00, 0x0D,
        0x49, 0x48, 0x44, 0x52,
        0, 0, 0, 0,  -- 'width' placeholder
        0, 0, 0, 0,  -- 'height' placeholder
        0x08, colorType, 0x00, 0x00, 0x00,
        0, 0, 0, 0,  -- IHDR CRC-32 placeholder
        -- IDAT chunk
        0, 0, 0, 0,  -- 'idatSize' placeholder
        0x49, 0x44, 0x41, 0x54,
        -- DEFLATE data
        0x08, 0x1D,
    }
    putBigUint32(width, header, 17)
    putBigUint32(height, header, 21)
    putBigUint32(idatSize, header, 34)

    state.crc = 0
    state:crc32(header, 13, 17)
    putBigUint32(state.crc, header, 30)
    state:writeBytes(header)

    state.crc = 0
    state:crc32(header, 38, 6);  -- 0xD7245B6B
    state.adler = 1

    state.positionX = 0
    state.positionY = 0
    state.deflateFilled = 0

    return state
end


    local native_ISteamFriends = ffi.cast("void***", pS_SteamApiCtx.steam_friends)
   
    local native_ISteamUtils = ffi.cast("void***", pS_SteamApiCtx.steam_utils)

    local native_ISteamFriends_GetSmallFriendAvatar = ffi.cast("int(__thiscall*)(void*, uint64_t)" ,native_ISteamFriends[0][34] )

    local native_ISteamUtils_GetImageSize = ffi.cast("bool(__thiscall*)(void*, int, uint32_t*, uint32_t*)" , native_ISteamUtils[0][5])

    local native_ISteamUtils_GetImageRGBA =  ffi.cast("bool(__thiscall*)(void*, int, unsigned char*, int)" , native_ISteamUtils[0][6])
   
    local VGUI_System010 = Utils_CreateInterface("vgui2.dll", "VGUI_System010") or print("Error finding VGUI_System010")

    local VGUI_System = ffi.cast(ffi.typeof('void***'), VGUI_System010)

    local cvar_interface = ffi_cast(ffi.typeof("uintptr_t**"), Utils_CreateInterface("vstdlib.dll", "VEngineCvar007")) or error ("Fail")

    local color_print_fn = ffi.cast("console_color_print", cvar_interface[0][25]) or error ("Fail")
   
    local function vtable_thunk(index, typedef)
        return function(v0, ...)
            local instance = ffi.cast(ffi.typeof('void***'), v0)
   
            local tdef = nil
   
            if seen[typedef] then
                tdef = seen[typedef]
            else
                tdef = ffi.typeof(typedef)
   
                seen[typedef] = tdef
            end
   
            return ffi.cast(tdef, instance[0][index])(instance, ...)
        end
    end
   
    local function vtable_bind(interface, index, typedef)
        local instance = ffi.cast('void***', interface);
   
        return function(...)
            return ffi.cast(typedef, instance[0][index])(instance, ...)
        end
    end
    local entity_list_pointer = ffi.cast("void***", Utils.CreateInterface("client.dll", "VClientEntityList003"))
    local get_client_entity_fn = ffi.cast("GetClientEntity_4242425_t", entity_list_pointer[0][3])
    local get_entity_address = function(ent_index)
        local addr = get_client_entity_fn(entity_list_pointer, ent_index)
        return addr
    end

    local hook_helpers = {
        copy = function(dst, src, len)
            return ffi.copy(ffi.cast('void*', dst), ffi.cast('const void*', src), len)
        end,

        virtual_protect = function(lpAddress, dwSize, flNewProtect, lpflOldProtect)
            return ffi.C.VirtualProtect(ffi.cast('void*', lpAddress), dwSize, flNewProtect, lpflOldProtect)
        end,

        virtual_alloc = function(lpAddress, dwSize, flAllocationType, flProtect, blFree)
            local alloc = ffi.C.VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
            if blFree then
                table.insert(buff.free, function()
                    ffi.C.VirtualFree(alloc, 0, 0x8000)
                end)
            end
            return ffi.cast('intptr_t', alloc)
        end
    }
    local buff = {free = {}}
    local vmt_hook = {hooks = {}}


    function vmt_hook.new(vt)
        local new_hook = {}
        local org_func = {}
        local old_prot = ffi.new('unsigned long[1]')
        local virtual_table = ffi.cast('intptr_t**', vt)[0]

        new_hook.this = virtual_table
        new_hook.hookMethod = function(cast, func, method)
            org_func[method] = virtual_table[method]
            hook_helpers.virtual_protect(virtual_table + method, 4, 0x4, old_prot)

            virtual_table[method] = ffi.cast('intptr_t', ffi.cast(cast, func))
            hook_helpers.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)

            return ffi.cast(cast, org_func[method])
        end

        new_hook.unHookMethod = function(method)
            hook_helpers.virtual_protect(virtual_table + method, 4, 0x4, old_prot)
            local alloc_addr = hook_helpers.virtual_alloc(nil, 5, 0x1000, 0x40, false)
            local trampoline_bytes = ffi.new('uint8_t[?]', 5, 0x90)

            trampoline_bytes[0] = 0xE9
            ffi.cast('int32_t*', trampoline_bytes + 1)[0] = org_func[method] - tonumber(alloc_addr) - 5

            hook_helpers.copy(alloc_addr, trampoline_bytes, 5)
            virtual_table[method] = ffi.cast('intptr_t', alloc_addr)

            hook_helpers.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)
            org_func[method] = nil
        end

        new_hook.unHookAll = function()
            for method, func in pairs(org_func) do
                new_hook.unHookMethod(method)
            end
        end

        table.insert(vmt_hook.hooks, new_hook.unHookAll)
        return new_hook
    end


    local hooked_function = nil
    local is_jumping = false
    local display_duration = 2
    local speed = 1
    local check_headshot = false
    local get_fake_amount = 0
    local noti_table = {}
    local sc_x,sc_y = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
    local M = {}
   
    local JSON = Panorama.LoadString([[
        return {
            stringify: JSON.stringify,
            parse: JSON.parse
        };
    ]])()

    local shl, shr, band = bit.lshift, bit.rshift, bit.band
    local char, byte, gsub, sub, format, concat, tostring, error, pairs = string.char, string.byte, string.gsub, string.sub, string.format, table.concat, tostring, error, pairs

    local extract = function(v, from, width)
        return band(shr(v, from), shl(1, width) - 1)
    end

    local function makeencoder(alphabet)
        local encoder, decoder = {}, {}
        for i=1, 65 do
            local chr = byte(sub(alphabet, i, i)) or 32 -- or " "
            if decoder[chr] ~= nil then
                error("invalid alphabet: duplicate character " .. tostring(chr), 3)
            end
            encoder[i-1] = chr
            decoder[chr] = i-1
        end
        return encoder, decoder
    end

    local encoders, decoders = {}, {}

    encoders["base64"], decoders["base64"] = makeencoder("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=")
    encoders["base64url"], decoders["base64url"] = makeencoder("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")

    local alphabet_mt = {
        __index = function(tbl, key)
            if type(key) == "string" and key:len() == 64 or key:len() == 65 then
                -- if key is a valid looking base64 alphabet, try to make an encoder/decoder pair from it
                encoders[key], decoders[key] = makeencoder(key)
                return tbl[key]
            end
        end
    }

    setmetatable(encoders, alphabet_mt)
    setmetatable(decoders, alphabet_mt)

    function M.encode(str, encoder)
        encoder = encoders[encoder or "base64"] or error("invalid alphabet specified", 2)

        str = tostring(str)

        local t, k, n = {}, 1, #str
        local lastn = n % 3
        local cache = {}

        for i = 1, n-lastn, 3 do
            local a, b, c = byte(str, i, i+2)
            local v = a*0x10000 + b*0x100 + c
            local s = cache[v]

            if not s then
                s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)])
                cache[v] = s
            end

            t[k] = s
            k = k + 1
        end

        if lastn == 2 then
            local a, b = byte(str, n-1, n)
            local v = a*0x10000 + b*0x100
            t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[64])
        elseif lastn == 1 then
            local v = byte(str, n)*0x10000
            t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[64], encoder[64])
        end

        return concat(t)
    end

    function M.decode(b64, decoder)
        decoder = decoders[decoder or "base64"] or error("invalid alphabet specified", 2)

        local pattern = "[^%w%+%/%=]"
        if decoder then
            local s62, s63
            for charcode, b64code in pairs(decoder) do
                if b64code == 62 then s62 = charcode
                elseif b64code == 63 then s63 = charcode
                end
            end
            pattern = format("[^%%w%%%s%%%s%%=]", char(s62), char(s63))
        end

        b64 = gsub(tostring(b64), pattern, '')

        local cache = {}
        local t, k = {}, 1
        local n = #b64
        local padding = sub(b64, -2) == "==" and 2 or sub(b64, -1) == "=" and 1 or 0

        for i = 1, padding > 0 and n-4 or n, 4 do
            local a, b, c, d = byte(b64, i, i+3)

            local v0 = a*0x1000000 + b*0x10000 + c*0x100 + d
            local s = cache[v0]
            if not s then
                local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d]
                s = char(extract(v,16,8), extract(v,8,8), extract(v,0,8))
                cache[v0] = s
            end

            t[k] = s
            k = k + 1
        end

        if padding == 1 then
            local a, b, c = byte(b64, n-3, n-1)
            local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40
            t[k] = char(extract(v,16,8), extract(v,8,8))
        elseif padding == 2 then
            local a, b = byte(b64, n-3, n-2)
            local v = decoder[a]*0x40000 + decoder[b]*0x1000
            t[k] = char(extract(v,16,8))
        end
        return concat(t)
    end

    local get_clipboard_text_count = ffi.cast("get_clipboard_text_count", VGUI_System[0][7]) or print("get_clipboard_text_count Invalid")

    local set_clipboard_text = ffi.cast("set_clipboard_text", VGUI_System[0][9]) or print("set_clipboard_text Invalid")

    local get_clipboard_text = ffi.cast("get_clipboard_text", VGUI_System[0][11]) or print("get_clipboard_text Invalid")

    local function str_to_sub(input, sep)
        local t = {}
   
        for str in string.gmatch(input, "([^" .. sep .. "]+)") do
            t[#t + 1] = string.gsub(str, "\n", "")
        end
   
        return t
    end

    local ffi_handler = {}
    ffi_handler.bind_argument = function(fn, arg)
        return function(...)
            return fn(arg, ...)
        end
    end

    ffi_handler.interface_type = ffi_typeof("uintptr_t**")

    ffi_handler.vgui_system = ffi_cast(ffi_handler.interface_type, Utils.CreateInterface("vgui2.dll", "VGUI_System010"))

    ffi_handler.get_clipboard_text_count = ffi_handler.bind_argument(ffi.cast("int(__thiscall*)(void*)", ffi_handler.vgui_system[0][7]), ffi_handler.vgui_system)
    ffi_handler.set_clipboard_text = ffi_handler.bind_argument(ffi.cast("void(__thiscall*)(void*, const char*, int)", ffi_handler.vgui_system[0][9]), ffi_handler.vgui_system)
    ffi_handler.get_clipboard_text_fn = ffi_handler.bind_argument(ffi.cast("void(__thiscall*)(void*, int, const char*, int)", ffi_handler.vgui_system[0][11]), ffi_handler.vgui_system)

    ffi_handler.clipboard_import = function()
        local clipboard_text_length = ffi_handler.get_clipboard_text_count()
   
        if clipboard_text_length > 0 then
            local buffer = ffi.new("char[?]", clipboard_text_length)
            local size = clipboard_text_length * ffi.sizeof("char[?]", clipboard_text_length)
       
            ffi_handler.get_clipboard_text_fn(0, buffer, size )
       
            return ffi.string( buffer, clipboard_text_length-1)
        end
   
        return ""
    end

    local function clipboard_export(string)
        if string then
            set_clipboard_text(VGUI_System, string, string:len())
        end
    end

    local debugger = function(...)
        local color_print = function(color,tel)
            if color == nil then
                return
            end
   
            local col = ffi.new("color_struct_t")
            col.r = color.r * 255
            col.g = color.g * 255
            col.b = color.b * 255
            col.a = color.a * 255
            color_print_fn(cvar_interface, col, tel)
        end
        local r,g,b,a = 224/255,159/255,154/255,1

        color_print(Color_new(r,g,b,a),"[Ataraxia] ")
        print(...)
    end
    local ui_reference = function(tab1,tab2,tab3,tab4)
        return Menu_FindVar(tab1,tab2,tab3,tab4)
    end

    local ui_set = function(type,elements,val,state)
        if type == "value" then
            return elements:Set(val)
        elseif type == "bool" then
            return elements:SetBool(val,state)
        end
    end

    local ui_get = function(type,elements,val)
        if type == "value" then
            return elements:Get()
        elseif type == "color" then
            local r,g,b,a = elements:GetColor().r,elements:GetColor().g,elements:GetColor().b,elements:GetColor().a
           
            return {r = r ,g = g,b = b,a = a }
        elseif type == "bool" then
            return elements:GetBool(val)
        end
    end
   
    local ui_set_visible = function(elements,val)
        return elements:SetVisible(val)
    end

    local ui_set_callback = function(elements,val)
        return elements:RegisterCallback(val)
    end

    local ui_new_multiselect = function(tab1,tab2,elements,combo,val,tooltips)
        return Menu_MultiCombo(tab1,tab2,elements,combo,val,tooltips)
    end

    local ui_new_combobox = function(tab1,tab2,elements,combo,val,tooltips)
        return Menu_Combo(tab1,tab2,elements,combo,val,tooltips)
    end

    local ui_new_colorpicker = function(tab1,tab2,elements,r,g,b,a,tooltips)
        return Menu_ColorEdit(tab1,tab2,elements,Color_RGBA(r,g,b,a),tooltips)
    end

    local ui_new_textbox = function(tab1,tab2,elements,max_size,val,tooltips)
        return Menu.TextBox(tab1,tab2,elements,max_size,val,tooltips)
    end
   
    local ui_new_label = function(tab1,tab2,elements)
        return Menu.Text(tab1,tab2,elements)
    end
   
    local ui_new_checkbox = function(type,tab1,tab2,elements,states,tooltips,r,g,b,a)
        if type == "bool" then
            return Menu_Switch(tab1,tab2,elements,states,tooltips)
        elseif type == "color" then
            return Menu_SwitchColor(tab1,tab2,elements,states,Color_RGBA(r,g,b,a),tooltips)
        end
    end

    local ui_new_slider = function(type,tab1,tab2,elements,min,max,val,tooltips)
        if type == "int" then
            return Menu_SliderInt(tab1,tab2,elements,val,min,max,tooltips)
        elseif type == "float" then
            return Menu.SliderFloat(tab1,tab2,elements,val,min,max,tooltips)
        end
    end

    local client_set_event_callback = function(events,func)
        return cheat_RegisterCallback(events,func)
    end

    local entity_get_prop = function(inx,prop)
        return inx:GetProp(prop)
    end

    local entity_get_localplayer = function()
        return EntityList_GetLocalPlayer()
    end
   
    Render.Texts = function(text, pos, col, size, font, bool)
        if font == nil then
            Render.Text(text, pos + Vector2.new(1, 1), Color.new(0, 0, 0, col.a), size, false , bool)
            Render.Text(text, pos, col, size, false , bool)
        else
            Render.Text(text, pos + Vector2.new(1, 1), Color.new(0, 0, 0, col.a), size, font, false , bool and bool or false)
            Render.Text(text, pos, col, size, font, false , bool and bool or false )
        end
    end
     
   
    local noscope_weapons = {
        [261] = true,
        [242] = true,
        [233] = true,
        [267] = true
    }

    local reference = {
        enable = ui_reference("Aimbot","Anti Aim","Main","Enable Anti Aim"),
        pitch = ui_reference("Aimbot","Anti Aim","Main","Pitch"),
        yaw_base = ui_reference("Aimbot","Anti Aim","Main","Yaw Base"),
        yaw_add = ui_reference("Aimbot","Anti Aim","Main","Yaw Add"),
        yaw_jitter_mode = ui_reference("Aimbot","Anti Aim","Main","Yaw Modifier"),
        yaw_jitter_slider = ui_reference("Aimbot","Anti Aim","Main","Modifier Degree"),
        fake_angle = ui_reference("Aimbot","Anti Aim","Fake Angle", "Enable Fake Angle"),
        inverter = ui_reference("Aimbot","Anti Aim","Fake Angle", "Inverter"),
        left_limit = ui_reference("Aimbot","Anti Aim", "Fake Angle", "Left Limit"),
        right_limit = ui_reference("Aimbot","Anti Aim","Fake Angle", "Right Limit"),
        fake_option = ui_reference("Aimbot","Anti Aim","Fake Angle", "Fake Options"),
        lby = ui_reference("Aimbot","Anti Aim", "Fake Angle", "LBY Mode"),
        freestanding_yaw = ui_reference("Aimbot","Anti Aim", "Fake Angle", "Freestanding Desync"),
        desync_shot = ui_reference("Aimbot","Anti Aim","Fake Angle", "Desync On Shot"),
        slow_motion = ui_reference("Aimbot","Anti Aim", "Misc", "Slow Walk"),
        leg_movement = ui_reference("Aimbot","Anti Aim","Misc", "Leg Movement"),
        autopeek = ui_reference("Miscellaneous", 'Main',  'Movement', 'Auto Peek'),
        windows = ui_reference("Miscellaneous", 'Main',  'Other', 'Windows'),

        auto_starfe = ui_reference("Miscellaneous", 'Main',  'Movement', 'Auto Strafe'),
        dmg = ui_reference("Aimbot", 'Ragebot', 'Accuracy', 'Minimum Damage'),
        ragebot = ui_reference("Aimbot", "Ragebot", "Main", "Enable Ragebot"),

        dt = ui_reference("Aimbot", "Ragebot", "Exploits", "Double Tap"),
        fl_main = ui_reference("Aimbot", "Anti Aim", "Fake Lag", "Enable Fake Lag"),
        fl_limit = ui_reference("Aimbot","Anti Aim", "Fake Lag", "Limit"),
        fl_jitter = ui_reference("Aimbot","Anti Aim","Fake Lag", "Randomization"),
        hs = ui_reference("Aimbot", "Ragebot", "Exploits", "Hide Shots"),

        hitchance = ui_reference("Aimbot", "Ragebot", "Accuracy", "Hit Chance"),
        body_aim = ui_reference("Aimbot", "Ragebot", "Misc", "Body Aim"),
        safe_point = ui_reference("Aimbot", "Ragebot", "Misc", "Safe Points"),
        tb = CVar.FindVar("sv_maxusrcmdprocessticks"),
        clock = CVar.FindVar("cl_clock_correction"),
        fakeduck = ui_reference("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
        lagCompensation = CVar.FindVar("cl_lagcompensation"),
        remove_scope = ui_reference("Visuals", "View", "Camera", "Remove Scope"),



    }

   
    local doubletap_charged = function()
        if not ui_get("value",reference.dt) or ui_get("value",reference.fakeduck) then
            return false
        end
   
        if entity_get_localplayer() == nil then
            return
        end
   
        local weap = entity_get_localplayer():GetActiveWeapon()
        if weap == nil then
            return
        end
   
        local next_attack = entity_get_prop(entity_get_localplayer(), "m_flNextAttack") + 0.25
        local jewfag = entity_get_prop(weap, "m_flNextPrimaryAttack")
   
        if jewfag == nil then
            return
        end
        local next_primary_attack = jewfag + 0.5
        if next_attack == nil or next_primary_attack == nil then
            return false
        end
        return next_attack - GlobalVars.curtime < 0 and next_primary_attack -GlobalVars.curtime < 0
    end

    table.insert(noti_table, {
        text = "Welcome to Ataraxia , "..userdata.username.." Current build: "..userdata.build.." Last update time: "..userdata.last_updatetime,
        timer = GlobalVars.realtime,
        smooth_y = sc_y + 100,
        alpha = 0,
    })

    local menu = {}
    menu.ui_data = {
        bool = {},
        int = {},
        float = {},
        str = {},
        color = {}
    }

    menu.callback_data = {}

    menu.new_elements = function(type,cheatVar)
        if type == "bool" then
           table_insert(menu.ui_data.bool,cheatVar)
        end
        if type == "int" then
            table_insert(menu.ui_data.int,cheatVar)
        end
        if type == "float" then
            table_insert(menu.ui_data.float,cheatVar)
        end
        if type == "str" then
            table_insert(menu.ui_data.str,cheatVar)
        end
        if type == "color" then
            table_insert(menu.ui_data.color,cheatVar)
        end
        if type == "button" then
            debugger("invoked button")
        end
        table_insert(menu.callback_data,cheatVar)
        return cheatVar
    end

    menu.interface = {}
    menu.interface.type = {"[Ataraxia] Info","[Ataraxia] Visuals","[Ataraxia] Antiaim","[Ataraxia] Misc"}
    menu.interface.info = {}
    menu.interface.antiaim = {}
    menu.interface.visuals = {}
    menu.interface.misc = {}

    local t1 = menu.interface.type[1]
    local t2 = menu.interface.type[2]
    local t3 = menu.interface.type[3]
    local t4 = menu.interface.type[4]

    local info = menu.interface.info
    local antiaim = menu.interface.antiaim
    local visuals = menu.interface.visuals
    local misc = menu.interface.misc

    local _state = {"Stand","Move","Slow walk","Duck","Air","Air + D"}
    local __state = {"1","2","3","4","5","6"}

 
    local g_config = {

        export_process = function(self)
            local data = {{},{},{},{},{}}
            for k, v in pairs(menu.ui_data.bool) do
                table_insert(data[1],v:GetBool())
            end
            for k, v in pairs(menu.ui_data.int) do
                table_insert(data[2],ui_get("value",v))
            end
            for k, v in pairs(menu.ui_data.float) do
                table_insert(data[3],ui_get("value",v))
            end
            for k, v in pairs(menu.ui_data.str) do
                table_insert(data[4],ui_get("value",v))
            end
            for _, colors in pairs(menu.ui_data.color) do
                local clr = colors:GetColor()
                table_insert(data[5], string.format("%02X%02X%02X%02X", math.floor(clr.r * 255), math.floor(clr.g * 255), math.floor(clr.b * 255), math.floor(clr.a * 255)))
            end

            clipboard_export(M.encode(JSON.stringify(data)))
        end,

        load_process = function(self,text)

            local protected = function()
                local clipboard = text == nil and ffi_handler.clipboard_import() or text
                local json_config = M.decode(clipboard)
                json_config = JSON.parse(json_config)

                if json_config == nil then
                    error("wrong_json")
                    return
                end
                for k, v in pairs(json_config) do
                        k = ({[1] = "bool", [2] = "int", [3] = "float", [4] = "str", [5] = "color"})[k]
                        for k2, v2 in pairs(v) do
                            if (k == "bool") then
                            if type(v2) == "boolean" then
                                menu.ui_data[k][k2]:SetBool(v2)
                            else
                                return debugger("Fail to load due to incorrect data type, expect boolean received "..type(v2))
                            end
                            end
                            if (k == "int") then
                                if type(v2) == "number" then
                                    menu.ui_data[k][k2]:SetInt(v2)
                                else
                                    return debugger("Fail to load due to incorrect data type, expect number received "..type(v2))
                                end
                            end
                            if (k == "float") then
                                if type(v2) == "number" then
                                    menu.ui_data[k][k2]:SetFloat(v2)
                                else
                                    return debugger("Fail to load due to incorrect data type, expect number received "..type(v2))
                                end
                        end
                        if (k == "string") then
                            menu.ui_data[k][k2]:SetString(v2)
                        end
                        if (k == "color") then
                            menu.ui_data[k][k2]:SetColor(Color.new(tonumber("0x"..v2:sub(1, 2))/255, tonumber("0x"..v2:sub(3, 4))/255, tonumber("0x"..v2:sub(5, 6))/255, tonumber("0x"..v2:sub(7, 8))/255))
                        end
                    end
                end
                Cheat_AddNotify("Ataraxia", "Config loaded!")
                debugger("Loaded config from clipboard")
                table.insert(noti_table, {
                    text = "Loaded config from clipboard",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
                table.insert(noti_table, {
                    text = "Reload lua to use config",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
       
            end
            local status, message = pcall(protected)

            if not status then
                debugger("Fail to load config "..message)
                table.insert(noti_table, {
                    text = "Failed to load config,check error message and send it to support",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
                Cheat_AddNotify("Ataraxia", "Failed to load config due to "..message)
                return
            end
        end,

        menu = function(self)

           
       
        end,

    }

    local clamp = function(num, min, max)
        if num < min then
            num = min
        elseif num > max then
            num = max
        end
        return num
    end
 

    local get_icon_size = Vector2.new(32,28)

    local bytes = Http.Get("https://i.imgur.com/WEZaLSo.png")
    local pfile = ffi.cast("void*", ffi.C.CreateFileA(ffi.cast("const char *", "nl\\ataraxia\\icon.png"), 0xC0000000, 0x00000003, 0, 0x4, 0x80, nil))
    if (not pfile) then
        debugger("Failed to create file, please restart the script or create a ticket.")
        return
    end



    local overlapped = ffi.new("OVERLAPPED")
    overlapped.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Offset = 0xFFFFFFFF
    overlapped.DUMMYUNIONNAME.DUMMYSTRUCTNAME.OffsetHigh = 0xFFFFFFFF

    ffi.C.WriteFile(pfile, ffi.cast("char*" , bytes) , 25600 , nil ,  ffi.cast("void*", overlapped))
    ffi.C.CloseHandle(pfile)
    local icon = Render.LoadImageFromFile("nl\\ataraxia\\icon.png", get_icon_size)

   

    local g_menu = {
       
        create_data = function(self)
            info.announcement = ui_new_label(t1,"[Announcement]","Thanks for all small8-yaw user's long waiting.")
            info.user = ui_new_label(t1,"[Userdata]","Welcome! "..userdata.username)
            info.build = ui_new_label(t1,"[Userdata]","Current build: "..userdata.build)
            info.last_updatetime = ui_new_label(t1,"[Userdata]","Last update time: "..userdata.last_updatetime)
            info.master_switch = menu.new_elements("bool",ui_new_checkbox("bool",t1,"[Announcement]","Enable Ataraxia",false,"[~] All features master switch"))
            info.feature_list = menu.new_elements("int",ui_new_multiselect(t1,"[Announcement]","Features list",{"Indicators","Built-in presets","Extra antiaim settings","Misc features"},0,"[~] Features list"))

            antiaim.import = menu.new_elements("button",Menu_Button(t1,"[Config]","                  Load config from clipboard              ","[~] Check here to load config",function()
                g_config:load_process()
            end))
       
            antiaim.export = menu.new_elements("button",Menu_Button(t1,"[Config]","                   Export config to clipboard               ","[~] Check here to export config",function()
                g_config:export_process()
                Cheat_AddNotify("Ataraxia", "Config Copied!")
                table.insert(noti_table, {
                    text = "Exported config!",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
                debugger("Exported config")
            end))
            info.download = menu.new_elements("button",Menu_Button(t1,"[Userdata]","Download userdata from clipboard ","[~] Check here to download userdata",function()
           
            end))
   

            visuals.info = ui_new_label(t2,"[Notice]","Enable in the main interface")
            antiaim.info = ui_new_label(t3,"[Notice]","Enable in the main interface")
            misc.info = ui_new_label(t4,"[Notice]","Enable in the main interface")

            visuals.indicator_settings = menu.new_elements("int",ui_new_multiselect(t2,"[Indicator settings]","Features list",{"Manual Arrows","Center","Watermark","Menu effect","Damage marker","Scope line","Solus render","Damage indicator"},0,"[~] Indicator features list"))
            visuals.disable_glow = menu.new_elements("bool",ui_new_checkbox("bool",t2,"[Indicator settings]","Disable glow",false,"[~] Disable all cointainer's glow"))
            visuals.indicator_color = menu.new_elements("color",ui_new_colorpicker(t2,"[Indicator settings]","Main color",224,159,154,255,"[~] Center & Arrows & Effect & Scopeline color"))
            visuals.watermark_color = menu.new_elements("color",ui_new_colorpicker(t2,"[Indicator settings]","Watermark color",224,159,154,255,"[~] Watermark color"))

            visuals.arrows_mode = menu.new_elements("int",ui_new_combobox(t2,"[Manual Arrows]","Arrows mode",{"+","-"},0,"[~] Arrows mode"))
            visuals.arrows_background = menu.new_elements("bool",ui_new_checkbox("bool",t2,"[Manual Arrows]","Background shadow",false,"[~] Arrows background shadow"))
            visuals.arrows_distance = menu.new_elements("int",ui_new_slider("int",t2,"[Manual Arrows]","Arrows distance",10,100,15,"[~] Distance between arrows"))

            visuals.center_mode = menu.new_elements("int",ui_new_combobox(t2,"[Center]","Center mode",{"Text","Gradient","Pixel","Icon"},0,"[~] Arrows mode"))
            visuals.center_scoped_anim = menu.new_elements("int",ui_new_multiselect(t2,"[Center]","Scoped animations",{"Alpha","Postion"},0,"[~] Scoped animations"))
            visuals.center_color_2 = menu.new_elements("color",ui_new_colorpicker(t2,"[Center]","Gradient color",170,170,170,255,"[~] Second color"))

            visuals.temp_keybind_x = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","TEMP_X",0,sc_x,500,"[~]"))
            visuals.temp_keybind_y = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","TEMP_Y",0,sc_y,500,"[~]"))
            visuals.temp_spec_x = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","STEMP_X",0,sc_x,500,"[~]"))
            visuals.temp_spec_y = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","STEMP_Y",0,sc_y,500,"[~]"))

            visuals.dmgmarker_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage marker]","Display mode",{"-","+","++"},0,"[~] Display mode"))
            visuals.dmgmarker_display_time = menu.new_elements("int",ui_new_slider("int",t2,"[Damage marker]","Display Duration",1,10,4,"[~] Maker's display time"))
            visuals.dmgmarker_speed = menu.new_elements("int",ui_new_slider("int",t2,"[Damage marker]","Speed",1,8,2,"[~] Maker's speed"))
            visuals.dmgmarker_color_2 = menu.new_elements("color",ui_new_colorpicker(t2,"[Damage marker]","Normal color",255,255,255,255,"[~] Second color"))

            visuals.scopeline_origin = menu.new_elements("int",ui_new_slider("int",t2,"[Scope line]","Scope origin",0,500,100,"[~] Scope origin"))
            visuals.scopeline_width = menu.new_elements("int",ui_new_slider("int",t2,"[Scope line]","Scope width",0,500,100,"[~] Scope origin"))

            visuals.solus_select = menu.new_elements("int",ui_new_multiselect(t2,"[Solus render]","Solus feature",{"Watermark","Keybind","Spectator"},0,"[~] Solus features"))
            visuals.solus_watermark_name = menu.new_elements("str",ui_new_textbox(t2,"[Solus render]","User name",30,userdata.username,"[~] Watermark main text"))

            visuals.dmgind_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display mode",{"-","+"},0,"[~] Display mode"))
            visuals.dmgind_pos = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display postion",{"Top left","Top right","Bottom left","Bottom Right"},0,"[~] Display mode"))

            antiaim.preset_mode = menu.new_elements("int",ui_new_combobox(t3,"[Built-in presets]","Presets manager",{"#1","Custom"},0,"[~] ."))
            antiaim.preset_static = menu.new_elements("int",ui_new_multiselect(t3,"[Built-in presets]","Suppress jitter select",_state,0,"[~] Disable jitter when choking commands"))

            antiaim.custom_states = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","Condition selection",_state,0,"[~] Select for custom states"))

            antiaim.ex_info = ui_new_label(t3,"[Extra-Notice]","Enable in the main interface")

            antiaim.ex_select = menu.new_elements("int",ui_new_multiselect(t3,"[Extra antiaim settings]","Extra settings",{"Manual antiaim","Antiaim on use","Edge yaw","Roll"},0,"[~] Select for extra antiaim settings"))
            antiaim.ex_manual_yawbase = menu.new_elements("int",ui_new_combobox(t3,"[Extra antiaim settings]","Manual Yawbase",{"At Target", "Forward", "Backward", "Right", "Left", "Freestanding"},0,"[~] Manual yaw base"))
            antiaim.on_use_select = menu.new_elements("int",ui_new_multiselect(t3,"[Extra antiaim settings]","Antiaim on use",{"Disable use to plant"},0,"[~] Antiaim on use setting"))
            antiaim.ex_prevent_jitter = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Extra antiaim settings]","Prevent sideways jitter",false,"[~] Prevent jitter on sideways"))
            antiaim.ex_edge_yaw = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Extra antiaim settings]","Edge yaw",false,"[~] Edge yaw"))

            antiaim.ex_roll_states = menu.new_elements("int",ui_new_multiselect(t3,"[Roll settings]","Roll states",{"Stand","Slow walk","Duck","Manual","Use"},0,"[~] Force roll states"))
            antiaim.ex_roll_options = menu.new_elements("int",ui_new_multiselect(t3,"[Roll settings]","Extra roll options",{"Jitter","Disable roll when peeking","Unsafe"},0,"[~] Force roll states"))
            antiaim.ex_roll_key = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Roll settings]","Roll key",false,"[~] Force roll"))
            -- antiaim.ex_roll_inverter = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Roll settings]","Roll inverter",false,"[~] only work on Stand"))

            antiaim.custom_data = {}


            for k, v in pairs(_state) do
                antiaim.custom_data[k] = {
                    enable = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Custom modifier]","Enable ".._state[k].." setting",false,"[~] Switch states")),
                    extra_options = menu.new_elements("int",ui_new_multiselect(t3,"[Custom modifier]","["..__state[k].."] Extra options",{"Suppress jitter","Freestand yaw","Desync on shot","Lby modifier","Avert concide","Anti bruteforce"},0,"[~] Extra antiaim options")),
                    lby_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] LBY mode",{"Opposite","Sway"},0,"[~] LBY modifier funtions")),
                    desync_on_shot = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Desync on shot",{"Opposite","Freestanding","Switch"},0,"[~] Desync on shot")),
                    freestanding_bodyyaw = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Freestand yaw",{"Peek fake","Peek real"},0,"[~] Freestanding bodyyaw")),
                    yaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Yaw built-in funcs",{"Static","Period jitter [Tick]","Period jitter [Choke]","Period jitter [Desync]"},0,"[~] Yaw modifier funtions")),
                    static_yaw = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw",-90,90,0,"[~] Yaw modifier")),
                    tick_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Tick]",-90,90,0,"[~] Yaw left will jitter by tick")),
                    tick_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Tick]",-90,90,0,"[~] Yaw right will jitter by tick")),
                    choke_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Choke]",-90,90,0,"[~] Yaw left will jitter by choke")),
                    choke_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Choke]",-90,90,0,"[~] Yaw right will jitter by choke")),
                    desync_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Desync]",-90,90,0,"[~] Yaw left will jitter by desync side")),
                    desync_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Desync]",-90,90,0,"[~] Yaw right will jitter by desync side")),
                    yaw_jitter = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Native yaw mode",{"Disabled","Center","Offset","Random","Spin"},0,"[~] Yaw native funtions")),
                    yaw_jitter_degree = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Native yaw degree",0,120,0,"[~] Yaw native degree")),
                    self_bodyyaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Body yaw mode",{"Disabled","Static","Jitter"},0,"[~] Bodyyaw native funtions")),
                    bodyyaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Body built-in funcs",{"Static","Period jitter","Recursion"},0,"[~] Bodyyaw modifier funtions")),
                    bodyyaw_degree = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw modifier",-180,180,0,"[~] Body yaw degree modifier")),
                    jitter_bodyyaw_degree_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw left",-180,180,0,"[~] Body yaw will jitter by your desync side")),
                    jitter_bodyyaw_degree_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw right",-180,180,0,"[~] Body yaw will jitter by your desync side")),
                    body_yaw_step_ticks = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Recursion ticks",1,15,0,"[~] Recursion ticks")),
                    body_yaw_step_value = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Recursion value",0,180,0,"[~] Recursion value")),
                    step_bodyyaw_degree_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw min",-180,180,0,"[~] Body yaw recursion min")),
                    step_bodyyaw_degree_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw max",-180,180,0,"[~] Body yaw recursion max")),
                    fake_yaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Fake built-in funcs",{"Static","Period tick jitter","Progressive"},0,"[~] Bodyyaw modifier funtions")),
                    static_fakeyaw = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit",0,60,0,"[~] Fake yaw limit")),
                    jitter_fakeyaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake left [Period]",0,60,0,"[~] Fake yaw will jitter by period")),
                    jitter_fakeyaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake right [Period]",0,60,0,"[~] Fake yaw will jitter by period")),
                    step_ticks = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Progressive ticks",1,15,7,"[~] Progressive ticks")),
                    step_value = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Progressive value",1,60,10,"[~] Progressive value")),
                    step_abs = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Custom modifier]","["..__state[k].."] Increment absolute value",false,"[~] Progressive will only progress abs value")),
                    step_fake_min = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit min",0,60,0,"[~] Fake yaw limit min ")),
                    step_fake_max = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit max",0,60,0,"[~] Fake yaw limit max ")),                  
                }
            end


         
            misc.select = menu.new_elements("int",ui_new_multiselect(t4,"[Misc features]","Misc settings",{"Anti knife","Animation breaker","Jump scout fix","Trash talk","Hit sound","Extra ragebot settings"},0,"[~] Misc list"))
            misc.hitsound_vol = menu.new_elements("int",ui_new_slider("int",t4,"[Hit sound]","Vol",0,100,100,"[~] Hitsound vol"))
            misc.antiknife_pitch = menu.new_elements("bool",ui_new_checkbox("bool",t4,"[Anti knife]","Reset pitch on knife",false,"[~] Disable pitch when knife"))
            misc.antiknife_distance = menu.new_elements("int",ui_new_slider("int",t4,"[Anti knife]","Anti knife radius",0,1000,280,"[~] Antiknife radius"))
           
            misc.anim_list = menu.new_elements("int",ui_new_multiselect(t4,"[Animation breaker]","Break anims",{"Pitch 0 on land","Static legs in air","Leg fucker"},0,"[~] Break anims list"))

            misc.dormant_aimbot = menu.new_elements("int",ui_new_checkbox("bool",t4,"[Dormant aimbot]","Dormant aimbot",false,"[~] Dormant Aimbot"))
            misc.dormant_aimbot_dmg = menu.new_elements("int",ui_new_slider("int",t4,"[Dormant aimbot]","Dormant aimbot damage",1,100,10,"[~] Dormant Aimbot damage"))

            misc.hitchance_noscope = menu.new_elements("int",ui_new_slider("int",t4,"[Hitchance modifier]","Noscope hitchance",0,100,50,"[~] Noscoped hitchance"))
            misc.hitchance_inair = menu.new_elements("int",ui_new_slider("int",t4,"[Hitchance modifier]","In air hitchance",0,100,50,"[~] Noscoped hitchance"))
        end,

        visible_data = function(self)
            local master_switch = ui_get("value",info.master_switch)

            ui_set_visible(antiaim.import,master_switch)

            ui_set_visible(antiaim.export,master_switch)

            ui_set_visible(info.feature_list,master_switch)

            local e_ind = ui_get("bool",info.feature_list,1) == true and master_switch
            local e_antiaim = ui_get("bool",info.feature_list,2) == true and master_switch
            local e_ex_antiaim = ui_get("bool",info.feature_list,3) == true and master_switch
            local e_misc = ui_get("bool",info.feature_list,4) == true and master_switch

            ui_set_visible(visuals.info,ui_get("bool",info.feature_list,1) == false and master_switch == true and true or false)
            ui_set_visible(antiaim.info,ui_get("bool",info.feature_list,2) == false and master_switch == true and true or false)
            ui_set_visible(antiaim.ex_info,ui_get("bool",info.feature_list,3) == false and master_switch == true and true or false)
            ui_set_visible(misc.info,ui_get("bool",info.feature_list,4) == false and master_switch == true and true or false)

            ui_set_visible(visuals.indicator_settings,e_ind)

            local e_arrows = ui_get("bool",visuals.indicator_settings,1) == true and e_ind
            local e_center = ui_get("bool",visuals.indicator_settings,2) == true and e_ind
            local e_watermark = ui_get("bool",visuals.indicator_settings,3) == true and e_ind
            local e_menu_effect = ui_get("bool",visuals.indicator_settings,4) == true and e_ind
            local e_dmgmarker = ui_get("bool",visuals.indicator_settings,5) == true and e_ind
            local e_scopeline = ui_get("bool",visuals.indicator_settings,6) == true and e_ind
            local e_solus = ui_get("bool",visuals.indicator_settings,7) == true and e_ind
            local e_dmgind = ui_get("bool",visuals.indicator_settings,8) == true and e_ind
         
            ui_set_visible(visuals.dmgind_mode,e_dmgind)
            ui_set_visible(visuals.dmgind_pos,e_dmgind)
           
            ui_set_visible(visuals.indicator_color,e_arrows or e_center or e_menu_effect)
            ui_set_visible(visuals.disable_glow,e_arrows or e_center or e_menu_effect or e_solus or e_scopeline)

           
            ui_set_visible(visuals.watermark_color,e_watermark or e_solus)

            ui_set_visible(visuals.arrows_mode,e_arrows)
            ui_set_visible(visuals.arrows_background,e_arrows)
            ui_set_visible(visuals.arrows_distance,e_arrows)

            ui_set_visible(visuals.center_mode,e_center)
            ui_set_visible(visuals.center_scoped_anim,e_center)

            ui_set_visible(visuals.center_color_2,e_center and ui_get("value",visuals.center_mode) == 1)

            ui_set_visible(visuals.dmgmarker_mode,e_dmgmarker)
            ui_set_visible(visuals.dmgmarker_display_time,e_dmgmarker)
            ui_set_visible(visuals.dmgmarker_speed,e_dmgmarker)
            ui_set_visible(visuals.dmgmarker_color_2,e_dmgmarker)

            ui_set_visible(visuals.scopeline_origin,e_scopeline)
            ui_set_visible(visuals.scopeline_width,e_scopeline)

            ui_set_visible(visuals.solus_select,e_solus)
            ui_set_visible(visuals.temp_keybind_x,false)
            ui_set_visible(visuals.temp_keybind_y,false)
            ui_set_visible(visuals.temp_spec_x,false)
            ui_set_visible(visuals.temp_spec_y,false)
            ui_set_visible(visuals.solus_watermark_name,e_solus and ui_get("bool",visuals.solus_select,1) == true)

           
            ui_set_visible(antiaim.preset_mode,e_antiaim)
            ui_set_visible(antiaim.preset_static,e_antiaim and ui_get("value",antiaim.preset_mode) == 0)
            local custom = e_antiaim and ui_get("value",antiaim.preset_mode) == 1
            ui_set_visible(antiaim.custom_states,custom)
            local selection = ui_get("value",antiaim.custom_states) + 1

            for k, v in pairs(_state) do
                local switch = ui_get("value",antiaim.custom_data[selection].enable)

                local show = custom and switch
   
                for n, c in pairs(antiaim.custom_data[k]) do
   
                    ui_set_visible(c,selection == k and e_antiaim and custom)
   
                end
                local m = antiaim.custom_data[selection]
                ui_set_visible(m.extra_options,show)
                local lby = ui_get("bool",m.extra_options,4) == true
                local desync = ui_get("bool",m.extra_options,3) == true
                local freestand = ui_get("bool",m.extra_options,2) == true
                ui_set_visible(m.lby_mode,show and lby)
                ui_set_visible(m.desync_on_shot,show and desync)
                ui_set_visible(m.freestanding_bodyyaw,show and freestand)

                ui_set_visible(m.yaw_mode,show)
                local static = ui_get("value",m.yaw_mode) == 0
                local tick = ui_get("value",m.yaw_mode) == 1
                local choke = ui_get("value",m.yaw_mode) == 2
                local desync = ui_get("value",m.yaw_mode) == 3
                ui_set_visible(m.static_yaw,show and static)
                ui_set_visible(m.tick_yaw_left,show and tick)
                ui_set_visible(m.tick_yaw_right,show and tick)
                ui_set_visible(m.choke_yaw_left,show and choke)
                ui_set_visible(m.choke_yaw_right,show and choke)
                ui_set_visible(m.desync_yaw_left,show and desync)
                ui_set_visible(m.desync_yaw_right,show and desync)

                ui_set_visible(m.yaw_jitter,show)
                local yaw_jitter_c = ui_get("value",m.yaw_jitter) ~= 0
                ui_set_visible(m.yaw_jitter_degree,show and yaw_jitter_c)

                ui_set_visible(m.self_bodyyaw_mode,show)

                local bodyyaw_c = ui_get("value",m.self_bodyyaw_mode) ~= 0
                ui_set_visible(m.bodyyaw_mode,show and bodyyaw_c)

                local static_body = ui_get("value",m.bodyyaw_mode) == 0 and bodyyaw_c
                local jitter_body = ui_get("value",m.bodyyaw_mode) == 1 and bodyyaw_c
                local step = ui_get("value",m.bodyyaw_mode) == 2 and bodyyaw_c

                ui_set_visible(m.bodyyaw_degree,show and static_body)
                ui_set_visible(m.jitter_bodyyaw_degree_left,show and jitter_body)
                ui_set_visible(m.jitter_bodyyaw_degree_right,show and jitter_body)
                ui_set_visible(m.body_yaw_step_ticks,show and step)
                ui_set_visible(m.body_yaw_step_value,show and step)
                ui_set_visible(m.step_bodyyaw_degree_left,show and step)
                ui_set_visible(m.step_bodyyaw_degree_right,show and step)
               
                local fake_c = show and bodyyaw_c
                ui_set_visible(m.fake_yaw_mode,fake_c)

                local static_fake = ui_get("value",m.fake_yaw_mode) == 0 and fake_c
                local jitter_fake = ui_get("value",m.fake_yaw_mode) == 1 and fake_c
                local step_fake = ui_get("value",m.fake_yaw_mode) == 2 and fake_c

                ui_set_visible(m.static_fakeyaw,fake_c and static_fake)

                ui_set_visible(m.jitter_fakeyaw_left,fake_c and jitter_fake)
                ui_set_visible(m.jitter_fakeyaw_right,fake_c and jitter_fake)
                ui_set_visible(m.step_ticks,fake_c and step_fake)
                ui_set_visible(m.step_value,fake_c and step_fake)
                ui_set_visible(m.step_abs,fake_c and step_fake)
                ui_set_visible(m.step_fake_min,fake_c and step_fake)
                ui_set_visible(m.step_fake_max,fake_c and step_fake)

            end


            ui_set_visible(antiaim.ex_select,e_ex_antiaim)

            local e_manual = ui_get("bool",antiaim.ex_select,1) == true and master_switch and e_ex_antiaim
            local e_on_use = ui_get("bool",antiaim.ex_select,2) == true and master_switch and e_ex_antiaim
            local e_edge_yaw = ui_get("bool",antiaim.ex_select,3) == true and master_switch and e_ex_antiaim
            local e_roll = ui_get("bool",antiaim.ex_select,4) == true and master_switch and e_ex_antiaim

            ui_set_visible(antiaim.ex_manual_yawbase,e_manual)
            ui_set_visible(antiaim.on_use_select,e_on_use)
            ui_set_visible(antiaim.ex_prevent_jitter,e_manual)
            ui_set_visible(antiaim.ex_edge_yaw,e_edge_yaw)
            ui_set_visible(antiaim.ex_roll_states,e_roll)
            ui_set_visible(antiaim.ex_roll_options,e_roll)
            ui_set_visible(antiaim.ex_roll_key,e_roll)

             
            ui_set_visible(misc.select,e_misc)
           
            local knife = ui_get("bool",misc.select,1) == true and e_misc
            local anim = ui_get("bool",misc.select,2) == true and e_misc
            local sound = ui_get("bool",misc.select,5) == true and e_misc
            local hitchance = ui_get("bool",misc.select,6) == true and e_misc
            ui_set_visible(misc.hitsound_vol,sound)
            ui_set_visible(misc.antiknife_pitch,knife)
            ui_set_visible(misc.antiknife_distance,knife)
            ui_set_visible(misc.anim_list,anim)

            ui_set_visible(misc.dormant_aimbot,hitchance)
            ui_set_visible(misc.dormant_aimbot_dmg,hitchance)
            ui_set_visible(misc.hitchance_inair,hitchance)
            ui_set_visible(misc.hitchance_noscope,hitchance)
        end,

        register = function(self)
            self.create_data()
            self.visible_data()
        end
    }

    g_config:menu()

    g_menu:register()
    local desync = 0
    local   IN_FORWARD            = bit_lshift(1, 3) -- Walk forward
    local   IN_JUMP                = bit_lshift(1, 1) -- Jump
    local check_roll = false
    local g_antiaim = {
        value_table = {
            randomseed = 0,
            states = 1,
            choke = 0,
            antiaim = {
                pitch = 0, --0 Disabled --1 Down
                yaw_base = 0,
                yaw_add = 0,
                yaw_jitter = 0, --0 Disabled --1 Center --2 Offset --3 Random --4 Spin
                yaw_jitter_degree = 0,
                fake_angle = true,
                inverter = false,
                left_limit = 0,
                right_limit = 0,
                fake_options = {false,false,false,false}, -- avoid overlap -- jitter -- Randomize jitter -- Anti bruteforce
                lby_mode = 0, --0disabled --1 Opposite --2 sway
                freestanding_desync = 0, --0 off -- 1peek fake --2 peek real
                desync_onshot = 0,--0 disabled --1 Opposite --2 Freestanding --3 Switch
            },

            on_use = {
                using = false,
                in_use = bit_lshift(1, 5)
            },

            on_ground_ticks = 0
        },

        bodyyaw_jitter = function(c, d, e)
            local f = {}
            if e == -180 then
                f[1] = 0.0
            else
                if e ~= 0 then
                    if e == 180 then
                        f[0] = 0.0
                        f[1] = d
                    else
                        math.randomseed(e)
                        f[0] = math.random(-d, d)
                        f[1] = math.random(-d, d)
                    end
                    return f[c % 2]
                end
                f[1] = d
            end
            f[0] = -d
            return f[c % 2]
        end,

        override_limit = function(self,g, h, i, j, f )
            local b = 60
            local k = f
            local l = self.bodyyaw_jitter(self.value_table.randomseed, 60, k)
            self.value_table.antiaim.inverter = l < 0 and true
            b = math.abs(l)
            AntiAim_OverrideLimit(math.min(b, j))
        end,

        bodyyaw_jitter_funcs = function(self,f,j)
            local m = ClientState.m_choked_commands
            local g = EntityList.GetLocalPlayer()
            local h = g:GetPlayer():GetActiveWeapon()
            if g == nil or h == nil then
                return
            end
            if m == 1 then
                self.value_table.randomseed = self.value_table.randomseed + 1
            end
            self:override_limit(g, h, m, j, f)
        end,
   
        bodyyaw_static_funcs = function(self,a, b)
            if a > b and a > 0 then
                AntiAim_OverrideLimit(math.min(b, 60))
                self.value_table.antiaim.inverter = false
            elseif a < b and a > 0 then
                AntiAim_OverrideLimit(math.min(a, 60))
                self.value_table.antiaim.inverter = true
            elseif math.abs(a) > b and a < 0 then
                AntiAim_OverrideLimit(math.min(b, 60))
                self.value_table.antiaim.inverter = true
            elseif math.abs(a) < b and a < 0 then
                AntiAim_OverrideLimit(math.min(math.abs(a), 60))
                self.value_table.antiaim.inverter = true
            end
        end,

        clamp = function(num, min, max)
            if num < min then
                num = min
            elseif num > max then
                num = max
            end
            return num
        end,

        calculate_angles = function(from, to)
            local sub = to - from
       
            local pitch = -math.deg(math.atan2(sub.z, math.sqrt(sub.x ^ 2 + sub.y ^ 2)))
            local yaw = math.deg(math.atan2(sub.y, sub.x))
       
            return pitch, yaw
        end,
       
        normalize_yaw = function(yaw)
            while yaw > 180 do
                yaw = yaw - 360
            end
       
            while yaw < -180 do
                yaw = yaw + 360
            end
       
            return yaw
        end,

        run_onuse = function(self,cmd)
            local v = self.value_table.on_use
            v.using = false
           
            if ui_get("bool",antiaim.ex_select,2) == true and ui_get("bool",info.feature_list,3) == true then
                local is_holding_using = bit_band(cmd.buttons, v.in_use) > 0
                local me = entity_get_localplayer()
                local active_weapon = me:GetActiveWeapon()
                if active_weapon == nil then
                    return
                end

                local is_bomb_in_hand = false      
                if active_weapon then
                    is_bomb_in_hand = active_weapon:GetClassName() == "CC4"
                end
                local is_in_bombzone = me:GetProp("m_bInBombZone")
                local is_planting = is_in_bombzone and is_bomb_in_hand      
                local planted_c4_table = EntityList_GetEntitiesByName("CPlantedC4")
                local is_c4_planted = #planted_c4_table > 0
                local bomb_distance = 100      
                if is_c4_planted then
                    local c4_entity = planted_c4_table[#planted_c4_table]      
                    local c4_origin = c4_entity:GetRenderOrigin()
                    local my_origin = me:GetRenderOrigin()      
                    bomb_distance = my_origin:DistTo(c4_origin)
                end      
                local is_defusing = bomb_distance < 62 and me:GetProp("m_iTeamNum") == 3      
                if is_defusing then
                    return
                end
                local camera_angles = EngineClient_GetViewAngles()
                local eye_position = me:GetEyePosition()
                local forward_vector = cheat_AngleToForward(camera_angles)
                local trace_end = eye_position + forward_vector * 8192
                local trace = EngineTrace_TraceRay(eye_position, trace_end, me, 0x4600400B)
                local is_using = is_holding_using
                if trace and trace.fraction < 1 and trace.hit_entity then
                    local class_name = trace.hit_entity:GetClassName()
                    is_using = class_name ~= "CWorld" and class_name ~= "CFuncBrush" and class_name ~= "CCSPlayer"
                end
                if not is_using and not is_planting then
                    cmd.buttons = bit_band(cmd.buttons, bit_bnot(v.in_use))
                    v.using = true
                end
            end
        end,

        get_distance = function(x1, y1, z1, x2, y2, z2)
            return math.sqrt((x2 - x1) ^ 2 + (y2 - y1) ^ 2 + (z2 - z1) ^ 2)
        end,

        run_antiknife = function(self)
            if ui_get("bool",misc.select,1) == true and ui_get("bool",info.feature_list,4) == true then
                local player = EntityList.GetPlayers()
                local entity_or = entity_get_prop(entity_get_localplayer(),"m_vecOrigin")
           
                for i = 1, #player do
                    if player[i] == entity_get_localplayer() or player[i]:IsTeamMate() then
                        goto skip
                    end
                    if Cheat.IsKeyDown(0x45) then
                        goto skip
                    end
                    local entity_e_or = entity_get_prop(player[i], "m_vecOrigin")

                    local active_weapon = player[i]:GetActiveWeapon()

                    local distance = self.get_distance(entity_or.x, entity_or.y, entity_or.z, entity_e_or.x, entity_e_or.y, entity_e_or.z)

                    if active_weapon == nil then
                        return
                    end
                    if active_weapon:IsKnife() and distance <= ui_get("value",misc.antiknife_distance) then
                     
                        if ui_get("value",misc.antiknife_pitch) then
                            self.value_table.antiaim.pitch = 0
                        end
                        AntiAim.OverrideYawOffset(180)
                    end
                    ::skip::
                end
            end
        end,

       
        run_direction = function(self)
            if ui_get("bool",antiaim.ex_select,1) == true then
                local antiaim_yawbase = ui_get("value",antiaim.ex_manual_yawbase)
                if antiaim_yawbase == 0 then
                    self.value_table.antiaim.yaw_base = 4
                elseif antiaim_yawbase == 1 then
                    self.value_table.antiaim.yaw_base = 0
                elseif antiaim_yawbase == 2 then
                    self.value_table.antiaim.yaw_base = 1
                elseif antiaim_yawbase == 3 then
                    self.value_table.antiaim.yaw_base = 2
                elseif antiaim_yawbase == 4 then
                    self.value_table.antiaim.yaw_base = 3
                elseif antiaim_yawbase == 5 then
                    self.value_table.antiaim.yaw_base = 5
                end
                if ui_get("value",antiaim.ex_prevent_jitter) and (self.value_table.antiaim.yaw_base == 2 or self.value_table.antiaim.yaw_base == 3) then
                    self.value_table.antiaim.yaw_add = 0
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    AntiAim_OverrideLimit(60)
                end
            end
        end,

        run_edge = function(self)
   
            if ui_get("value",antiaim.ex_edge_yaw) and ui_get("bool",antiaim.ex_select,3) == true then
                local entity = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
                local player = entity:GetPlayer()
                local eye_pos = player:GetEyePosition()
                local view_angles = EngineClient.GetViewAngles()
           
                local distance = 8192
                local closest_point = nil
           
                for i = view_angles.yaw - 180, view_angles.yaw + 180, 15 do
                    local rotation = math.rad(i)
                    local point = Vector.new(eye_pos.x + math.cos(rotation) * 100, eye_pos.y + math.sin(rotation) * 100, eye_pos.z)
           
                    local trace = EngineTrace.TraceRay(eye_pos, point, entity, 0x4600400b)
           
                    if trace.fraction * 100 < distance then
                        distance = trace.fraction * 100
                        closest_point = point
                    end
                end
           
                if distance > 30 then
                    return
                end
           
                local _, yaw = self.calculate_angles(eye_pos, closest_point)
                local delta = self.normalize_yaw(view_angles.yaw - 180)
                local final_yaw = self.normalize_yaw(yaw - delta)
           
                AntiAim.OverrideYawOffset(final_yaw)
            end
        end,

        run_aa_logic = (function()
            local aa = {}

            local choke_var = 0
            local choke_reverse = 0

            local clamp = function(num, min, max)
                if num < min then
                    num = min
                elseif num > max then
                    num = max
                end
                return num
            end
           
            aa.get_tick = function(a,b)
                return GlobalVars.tickcount % 4 >= 2 and a or b
            end

            aa.get_choke = function(a,b)
                if GlobalVars.tickcount - choke_var > 1  then
                    choke_reverse = choke_reverse == 1 and 0 or 1
                    choke_var = GlobalVars.tickcount
                end
                return choke_reverse >= 1 and a or b
            end

            aa.get_desync = function(a,b)
                return AntiAim_GetInverterState() and a or b
            end
            local return_value = 0


            aa.get_step = function(a,b,step_value,step_tick)
                local step_min = a
                local step_max = b
                local step_v = step_value
                local step_t = GlobalVars.tickcount % step_tick
                if step_t == step_tick - 1 then
                    if return_value < step_max then
                        return_value = return_value + step_v
                    elseif return_value >= step_max then
                        return_value = step_min
                    end
                end

                return clamp(return_value,step_min,step_max)
            end
            return aa
           
        end)(),

        run_custom = function(self,cmd)
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.value_table.on_ground_ticks = self.value_table.on_ground_ticks + 1
            else
                self.value_table.on_ground_ticks = 0
            end
            if ui_get("value",reference.slow_motion) and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[3].enable) then
                self.value_table.states = 3
            elseif in_air and duck and ui_get("value",antiaim.custom_data[6].enable) then
                self.value_table.states = 6
            elseif in_air and ui_get("value",antiaim.custom_data[5].enable) then
                self.value_table.states = 5
       
            elseif duck and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[4].enable) then
                self.value_table.states = 4
            elseif velocity > 10 and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[2].enable) and not ui_get("value",reference.slow_motion) then
                self.value_table.states = 2
            elseif velocity < 2 and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[1].enable) then
                self.value_table.states = 1
            end

            local m = antiaim.custom_data
            local s = self.value_table.states
            self.value_table.antiaim.pitch = 1

            self.value_table.antiaim.lby_mode = ui_get("bool",m[s].extra_options,4) == true and ui_get("value",m[s].lby_mode) + 1 or 0
            self.value_table.antiaim.freestanding_desync = ui_get("bool",m[s].extra_options,2) == true and ui_get("value",m[s].freestanding_bodyyaw) + 1 or 0
            self.value_table.antiaim.desync_onshot = ui_get("bool",m[s].extra_options,3) == true and ui_get("value",m[s].desync_on_shot) + 1 or 0

            self.value_table.antiaim.fake_options[1] = ui_get("bool",m[s].extra_options,5) == true and true or false
            self.value_table.antiaim.fake_options[4] = ui_get("bool",m[s].extra_options,6) == true and true or false


            if s == 1 and ui_get("bool",m[1].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 2 and ui_get("bool",m[2].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 3 and ui_get("bool",m[3].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 18
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 4 and ui_get("bool",m[4].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 24
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 5 and ui_get("bool",m[5].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif s == 6 and ui_get("bool",m[5].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs)  then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            else
                local static_yaw = ui_get("value",m[s].yaw_mode) == 0
                local tick_yaw = ui_get("value",m[s].yaw_mode) == 1
                local choke_yaw = ui_get("value",m[s].yaw_mode) == 2
                local desync_yaw = ui_get("value",m[s].yaw_mode) == 3
               
                local static_yaw_value = ui_get("value",m[s].static_yaw)
                local tick_yaw_value_left = ui_get("value",m[s].tick_yaw_left)
                local tick_yaw_value_right = ui_get("value",m[s].tick_yaw_right)
                local choke_yaw_value_left = ui_get("value",m[s].choke_yaw_left)
                local choke_yaw_value_right = ui_get("value",m[s].choke_yaw_right)
                local desync_yaw_value_left = ui_get("value",m[s].desync_yaw_left)
                local desync_yaw_value_right = ui_get("value",m[s].desync_yaw_right)

                local yaw_jitter = ui_get("value",m[s].yaw_jitter)
                local yaw_jitter_value = ui_get("value",m[s].yaw_jitter_degree)

                self.value_table.antiaim.yaw_jitter = yaw_jitter
                self.value_table.antiaim.yaw_jitter_degree = yaw_jitter_value

                if ui_get("value",m[s].yaw_mode) == 3 or ui_get("value",m[s].bodyyaw_mode) == 1 or ui_get("value",m[s].fake_yaw_mode) == 1 then
                    self.value_table.antiaim.fake_options[2] = true
                else
                    self.value_table.antiaim.fake_options[2] = false
                end


                if ui_get("value",m[s].yaw_mode) == 0 then
                    self.value_table.antiaim.yaw_add = static_yaw_value
                elseif ui_get("value",m[s].yaw_mode) == 1 then

                    self.value_table.antiaim.yaw_add = self.run_aa_logic.get_tick(tick_yaw_value_left,tick_yaw_value_right)
                elseif ui_get("value",m[s].yaw_mode) == 2 then
                    self.value_table.antiaim.yaw_add = self.run_aa_logic.get_choke(choke_yaw_value_left,choke_yaw_value_right)
                elseif ui_get("value",m[s].yaw_mode) == 3 then
                    self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(desync_yaw_value_left,desync_yaw_value_right)
                end


                local fake = ui_get("value",m[s].static_fakeyaw)
                if ui_get("value",m[s].fake_yaw_mode) == 0 then
                    desync = fake
                elseif ui_get("value",m[s].fake_yaw_mode) == 1 then
                    desync = self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_fakeyaw_left),ui_get("value",m[s].jitter_fakeyaw_right))
                elseif ui_get("value",m[s].fake_yaw_mode) == 2 then
                    if ui_get("value",m[s].step_abs) == true then
                        desync = math.abs(self.run_aa_logic.get_step(ui_get("value",m[s].step_fake_min),ui_get("value",m[s].step_fake_max),ui_get("value",m[s].step_value),ui_get("value",m[s].step_ticks)))
                    else
                        desync = self.run_aa_logic.get_step(ui_get("value",m[s].step_fake_min),ui_get("value",m[s].step_fake_max),ui_get("value",m[s].step_value),ui_get("value",m[s].step_ticks))
                    end
                end


                if ui_get("value",m[s].self_bodyyaw_mode) == 0 then
                    self:bodyyaw_static_funcs(0,0)
                elseif ui_get("value",m[s].self_bodyyaw_mode) == 1 then
                    if ui_get("value",m[s].bodyyaw_mode) == 0 then
                     
                        self:bodyyaw_static_funcs(ui_get("value",m[s].bodyyaw_degree),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 1 then

                        self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_bodyyaw_degree_left),ui_get("value",m[s].jitter_bodyyaw_degree_right)),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 2 then
                   
                        self:bodyyaw_static_funcs(self.run_aa_logic.get_step(ui_get("value",m[s].step_bodyyaw_degree_left),ui_get("value",m[s].step_bodyyaw_degree_right),ui_get("value",m[s].body_yaw_step_value),ui_get("value",m[s].body_yaw_step_ticks)),desync)
                    end

                elseif ui_get("value",m[s].self_bodyyaw_mode) == 2 then
                    if ui_get("value",m[s].bodyyaw_mode) == 0 then
                        self:bodyyaw_jitter_funcs(ui_get("value",m[s].bodyyaw_degree),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 1 then
                        self:bodyyaw_jitter_funcs(self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_bodyyaw_degree_left),ui_get("value",m[s].jitter_bodyyaw_degree_right)),desync)
                    elseif ui_get("value",m[s].bodyyaw_mode) == 2 then
                        self:bodyyaw_jitter_funcs(self.run_aa_logic.get_step(ui_get("value",m[s].step_bodyyaw_degree_left),ui_get("value",m[s].step_bodyyaw_degree_right),ui_get("value",m[s].body_yaw_step_value),ui_get("value",m[s].body_yaw_step_ticks)),desync)
                    end
                end

            end

     
           
       

   

        end,
       
        lean_body = function(self,cmd)
            if check_roll == false then
                return
            end
            local local_player = EntityList.GetLocalPlayer()
            if (math.abs(cmd.forwardmove) > 1) or (math.abs(cmd.sidemove) > 1) or bit_band(cmd.buttons, IN_JUMP) > 0 or entity_get_prop(local_player, "m_MoveType") == 9 then
                return
            end
           

            local desync_amount = cmd.viewangles.yaw - desync
            if desync_amount == nil then
                return
            end
           
            if math.abs(desync_amount) < 15 or cmd.chokedcommands == 0 then
                return
            end
       
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)
            local inair = bit.band(entity_get_prop(local_player, "m_fFlags" ), 1 ) == 0
       
            if velocity > 80 and not inair then return end

            cmd.forwardmove = 0
            cmd.buttons = bit.band(cmd.buttons, IN_FORWARD)
        end,

        roll_var = {
            ground_ticks = 0
        },

        get_roll_states = function(self)
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.roll_var.ground_ticks = self.roll_var.ground_ticks + 1
            else
                self.roll_var.ground_ticks = 0
            end
           
            if Cheat_IsKeyDown(0x45) then
                return "USE"
            elseif self.value_table.antiaim.yaw_base == 3 or self.value_table.antiaim.yaw_base == 2 then
                return "MANUAL"
            elseif in_air then
                return "IN_AIR"
            elseif ui_get("value",reference.slow_motion) and self.roll_var.ground_ticks > 8 then
                return "SLOW_WALK"
            elseif duck and self.roll_var.ground_ticks > 8 then
                return "DUCK"
            elseif velocity > 4 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "MOVE"
            elseif velocity < 2 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "STAND"
            else
                return "IN_AIR"
            end

        end,

        run_roll = function(self,cmd)
            if ui_get("bool",antiaim.ex_select,4) == true then
                self.value_table.antiaim.pitch = 1
                local states = self:get_roll_states()
                if ui_get("value",antiaim.ex_roll_key) then
                    check_roll = true
                elseif ui_get("value",reference.autopeek) == true and ui_get("bool",antiaim.ex_roll_options,2) == true then
                    check_roll = false
                elseif states == "USE" and ui_get("bool",antiaim.ex_roll_states,5) == true then
                    check_roll = true
                elseif states == "MANUAL" and ui_get("bool",antiaim.ex_roll_states,4) == true then
                    check_roll = true
                elseif states == "DUCK" and ui_get("bool",antiaim.ex_roll_states,3) == true then
                    check_roll = true
                elseif states == "SLOW_WALK" and ui_get("bool",antiaim.ex_roll_states,2) == true then
                    check_roll = true
                elseif states == "STAND" and ui_get("bool",antiaim.ex_roll_states,1) == true then
                    check_roll = true
                elseif states == "MOVE" then
                    check_roll = false
                elseif states == "IN_AIR" then
                    check_roll = false
                else
                    check_roll = false
                end
   
                local degree = 0
   
                if states == "USE" then
                    self.value_table.antiaim.yaw_add = 2
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.inverter = false
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
   
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = 90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                       
                        degree = 50
                    end
   
                end
   
                if states == "MANUAL" then
                    self.value_table.antiaim.inverter = false
   
                    self.value_table.antiaim.yaw_add = -2
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                       
                        degree = -50
                    end
                end
   
                if states == "SLOW_WALK" then
                    self.value_table.antiaim.inverter = false
   
                    self.value_table.antiaim.yaw_add = 51
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                       
                        degree = -50
                    end
                end
   
                if states == "STAND" then
                    self.value_table.antiaim.inverter = false
   
                    self.value_table.antiaim.yaw_add = 33
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    self.value_table.antiaim.inverter = false
   
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                       
                        degree = -50
                    end
                end
   
   
                if states == "DUCK" then
                    self.value_table.antiaim.yaw_add = 47
                    self.value_table.antiaim.yaw_jitter = 0
                    self.value_table.antiaim.yaw_jitter_degree = 0
                    self.value_table.antiaim.fake_angle = true
                    self.value_table.antiaim.left_limit = 60
                    self.value_table.antiaim.right_limit = 60
                    self.value_table.antiaim.fake_options[1] = false
                    self.value_table.antiaim.fake_options[2] = false
                    self.value_table.antiaim.fake_options[3] = false
                    self.value_table.antiaim.fake_options[4] = false
                    if ui_get("bool",antiaim.ex_roll_options,3) == true then
                        degree = -90
                    elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
                        degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
                    else
                       
                        degree = -50
                    end
                end
   
                if check_roll == true then
                    AntiAim_OverrideLimit(58)
                    self.value_table.antiaim.lby_mode = 0
                    self:lean_body(cmd)
                    cmd.viewangles.roll = degree
   
                else
                    cmd.viewangles.roll = 0
                end
            else
                check_roll = false
                cmd.viewangles.roll = 0

            end



           

            -- antiaim.ex_roll_states = "[Roll settings]","Roll states",{"Stand","Slow walk","Duck","Manual","Use"}
            -- antiaim.ex_roll_options = "[Roll settings]","Extra roll options",{"Jitter","Disable roll when peeking","Unsafe"},
            -- antiaim.ex_roll_key = "[Roll settings]","Roll key",false,"[~] Force roll"))
            -- antiaim.ex_roll_inverter = "[Roll settings]","Roll inverter",false,"[~] only work on Stand"))



        end,

        run_presets_states = function(self,cmd)
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.roll_var.ground_ticks = self.roll_var.ground_ticks + 1
            else
                self.roll_var.ground_ticks = 0
            end
           
            if Cheat_IsKeyDown(0x45) then
                return "USE"
            elseif self.value_table.antiaim.yaw_base == 3 or self.value_table.antiaim.yaw_base == 2 then
                return "MANUAL"
            elseif in_air and duck then
                return "AIR_DUCK"
            elseif in_air then
                return "IN_AIR"
            elseif ui_get("value",reference.slow_motion) and self.roll_var.ground_ticks > 8 then
                return "SLOW_WALK"
            elseif duck and self.roll_var.ground_ticks > 8 then
                return "DUCK"
            elseif velocity > 4 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "MOVE"
            elseif velocity < 2 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "STAND"
            else
                return "AIR_DUCK"
            end

        end,

        run_presets_1 = function(self,cmd)
            local states = self:run_presets_states(cmd)
            self.value_table.antiaim.pitch = 1
            if states == "STAND" and ui_get("bool",antiaim.preset_static,1) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "STAND" then
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(5,18)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 60
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                st_deysnc = self.run_aa_logic.get_step(20,60,1,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_step(90,180,1,1),st_deysnc)
                self.value_table.antiaim.fake_options[2] = true

            end

            if states == "MOVE" and ui_get("bool",antiaim.preset_static,2) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "MOVE" then
               
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-14,26)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 40
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                mv_deysnc = self.run_aa_logic.get_step(20,60,5,3)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(180,180),mv_deysnc)
                self.value_table.antiaim.fake_options[2] = true

            end

            if states == "SLOW_WALK" and ui_get("bool",antiaim.preset_static,3) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 18
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "SLOW_WALK" then
                self.value_table.antiaim.fake_options[2] = true

                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-2,20)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 60
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
               sw_deysnc = self.run_aa_logic.get_step(20,60,1,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_step(90,180,1,1),sw_deysnc)

            end

               
            if states == "DUCK" and ui_get("bool",antiaim.preset_static,4) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "DUCK" then
               
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-5,35)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 40
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60

            end
           
            if states == "IN_AIR" and ui_get("bool",antiaim.preset_static,5) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "IN_AIR" then
               
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(2,16)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 51
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                local arid = self.run_aa_logic.get_step(30,60,5,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(180,180),arid)
                self.value_table.antiaim.fake_options[2] = true

            end

            if states == "AIR_DUCK" and ui_get("bool",antiaim.preset_static,6) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
                self.value_table.antiaim.yaw_add = 25
                self.value_table.antiaim.yaw_jitter = 0
                self.value_table.antiaim.yaw_jitter_degree = 0
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                self.value_table.antiaim.fake_options[1] = false
                self.value_table.antiaim.fake_options[2] = false
                self.value_table.antiaim.fake_options[3] = false
                self.value_table.antiaim.fake_options[4] = false
            elseif states == "AIR_DUCK" then
               
                self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-1,33)
                self.value_table.antiaim.yaw_jitter = 1
                self.value_table.antiaim.yaw_jitter_degree = 45
                self.value_table.antiaim.fake_angle = true
                self.value_table.antiaim.inverter = false
                self.value_table.antiaim.left_limit = 60
                self.value_table.antiaim.right_limit = 60
                AIR_deysnc = self.run_aa_logic.get_step(30,60,5,2)
                self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(-180,180),AIR_deysnc)
                self.value_table.antiaim.fake_options[2] = true

            end

            -- antiaim.preset_static = menu.new_elements("int",ui_new_multiselect(t3,
            -- "[Built-in presets]","Suppress jitter select",_state,0,"[~] Disable jitter when choking commands"))
            -- local _state = {"Stand","Move","Slow walk","Duck","Air","Air + D"}



        end,

        run_main = function(self,cmd)
            self.value_table.choke = cmd.chokedcommands
            self:run_roll(cmd)



            if check_roll == false then

                if ui_get("value",antiaim.preset_mode) == 0 then
                    self:run_presets_1(cmd)
                elseif ui_get("value",antiaim.preset_mode) == 1 then
                    self:run_custom(cmd)
                end
            end
         

                 
       

   
            self:run_direction()
            self:run_edge()
            self:run_antiknife()

            if Cheat.IsKeyDown(0x45) then
                self.value_table.antiaim.pitch = 0
                self.value_table.antiaim.yaw_add = 0
                self.value_table.antiaim.yaw_base = 0
                self.value_table.antiaim.freestanding_desync = 1
            end
            ui_set("value",reference.pitch,self.value_table.antiaim.pitch)
            ui_set("value",reference.yaw_base,self.value_table.antiaim.yaw_base)
            ui_set("value",reference.yaw_add,self.value_table.antiaim.yaw_add)
            ui_set("value",reference.yaw_jitter_mode,self.value_table.antiaim.yaw_jitter)
            ui_set("value",reference.yaw_jitter_slider,self.value_table.antiaim.yaw_jitter_degree)
            ui_set("value",reference.fake_angle,self.value_table.antiaim.fake_angle)
            ui_set("value",reference.inverter,self.value_table.antiaim.inverter)
            ui_set("value",reference.left_limit,self.value_table.antiaim.left_limit)
            ui_set("value",reference.right_limit,self.value_table.antiaim.right_limit)
            ui_set("bool",reference.fake_option,1,self.value_table.antiaim.fake_options[1])
            ui_set("bool",reference.fake_option,2,self.value_table.antiaim.fake_options[2])
            ui_set("bool",reference.fake_option,3,self.value_table.antiaim.fake_options[3])
            ui_set("bool",reference.fake_option,4,self.value_table.antiaim.fake_options[4])
            ui_set("value",reference.lby,self.value_table.antiaim.lby_mode)
            ui_set("value",reference.freestanding_yaw,self.value_table.antiaim.freestanding_desync)
            ui_set("value",reference.desync_shot,self.value_table.antiaim.desync_onshot)
        end,

        run_jumpscout_fix = function()
            if ui_get("bool",misc.select,3) == true  then
                local me = EntityList.GetLocalPlayer()
                if me == nil then
                    return
                end
                local weap = me:GetActiveWeapon()
                if weap == nil then
                    return
                end
                local speed_x = me:GetProp("DT_BasePlayer", "m_vecVelocity[0]")
                local speed_y = me:GetProp("DT_BasePlayer", "m_vecVelocity[1]")
                local speed = math.sqrt(speed_x * speed_x + speed_y * speed_y)
                if weap:IsGrenade() then
                    ui_set("value",reference.auto_starfe,true)
                else
                    if speed < 5 then
                        ui_set("value",reference.auto_starfe,false)
                    else
                        ui_set("value",reference.auto_starfe,true)
                    end  
                end
            else
                ui_set("value",reference.auto_starfe,ui_get("value",reference.auto_starfe))
            end

               

           
        end,

        load_antiaim = function(self,cmd)
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
         
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end

            if not ui_get("bool",info.feature_list,2) == true then return end
            if EngineClient.IsConnected() and my_index:IsAlive() then
                self:run_main(cmd)
            end
        end,

        load_pre_antiaim = function(self,cmd)
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
         
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end
            if not ui_get("bool",info.feature_list,2) == true then return end

            if EngineClient.IsConnected() and my_index:IsAlive() then
                self:run_jumpscout_fix()
                self:run_onuse(cmd)
            end
        end
           
    }
    local damage_indicator_displays = {}


    local g_misc = {

        phrases = {
            "by UNFAILEr hvh boss",
            "sleep",
            "GLhf.exe Activated",
            "what you do dog??",
            "1 week lou doggo ovnet",
            "l2p bot",
            "why you sleep dog???",
            "$$$ 1 TAP UFF YA $$$",
            "0 iq",
            "iq ? HAHAHA",
            "Best and cheap configurations for gamesense, ot and neverlose waiting for your order  at ---> shoppy.gg/@Xamidimura",
            "最好的AA -> Ataraxia.pub",
            "中国的科技?>Ataraxia.pub,最好的AA",
            "XAXAXAXAXAXA (◣_◢)",
        },
       
        get_phrase = function(self)
            return self.phrases[Utils.RandomInt(1, #self.phrases)]:gsub('\"', '')
        end,

        run_trashtalk = function(self,event)
            if event:GetName() ~= "player_death" then return end
       
            local me = EntityList.GetLocalPlayer()
            local victim = EntityList.GetPlayerForUserID(event:GetInt("userid"))
            local attacker = EntityList.GetPlayerForUserID(event:GetInt("attacker"))
       
            if victim == attacker or attacker ~= me then return end
            if ui_get("bool",misc.select,4) == true then
                EngineClient.ExecuteClientCmd('say "' .. self:get_phrase() .. '"')

            end
        end,
        clant_var = {
            _set_clantag = ffi.cast('int(__fastcall*)(const char*, const char*)', Utils.PatternScan('engine.dll', '53 56 57 8B DA 8B F9 FF 15')),
            _last_clantag = nil,
        },
     
        set_clantag = function(self,v)
            if v == self.clant_var._last_clantag then return end
            self.clant_var._set_clantag(v, v)
            self.clant_var._last_clantag = v
        end,

        set_callback_clantag = function(self)
         
        end,

        run_marker_hurt = function(self,e)
            if e:GetName() ~= "player_hurt" then return end
            if e:GetInt("userid") == nil or e:GetInt("attacker") == nil or e:GetInt("dmg_health",0) == nil then
                return
            end
            local player = EntityList.GetPlayerForUserID(e:GetInt("userid"))
            local get_player_origin = entity_get_prop(player,"m_vecOrigin")
            if get_player_origin.x == nil or get_player_origin.y == nil or get_player_origin.z == nil then
                return
            end

            local voZ = entity_get_prop(player,"m_vecViewOffset[2]")

            if e.hitgroup == 1 then
                check_headshot = true
            else
                check_headshot = false
            end


            table_insert(damage_indicator_displays,{e:GetInt("dmg_health",0),GlobalVars.realtime,get_player_origin.x,get_player_origin.y,get_player_origin.z + voZ,check_headshot})

        end,

        run_hitsound = function(self,e)
            if e:GetName() ~= "player_hurt" then return end
            local localplayer = entity_get_localplayer()
            local attacker = EntityList.GetPlayerForUserID(e:GetInt("attacker"))
            if attacker == localplayer then
              if ui_get("bool",misc.select,5) == true then
                 EngineClient.ExecuteClientCmd(string.format("playvol %s %s", "buttons/arena_switch_press_02",ui_get("value",misc.hitsound_vol)/100))
              end
            end
        end,

        run_autostop = function(self,cmd, goal_speed)
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end

            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end

            local minspeed = math.sqrt((cmd.forwardmove * cmd.forwardmove) + (cmd.sidemove * cmd.sidemove))
            if goal_speed <= 0 or minspeed <= 0 then return end

            local flags = my_index:GetProp("m_fFlags")
            if bit.band(flags, 4) == 4 then
                goal_speed = goal_speed * 2.94117647
            end

            if minspeed <= goal_speed then return end
            local speed_factor = goal_speed / minspeed

            cmd.forwardmove = cmd.forwardmove * speed_factor
            cmd.sidemove = cmd.sidemove * speed_factor
        end,

        vars = {
            player_info_prev = {},
            round_started = 0,
            is_dormant_flag = false,

            minimal_vector = Vector.new(),
            maximal_vector = Vector.new()
        },

        calculate_angles = function(self,source, point)
            local world_to_screen = function(x_position, y_position)
                if x_position == 0 and y_position == 0 then return 0 end
     
                local atan_position = math.atan2(y_position, x_position)
                local deg_position = math.deg(atan_position)
     
                return deg_position
            end

            local delta_of_vectors = point - source
            local hyp = math.sqrt(delta_of_vectors.x * delta_of_vectors.x + delta_of_vectors.y * delta_of_vectors.y)

            local yaw = world_to_screen(delta_of_vectors.x, delta_of_vectors.y)
            local pitch = world_to_screen(hyp, -delta_of_vectors.z)

            return Vector.new(pitch, yaw, 0)
        end,

        get_hittable_damage = function(self,my_index, enemy, start_point, end_point)
            if my_index ~= nil then
                if enemy ~= nil then
                    local bullet_data = Cheat.FireBullet(my_index, start_point, end_point)
                    local bullet_damage = bullet_data.damage

                    local minimum_damage = ui_get("value",misc.dormant_aimbot_dmg)
                    local enemy_health = enemy:GetProp("m_iHealth")

                    if bullet_damage < math.min(minimum_damage, enemy_health) then
                        return 0
                    end

                    if bullet_data.trace.hit_entity ~= nil then
                        if bullet_data.trace.hit_entity:EntIndex() ~= enemy:EntIndex() then
                            return 0
                        end
                    end

                    if enemy:IsVisible(end_point) then
                        return 0
                    end

                    return bullet_damage
                end
            end
        end,

        run_dormant_aimbot = function(self,cmd)
            if ui_get("value",misc.dormant_aimbot) then
                local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
                if not localplayer then return end
     
                local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
                if not my_index then return end
     
                local my_weapon = my_index:GetActiveWeapon()
                if not my_weapon then return end
     
                local weapon_id = my_weapon:GetWeaponID()
                if not weapon_id then return end

                if EngineClient.IsConnected() and my_index:IsAlive() then
                    local get_inaccuracy = my_weapon:GetInaccuracy(my_weapon)
                    local tickcount = GlobalVars.tickcount
     
                    local player_resource = EntityList.GetPlayerResource()
                    local eye_position = my_index:GetEyePosition()
     
                    local simulation_time = my_index:GetProp("m_flSimulationTime")
                    local on_ground = bit.band(my_index:GetProp("m_fFlags"), bit.lshift(1, 0)) == 1 and true or false

                    if tickcount < self.vars.round_started then
                        return
                    end

                    local primary_attack = my_weapon:GetProp("m_flNextPrimaryAttack")
                    local next_attack = my_index:GetProp("m_flNextAttack")
                    local secondary_attack = my_weapon:GetProp("m_flNextSecondaryAttack")

                    local can_shoot = false
                    if weapon_id == 64 then -- revolver
                        can_shoot = simulation_time > primary_attack
                    elseif my_weapon:IsKnife() or my_weapon:IsGrenade() or weapon_id == 31 then
                        can_shoot = false
                    else
                        can_shoot = simulation_time > math.max(next_attack, primary_attack, secondary_attack)
                    end

                    local player_info = {}
                    local players = EntityList.GetEntitiesByName("CCSPlayer")
                 
                    for i = 1, #players do
                        local enemy = players[i]:GetPlayer()
                        if enemy ~= my_index and not enemy:IsTeamMate() and enemy:IsAlive() then
                            local network_state = enemy:GetNetworkState()
                            if enemy:IsDormant() and network_state ~= -1 then
                                local can_hit = false
                                local origin = enemy:GetProp("m_vecOrigin")
                                local alpha_multiplier = enemy:GetESPAlpha()

                                if self.vars.player_info_prev[i] ~= nil and origin.x ~= 0 and alpha_multiplier > 0 then
                                    local is_dormant_accurate = alpha_multiplier > 0.2
                                    if is_dormant_accurate then
                                        local bounds = enemy:GetRenderBounds(self.vars.minimal_vector, self.vars.maximal_vector)
                                        local all_vector_points = {
                                            origin + Vector.new(0, 0, 38),
                                            origin + Vector.new(0, 0, 40),
                                            origin + Vector.new(0, 0, 42),
                                            origin + Vector.new(0, 0, 50)
                                        }

                                        local best_damage = 0
                                        local best_point = Vector.new()
                                        local my_eye_position = my_index:GetEyePosition()
                                     
                                        for point = 1, #all_vector_points do
                                            local current_point = all_vector_points[point]
                                            local start_position = self:calculate_angles(my_eye_position, current_point)
                                            local damage = self:get_hittable_damage(my_index, enemy, my_eye_position, current_point)

                                            if damage > best_damage then
                                                best_damage = damage
                                                best_point = start_position
                                                can_hit = true
                                            end
                                        end

                                        local get_max_speed = my_weapon:GetMaxSpeed()
                                        if can_shoot and can_hit then
                                            self.vars.is_dormant_flag = true
                                            self:run_autostop(cmd, get_max_speed * 0.33)

                                            if get_inaccuracy < 0.009 then
                                                cmd.viewangles.pitch = best_point.x
                                                cmd.viewangles.yaw = best_point.y
                                                cmd.viewangles.roll = 0.0

                                                cmd.buttons = bit.bor(cmd.buttons, 1)
                                                self.vars.is_dormant_flag = true

                                                can_shoot = false
                                            end
                                        elseif not can_hit then
                                            self.vars.is_dormant_flag = false
                                        end
                                    end
                                end
                                player_info[i] = {origin, alpha_multiplier, can_hit}
                            end
                        end
                    end
                    self.vars.player_info_prev = player_info
                end
            end
        end,

        reset_data = function(self, e)
            if ui_get("value",misc.dormant_aimbot) then
                local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
                if not localplayer then return end
     
                local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
                if not my_index then return end
     
                if EngineClient.IsConnected() and my_index:IsAlive() then
                    if e:GetName() == "round_prestart" then
                        local mp_freezetime = CVar.FindVar("mp_freezetime"):GetFloat()
                        local ticks = GlobalVars.interval_per_tick
             
                        local freezetime = (mp_freezetime + 1) / ticks
                        local tickcount = GlobalVars.tickcount
             
                        self.vars.round_started = tickcount + freezetime
                    end
                end
            end
        end,

        run_evets = function(self,e)
            if e:GetName() == "round_start" then
                table.insert(noti_table, {
                    text = "Reseted data due to round start",
                    timer = GlobalVars.realtime,
                    smooth_y = sc_y + 100,
                    alpha = 0,
                })
            end

            if e:GetName() == "player_death" then
                if EntityList.GetPlayerForUserID(e:GetInt("userid")) == EntityList.GetLocalPlayer() then
                    table.insert(noti_table, {
                        text = "Reseted data due to player death",
                        timer = GlobalVars.realtime,
                        smooth_y = sc_y + 100,
                        alpha = 0,
                    })
                end
            end

            if e:GetName() == "player_hurt" then
                if EntityList.GetPlayerForUserID(e:GetInt("userid")) == EntityList.GetLocalPlayer() and e:GetInt("hitgroup") ~= 0 then
                    table.insert(noti_table, {
                        text = "Received data due to player hurt",
                        timer = GlobalVars.realtime,
                        smooth_y = sc_y + 100,
                        alpha = 0,
                    })
                end
            end


        end,

        run_hitchance = function(self)
            if ui_get("bool",misc.select,6) == true then
                if entity_get_localplayer() == nil then
                    return
                end
                local is_scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
       
                local player = entity_get_localplayer()
                local weapon = player:GetActiveWeapon()
               
               
                local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
                if weapon ~= nil then
                    if weapon:GetWeaponID() == 38 or 11 or 9 or 40 then
                        if not is_scoped then
                            for i = 1, 64 do
                                RageBot.OverrideHitchance(i, ui_get("value",misc.hitchance_noscope))
                            end
                        end
                    end
                end

                if on_ground == 0 then
                    for i = 1, 64 do
                        RageBot.OverrideHitchance(i, ui_get("value",misc.hitchance_inair))
                    end
                end
            end
           
        end,

        hit_groups = {
            [0] = "body",
            [1] = "head",
            [2] = "chest",
            [3] = "stomach",
            [4] = "left arm",
            [5] = "right arm",
            [6] = "left leg",
            [7] = "right leg",
            [10] = "unknown"
        },

        get_round = function(self,num, numDecimalPlaces)
            return tonumber(string.format("%." .. (numDecimalPlaces or 0) .. "f", num))
        end,

        on_shot = function(self,e)
            local entity = EntityList.GetClientEntity(e.target_index)
            local player = entity:GetPlayer()
            local reason = ""
            if (e.reason == 0) then
                self:on_hurt(e)
                return
            elseif (e.reason == 1) then
       
                reason = "resolver"
                if (Menu.FindVar("Aimbot", "Ragebot", "Main", "Override Resolver"):GetBool()) then
                    reason = "resolver"
                end
            elseif (e.reason == 2) then
                reason = "spread degree (" .. tostring(self:get_round(e.spread_degree, 3)) .."°) safepoint (false)"
            elseif (e.reason == 3) then
                reason = "spread degree (" .. tostring(self:get_round(e.spread_degree, 3)) .."°) safepoint (true)"
            elseif (e.reason == 4) then
                reason = "prediction error"
            end
            local hitbox = ""
            if ((e.wanted_hitgroup > -1 and e.wanted_hitgroup < 8) or e.wanted_hitgroup == 10) then
                hitbox = self.hit_groups[e.wanted_hitgroup]
            else
                hitbox = "unknown"
            end
            debugger("Missed ["..player:GetName().."] hitbox: [".. hitbox.."] hitchance: ["..e.hitchance.."] reason: ["..reason.."] backtrack: ".. e.backtrack.."ticks health remain: ["..entity:GetProp('m_iHealth').."]")

        end,

        on_hurt = function(self,e)
            if e.reason > 0 and e.reason < 5 then
                self:on_shot(e)
                return
            end
            local entity = EntityList.GetClientEntity(e.target_index)
            local player = entity:GetPlayer()
            local hitbox = ""
            if ((e.hitgroup > -1 and e.hitgroup < 8) or e.hitgroup == 10) then
                hitbox = self.hit_groups[e.hitgroup]
            else
                hitbox = "unknown"
            end
            debugger("Hit ["..player:GetName().."] hitbox: ["..hitbox.."] hitchance: ["..e.hitchance.."] damage: ["..e.damage.."] backtrack: ".. e.backtrack.."ticks health remain: ["..entity:GetProp('m_iHealth').."]")
        end,
   
        run_hitlog = function(self,e)
            self:on_shot(e)

        end,

        load_events = function(self,event)
            self:run_trashtalk(event)
            self:run_marker_hurt(event)
            self:run_hitsound(event)
            self:run_evets(event)
            self:reset_data(event)
        end
       
    }

    local lerp = function(start, vend, time)
        return start + (vend - start) * time
    end
       
    local render_measure_text = function(size,fonts,text)
        local size = Render_CalcTextSize(text,size,fonts)
        return size
    end

    local render_text = function(x,y,fonts,size,outline,center,r,g,b,a,text)
        Render_Text(text,Vector2.new(x,y),Color_RGBA(math.floor(r),math.floor(g),math.floor(b),math.floor(a)),size,fonts,outline,center)
    end
   
    local render_rectangle = function(x,y,w,h,r,g,b,a,round)
        Render_BoxFilled(Vector2.new(x ,y ),Vector2.new(x + w,y + h),Color_new(r/255,g/255,b/255,a/255),round)
    end


    local render_Box = function(x,y,w,h,r,g,b,a,round)
        Render.Box(Vector2.new(x ,y ),Vector2.new(x + w,y + h),Color_new(r/255,g/255,b/255,a/255),round)
    end

    local render_gradient = function(x,y,w,h,r,g,b,a,r1,g1,b1,a1,type)
        local first_gradient = Color_new(r/255,g/255,b/255,a/255)
        local second_gradient = Color_new(r1/255,g1/255,b1/255,a1/255)

        if type == true then
            Render_GradientBoxFilled(Vector2.new(x, y), Vector2.new(x + w, y + h),first_gradient,second_gradient,first_gradient, second_gradient)
        elseif type == false then
            Render_GradientBoxFilled(Vector2.new(x, y), Vector2.new(x + w, y + h), first_gradient, first_gradient, second_gradient, second_gradient)
        end    
    end

   
    local render_circle_outline = function(x,y,radius,r,g,b,a,thickness,start,enddegree)
        Render.Circle(Vector2.new(x, y),radius, 32, Color.new(r/255, g/255, b/255, a/255),thickness,start,enddegree)
    end

    local render_circle = function(x,y,radius,r,g,b,a,start,enddegree)
        Render_CircleFilled(Vector2.new(x, y), radius, 30, Color.new(r/255, g/255, b/255, a/255))
    end

    local render_glow_rectangle = function(x,y,w,h,r,g,b,a,round,size,g_w)
        for i = 1 , size , 0.3 do
            local fixpositon = (i  - 1) * 2    
            local fixi = i  - 1
            render_Box(x - fixi, y - fixi, w + fixpositon , h + fixpositon , r , g ,b , (a -  i * g_w) , round)  
           
        end
    end

    local render_glow_rectangle_gradient = function(x,y,w,h,r,g,b,a,r1,g1,b1,a1,type,size,g_w,type)
        for i = 1 , size , 1.0 do
            local fixpositon = (i  - 1) * 2    
            local fixi = i  - 1
            render_gradient(x - fixi, y - fixi, w + fixpositon , h + fixpositon , r , g ,b , (a -  i * g_w) ,r1,g1,b1, (a1 -  i * g_w) , type)  
        end
    end

    local linear = function(check,val,value,speed)
        if check then
            return val + (value - val) * GlobalVars.frametime * speed
        else
            return val - (value + val) * GlobalVars.frametime * speed / 2;
        end
    end

    local entity_is_enemy = function(index)
        if index == nil then
            return false
        end

        return index:IsTeamMate() == false
    end

    local entity_is_alive = function(index)
        if index == nil then
            return false
        end

        return entity_get_prop(index,"m_lifeState") == false
    end

    local distance_3d = function(x1,y1,z1,x2,y2,z2)
        if x1 == nil or y1 == nil or z1 == nil or x2 == nil or y2 == nil or z2 == nil then
            return 0
        end
        return math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
    end

    local client_threat = function()
        local me = entity_get_localplayer()
        if entity_get_localplayer() == nil then
            return nil
        end
        local lm = entity_get_prop(entity_get_localplayer(),"m_vecOrigin")
        local lx,ly,lz = lm.x,lm.y,lm.z
        local view = EngineClient_GetViewAngles()
        local viewangle_x,viewangle_y,roll = view.pitch,view.yaw,view.roll
        local enemies = EntityList.GetPlayers()

        if #enemies == 0 then
            return nil
        end
        local data = {id = nil ,dis = 0 ,last_dmg = 0}
        for k, v in pairs(enemies) do
            if (not entity_is_enemy(enemies[k]) or (enemies[k] == me) or (not entity_is_alive(enemies[k])) or (enemies[k]:IsDormant())) then goto skip end
            local em = enemies[k]:GetProp("m_vecOrigin")
            local ex,ey,ez = em.x,em.y,em.z
            local trace = Cheat.FireBullet(me,Vector.new(ex,ey,ez),Vector.new(lx,ly,lz))

            if trace.damage > data.last_dmg then
                table_insert(data,{id = enemies[k],dis = distance_3d(lx,ly,lz,ex,ey,ez),last_dmg = trace.damage})
            end
            ::skip::
        end

        if data == nil then
            return
        end
        if data.id == nil then
            return
        end

        return data
    end


    local gradient_text = function(b, c, d, e, f, g, h, i, j, k, l, size, fonts, out)
        local m = ""
        local n = 0
        local o = #l - 1
        local p = (h - d) / o
        local q = (i - e) / o
        local r = (j - f) / o
        local s = (k - g) / o
        for t = 1, o + 1 do
            local u = string.sub(l, t, t)
            local v = Render.CalcTextSize(u, size, fonts)
            Render.Text(u .. "", Vector2.new(b + n, c), Color.new(d, e, f, g), size, fonts, out)
            d = d + p
            e = e + q
            f = f + r
            g = g + s
            n = n + v.x
        end
    end
   

    local FONTS = {
        PIXEL_10 = Render_InitFont("Smallest Pixel-7",10,{"","",""}),
        PIXEL_11 = Render_InitFont("Smallest Pixel-7",11,{"","",""}),

        PIXEL_12 = Render_InitFont("Smallest Pixel-7",12,{"","",""}),
        PIXEL_18 = Render_InitFont("Smallest Pixel-7",18,{"","",""}),
        TAHOMA_15 = Render_InitFont("Tahoma",15,{"","",""}),
        TAHOMA_15_BOLD = Render_InitFont("Tahoma",15,{"b","",""}),
        TAHOMA_12_BOLD = Render_InitFont("Tahoma",12,{"b","",""}),
        VERDANA_12 = Render_InitFont("Verdana",11,{"","",""}),
        VERDANA_12_BOLD = Render_InitFont("Verdana",11,{"b","",""}),
        VERDANA_12_R = Render_InitFont("Verdana",11,{"","","r"}),

        VERDANA_13 = Render_InitFont("Verdana",13,{"","",""}),
        VERDANA_13_BOLD = Render_InitFont("Verdana",13,{"b","",""}),
        VERDANA_36_BOLD = Render_InitFont("Verdana",36,{"b","",""}),

        VERDANA_40_BOLD = Render_InitFont("Verdana",40,{"b","",""}),
        ARROWS_12 = Render.InitFont("Acta Symbols W95 Arrows", 12),
        ARROWS_24 = Render.InitFont("Acta Symbols W95 Arrows", 20)

       
    }

    local svg = '<svg t="1650815150236" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="1757" width="200" height="200"><path d="M750.688207 480.651786c-40.458342 65.59852-115.105654 102.817686-205.927943 117.362627 2.382361 26.853806 0.292571 62.00408 20.897903 102.232546 40.77181 79.621013 76.486328 166.28462 88.356337 229.897839 69.819896 30.824408 215.958937-42.339153 257.671154-134.540705 44.721514-98.847085 0-202.082729-74.103967-210.755359-74.083069-8.651732-117.655198 31.555835-109.902076 78.65971 7.732224 47.103875 51.868597 47.918893 96.485622 16.822812 44.617024-31.075183 85.869486 32.517138 37.992389 60.562125-47.897995 28.044987-124.133548 44.867799-168.228125-5.642434-44.094577-50.489335-40.458342-228.205109 143.65219-211.716662 184.110532 16.509344 176.127533 261.683551 118.804583 344.042189C894.465785 956.497054 823.600993 1024.519731 616.37738 1023.997283h-167.18323V814.600288 1023.997283h-168.269921c-83.424432 0-24.743118-174.267619 51.826801-323.750324 20.584435-40.228465 18.494645-75.378739 20.897904-102.232546C262.784849 583.469472 188.137536 546.250306 147.679195 480.651786H93.867093A20.814312 20.814312 0 0 1 73.031883 459.753882c0-11.535643 9.46675-20.897904 20.83521-20.897903H127.993369a236.480679 236.480679 0 0 1-10.093687-41.795808H52.071285A20.814312 20.814312 0 0 1 31.236075 376.162267c0-11.535643 9.46675-20.897904 20.83521-20.897903H114.82769v-0.877712c0-57.009481 15.171878-103.131155 41.795808-139.514406V28.379353c0-11.535643 8.630834-17.136281 19.267867-12.517844l208.979037 90.864085c20.793414-2.08979 42.318255-3.113788 64.323748-3.113787s43.530333 1.044895 64.344646 3.134685l208.979037-90.884983c10.616135-4.618437 19.246969 0.982201 19.246969 12.538742v186.471995c26.623929 36.38325 41.795807 82.504924 41.795808 139.514406V355.264364h62.756405c11.493847 0 20.83521 9.278669 20.83521 20.897903 0 11.535643-9.46675 20.897904-20.83521 20.897904h-65.828397a236.480679 236.480679 0 0 1-10.093688 41.795808h34.126277c11.493847 0 20.83521 9.278669 20.83521 20.897903 0 11.535643-9.46675 20.897904-20.83521 20.897904h-53.833z" p-id="1758" fill="#ffffff"></path></svg>'
    local image_loaded = Render.LoadImage(svg, Vector2_new(32,32))

    local render_stringwithshadow = function(type,x,y,center,r,g,b,a,text)
        if type == "n" then
            render_text(x + 1,y + 1,FONTS.VERDANA_12,11,false,center,30,30,30,a,text)

            render_text(x,y,FONTS.VERDANA_12,11,false,center,r,g,b,a,text)

        elseif type == "b" then
            render_text(x + 1,y + 1,FONTS.VERDANA_12_BOLD,11,false,center,30,30,30,a,text)
            render_text(x,y,FONTS.VERDANA_12_BOLD,11,false,center,r,g,b,a,text)

        end
    end
    local is_breaking_lc = false
    local last_sent,current_choke = 0,0

 


    local g_visual = {
        g_vars = {
            check_show = false,
            check_show_time = GlobalVars.realtime,
            g_alpha = 0,
            arrows = {
                g_alpha = 0,
                l=0,
                r=0
            },
            menu_effect = {
                g_alpha = 0,
                o_alpha = 0,
                height = 0,
                cur_alpha = 200,
                min_alpha = 75,
                max_alpha = 200,
                target_alpha = 0,
                speed = 0.08,
                last_change = GlobalVars.realtime - 1,

                dots_alpha = 0,
                key_last_press = 0,
                dots = {},
                dot_size = 3,
                menu_open_prev = true,
            },
            watermark = {
                g_alpha = 0,
                cur_alpha = 1,
                min_alpha = 0.2,
                max_alpha = 1,
                target_alpha = 0,
                speed = 0.2,

            },
            center = {
                g_alpha = 0,
                o_alpha = 0,
                add_x = 0,
                cur_alpha = 22,
                min_alpha = 15,
                max_alpha = 22,
                target_alpha = 0,
                speed = 0.2,
                add_y = 0,
                width = 0,
                r_alpha = 0,

                desync_line = 0,

                left_r = 0,
                left_g = 0,
                left_b = 0,
                left_a = 0,

                right_r = 0,
                right_g = 0,
                right_b = 0,
                right_a = 0,

                rect_alpha = 0,
                rect_add_y = 0,
                rect_width = 0,

                dt_add_y = 0,
                dt_r = 0,
                dt_g = 0,
                dt_b = 0,
                dt_a = 0,

                hs_add_y = 0,

                ground_ticks = 0,




            },
            scopeline = {
                toleng = 0
            },
            s_watermark = {
                g_alpha = 0,
                current_time = GlobalVars.curtime,
                current_fps = 0,
                fps_counter = 0,      
                width = 0,

                --anti-aimbot & FL Text indicator
                add_x = 0,
                get_cmd_width = 0,
                get_fake_width = 0,
                get_circle_degree = 0,
                GET_FAKE_AMOUNT_LERP = 0
               
            },

            s_keybind = {
                g_alpha = 0,
                keybinds_alpha = {},
                keybinds_anime_posy = {},
                keybinds_y = {},

                width = 0,
                is_draggable = false,
                cursor_last_pos = Vector2.new(0, 0),
                container_alpha = 0,
                re_anim_width = 0,
                re_anim_x = 0,
                re_anim_y = 0,
                re_anim_add_y = 0,
                anims_add_y = 0,
                real_add_y = 0

            },
            s_spec = {
                g_alpha = 0,
                keybinds_alpha = {},
                keybinds_anime_posy = {},
                keybinds_y = {},

                width = 0,
                is_draggable = false,
                cursor_last_pos = Vector2.new(0, 0),
                container_alpha = 0,
                re_anim_width = 0,
                re_anim_x = 0,
                re_anim_y = 0,
                re_anim_add_y = 0,
                anims_add_y = 0,
                real_add_y = 0,
                binds = {},
                spec_offset = 0,
                size = Vector2.new(122 , 17)



            }
        },

       

        solus_render = (function()
            local solus_m = {}
            local rounding = 4;
            local rad = rounding + 2;
            local n = 45;
            local o = 20;

            local roundedrect = function(x, y, w, h, radius, r, g, b, a)
                Render.Blur(Vector2.new(x, y), Vector2.new(x + w, y + h),Color.new(255,255,255,a*255),radius)
                render_rectangle(x,y,w,h,r,g,b,a,radius)
            end

            local outline_glow = function(x,y,w,h,radius,r,g,b,a)
                render_rectangle(x + 2, y + radius + rad, 1, h - rad * 2 - radius * 2,r, g, b, a,0)
                render_rectangle(x + w - 3, y + radius + rad, 1,h - rad * 2 - radius * 2, r, g, b, a,0)
                render_rectangle(x + radius + rad, y + 2, w - rad * 2 - radius * 2, 1,r, g, b, a,0)
                render_rectangle(x + radius + rad, y + h - 3,w - rad * 2 - radius * 2, 1, r, g, b, a,0)
                render_circle_outline(x + radius + rad, y + radius + rad, radius + rounding,r,g,b,a,1,-90,-180)
                render_circle_outline(x + w - radius - rad, y + radius + rad, radius + rounding,r, g, b,a,1, -90, 0)

                render_circle_outline(x + radius + rad, y + h - radius - rad, radius + rounding,r, g, b,a,1, 90, 180)
                render_circle_outline(x + w - radius - rad, y + h - radius - rad, radius + rounding,r, g, b,a,1, 90, 0)
       
            end
            local FadedRoundedRect = function(x, y, w, h, radius, r, g, b, a, glow)
                local n = a / 255 * n;
                if not ui_get("value",visuals.disable_glow) then
                    for radius = 4, glow do
                        local radius = radius / 2;
                        outline_glow(x - radius, y - radius, w + radius * 2,h + radius * 2, radius, r, g, b, glow - radius * 2)
                    end
                end
       
                render_rectangle(x + radius, y, w - radius * 2, 1, r, g, b, a,0)
                render_circle_outline(x + radius, y + radius,radius,  r, g, b, a, 1,-90,-180)
                render_circle_outline(x + w - radius, y + radius,radius,  r, g, b, a, 1,-90,0)
                render_circle_outline(x + radius, y + h - radius,radius,  r, g, b, n, 1,90,180)
                render_circle_outline(x + w - radius, y + h - radius,radius,  r, g, b, n, 1,90,0)
           
                render_gradient(x, y + radius, 1, h - radius * 2, r, g, b, a, r, g, b,n, false)
                render_gradient(x + w - 1, y + radius, 1, h - radius * 2, r, g, b, a,r, g, b, n, false)

                render_rectangle(x + radius, y + h - 1, w - radius * 2, 1, r, g, b, n,0)
               
            end;

            solus_m.glow = function(x, y, w, h, radius, r, g, b, a, glow)
                for radius = 1, glow do
                    local radius = radius / 2;
                    render_rectangle(x - radius, y - radius, w + radius * 2,h + radius * 2,r, g, b, glow - radius * 2,radius)
                end
            end

            solus_m.glow_gradient = function(x, y, w, h, radius,r, g, b, a,r1,g1,b1,a1, glow)
                for radius = 1, glow do
                    local radius = radius / 2;
                    render_gradient(x - radius, y - radius, w + radius * 2,h + radius * 2,r, g, b, glow - radius * 2,r1,g1,b1,glow - radius * 2,true)
                end
            end


            solus_m.container = function(x, y, w, h, r, g, b, a, alpha)
                roundedrect(x, y, w, h, rounding, 17, 17, 17,a)
                FadedRoundedRect(x,y,w,h,rounding,r,g,b,alpha * 255, alpha * o)
            end
            solus_m.measure_multitext = function(fonts,size,_table)
                local x,y = 0,0
                for k, v in pairs(_table) do
                    local text_ = render_measure_text(size,fonts,v.text)
                    x = x + text_.x
                    y = y + text_.y
                end
                return {x = x ,y = y}
            end

            solus_m.multitext = function(x,y,fonts,size,outline,center,_table)
                for k, v in pairs(_table) do
                    v.color = v.color or {255,255,255,255}
                    v.color[4] = v.color[4] or 255

                    render_text(x,y,fonts,size,outline,center,v.color[1],v.color[2],v.color[3],v.color[4],v.text)
                    x = x + render_measure_text(size,fonts,v.text).x
                end
            end

            return solus_m
        end)(),

        on_script_start = function(self)

            if not self.g_vars.check_show then

                self.g_vars.g_alpha = lerp(self.g_vars.g_alpha,1,GlobalVars.frametime * 3.5)
            else
                self.g_vars.g_alpha = lerp(self.g_vars.g_alpha,0,GlobalVars.frametime * 3.5)
            end

     
            local screen = EngineClient_GetScreenSize()
            local cx , cy = screen.x /2,screen.y/2
            local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Welcome to Ataraxia , "..userdata.username..".")
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            Render.Blur(Vector2.new(0,0), Vector2.new(screen.x  , screen.y ),Color_RGBA(255,255,255,math_floor(255 * self.g_vars.g_alpha)))
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            render_gradient(cx - text_size.x/2 - 3,cy + text_size.y/2  ,text_size.x/2 +  6 ,2,r,g,b,0,r,g,b,255 * self.g_vars.g_alpha ,true)
            render_gradient(cx + 3,cy + text_size.y/2 ,text_size.x/2 +  5 + 2 ,2,r,g,b,255 * self.g_vars.g_alpha,r,g,b,0 ,true)


            render_stringwithshadow("b",cx,cy,true,255,255,255,255 * self.g_vars.g_alpha,"Welcome to Ataraxia , "..userdata.username..".")
            if self.g_vars.check_show_time + 3 < GlobalVars.realtime then
                self.g_vars.check_show_time = GlobalVars.realtime
                self.g_vars.check_show = true
            end
        end,

        get_center_states = function(self)
           
            local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
            local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
            local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
            local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
            local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)

            if on_ground == 1 then
                self.g_vars.center.ground_ticks = self.g_vars.center.ground_ticks + 1
            else
                self.g_vars.center.ground_ticks = 0
            end
           
            if Cheat_IsKeyDown(0x45) then
                return "USE"
            elseif check_roll == true then
                return "ROLL"
            elseif g_antiaim.value_table.antiaim.yaw_base == 3 or g_antiaim.value_table.antiaim.yaw_base == 2 then
                return "MANUAL"
            elseif in_air and duck then
                return "AIR+D"
            elseif in_air then
                return "AIR"
            elseif ui_get("value",reference.slow_motion) and self.g_vars.center.ground_ticks > 8 then
                return "SLOWWALK"
            elseif duck and self.g_vars.center.ground_ticks > 8 then
                return "DUCK"
            elseif velocity > 4 and self.g_vars.center.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "MOVE"
            elseif velocity < 2 and self.g_vars.center.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
                return "STAND"
            else
                return "AIR"
            end
        end,

        run_center = function(self)
            local v = self.g_vars.center
            if ui_get("bool",visuals.indicator_settings,2) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
            elseif ui_get("bool",visuals.indicator_settings,2) == false then
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
            end

            local cx ,cy = EngineClient_GetScreenSize().x /2,EngineClient_GetScreenSize().y/2
            local is_scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
            local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Ataraxia")
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            local r_td,g_td,b_td,a_td = ui_get("color",visuals.center_color_2).r,ui_get("color",visuals.center_color_2).g,ui_get("color",visuals.center_color_2).b,ui_get("color",visuals.center_color_2).a
            local r1,g1,b1,a1 = r_td*255,g_td*255,b_td *255 ,a_td *255
            local modifier = entity_get_prop(entity_get_localplayer(), "m_flVelocityModifier")

            local get_anims_alpha = ui_get("bool",visuals.center_scoped_anim,1)
            local get_anims_pos = ui_get("bool",visuals.center_scoped_anim,2)

            if is_scoped then
                if get_anims_pos == true then
                    v.add_x = lerp(v.add_x,30,GlobalVars.frametime * 8)
                end

                if get_anims_alpha == true then
                    v.o_alpha = lerp(v.o_alpha,0.3,GlobalVars.frametime * 8)
                end
            else
                if modifier ~= 1 then
                    v.add_y = lerp(v.add_y,1,GlobalVars.frametime * 8)
                else
                    v.add_y = lerp(v.add_y,0,GlobalVars.frametime * 8)
                end

                    v.o_alpha = lerp(v.o_alpha,1,GlobalVars.frametime * 8)
               

                if get_anims_pos == true then
                    v.add_x = lerp(v.add_x,0,GlobalVars.frametime * 8)
                end

            end

            if (v.cur_alpha < v.min_alpha + 1) then
                v.target_alpha = v.max_alpha
            elseif (v.cur_alpha > v.max_alpha - 1) then
                v.target_alpha = v.min_alpha
            end
            v.cur_alpha = v.cur_alpha + (v.target_alpha - v.cur_alpha)*v.speed*(GlobalVars.absoluteframetime*10)
            local inverted = AntiAim_GetInverterState()
            if inverted then
                v.left_r = lerp(v.left_r,r,GlobalVars.frametime * 12)
                v.left_g = lerp(v.left_g,g,GlobalVars.frametime * 12)
                v.left_b = lerp(v.left_b,b,GlobalVars.frametime * 12)
                v.left_a = lerp(v.left_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                v.right_r = lerp(v.right_r,255,GlobalVars.frametime * 12)
                v.right_g = lerp(v.right_g,255,GlobalVars.frametime * 12)
                v.right_b = lerp(v.right_b,255,GlobalVars.frametime * 12)
                v.right_a = lerp(v.right_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
            else
                v.left_r = lerp(v.left_r,255,GlobalVars.frametime * 12)
                v.left_g = lerp(v.left_g,255,GlobalVars.frametime * 12)
                v.left_b = lerp(v.left_b,255,GlobalVars.frametime * 12)
                v.left_a = lerp(v.left_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                v.right_r = lerp(v.right_r,r,GlobalVars.frametime * 12)
                v.right_g = lerp(v.right_g,g,GlobalVars.frametime * 12)
                v.right_b = lerp(v.right_b,b,GlobalVars.frametime * 12)
                v.right_a = lerp(v.right_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
            end

            if modifier ~= 1 then
                v.rect_add_y = lerp(v.rect_add_y,1,GlobalVars.frametime * 12)
               
            else
                v.rect_add_y = lerp(v.rect_add_y,0,GlobalVars.frametime * 12)
            end

            if ui_get("value",reference.dt) then

                if doubletap_charged() then
                    v.dt_r = lerp(v.dt_r,r,GlobalVars.frametime * 12)
                    v.dt_g = lerp(v.dt_g,g,GlobalVars.frametime * 12)
                    v.dt_b = lerp(v.dt_b,b,GlobalVars.frametime * 12)
                    v.dt_a = lerp(v.dt_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                else
                    v.dt_r = lerp(v.dt_r,255,GlobalVars.frametime * 12)
                    v.dt_g = lerp(v.dt_g,0,GlobalVars.frametime * 12)
                    v.dt_b = lerp(v.dt_b,0,GlobalVars.frametime * 12)
                    v.dt_a = lerp(v.dt_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
                end
                v.dt_add_y = lerp(v.dt_add_y,1,GlobalVars.frametime * 12)

            else
                v.dt_add_y = lerp(v.dt_add_y,0,GlobalVars.frametime * 12)

            end

            if ui_get("value",reference.hs) then
                v.hs_add_y = lerp(v.hs_add_y,1,GlobalVars.frametime * 12)
            else
                v.hs_add_y = lerp(v.hs_add_y,0,GlobalVars.frametime * 12)
            end


            if ui_get("value",visuals.center_mode) == 0 then
                self.solus_render.glow(cx - text_size.x/2 - 1 + 4+ math_floor(v.add_x),cy + 25.5,text_size.x - 8,(text_size.y - 5)/2 - 4,5,r,g,b,math_floor(a*v.g_alpha),math_floor(v.cur_alpha *v.g_alpha)*v.o_alpha)
                render_rectangle(
                    cx - text_size.x/2 + math_floor(v.add_x),cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 *  v.add_y),text_size.x,3,25,25,25,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
                )
                render_rectangle(
                    cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18   + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y) + 1,math_floor(((text_size.x - 1) * modifier) * v.add_y),1,r,g,b,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
                )
                render_stringwithshadow("b",cx - text_size.x/2 + math_floor(v.add_x),cy + 18 -  math_floor(4 * v.add_y),false,r,g,b,math_floor(a*v.g_alpha)*v.o_alpha,"Ataraxia")
            elseif ui_get("value",visuals.center_mode) == 1 then

                self.solus_render.glow_gradient(cx - text_size.x/2 - 1 + 4+ math_floor(v.add_x) + 2,cy + 25.5,text_size.x - 8,(text_size.y - 5)/2 - 4,2,r,g,b,math_floor(a*v.g_alpha),r1,g1,b1,math_floor(a1*v.g_alpha),math_floor(v.cur_alpha *v.g_alpha)*v.o_alpha)
                render_rectangle(
                    cx - text_size.x/2 + math_floor(v.add_x),cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 *  v.add_y),text_size.x,3,25,25,25,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
                )

                render_gradient(cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18   + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y) + 1,math_floor(((text_size.x - 1) * modifier) * v.add_y),1,r,g,b,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,r1,g1,b1,math_floor((a1 * v.add_y)*v.g_alpha)*v.o_alpha,true)
                render_text(cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18 -  math_floor(4 * v.add_y) + 1,FONTS.VERDANA_12_BOLD,11,false,false,30,30,30,math_floor(a1*v.g_alpha)*v.o_alpha,"Ataraxia")
                gradient_text(cx - text_size.x/2 + math_floor(v.add_x),cy + 18 -  math_floor(4 * v.add_y),r/255,g/255,b/255,math_floor(a*v.g_alpha)*v.o_alpha/255,r1/255,g1/255,b1/255,math_floor(a1*v.g_alpha)*v.o_alpha/255,"Ataraxia",11,FONTS.VERDANA_12_BOLD,false,false)
            elseif ui_get("value",visuals.center_mode) == 2 then
                local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Atar")
                local text_size_2  = render_measure_text(11,FONTS.VERDANA_12_BOLD,"axia")
                local g_x = text_size.x + text_size_2.x
                local x,y = cx - g_x / 2 + math_floor(v.add_x ) ,cy + 18

                local modifier = entity_get_prop(entity_get_localplayer(), "m_flVelocityModifier")

                local alpha = math.floor(
                    math.sin(math.abs(-math.pi + (GlobalVars.curtime * (1.25 / .75)) % (math.pi * 2))) * 200
                )
                v.desync_line = lerp(v.desync_line,math_floor(get_fake_amount/100 ),GlobalVars.frametime * 12)

                local inverted = AntiAim_GetInverterState()


                local get_states = self:get_center_states()

               

                local dt_r,dt_g,dt_b,dt_a = math_floor(v.dt_r),math_floor(v.dt_g),math_floor(v.dt_b),math_floor(v.dt_a)
                local left_r,left_g,left_b,left_a = math_floor(v.left_r),math_floor(v.left_g),math_floor(v.left_b),math_floor(v.left_a)
                local right_r,right_g,right_b,right_a = math_floor(v.right_r),math_floor(v.right_g),math_floor(v.right_b),math_floor(v.right_a)

                render_text(x + 1,y + 1,FONTS.VERDANA_12_BOLD,11,false,false,0,0,0,left_a - 50,"Ataraxia")

                render_text(x + text_size.x - 1 , y  - 4 + 1,FONTS.PIXEL_10,10,true,true,r,g,b,math_floor(alpha * v.g_alpha * v.o_alpha),"|"..userdata.build.."|")
                render_text(x,y,FONTS.VERDANA_12_BOLD,11,false,false,left_r,left_g,left_b,left_a,"Atar")
                render_text(x + text_size.x,y,FONTS.VERDANA_12_BOLD,11,false,false,right_r,right_g,right_b,right_a,"axia")

                render_rectangle(x ,y + text_size.y  + math_floor( 3 * v.rect_add_y),g_x,3,25,25,25,math_floor(255 * v.g_alpha * v.o_alpha * v.rect_add_y),0)
                render_rectangle(x  + 1,y + text_size.y + 1  + math_floor( 3 * v.rect_add_y),math_floor((g_x - 2) * modifier),1,r,g,b,math_floor(255 * v.g_alpha * v.o_alpha * v.rect_add_y),0)

                render_text(x  + text_size.x/2 + 11,y + text_size.y + 5  + math_floor( 5 * v.rect_add_y) ,FONTS.PIXEL_10,10,true,true,255,255,255,math_floor(255 * v.g_alpha * v.o_alpha),get_states)
                render_text(x  + text_size.x/2 + 7,y + text_size.y + 7  + math_floor( 3 * v.dt_add_y) + math_floor( 4 * v.rect_add_y) ,FONTS.PIXEL_10,math_floor(10 * v.dt_add_y + 0.5),true,false,dt_r,dt_g,dt_b,dt_a,"DT")
                render_text(x  + text_size.x/2 + 7,y + text_size.y + 7   + math_floor( 3 * v.hs_add_y) + math_floor( 10 * v.dt_add_y) + math_floor( 4 * v.rect_add_y),FONTS.PIXEL_10,math_floor(10 * v.hs_add_y + 0.5),true,false,r,g,b,math_floor(255 * v.g_alpha * v.o_alpha),"HS")




            elseif ui_get("value",visuals.center_mode) == 3 then

                local x,y = (cx - 14)  + math_floor(v.add_x ) ,cy + 18
                local re_r,re_g,re_b = math_floor(r),math_floor(g),math_floor(b)
             
                Render.Image(icon,Vector2_new(x + 1,y + 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
                Render.Image(icon,Vector2_new(x - 1,y - 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
                Render.Image(icon,Vector2_new(x + 1,y - 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
                Render.Image(icon,Vector2_new(x - 1,y + 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))

                Render.Image(icon,Vector2_new(x,y),get_icon_size,Color_RGBA(re_r,re_g,re_b,math_floor(255 * v.g_alpha * v.o_alpha)))
            end


       
        end,

        run_arrows = function(self)
            local v = self.g_vars.arrows
            if ui_get("bool",visuals.indicator_settings,1) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
            elseif ui_get("bool",visuals.indicator_settings,1) == false then
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
            end

            local cx ,cy = EngineClient_GetScreenSize().x /2,EngineClient_GetScreenSize().y/2
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255          
            local ds = (EngineClient_GetScreenSize().x/2) / 210 * ui_get("value",visuals.arrows_distance)
            local mode = ui_get("value",visuals.arrows_mode)
            local check_back = ui_get("value",visuals.arrows_background)
         
            v.l =  linear(g_antiaim.value_table.antiaim.yaw_base == 3,v.l,math_floor(255* v.g_alpha),6)
            v.r =  linear(g_antiaim.value_table.antiaim.yaw_base == 2,v.r,math_floor(255* v.g_alpha),6)
            if mode == 0 then
                if check_back == true then
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(125 * v.g_alpha),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(125 * v.g_alpha),"w")
                    render_text(cx+ds,cy,FONTS.ARROWS_24,20,false,true,60,60,60,math_floor(125 * v.g_alpha),"x")
                    render_text(cx-ds,cy,FONTS.ARROWS_24,20,false,true,60,60,60,math_floor(125 * v.g_alpha),"w")
                else
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(v.r),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(v.l),"w")
                end
                render_text(cx+ds,cy,FONTS.ARROWS_24,20,false,true,r,g,b,math_floor(v.r),"x")

                render_text(cx-ds,cy,FONTS.ARROWS_24,20,false,true,r,g,b,math_floor(v.l),"w")


            elseif mode == 1 then
                if check_back == true then
               
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(125 * v.g_alpha),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(125 * v.g_alpha),"w")
                    render_text(cx+ds,cy,FONTS.ARROWS_12,12,false,true,60,60,60,math_floor(125 * v.g_alpha),"x")
                    render_text(cx-ds,cy,FONTS.ARROWS_12,12,false,true,60,60,60,math_floor(125 * v.g_alpha),"w")
                else
                    render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(v.r),"x")
                    render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(v.l),"w")
                end
                render_text(cx+ds,cy,FONTS.ARROWS_12,12,false,true,r,g,b,math_floor(v.r),"x")

                render_text(cx-ds,cy,FONTS.ARROWS_12,12,false,true,r,g,b,math_floor(v.l),"w")
            end
     

        end,

   

        distance = function(self,x1, y1, x2, y2)
            return math.sqrt((x2-x1)^2 + (y2-y1)^2)
        end,

        run_menueffect = function(self)
            if ui_get("bool",visuals.indicator_settings,4) == true then
                self.g_vars.menu_effect.g_alpha = lerp(self.g_vars.menu_effect.g_alpha,1,GlobalVars.frametime * 24)
            elseif ui_get("bool",visuals.indicator_settings,4) == false then
                self.g_vars.menu_effect.g_alpha = lerp(self.g_vars.menu_effect.g_alpha,0,GlobalVars.frametime * 24)
            end
            if self.g_vars.menu_effect.g_alpha <= 0.001 then
                self.g_vars.menu_effect.g_alpha = 0
            end
            if Cheat_IsMenuVisible() == true then
                self.g_vars.menu_effect.o_alpha = lerp(self.g_vars.menu_effect.o_alpha,self.g_vars.menu_effect.g_alpha,GlobalVars.frametime * 12)
            else
                self.g_vars.menu_effect.o_alpha = lerp(self.g_vars.menu_effect.o_alpha,0,GlobalVars.frametime * 12)
            end
            if self.g_vars.menu_effect.o_alpha <= 0.001 then
                self.g_vars.menu_effect.o_alpha = 0
            end
            local sx,sy = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            if (self.g_vars.menu_effect.cur_alpha < self.g_vars.menu_effect.min_alpha + 2) then
                self.g_vars.menu_effect.target_alpha = self.g_vars.menu_effect.max_alpha
            elseif (self.g_vars.menu_effect.cur_alpha > self.g_vars.menu_effect.max_alpha - 2) then
                self.g_vars.menu_effect.target_alpha = self.g_vars.menu_effect.min_alpha
            end
            self.g_vars.menu_effect.cur_alpha = self.g_vars.menu_effect.cur_alpha + (self.g_vars.menu_effect.target_alpha - self.g_vars.menu_effect.cur_alpha)*self.g_vars.menu_effect.speed*(GlobalVars.frametime*10)
            render_gradient(0,0,sx,600 ,r,g,b,self.g_vars.menu_effect.cur_alpha*self.g_vars.menu_effect.o_alpha,r,g,b,0,false)

            local v = self.g_vars.menu_effect
            local menu_open = Cheat_IsMenuVisible()
            local realtime = GlobalVars.realtime
            if menu_open and not v.menu_open_prev then
                v.last_change = realtime
            end
            if not menu_open then
                return
            end

            local opacity_multiplier = menu_open and 1 or 0
   
            local menu_fade_time = 0.2
       
            if realtime - v.last_change < menu_fade_time then
                opacity_multiplier = (realtime - v.last_change) / menu_fade_time
            end
       
            if opacity_multiplier ~= 1 then
                --client.log(opacity_multiplier)
            end
   
            local screen_width, screen_height = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
            if opacity_multiplier > 0 and v.o_alpha >= 0.5 then
                local r, g, b, a = 255,255,255,200
                a = a * opacity_multiplier
                local r_connect, g_connect, b_connect, a_connect = 255,255,255,255
                a_connect = a_connect * opacity_multiplier * 0.5
                local speed_multiplier = 61 / 100
                local dots_amount = 23
                local dots_connect_distance = 307
                local line_a = a/4

                while #v.dots > dots_amount do
                    table_remove(v.dots, #v.dots)
                end
                while #v.dots < dots_amount do
                    local x, y = Utils_RandomInt(-dots_connect_distance, screen_width+dots_connect_distance), Utils_RandomInt(-dots_connect_distance, screen_height+dots_connect_distance)
                    local max = 12
                    local min = 4

                    local velocity_x
                    if Utils_RandomInt(0, 1) == 1 then
                        velocity_x = Utils_RandomFloat(-max, -min)
                    else
                        velocity_x = Utils_RandomFloat(min, max)
                    end
   
                    local velocity_y
                    if Utils_RandomInt(0, 1) == 1 then
                        velocity_y = Utils_RandomFloat(-max, -min)
                    else
                        velocity_y = Utils_RandomFloat(min, max)
                    end
   
                    local size = Utils_RandomFloat(v.dot_size-1, v.dot_size+1)
                    table_insert(v.dots, {x, y, velocity_x, velocity_y, size})
                end

                local dots_new = {}
                for i=1, #v.dots do
                    local dot = v.dots[i]
                    local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
                    x = x + velocity_x*speed_multiplier*0.2
                    y = y + velocity_y*speed_multiplier*0.2
                    if x > -dots_connect_distance and x < screen_width+dots_connect_distance and y > -dots_connect_distance and y < screen_height+dots_connect_distance then
                        table_insert(dots_new, {x, y, velocity_x, velocity_y, size})
                    end
                end
                v.dots = dots_new
   
                for i=1, #v.dots do
                    local dot = v.dots[i]
                    local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
                    for i2=1, #v.dots do
                        local dot2 = v.dots[i2]
                        local x2, y2 = dot2[1], dot2[2]
                        local distance = self:distance(x, y, x2, y2)
                        if distance <= dots_connect_distance then
                            local a_connect_multiplier = 1
                            if distance > dots_connect_distance * 0.7 then
                                a_connect_multiplier = (dots_connect_distance - distance) / (dots_connect_distance * 0.3)
                                --distance - dots_connect_distance /
                            end
                            Render.Line(Vector2.new(x, y), Vector2.new(x2, y2), Color.RGBA(r_connect, g_connect, b_connect, math_floor(a_connect*a_connect_multiplier)))

                        end
                    end
                end
   
                for i=1, #v.dots do
                    local dot = v.dots[i]
                    local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
                    Render.CircleFilled(Vector2.new(x, y), math_floor(size), 32, Color.new(r, g, b, math_floor(a)))
                end
            end


        end,


        run_watermark = function(self)
            local v = self.g_vars.watermark
            if ui_get("bool",visuals.indicator_settings,3) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
            end

            -- solus_m.container = function(x, y, w, h, r, g, b, a, alpha)
            local screen = EngineClient_GetScreenSize()
            local cx , cy = screen.x /2,screen.y/2  
            local r_t,g_t,b_t,a_t = ui_get("color",visuals.watermark_color).r,ui_get("color",visuals.watermark_color).g,ui_get("color",visuals.watermark_color).b,ui_get("color",visuals.watermark_color).a
            local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
            local tabled = {
                {text = "ATARAXIA",color = {r,g,b,math_floor(255*v.g_alpha)}},
                {text = ".PUB",color = {255,255,255,math_floor(255*v.g_alpha)}},
                {text = "  ",color = {255,255,255,math_floor(255*v.g_alpha)}},
                {text = "@"..string.upper(userdata.username),color = {r,g,b,math_floor(255*v.g_alpha)}},
                {text = "  ",color = {255,255,255,math_floor(255*v.g_alpha)},flags = "-"},
                {text = string.upper(userdata.build),color = {159,227,255,math_floor(255*v.g_alpha)}},
                {text = "  ",color = {255,255,255,math_floor(255*v.g_alpha)}},
                {text = string.upper(userdata.last_updatetime),color = {255,255,255,math_floor(255*v.g_alpha)}},
            }

            if (v.cur_alpha < v.min_alpha + 0.02) then
                v.target_alpha = v.max_alpha
            elseif (v.cur_alpha > v.max_alpha - 0.02) then
                v.target_alpha = v.min_alpha
            end
            v.cur_alpha = v.cur_alpha + (v.target_alpha - v.cur_alpha)*v.speed*(GlobalVars.frametime*10)
            local lua = self.solus_render.measure_multitext(FONTS.PIXEL_10,10,tabled).x + 8
            local w,h = lua+ 12 ,18
            local sx,sy = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
            local x ,y = sx/ 2 -lua/2, sy - 30
            Render.Image(image_loaded, Vector2.new(500, 500), Vector2_new(32,32))

            self.solus_render.container(x, y, w, h, r, g, b, a*v.g_alpha,v.cur_alpha*v.g_alpha )
            self.solus_render.multitext(x + 11 , y + 3,FONTS.PIXEL_10,10,true,false, tabled)
        end,

        run_damage_maker = function(self)
            if ui_get("bool",visuals.indicator_settings,5) == true then
                local damage_indicator_displays_new = {}
                local max_time_delta = ui_get("value",visuals.dmgmarker_display_time) / 2
                local speed = ui_get("value",visuals.dmgmarker_speed) / 3
                local realtime = GlobalVars.realtime
                local max_time = realtime - max_time_delta / 2
                local aimbot_enabled = ui_get("value",reference.ragebot)
                local minimum_damage = 0
                if aimbot_enabled then
                    minimum_damage = ui_get("value",reference.dmg)
                end
                -- local r_t,g_t,b_t,a_t = ui_get("color",visuals.dmgmarker_color_1).r,ui_get("color",visuals.dmgmarker_color_1).g,ui_get("color",visuals.dmgmarker_color_1).b,ui_get("color",visuals.dmgmarker_color_1).a
                -- local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
                local r_td,g_td,b_td,a_td = ui_get("color",visuals.dmgmarker_color_2).r,ui_get("color",visuals.dmgmarker_color_2).g,ui_get("color",visuals.dmgmarker_color_2).b,ui_get("color",visuals.dmgmarker_color_2).a
                local r1,g1,b1,a1 = r_td*255,g_td*255,b_td *255 ,a_td *255

                for i=1, #damage_indicator_displays do
                    local damage_indicator_display = damage_indicator_displays[i]
                    local damage, time, x, y, z, e = damage_indicator_display[1], damage_indicator_display[2], damage_indicator_display[3], damage_indicator_display[4], damage_indicator_display[5], damage_indicator_display[6]
                    local r_s, g_s, b_s, a_s = r1,g1,b1,a1
                    if time > max_time then
                        local sx, sy = Render.WorldToScreen(Vector_new( x, y, z)).x,Render.WorldToScreen(Vector_new( x, y, z)).y
               
               
                        -- if damage < minimum_damage and e.health ~= 0 then
                        --     r, g, b = r1, g1,b1
                        -- end
           
                        if (time - max_time) < 0.7 then
                            a_s = math_floor((time - max_time) / 0.7 * 255)
                        end
           
                        if not (sx == nil or sy == nil) then
                            if ui_get("value",visuals.dmgmarker_mode) == 0 then
                       
                                render_text(math_floor(sx) + 1, math_floor(sy) + 1,FONTS.VERDANA_13, 13,false,false,30,30,30,a_s,tostring(damage))
                                render_text(math_floor(sx), math_floor(sy),FONTS.VERDANA_13, 13,false,false,r_s, g_s, b_s,a_s,tostring(damage))


                            elseif ui_get("value",visuals.dmgmarker_mode) == 1 then
                                render_text(sx + 1, sy + 1,FONTS.VERDANA_12_BOLD,11,false,false,30,30,30,a_s,tostring(damage))
                                render_text(sx, sy,FONTS.VERDANA_12_BOLD, 11,false,false,r_s, g_s, b_s,a_s,tostring(damage))

                            elseif ui_get("value",visuals.dmgmarker_mode) == 2 then
                                 render_text(sx + 1, sy + 1,FONTS.VERDANA_36_BOLD,36,false,false,30,30,30,a_s,tostring(damage))
                                 render_text(sx, sy,FONTS.VERDANA_36_BOLD,36,false,false,r_s, g_s, b_s,a_s,tostring(damage))

                                   
                            end
                        end
                        table_insert(damage_indicator_displays_new, {damage, time, x, y, z+0.4*speed, e})
                    end
                end
           
                damage_indicator_displays = damage_indicator_displays_new

            end
        end,
       
        run_scopeline = function(self)
            local v = self.g_vars.scopeline
            local scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
            local sc = EngineClient.GetScreenSize()
            local gui = CVar.FindVar("r_drawvgui")
            if ui_get("bool",visuals.indicator_settings,6) == true then
                ui_set("value",reference.remove_scope,2)
                local Scoped_color = ui_get("color",visuals.indicator_color)
                local r, g, b, a = Scoped_color.r, Scoped_color.g, Scoped_color.b, Scoped_color.a
                local org = ui_get("value",visuals.scopeline_origin)
                local width = ui_get("value",visuals.scopeline_width)
                if scoped then
                    if v.toleng < (org/ 2 + width) then
                        v.toleng = v.toleng + 2
                    else
                        v.toleng = (org/ 2 + width)
                    end
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 - 0.1,sc.y / 2 - math.min(org, v.toleng)),Vector2.new(sc.x / 2 + 1, sc.y / 2 - math.min(org, v.toleng) -math.min(width, v.toleng)),Color.new(r , g , b , a), Color.new(r , g , b , a),Color.new(r , g , b , 0), Color.new(r, g , b , 0))
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 - math.min(org, v.toleng),
                        sc.y / 2 - 0.1), Vector2.new(sc.x / 2 - math.min(org, v.toleng) -
                                                         math.min(width, v.toleng), sc.y / 2 + 1),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0))
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 - 0.1,
                        sc.y / 2 + math.min(org, v.toleng)),
                        Vector2.new(sc.x / 2 + 1, sc.y / 2 + math.min(org, v.toleng) +
                            math.min(width, v.toleng)),
                        Color.new(r , g , b , a), Color.new(r , g , b , a),
                        Color.new(r , g , b , 0), Color.new(r , g , b , 0))
                    Render.GradientBoxFilled(Vector2.new(sc.x / 2 + math.min(org, v.toleng),
                        sc.y / 2 - 0.1), Vector2.new(sc.x / 2 + math.min(org, v.toleng) +
                                                         math.min(width, v.toleng), sc.y / 2 + 1),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0),
                        Color.new(r , g , b , a), Color.new(r , g , b , 0))
                else
                    if v.toleng > 0 then
                        v.toleng = v.toleng - 2
                    else
                        v.toleng = 0
                    end
                end

            else
                ui_set("value",reference.remove_scope,1)
            end


       
        end,

        run_notifications = function(self)
            local y = sc_y - 100

            for i, info in pairs(noti_table) do
                if i > 5 then
                    table_remove(noti_table,i)
                end

                if info.text ~= nil and info.text ~= "" then
               

                    if info.timer + 3.8 < GlobalVars.realtime then
                        info.smooth_y = lerp(info.smooth_y,sc_y + 100,GlobalVars.frametime * 2)
                        info.alpha = lerp(info.alpha,0,GlobalVars.frametime * 4)
                    else
                        info.alpha = lerp(info.alpha,1,GlobalVars.frametime * 4)
                        info.smooth_y = lerp(info.smooth_y,y,GlobalVars.frametime * 4)
                    end

                    local add_y = math_floor(info.smooth_y)
                    local alpha = info.alpha
               
                    local get_color = ui_get("color",visuals.watermark_color)
                    local r,g,b,a = get_color.r * 255,get_color.g * 255,get_color.b * 255,get_color.a * 255
                    local tabled = {
                        {text = "[Ataraxia]",color = {r,g,b,math_floor(255*alpha)}},
                        {text = " ",color = {r,g,b,math_floor(255*alpha)}},
                        {text = info.text,color = {255,255,255,math_floor(255*alpha)}},
                    }
                    local text_size = self.solus_render.measure_multitext(FONTS.VERDANA_12,11,tabled).x + 8
                    local text_size_y = self.solus_render.measure_multitext(FONTS.VERDANA_12,11,tabled).y/2 + 4
                    -- solus_m.container = function(x, y, w, h, r, g, b, a, alpha)

                    self.solus_render.container(sc_x/2 - text_size/2,add_y - 26 - 7 + 2 + 31,text_size + 2,text_size_y,r,g,b,math_floor(a*alpha),1*alpha)
                    self.solus_render.multitext(sc_x/2 - text_size/2 + 5  ,add_y - 26 - 7 + 2 + 31 + 3,FONTS.VERDANA_12,11,true,false, tabled)
                    y = y - 45
                    if info.timer + 4 < GlobalVars.realtime then
                        table_remove(noti_table,i)
                    end
                end
            end
        end,
       
        get_ping = function(self)
            local netchann_info = EngineClient.GetNetChannelInfo()
            if not netchann_info then return "0" end

            local latency = netchann_info:GetLatency(0)
            return math_floor(latency * 1000.0 + 0.5).."ms"
        end,


        get_ticks = function(self)
            return math.floor(1.0 / GlobalVars.interval_per_tick)
        end,

        get_fps = function(self)
            local get_fps = function()
                self.g_vars.s_watermark.fps_counter = 0.9 * self.g_vars.s_watermark.fps_counter + (1.0 - 0.9) * GlobalVars.absoluteframetime
                return math.floor((1.0 / self.g_vars.s_watermark.fps_counter) + 0.5)
            end

            local current_fps = get_fps()
            if self.g_vars.s_watermark.current_time + 0.3 < GlobalVars.curtime then
                self.g_vars.s_watermark.current_fps = current_fps
                self.g_vars.s_watermark.current_time = GlobalVars.curtime
            end

            return self.g_vars.s_watermark.current_fps
        end,

        get_fl_amount = function(self,cmd)
           
            if doubletap_charged() then
                is_breaking_lc = true
            else
                is_breaking_lc = false
            end


            if ClientState.m_choked_commands == 0 then
           
       
                    last_sent = current_choke
               

            end
            current_choke = ClientState.m_choked_commands


            return last_sent
        end,

        normalize_yaw = function(self,ang)
            while (ang > 180.0) do
                ang = ang - 360.0
            end
            while (ang < -180.0) do
                ang = ang + 360.0
            end
            return ang
        end,

        get_desync = function(self,cmd)

            local ptr = entity_get_localplayer()
            local degree = self:normalize_yaw(AntiAim_GetCurrentRealRotation() - ptr:GetProp("m_angEyeAngles[1]"))

       
           

            get_fake_amount = math_abs(math_floor(tonumber(string_format("%.2f", (clamp(degree, AntiAim_GetMinDesyncDelta(), AntiAim_GetMaxDesyncDelta())))) + 0.5))
            return get_fake_amount
        end,

        run_solus_watermark = function(self)
            local v = self.g_vars.s_watermark
            if ui_get("bool",visuals.indicator_settings,7) == false then
                return
            end

            if ui_get("bool",visuals.solus_select,1) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
            end
           
            local get_n_watermark = ui_get("bool",reference.windows,3)
           
            if ui_get("bool",visuals.solus_select,1) == true then
                ui_set("bool",reference.windows,3,false)
            else
                ui_set("bool",reference.windows,3,get_n_watermark)
            end
            local r,g,b,a = ui_get("color",visuals.watermark_color).r * 255,ui_get("color",visuals.watermark_color).g * 255,ui_get("color",visuals.watermark_color).b * 255,math_floor((ui_get("color",visuals.watermark_color).a*255) * v.g_alpha)
            local rea = math_floor(255*v.g_alpha)
            local text_Table = {
                {text = "Ataraxia",color = {r,g,b,rea}},
                {text = ".pub",color = {255,255,255,rea}},
                {text = "[",color = {255,255,255,rea}},
                {text = userdata.build,color = {159,227,255,rea}},
                {text = "]",color = {255,255,255,rea}},
                {text = "  ",color = {255,255,255,rea}},
                {text = ui_get("value",visuals.solus_watermark_name),color = {255,255,255,rea}},
                {text = "  ",color = {255,255,255,rea}},
                {text = "delay:"..self:get_ping(),color = {255,255,255,rea}},
                {text = "  ",color = {255,255,255,rea}},
                {text = self:get_ticks().."tick",color = {255,255,255,rea}}
            }

            local get_text_size_x,get_text_size_y = self.solus_render.measure_multitext(FONTS.VERDANA_12_R,11,text_Table).x,self.solus_render.measure_multitext(FONTS.PIXEL_10,10,text_Table).y

            v.width = lerp(v.width,(get_text_size_x + 10) * v.g_alpha,GlobalVars.frametime * 12)
            local w,h = math_floor(v.width), math_floor(18 * v.g_alpha + 0.5)


            -- print(math.floor(ping * 1000 + 0.5))
            -- local text_size =
            -- local w,h =
           
            self.solus_render.container(sc_x - (w+8),h/2,w,h,r,g,b,a,1 * v.g_alpha)
            local reget_text = "Ataraxia.pub  "..userdata.build.."  "..ui_get("value",visuals.solus_watermark_name).."  ".."delay:"..self:get_ping().."  "..self:get_ticks().."tick"
            render_text(sc_x - (w+8) + 5 + 1,h/2 + 2 +1,FONTS.VERDANA_12_R,math_floor(11*v.g_alpha + 0.5),false,false,10,10,10,rea,reget_text)

            self.solus_render.multitext(sc_x - (w+8) + 5,h/2 + 2,FONTS.VERDANA_12_R,math_floor(11*v.g_alpha + 0.5),false,false, text_Table)
           
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
         
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end


            local text_fl = ("FL:%s"):format(
                    (function()
                        if tonumber(last_sent) < 10 then
                            return "\x20"..last_sent
                        end
                        return last_sent
                end)()
            )

            v.GET_FAKE_AMOUNT_LERP = lerp(v.GET_FAKE_AMOUNT_LERP,get_fake_amount + 0.5,GlobalVars.frametime * 3.5)

            local text_fake = ("FAKE:(%.1f°)"):format(v.GET_FAKE_AMOUNT_LERP + 0.5)
            local text_fake_size = render_measure_text(11,FONTS.VERDANA_12_R,text_fake)
            v.get_fake_width = lerp(v.get_fake_width,(text_fake_size.x + 10 + 10)*v.g_alpha,GlobalVars.frametime * 12)
            local w_f,h_f = v.get_fake_width,18
            local text_tick = ""
            if is_breaking_lc == true then
                text_tick = " | SHIFTING"
            elseif is_breaking_lc == false then

                text_tick = ""
            end

            local text_tick_size = render_measure_text(11,FONTS.VERDANA_12_R,text_tick)
            local text_fl_size = render_measure_text(11,FONTS.VERDANA_12_R,text_fl)

            local text_cmd = text_fl..text_tick
            local text_cmd_size = text_fl_size.x + text_tick_size.x
            v.get_cmd_width = lerp(v.get_cmd_width,(text_cmd_size + 10)*v.g_alpha,GlobalVars.frametime * 12)

            local w_cmd ,h_cmd = v.get_cmd_width,18
            self.solus_render.container(sc_x - (w_cmd+8) ,h_cmd/2 + h_cmd + 6,w_cmd,h_cmd,r,g,b,a,1 * v.g_alpha)


            self.solus_render.container(sc_x - (w_f + w_cmd +15) ,h_f/2 + h + 6,w_f,h_f,r,g,b,a,1 * v.g_alpha)
            render_text(sc_x - (w_cmd+8) + 5 + 1 ,h_cmd/2 + h + 6 + 1 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,10,10,10,rea,text_cmd)
            render_text(sc_x - (w_cmd+8) + 5 ,h_cmd/2 + h + 6 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,255,255,255,rea,text_cmd)

            render_text(sc_x - (w_f + w_cmd +15) + 6  + 1 + 10,h_f/2 + h + 6 + 1 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,10,10,10,rea,text_fake)
            render_text(sc_x - (w_f+ w_cmd + 15) + 6  + 10 ,h_f/2 + h + 6 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,255,255,255,rea,text_fake)
         
            v.get_circle_degree = lerp(v.get_circle_degree,((get_fake_amount + 0.5)*6)*v.g_alpha,GlobalVars.frametime * 12)

            render_circle_outline(sc_x - (w_f+ w_cmd + 15) + 6 + 3,h_f/2 + h + 6 + 1 + 8,4.5,r,g,b,rea,3,0,v.get_circle_degree)


   
        end,

        render_text_key = function(self,text, pos, color, size, text_font, outline, align)
            local text_size = Render.CalcTextSize(text, size, text_font)

            if align == 0 then -- To the left
                Render.Text(text, Vector2.new(pos.x - text_size.x, pos.y), color, size, text_font, outline)
            elseif align == 1 then -- To the center
                Render.Text(text, Vector2.new(pos.x - (text_size.x / 2), pos.y), color, size, text_font, outline)
            elseif align == 2 then -- To the right
                Render.Text(text, pos, color, size, text_font, outline)
            end
        end,

        run_solus_keybind = function(self)
            local v = self.g_vars.s_keybind
            if ui_get("bool",visuals.indicator_settings,7) == false then
                return
            end

            if ui_get("bool",visuals.solus_select,2) == true then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
            end
                       
            local get_n_keybind = ui_get("bool",reference.windows,1)
           
            if ui_get("bool",visuals.solus_select,2) == true then
                ui_set("bool",reference.windows,1,false)
            else
                ui_set("bool",reference.windows,1,get_n_keybind)
            end

            if EngineClient.IsConnected() then
                local x = ui_get("value",visuals.temp_keybind_x)
                local y = ui_get("value",visuals.temp_keybind_y)

                local max_width = 0
                local g_res_alpha = math_floor(255 * v.g_alpha)

                local render_container = function(x, y, w,alpha)
                    local color = ui_get("color",visuals.watermark_color)
                    local name_size = Render.CalcTextSize("keybinds", 11, FONTS.VERDANA_12_R)

                    local height = 18
                    local line_height = 1.5
             


                    self.solus_render.container(x - 66,y , w  ,18,color.r * 255,color.g * 255,color.b * 255,math_floor((color.a * 255) * alpha),1 * alpha)
                    -- render_rounded_line()
                    render_text( x - 64  + w/2 - name_size.x /2 , y + 2 + 1,FONTS.VERDANA_12_R,11,false,false,30,30,30,255 * alpha - 50,"keybinds")

                    render_text( x  - 64 + w/2 - name_size.x /2, y + 2,FONTS.VERDANA_12_R,11,false,false,255,255,255, 255 * alpha,"keybinds")
   
                end

                local binds = Cheat.GetBinds()
                local add_y = 0
                local anim_y = math_floor(v.re_anim_add_y)
                v.re_anim_add_y = lerp(v.re_anim_add_y , y,GlobalVars.frametime * 24)

                v.re_anim_y = lerp(v.re_anim_y,y,GlobalVars.frametime * 24)

                local re_anim_width = math_floor(v.re_anim_width)
                local re_anim_y = math_floor(v.re_anim_y)
                for i = 1, #binds do
                    v.anims_add_y = lerp(v.anims_add_y,13,GlobalVars.frametime * 12)


                    local bind = binds[i]
                   
                    local yaw_base = Menu.FindVar("Aimbot", "Anti Aim", "Main", "Yaw Base"):Get()
                    local isFS = yaw_base == 5
                   
                    local bind_name = bind:GetName()
                    local stringname = tostring(bind_name)
                    table.insert(v.keybinds_alpha, bind_name)
                    if v.keybinds_alpha[stringname] == nil then
                        v.keybinds_alpha[stringname] = 0
                    end
                 
                 
                    bind_name = bind_name:gsub("Double Tap", "Double tap")
                    bind_name = bind_name:gsub("Fake Duck", "Duck peek assist")
                    bind_name = bind_name:gsub("Auto Peek", "Quick peek assist")
                    bind_name = isFS and bind_name:gsub("Yaw Base", "Freestanding") or bind_name:gsub("Yaw Base", "")
                    v.real_add_y = lerp(v.real_add_y,add_y,GlobalVars.frametime * 12)
                    local add_y_r = math_floor(v.real_add_y + 0.5)

                    add_y = add_y + v.keybinds_alpha[stringname] / 20
                    add_y_r = add_y_r + math_floor(v.anims_add_y)

                    if bind_name ~= "" then

                        if bind:IsActive() then
                            v.keybinds_alpha[stringname] = lerp(
                                v.keybinds_alpha[stringname],
                                255,
                                GlobalVars.frametime * 12
                            )
                        else
                            v.keybinds_alpha[stringname] = lerp(
                                v.keybinds_alpha[stringname],
                                0,
                                GlobalVars.frametime * 12
                            )
                        end

               
                        local render_binds = function(binds, name)
                            local x = ui_get("value",visuals.temp_keybind_x)

                            local bind_state = binds:GetMode() == 1 and "[holding]" or "[toggled]"
                            local bind_name = name

                            local bind_state_size = Render.CalcTextSize(bind_state, 11, FONTS.VERDANA_12_R)
                            local bind_name_size = Render.CalcTextSize(bind_name, 11, FONTS.VERDANA_12_R)

                            local smooth_alpha = math.floor(v.keybinds_alpha[stringname] * v.g_alpha)
                            local width = math.floor(v.width)

                            v.re_anim_x = lerp(v.re_anim_x,(width - bind_state_size.x) - 5 - 25 ,GlobalVars.frametime * 24)
                            local re_anim_x = math_floor(v.re_anim_x)

                            render_text(x - 63 + 1, re_anim_y + 7 + 1 + add_y,FONTS.VERDANA_12_R,11,false,false,0,0,0,smooth_alpha - 50,bind_name)
                            render_text(x - 63, re_anim_y + 7 + add_y,FONTS.VERDANA_12_R,11,false,false,255,255,255,smooth_alpha,bind_name)

                            render_text(x + re_anim_x + 1, re_anim_y + 7  + 1+ add_y,FONTS.VERDANA_12_R,11,false,false,30,30,30,smooth_alpha - 50,bind_state)
                            render_text(x + re_anim_x, re_anim_y + 7 + add_y,FONTS.VERDANA_12_R,11,false,false,255,255,255,smooth_alpha,bind_state)
           

                            local bind_width = bind_state_size.x + bind_name_size.x
                            local length = 40

                            if bind_width > length then
                                if bind_width > max_width then
                                    max_width = bind_width
                                end
                            end
                        end
               
                        render_binds(bind, bind_name)
                    else

                        add_y = add_y - v.keybinds_alpha[stringname] / 20
                    end
                   
                end

                v.width = math.max(40, max_width)
                if not Cheat.IsMenuVisible() then
                    v.is_draggable = false
                end

                local width = math.floor(v.width)
                if Cheat.IsMenuVisible() or #binds > 0 then
                    v.container_alpha = lerp(v.container_alpha,1 * v.g_alpha,GlobalVars.frametime * 12)
                else
                    v.container_alpha = lerp(v.container_alpha,0 * v.g_alpha,GlobalVars.frametime * 12)
                end
     
                v.re_anim_width = lerp(v.re_anim_width,width +  40,GlobalVars.frametime * 24)


                render_container(x, re_anim_y,re_anim_width,v.container_alpha)

                if Cheat.IsMenuVisible() or #binds > 0 then

                    local mouse = Cheat.GetMousePos()

                    if Cheat.IsKeyDown(0x1) then
                        if not v.is_draggable then
                            if mouse.x >= x - 70 and mouse.y >= y and mouse.x <= x + width and mouse.y <= y + 18 then
                                v.is_draggable = true
                            end
                        else
                            local x_pos = x + (mouse.x - v.cursor_last_pos.x)
                            local y_pos = y + (mouse.y - v.cursor_last_pos.y)

                            ui_set("value",visuals.temp_keybind_x, math.floor(x_pos))
                            ui_set("value",visuals.temp_keybind_y, math.floor(y_pos))

                        end
                    else
                        v.is_draggable = false
                    end

                    v.cursor_last_pos = mouse
                end
            end

        end,

       get_specs = function(self)
            if not EngineClient.IsConnected() or not EngineClient.IsInGame() then
                return
            end
            local spectators = {}
            local local_player = EntityList.GetLocalPlayer()
            if not local_player then
                return
            end
            local local_player_ent_index = local_player:EntIndex()
            local local_target = bit.band(local_player:GetProp("m_hObserverTarget"), 0xFFF)
            local is_local_alive = entity_is_alive(local_player)
            for i = 1, EngineClient.GetMaxClients() do
                local entity = EntityList.GetClientEntity(i)
                if not entity then
                    goto continue
                end
                local observer = bit.band(entity:GetProp("m_hObserverTarget"), 0xFFF)
                if not observer then
                    goto continue
                end
                if is_local_alive then
                    if observer ~= local_player_ent_index then
                        goto continue
                    end
                    local player = entity:GetPlayer()
                    if not player then
                        goto continue
                    end
                    if player:IsDormant() then
                        goto continue
                    end
                    local name = player:GetName()
                    if not name then
                        goto continue
                    end
   
                    spectators[#spectators+1] ={
                        name = name,
                        id = player:EntIndex(),
                    }
                else
                    if observer ~= local_target then
                        goto continue
                    end
                    local player = entity:GetPlayer()
                    if not player then
                        goto continue
                    end
                    if player:IsDormant() then
                        goto continue
                    end
                    local name = player:GetName()
                    if not name then
                        goto continue
                    end
   
                    spectators[#spectators+1] ={
                        name = name,
                        id = player:EntIndex(),
                    }
   
                end
   
                ::continue::
            end
   
            return spectators
        end,

        run_solus_spectators = function(self)
            local global_alpha = 0
           
            local function get_steam_id_fn(ent_idx)

                local panorama_handle = Panorama.Open()
                local huy = panorama_handle.GameStateAPI.GetPlayerXuidStringFromEntIndex(ent_idx)
                return huy
           
            end


       
       
            local spec = self:get_specs()
            if spec == nil then
                return
            end


           
            local v = self.g_vars.s_spec
            if ui_get("bool",visuals.indicator_settings,7) == false then
                return
            end

           
   
                       
            local get_n_keybind = ui_get("bool",reference.windows,2)
           
            if ui_get("bool",visuals.solus_select,3) == true then
                ui_set("bool",reference.windows,2,false)
            else
                ui_set("bool",reference.windows,2,get_n_keybind)
            end

            local should_work = true
   
   
            if not spec then should_work = false goto c end
   
       
   
            if  spec   then  if #spec==0 then should_work = false end end
            if not ui_get("bool",visuals.solus_select,3) then
                should_work = false
            end
   
            ::c::
   
            if should_work or (Cheat.IsMenuVisible() and ui_get("bool",visuals.solus_select,3)) then
                v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
            else
                v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
            end

   
       
            if v.g_alpha < 0.01  then return end

            local max_size = 75
            local clamp_alpha = visuals.watermark_color:GetColor().a
            local start = {x = ui_get("value",visuals.temp_spec_x),y = ui_get("value",visuals.temp_spec_y)}
            -- local colors = ui_get("color",visuals.watermark_color)

            -- local colors = {
            --     Color.new(colors[1].r, colors[1].g, colors[1].b, colors[1].a * (v.g_alpha )),
            --     Color.new(colors[2].r, colors[2].g, colors[2].b, colors[2].a * (v.g_alpha )),
            --     Color.new(colors[3].r, colors[3].g, colors[3].b, colors[3].a * (v.g_alpha ))
            -- }
            local offset = Vector2.new(v.size.x  / 2, 2)
   
            if start.x + v.size.x/2 < sc_x/2 then
                v.spec_offset = lerp(v.spec_offset,1,GlobalVars.frametime * 12)
            else
                v.spec_offset = lerp(v.spec_offset,0,GlobalVars.frametime * 12)
            end
   
            local y_off = 0

            if spec then
               
                for i = 1 , #spec do
                    local bind = spec[i]
                    local bind_name = bind.name
                    if not v.binds[bind_name] then
                        v.binds[bind_name] = 0
                    end
   
   
   
                    v.binds[bind_name]  =  lerp(v.binds[bind_name] ,  1  , GlobalVars.frametime * 12)
   
                    if v.binds[bind_name] <0.01 then goto skip end
   
   
                    local alpha = v.binds[bind_name]
   
                    local text_size = Vector2.new(11,11)
                    local text_size2 = Render.CalcTextSize(bind_name, 11, FONTS.VERDANA_12_R) + Vector2.new(11,11)
                    local off = start.y + (y_off ) + 20
   
                 
                        Render.Texts(bind_name, Vector2.new(start.x  + 5, off), Color.new(1.0, 1.0, 1.0, alpha*v.g_alpha ), 11,  FONTS.VERDANA_12_R)
                        -- Render.Image(val , Vector2.new(start.x + (size.x - 15)*(1-v.spec_offset) + 2*v.spec_offset , off) , Vector2.new(12,12) , Color.new(1,1,1,v.g_alpha) )
               
     
               
   
   
                    if max_size < (text_size2.x)+18 then max_size = (text_size2.x+18 ) end
   
               
                    y_off =   y_off + 14
                    ::skip::
                end
            end
            local r,g,b,a = ui_get("color",visuals.watermark_color).r * 255,ui_get("color",visuals.watermark_color).g * 255,ui_get("color",visuals.watermark_color).b * 255,math_floor((ui_get("color",visuals.watermark_color).a*255) * v.g_alpha)

            v.size.x = lerp(v.size.x,max_size,GlobalVars.frametime * 12)

            -- if box_alpha~=0 then
            --     Render.BoxFilled(start, start +  kbinds.size, color(17, 17, 17, g_alpha * accent_alpha*255 * box_alpha))
            -- end
            -- if blur_alpha~=0 then
            --     local blur_col = Color.new(ui.vis.blur_bg:GetColor().r , ui.vis.blur_bg:GetColor().g, ui.vis.blur_bg:GetColor().b, g_alpha*accent_alpha * blur_alpha* ui.vis.blur_bg:GetColor().a)
            --     Render.Blur(start, start +  kbinds.size, blur_col)
            -- end
   
            -- Render.GradientBoxFilled(start, start + offset, colors[1], colors[2], colors[1], colors[2])
            -- Render.GradientBoxFilled(start + offset, start + offset + Vector2.new(offset.x, -offset.y), colors[2], colors[3], colors[2], colors[3])
            self.solus_render.container(start.x, start.y,math_floor(v.size.x) ,18,r,g,b,a,1 * v.g_alpha)
            Render.Texts("spectators", Vector2.new(start.x+ v.size.x/2  , start.y + 8), Color.new(1.0, 1.0, 1.0, v.g_alpha ), 11, FONTS.VERDANA_12_R , true)
            if Cheat.IsMenuVisible() or #spec > 0 then

                local mouse = Cheat.GetMousePos()

                if Cheat.IsKeyDown(0x1) then
                    if not v.is_draggable then
                        if mouse.x >= start.x - 70 and mouse.y >= start.y and mouse.x <= start.x + v.size.x and mouse.y <= start.y + 18 then
                            v.is_draggable = true
                        end
                    else
                        local x_pos = start.x + (mouse.x - v.cursor_last_pos.x)
                        local y_pos = start.y + (mouse.y - v.cursor_last_pos.y)

                        ui_set("value",visuals.temp_spec_x, math.floor(x_pos))
                        ui_set("value",visuals.temp_spec_y, math.floor(y_pos))

                    end
                else
                    v.is_draggable = false
                end

                v.cursor_last_pos = mouse
            end
        end,

        -- PLAYERS_INFO = {},
       
        -- getsteam_id = function(self, steamid)
        --     return string.sub(tostring(ffi.new('uint64_t', 76561197960265728) + ffi.new('uint64_t', steamid)), 1, -4)
        -- end,

        -- get_spectators = function(self,player)
        --     local buffer = { }
       
        --     local players = EntityList.GetPlayers()
        --     for tbl_idx, player_pointer in pairs(players) do
        --         if player_pointer:EntIndex() ~= player:EntIndex() then
        --             if not player_pointer:IsAlive() then
        --                 local spectatingMode = player_pointer:GetProp('m_iObserverMode')
        --                 local spectatingPlayer = player_pointer:GetProp('m_hObserverTarget')
   
        --                 if spectatingPlayer then
        --                     if spectatingMode >= 4 or spectatingMode <= 5 then
        --                         local spectatingEntity = EntityList.GetClientEntityFromHandle(spectatingPlayer)
        --                         if spectatingEntity ~= nil and spectatingEntity:EntIndex() == player:EntIndex() then
        --                             local player_info = player_pointer:GetPlayerInfo()
   
        --                             table.insert(buffer, 1, {
        --                                 ['id'] = player_info.iSteamID,
        --                                 ['id64'] = self:getsteam_id(player_info.iSteamID),
        --                                 ['name'] = player_pointer:GetName()
        --                             })
        --                         end
        --                     end
        --                 end
        --             end
        --         end
        --     end

        --     return buffer
        -- end,

        -- getspectators = function(self)
        --     if not EngineClient.IsConnected() or EngineClient.GetLocalPlayer() == nil or EntityList.GetLocalPlayer() == nil then return end
        --     local local_player = EntityList.GetLocalPlayer()
        --     if local_player == nil then return end
   
        --     if local_player:IsAlive() then
        --         return self:get_spectators(local_player:GetPlayer())
        --     else
        --         local m_hObserverTarget = local_player:GetProp('m_hObserverTarget')
        --         if m_hObserverTarget then
        --             local targetEntity = EntityList.GetClientEntityFromHandle(m_hObserverTarget)
        --             if targetEntity ~= nil and targetEntity:IsPlayer() then
        --                 return self:get_spectators(targetEntity:GetPlayer())
        --             end
        --         end
        --     end
        -- end,

        -- run_solus_spectators = function(self)

        --     local spectators = self:getspectators()

        --     if spectators ~= nil then
        --         print(spectators[1]['name'])

        --     end
           
   
        -- end,

        run_dmgind = function(self)
            -- visuals.dmgind_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display mode",{"-","+"},0,"[~] Display mode"))
            -- visuals.dmgind_pos = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display postion",{"Top left","Top right","Bottom left","Bottom light"},0,"[~] Display mode"))
            if ui_get("bool",visuals.indicator_settings,8) == true then
                local font = FONTS.VERDANA_12_R
                local x , y = 0,0
                local damage = Menu.FindVar("Aimbot", "Ragebot", "Accuracy", "Minimum Damage"):GetInt()
                local dmg = '' .. damage
                -- {"Top left","Top right","Bottom left","Bottom light"}
                if ui_get("value",visuals.dmgind_pos) == 0 then
                    x = sc_x/2 - 30
                    y = sc_y/2 - 20
                elseif ui_get("value",visuals.dmgind_pos) == 1 then
                    x = sc_x/2 + 20
                    y = sc_y/2 - 20
                elseif ui_get("value",visuals.dmgind_pos) == 2 then
                    x = sc_x/2 - 30
                    y = sc_y/2 + 20
                elseif ui_get("value",visuals.dmgind_pos) == 3 then
                    x = sc_x/2 + 20
                    y = sc_y/2 + 20
                end

                if ui_get("value",visuals.dmgind_mode) == 0 then
                    render_text(x,y,FONTS.PIXEL_10,10,true,false,255,255,255,255,dmg)
                elseif ui_get("value",visuals.dmgind_mode) == 1 then
                    render_text(x + 1,y + 1,FONTS.VERDANA_12_R,11,false,false,0,0,0,205,dmg)
                    render_text(x,y,FONTS.VERDANA_12_R,11,false,false,255,255,255,255,dmg)

                end



            end

        end,

        load_indicators = function(self)
            self:on_script_start()
            self:run_menueffect()
            self:run_watermark()
            self:run_damage_maker()
            self:run_notifications()
            self:run_solus_watermark()
            self:run_solus_keybind()
            self:run_solus_spectators()
            -- self:run_solus_spectators()
            local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
            if not localplayer then return end
         
            local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
            if not my_index then return end

            if EngineClient.IsConnected() and my_index:IsAlive() then
                if ui_get("bool",info.feature_list,1) == true then
                    self:run_arrows()
                    self:run_center()
                    self:run_scopeline()
                    self:run_dmgind()

                end
            end
        end

    }


    local updateCSA = function(thisptr, edx)
        local is_localplayer = ffi.cast("uintptr_t", thisptr) == get_entity_address(EngineClient.GetLocalPlayer())
        hooked_function(thisptr, edx)
   
        if is_localplayer then
            local addons = misc.anim_list
           
            if  addons:GetBool(2) and misc.select:GetBool(2) then
                ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[6] = 0.5
            end
   
            if  addons:GetBool(3) and misc.select:GetBool(2) then
                ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[0] = 1
                Menu.FindVar("Aimbot", "Anti Aim", "Misc", "Leg Movement"):Set(1)
            end
   
            if  addons:GetBool(1) and misc.select:GetBool(2) then
                if ffi.cast("CCSGOPlayerAnimationState_534535_t**", ffi.cast("uintptr_t", thisptr) + 0x9960)[0].bHitGroundAnimation then
                    if not is_jumping then
                        ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[12] = 0.5
                    end
                end
            end
        end
    end


    ESP.CustomText("Dormant aimbot", "enemies", "DA", function(ent)
        if g_misc.vars.is_dormant_flag then
            return "DA"
        else
            return false
        end
    end)

    local all_callbacks = {

        on_draw = function()
            g_visual:load_indicators()
        end,
   
        on_prediction = function(cmd)
            g_antiaim:load_antiaim(cmd)
            g_visual:get_desync(cmd)
            g_visual:get_fl_amount(cmd)
            g_misc:run_hitchance()
            g_misc:run_dormant_aimbot(cmd)
        end,
   
        on_pre_prediction = function(cmd)
            is_jumping = bit.band(cmd.buttons, bit.lshift(1, 1)) ~= 0
            g_antiaim:load_pre_antiaim(cmd)

        end,

        register_shot = function(e)
            g_misc:run_hitlog(e)
        end,

        on_create_move = function()
            local local_player = EntityList.GetLocalPlayer()
            if not local_player then return end

            local local_player_ptr = get_entity_address(local_player:EntIndex())
            if not local_player_ptr or hooked_function then return end

            local C_CSPLAYER = vmt_hook.new(local_player_ptr)
            hooked_function = C_CSPLAYER.hookMethod("void(__fastcall*)(void*, void*)", updateCSA, 224)
        end,

        on_destory = function()
            for i, unHookFunc in ipairs(vmt_hook.hooks) do
                unHookFunc()
            end
            for i, free in ipairs(buff.free) do
                free()
            end
        end,

        on_event = function(events)
            g_misc:load_events(events)
           
        end,
   
        __call = function(self)
            EngineClient.ExecuteClientCmd("clear")
            print(cat)
            local d = 0
            for k, v in pairs(menu.callback_data) do
                ui_set_callback(v,g_menu.visible_data)
                d = k
            end
            debugger("invoked ui callback: "..d)
        end,
   

        load_callbacks = function(self)
           
            self:__call()
            if not ui_get("value",info.master_switch) then
                return
            end
            client_set_event_callback("draw",self.on_draw)
            client_set_event_callback("prediction",self.on_prediction)
            client_set_event_callback("pre_prediction",self.on_pre_prediction)
            client_set_event_callback("createmove",self.on_create_move)
            client_set_event_callback("destroy",self.on_destory)
            client_set_event_callback("events",self.on_event)
            client_set_event_callback("registered_shot",self.register_shot)

        end
    }
   
    all_callbacks:load_callbacks()
end

_ataraxia_()
что-то интересное есть?
 
Олдфаг
Статус
Оффлайн
Регистрация
28 Дек 2018
Сообщения
2,583
Реакции[?]
1,439
Поинты[?]
0
когда слив аситеч
 
Начинающий
Статус
Оффлайн
Регистрация
16 Мар 2022
Сообщения
62
Реакции[?]
5
Поинты[?]
1K
скоро слив аситеч?
 
Сверху Снизу