Crack Lua Cyrax.tech

[znez]

local bit = require("bit")
local ffi = require("ffi")
local clipboard = require("neverlose/clipboard")
local base64 = require("neverlose/base64")
local aantiaim = require("neverlose/anti_aim")
local color_p = require("neverlose/color_print")
local texts = render.measure_text
local beta = 'Debug' -- 'Debug' or 'Beta' or 'Live'
local username = common.get_username() -- getting cheat username pls elleqt allow me
local callbacks = {}
local func = {}
local tbl = {}
local str = 'Cyrax.Tech'
local yawbases = {
    Forward = 180,
    Left = -90,
    Right = 90,
    Backward = 0,
}
ffi.cdef[[
    
    typedef struct
    {
        float x;
        float y;
        float z;
    } Vector_t;

    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
    {
        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;

    ]]
local log = {}
local cyraxUI = {}
local conditional_aa = {}
conditional_aa.pitch = ui.find("Aimbot", "Anti Aim", "Angles", "Pitch")
conditional_aa.yawbase = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw")
conditional_aa.yawadd = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset")
conditional_aa.yawmodifier = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier")
conditional_aa.modifierdegree = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier", "Offset")
conditional_aa.fakelimitleft = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Left Limit")
conditional_aa.fakelimitright = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Right Limit")
conditional_aa.fakeoptions = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Options")
conditional_aa.lbymode = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "LBY Mode")
conditional_aa.freestandingdesync = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Freestanding")
conditional_aa.desynconshot = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "On Shot")
conditional_aa.slow_walk = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk")
conditional_aa.legmovement = ui.find("Aimbot", "Anti Aim", "Misc", "Leg Movement")
conditional_aa.freestanding = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding")
conditional_aa.freestanding_setts = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding", "Disable Yaw Modifiers")

local urlmon = ffi.load 'UrlMon'
local wininet = ffi.load 'WinInet'

function func:lerp(a, b, t)
    return a + (b - a) * t
end
local solus_lerp = function(time,a,b)
    return a * (1-time) + b * time
end

panorama.loadstring([[
    return {
        asdstringify: JSON.stringify,
        asdparse: JSON.parse
    };
]], "CSGOMainMenu")()

ffi.cdef[[
    void* __stdcall URLDownloadToFileA(void* LPUNKNOWN, const char* LPCSTR, const char* LPCSTR2, int a, int LPBINDSTATUSCALLBACK);

    bool DeleteUrlCacheEntryA(const char* lpszUrlName);
]]

function func:contains(list, x)
    for _, v in pairs(list) do
        if v == x then return true end
    end
    return false
end
function func:get_neverlose_path()
    return common.get_game_directory():sub(1, -5) .. "nl\\"
end
files.create_folder(common.get_game_directory().."\\sound\\cyrax\\")
function func:Download(from, to)
    wininet.DeleteUrlCacheEntryA(from)
    urlmon.URLDownloadToFileA(nil, from, to, 0,0)
end
function func:file_exists(file, path_id)
    local func_file_exists = ffi.cast("bool (__thiscall*)(void*, const char*, const char*)", ffi.cast(ffi.typeof("void***"), utils.create_interface("filesystem_stdio.dll", "VBaseFileSystem011"))[0][10])
    return func_file_exists(ffi.cast(ffi.typeof("void***"), utils.create_interface("filesystem_stdio.dll", "VBaseFileSystem011")), file, path_id)
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\skeet.tff", "GAME") then
    func:Download('https://github.com/fakeangle/neverlose_bettervisuals/blob/main/Small_Fonts.ttf?raw=true', func:get_neverlose_path().."Cyrax\\skeet.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\smallest.tff", "GAME") then
    func:Download('https://github.com/fakeangle/neverlose_bettervisuals/blob/main/smallest_pixel-7.ttf?raw=true', func:get_neverlose_path().."Cyrax\\smallest.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\code_bold.tff", "GAME") then
    func:Download('https://github.com/lordcristi/whatisthis/blob/main/CODE%20Bold.ttf?raw=true', func:get_neverlose_path().."Cyrax\\code_bold.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\cyrax1.gif", "GAME") then
    func:Download('https://raw.githubusercontent.com/lordcristi/whatisthis/main/21.gif', func:get_neverlose_path().."Cyrax\\cyrax1.gif")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\funny_dog.png", "GAME") then
    func:Download('https://raw.githubusercontent.com/lordcristi/whatisthis/main/shaved_cat.png', func:get_neverlose_path().."Cyrax\\funny_dog.png")
end

files.create_folder(func:get_neverlose_path().."Cyrax\\")

local vars = {
    font = {
        pixel = render.load_font(func:get_neverlose_path().."Cyrax\\smallest.tff", 10, 'o'),
        verdana = render.load_font("Verdana", 11),
        verdana_r = render.load_font("Verdana", 11, 'a'),
        calibri = render.load_font("Calibri", 16, 'b'),
        calibri_dog = render.load_font(func:get_neverlose_path().."Cyrax\\code_bold.tff", 35),
        calibri_dog2 = render.load_font(func:get_neverlose_path().."Cyrax\\code_bold.tff", 10),
        skeet = render.load_font(func:get_neverlose_path().."Cyrax\\skeet.tff", 11, 'o')},
    menu = {
        thirdperson = ui.find("Visuals", "World", "Main", "Force Thirdperson"),
        dt = ui.find("Aimbot", "Ragebot", "Main", "Double Tap"),
        hs = ui.find("Aimbot", "Ragebot", "Main", "Hide Shots"),
        fd = ui.find("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
        fs = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"),
        remove_scope = ui.find("Visuals", "World", "Main", "Override Zoom", "Scope Overlay"),
        qp = ui.find("Aimbot", "Ragebot", "Main", "Peek Assist"),
        sw = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk"),
        fl = ui.find("Aimbot", "Anti Aim", "Fake Lag", "Enabled"),
        body = ui.find("Aimbot", "Ragebot", "Safety", "Body Aim"),
        sp = ui.find("Aimbot", "Ragebot", "Safety", "Safe Points")
    },
    da = {
        [1] = true,
        [2] = true,
        [3] = true,
        [4] = true
    },
    sus = {
        [1] = 40,
        [2] = 31,
        [3] = 9,
        [4] = 1
    },
    ind = {
        fs_alpha = 0,
        dt_alpha = 0,
        dmg_alpha = 0,
        dt_bar_alpha = 0,
        hs_pos = 0,
        dmg_pos = 0,
        dmg_val = 0,
        smooth = 0,
        scope_smooth = 2,
        legacy_check = false,
        v2 = {
            a = {           
                [1] = {
                    0,
                    0,
                    0,
                },
                [2] = 0,
                [3] = 0,
                [4] = 0,
            },
            p = {           
                [1] = 40,
                [2] = 40,
                [3] = 40,
            },
            cond_text = "amingus"
        },
        lavendu = {
            textu = "",
            anim = {
                [1] = {
                    dt = 0,
                    fs = 0,
                },
                [2] = {
                    dt = 0,
                    fs = 0,
                },
                [3] = {
                    [1] = 0,
                    [2] = 0,
                    [3] = 0,
                },
            },
            chestie = 0,
        },
    },
    mark = {
        
    },
    pi_divided = math.pi / 180,
}

function func:version()
    return beta
end

local function IsPlayer(player)
    if not player then return false end
    if not player:is_bot() then return true end
end

function func:CanSee(self, entity)
    if not entity then return false end
    if IsPlayer(entity) then return false end

    local hitboxes = {0, 5, 7, 8, 11, 12, 13, 14, 15, 17}

    for i, hitbox in pairs(hitboxes) do
        local trace = utils.trace_line(self:get_eye_position(), entity:get_hitbox_position(hitbox), self, 0x4600400B)
        if trace.hit_entity then
            return IsPlayer(trace.hit_entity)
        end
    end
    return false
end
color_p("cyrax - ", color(255,255,255,255))
color_p("information \n", color(222, 194, 153, 255))
color_p("version - ", color(255,255,255,255))
color_p(string.lower(func:version().."\n"), color(222, 194, 153, 255))
color_p("username - ", color(255,255,255,255))
color_p(username.."\n", color(222, 194, 153, 255))
color_p("discord server - ", color(255,255,255,255))
color_p("https://discord.gg/R5VrugTNbg\n", color(222, 194, 153, 255))

local group = {
    info = {
        gif = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", ""),
        info = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\aFFD5BBFFInformation"),
        cfg = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\aFFD5BBFFConfigs"),
        misc = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\aFFD5BBFFMisc"),
    },
    aa = {
        aa = ui.create("\aFFD5BBFFAnti-Aim", "Anti-Aim"),
        conditions = {
            standing = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFStanding"),
            crouching = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFCrouching"),
            slowwalk = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFSlowwalk"),
            moving = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFMoving"),
            in_air = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFIn Air"),
            in_air_d = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFIn Air + Duck"),
        },
    },
    settings = {
        visuals = ui.create("\affd5bbffS\affdbc5ffe\affe1cefft\affe7d8fft\affede2ffi\afff3ecffn\afff9f5ffg\affffffffs", "Visuals"),
        misc = ui.create("\affd5bbffS\affdbc5ffe\affe1cefft\affe7d8fft\affede2ffi\afff3ecffn\afff9f5ffg\affffffffs", "Miscellaneous"),
    },
}
print_dev("Cyrax - Welcome, "..username..".")
-- INFORMATION
local gif = render.load_image_from_file(func:get_neverlose_path().."Cyrax\\cyrax1.gif", vector(540, 540))
local dog = render.load_image_from_file(func:get_neverlose_path().."Cyrax\\funny_dog.png", vector(828, 828))
group.info.gif:texture(gif,vector(270, 270), color(255, 255, 255), 'f')
group.info.info:label("User: \aFFD5BBFF"..username)
group.info.info:label("Build: \aFFD5BBFF"..func:version())
group.info.info:label("If you have any issues open a ticket in the discord server or message \aFFD5BBFFcomezo#2441")
group.info.cfg:button("Discord Link", function() panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://discord.gg/R5VrugTNbg") end, true)
group.info.cfg:button("Neverlose Config", function() panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://en.neverlose.cc/market/item?id=yXbDoa") end, true)
local anim_switch = group.info.misc:switch("Loading Animation", true)
local funny_dog = group.info.misc:switch("Funny Dog", true)
local smooth = {0, 0, 0}
function func:funnydog()
    local screen = render.screen_size()

    if funny_dog:get() then
        smooth[1] = func:lerp(smooth[1], 150, globals.frametime * 5)
        smooth[3] = func:lerp(smooth[3], ui.get_position().y - 125, globals.frametime * 5)
    else
        smooth[1] = func:lerp(smooth[1], 0, globals.frametime * 5)
        smooth[3] = func:lerp(smooth[3], screen.y, globals.frametime * 5)
    end
    smooth[2] = func:lerp(smooth[2], ui.get_position().x - 20, globals.frametime * 5)

    render.texture(dog, vector(smooth[2], smooth[3]), vector(smooth[1], smooth[1]), color(255, 255, 255,  smooth[1]*1.7), 'f')

end
local menu_cyrax = {
    visuals_switch = {
        _ = group.settings.visuals:switch("\aFFD5BBFFEnable Visual Options", false),
        name = "visuals_switch",
        element = "switch"
    },
    indicators_switch = {
        _ = group.settings.visuals:switch("Indicators", false),
        name = "indicators_switch",
        element = "switch"
    },
    watermark_switch = {
        _ = group.settings.visuals:switch("Watermark", false),
        name = "watermark_switch",
        element = "switch"
    },
    scope_switch = {
        _ = group.settings.visuals:switch("Custom Scope", false),
        name = "scope_switch",
        element = "switch"
    },
    logs_switch = {
        _ = group.settings.visuals:switch("Aimbot Logging", false),
        name = "logs_switch",
        element = "switch"
    },
    solus_switch = {
        _ = group.settings.visuals:switch("Widgets", false),
        name = "solus_switch",
        element = "switch"
    },
    misc_switch = {
        _ = group.settings.misc:switch("\aFFD5BBFFEnable Miscellaneous Options", false),
        name = "misc_switch",
        element = "switch"
    },
    jumpscout_switch = {
        _ = group.settings.misc:switch("Jumpscout Fix", false),
        name = "jumpscout_switch",
        element = "switch"
    },
    killsay_switch = {
        _ = group.settings.misc:switch("Killsay", false),
        name = "killsay_switch",
        element = "switch"
    },
    animbreaker_switch = {
        _ = group.settings.misc:switch("Anim. Breaker", false),
        name = "animbreaker_switch",
        element = "switch"
    }
}
local data = {

    YawBase_Standing = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_Crouching = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_Slowwalk = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_Moving = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_InAir = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_InAirDuck = {"Forward", "Backward", "Right", "Left", "At Target"},

    Pitch_Standing = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_Crouching = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_Slowwalk = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_Moving = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_InAir = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_InAirDuck = {"Disabled", "Down", "Fake Down", "Fake Up"},

    YawModifier_Standing = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_Crouching = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_Slowwalk = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_Moving = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_InAir = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_InAirDuck = {"Disabled", "Center", "Offset", "Random", "Spin"},

    YawModifierType_Standing = {"Default", "Random"},
    YawModifierType_Crouching = {"Default", "Random"},
    YawModifierType_Slowwalk = {"Default", "Random"},
    YawModifierType_Moving = {"Default", "Random"},
    YawModifierType_InAir = {"Default", "Random"},
    YawModifierType_InAirDuck = {"Default", "Random"},

    FakeLimitType_Standing = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_Crouching = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_Slowwalk = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_Moving = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_InAir = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_InAirDuck = {"Static", "Jitter", "Random Jitter"},

    FakeOptions_Standing = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_Crouching = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_Slowwalk = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_Moving = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_InAir = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_InAirDuck = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},

    LBYMode_Standing = {"Disabled", "Opposite", "Sway"},
    LBYMode_Crouching = {"Disabled", "Opposite", "Sway"},
    LBYMode_Slowwalk = {"Disabled", "Opposite", "Sway"},
    LBYMode_Moving = {"Disabled", "Opposite", "Sway"},
    LBYMode_InAir = {"Disabled", "Opposite", "Sway"},
    LBYMode_InAirDuck = {"Disabled", "Opposite", "Sway"},

    FreestandingDesync_Standing = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_Crouching = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_Slowwalk = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_Moving = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_InAir = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_InAirDuck = {"Off", "Peek Fake", "Peek Real"},

    DesyncOnShot_Standing = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_Crouching = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_Slowwalk = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_Moving = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_InAir = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_InAirDuck = {"Disabled", "Opposite", "Freestanding", "Switch"},

    indicators_styles = {"Cyrax", "Cyrax V2", "Cyrax V3", "Cyrax V4"},

    sparg = {"Static Legs In Air", "Leg Breaker"},

}
local menu_aa = {

    Switch_AntiAim = {
        _ = group.aa.aa:switch("\aFFD5BBFFEnable Custom Anti Aim", false),
        name = "Switch_AntiAim",
        element = "switch"
    },

    --YAW BASE
    
    YawBase_Standing = {
        _ = group.aa.conditions.standing:combo("Yaw Base", data.YawBase_Standing, 0),
        name = "YawBase_Standing",
        element = "combo"
    },
    YawBase_Crouching = {
        _ = group.aa.conditions.crouching:combo("Yaw Base", data.YawBase_Crouching, 0),
        name = "YawBase_Crouching",
        element = "combo"
    },
    YawBase_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Yaw Base", data.YawBase_Slowwalk, 0),
        name = "YawBase_Slowwalk",
        element = "combo"
    },
    YawBase_Moving = {
        _ = group.aa.conditions.moving:combo("Yaw Base", data.YawBase_Moving, 0),
        name = "YawBase_Moving",
        element = "combo"
    },
    YawBase_InAir = {
        _ = group.aa.conditions.in_air:combo("Yaw Base", data.YawBase_InAir, 0),
        name = "YawBase_InAirDuck",
        element = "combo"
    },
    YawBase_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Yaw Base", data.YawBase_InAirDuck, 0),
        name = "YawBase_InAirDuck",
        element = "combo"
    },
    
    --YAW ADD LEFT
    
    YawAddLeft_Standing = {
        _ = group.aa.conditions.standing:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Standing",
        element = "slider"
    },
    YawAddLeft_Crouching = {
        _ = group.aa.conditions.crouching:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Crouching",
        element = "slider"
    },
    YawAddLeft_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Slowwalk",
        element = "slider"
    },
    YawAddLeft_Moving = {
        _ = group.aa.conditions.moving:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Moving",
        element = "slider"
    },
    YawAddLeft_InAir = {
        _ = group.aa.conditions.in_air:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_InAir",
        element = "slider"
    },
    YawAddLeft_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_InAirDuck",
        element = "slider"
    },
    
    --YAW ADD RIGHT
    
    YawAddRight_Standing = {
        _ = group.aa.conditions.standing:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Standing",
        element = "slider"
    },
    YawAddRight_Crouching = {
        _ = group.aa.conditions.crouching:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Crouching",
        element = "slider"
    },
    YawAddRight_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Slowwalk",
        element = "slider"
    },
    YawAddRight_Moving = {
        _ = group.aa.conditions.moving:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Moving",
        element = "slider"
    },
    YawAddRight_InAir = {
        _ = group.aa.conditions.in_air:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_InAir",
        element = "slider"
    },
    YawAddRight_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_InAirDuck",
        element = "slider"
    },
    
    --PITCH
    
    Pitch_Standing = {
        _ = group.aa.conditions.standing:combo("Pitch", data.Pitch_Standing, 0),
        name = "Pitch_Standing",
        element = "combo"
    },
    Pitch_Crouching = {
        _ = group.aa.conditions.crouching:combo("Pitch", data.Pitch_Crouching, 0),
        name = "Pitch_Crouching",
        element = "combo"
    },
    Pitch_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Pitch", data.Pitch_Slowwalk, 0),
        name = "Pitch_Slowwalk",
        element = "combo"
    },
    Pitch_Moving = {
        _ = group.aa.conditions.moving:combo("Pitch", data.Pitch_Moving, 0),
        name = "Pitch_Moving",
        element = "combo"
    },
    Pitch_InAir = {
        _ = group.aa.conditions.in_air:combo("Pitch", data.Pitch_InAir, 0),
        name = "Pitch_InAir",
        element = "combo"
    },
    Pitch_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Pitch", data.Pitch_InAirDuck, 0),
        name = "Pitch_InAirDuck",
        element = "combo"
    },
    
    --YAW MODIFIER
    
    YawModifier_Standing = {
        _ = group.aa.conditions.standing:combo("Yaw Modifier", data.YawModifier_Standing, 0),
        name = "YawModifier_Standing",
        element = "combo"
    },       
    YawModifier_Crouching = {
        _ = group.aa.conditions.crouching:combo("Yaw Modifier", data.YawModifier_Crouching, 0),
        name = "YawModifier_Crouching",
        element = "combo"
    },       
    YawModifier_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Yaw Modifier", data.YawModifier_Slowwalk, 0),
        name = "YawModifier_Slowwalk",
        element = "combo"
    },       
    YawModifier_Moving = {
        _ = group.aa.conditions.moving:combo("Yaw Modifier", data.YawModifier_Moving, 0),
        name = "YawModifier_Moving",
        element = "combo"
    },
    YawModifier_InAir = {
        _ = group.aa.conditions.in_air:combo("Yaw Modifier", data.YawModifier_InAir, 0),
        name = "YawModifier_InAir",
        element = "combo"
    },
    YawModifier_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Yaw Modifier", data.YawModifier_InAirDuck, 0),
        name = "YawModifier_InAirDuck",
        element = "combo"
    },
    
    --YAW MODIFIER TYPE
    
    YawModifierType_Standing = {
        _ = group.aa.conditions.standing:combo("Yaw Modifier Type", data.YawModifierType_Standing, 0),
        name = "YawModifierType_Standing",
        element = "combo"
    },       
    YawModifierType_Crouching = {
        _ = group.aa.conditions.crouching:combo("Yaw Modifier Type", data.YawModifierType_Crouching, 0),
        name = "YawModifierType_Crouching",
        element = "combo"
    },       
    YawModifierType_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Yaw Modifier Type", data.YawModifierType_Slowwalk, 0),
        name = "YawModifierType_Slowwalk",
        element = "combo"
    },       
    YawModifierType_Moving = {
        _ = group.aa.conditions.moving:combo("Yaw Modifier Type", data.YawModifierType_Moving, 0),
        name = "YawModifierType_Moving",
        element = "combo"
    },
    YawModifierType_InAir = {
        _ = group.aa.conditions.in_air:combo("Yaw Modifier Type", data.YawModifierType_InAir, 0),
        name = "YawModifierType_InAir",
        element = "combo"
    },
    YawModifierType_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Yaw Modifier Type", data.YawModifierType_InAirDuck, 0),
        name = "YawModifierType_InAirDuck",
        element = "combo"
    },
    
    --MODIFIER DEGREE   
    
    ModifierDegree_Standing = {
        _ = group.aa.conditions.standing:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Standing",
        element = "slider"
    },
    ModifierDegree_Crouching = {
        _ = group.aa.conditions.crouching:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Crouching",
        element = "slider"
    },
    ModifierDegree_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Slowwalk",
        element = "slider"
    },
    ModifierDegree_Moving = {
        _ = group.aa.conditions.moving:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Moving",
        element = "slider"
    },
    ModifierDegree_InAir = {
        _ = group.aa.conditions.in_air:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_InAir",
        element = "slider"
    },
    ModifierDegree_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_InAirDuck",
        element = "slider"
    },
    
    --MODIFIER DEGREE MINMINUM
    
    ModifierDegreeMin_Standing = {
        _ = group.aa.conditions.standing:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Standing",
        element = "slider"
    },
    ModifierDegreeMin_Crouching = {
        _ = group.aa.conditions.crouching:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Crouching",
        element = "slider"
    },
    ModifierDegreeMin_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Slowwalk",
        element = "slider"
    },
    ModifierDegreeMin_Moving = {
        _ = group.aa.conditions.moving:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Moving",
        element = "slider"
    },
    ModifierDegreeMin_InAir = {
        _ = group.aa.conditions.in_air:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_InAir",
        element = "slider"
    },
    ModifierDegreeMin_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_InAirDuck",
        element = "slider"
    },
    
    --MODIFIER DEGREE MAXIMUM
    
    ModifierDegreeMax_Standing = {
        _ = group.aa.conditions.standing:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Standing",
        element = "slider"
    },
    ModifierDegreeMax_Crouching = {
        _ = group.aa.conditions.crouching:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Crouching",
        element = "slider"
    },
    ModifierDegreeMax_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Slowwalk",
        element = "slider"
    },
    ModifierDegreeMax_Moving = {
        _ = group.aa.conditions.moving:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Moving",
        element = "slider"
    },
    ModifierDegreeMax_InAir = {
        _ = group.aa.conditions.in_air:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_InAir",
        element = "slider"
    },
    ModifierDegreeMax_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_InAirDuck",
        element = "slider"
    },
    
    --FAKE LIMIT TYPE
    
    FakeLimitType_Standing = {
        _ = group.aa.conditions.standing:combo("Fake Limit Type", data.FakeLimitType_Standing, 0),
        name = "FakeLimitType_Standing",
        element = "combo"
    },
    FakeLimitType_Crouching = {
        _ = group.aa.conditions.crouching:combo("Fake Limit Type", data.FakeLimitType_Crouching, 0),
        name = "FakeLimitType_Crouching",
        element = "combo"
    },
    FakeLimitType_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Fake Limit Type", data.FakeLimitType_Slowwalk, 0),
        name = "FakeLimitType_Slowwalk",
        element = "combo"
    },
    FakeLimitType_Moving = {
        _ = group.aa.conditions.moving:combo("Fake Limit Type", data.FakeLimitType_Moving, 0),
        name = "FakeLimitType_Moving",
        element = "combo"
    },
    FakeLimitType_InAir = {
        _ = group.aa.conditions.in_air:combo("Fake Limit Type", data.FakeLimitType_InAir, 0),
        name = "FakeLimitType_InAir",
        element = "combo"
    },
    FakeLimitType_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Fake Limit Type", data.FakeLimitType_InAirDuck, 0),
        name = "FakeLimitType_InAirDuck",
        element = "combo"
    },
    
    --LEFT LIMIT
    
    LeftLimit_Standing = {
        _ = group.aa.conditions.standing:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Standing",
        element = "slider"
    },
    LeftLimit_Crouching = {
        _ = group.aa.conditions.crouching:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Crouching",
        element = "slider"
    },
    LeftLimit_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Slowwalk",
        element = "slider"
    },
    LeftLimit_Moving = {
        _ = group.aa.conditions.moving:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Moving",
        element = "slider"
    },
    LeftLimit_InAir = {
        _ = group.aa.conditions.in_air:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_InAir",
        element = "slider"
    },
    LeftLimit_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_InAirDuck",
        element = "slider"
    },
    
    --RIGHT LIMIT
    
    RightLimit_Standing = {
        _ = group.aa.conditions.standing:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Standing",
        element = "slider"
    },
    RightLimit_Crouching = {
        _ = group.aa.conditions.crouching:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Crouching",
        element = "slider"
    },
    RightLimit_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Slowwalk",
        element = "slider"
    },
    RightLimit_Moving = {
        _ = group.aa.conditions.moving:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Moving",
        element = "slider"
    },
    RightLimit_InAir = {
        _ = group.aa.conditions.in_air:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_InAir",
        element = "slider"
    },
    RightLimit_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_InAirDuck",
        element = "slider"
    },
    
    --FAKE OPTIONS
    
    FakeOptions_Standing = {
        _ = group.aa.conditions.standing:selectable("Fake Options", data.FakeOptions_Standing, 0),
        name = "FakeOptions_Standing",
        element = "selectable"
    },
    FakeOptions_Crouching = {
        _ = group.aa.conditions.crouching:selectable("Fake Options", data.FakeOptions_Crouching, 0),
        name = "FakeOptions_Crouching",
        element = "selectable"
    },
    FakeOptions_Slowwalk = {
        _ = group.aa.conditions.slowwalk:selectable("Fake Options", data.FakeOptions_Slowwalk, 0),
        name = "FakeOptions_Slowwalk",
        element = "selectable"
    },
    FakeOptions_Moving = {
        _ = group.aa.conditions.moving:selectable("Fake Options", data.FakeOptions_Moving, 0),
        name = "FakeOptions_Moving",
        element = "selectable"
    },
    FakeOptions_InAir = {
        _ = group.aa.conditions.in_air:selectable("Fake Options", data.FakeOptions_InAir, 0),
        name = "FakeOptions_InAir",
        element = "selectable"
    },
    FakeOptions_InAirDuck = {
        _ = group.aa.conditions.in_air_d:selectable("Fake Options", data.FakeOptions_InAirDuck, 0),
        name = "FakeOptions_InAirDuck",
        element = "selectable"
    },
    
    --LBY MODE
    
    LBYMode_Standing = {
        _ = group.aa.conditions.standing:combo("LBY Mode", data.LBYMode_Standing, 0),
        name = "LBYMode_Standing",
        element = "combo",
    },
    LBYMode_Crouching = {
        _ = group.aa.conditions.crouching:combo("LBY Mode", data.LBYMode_Crouching, 0),
        name = "LBYMode_Crouching",
        element = "combo",
    },
    LBYMode_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("LBY Mode", data.LBYMode_Slowwalk, 0),
        name = "LBYMode_Slowwalk",
        element = "combo",
    },
    LBYMode_Moving = {
        _ = group.aa.conditions.moving:combo("LBY Mode", data.LBYMode_Moving, 0),
        name = "LBYMode_Moving",
        element = "combo",
    },
    LBYMode_InAir = {
        _ = group.aa.conditions.in_air:combo("LBY Mode", data.LBYMode_InAir, 0),
        name = "LBYMode_InAir",
        element = "combo",
    },
    LBYMode_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("LBY Mode", data.LBYMode_InAirDuck, 0),
        name = "LBYMode_InAirDuck",
        element = "combo",
    },
    
    --FREESTANDING DESYNC
    
    FreestandingDesync_Standing = {
        _ = group.aa.conditions.standing:combo("Freestanding Desync", data.FreestandingDesync_Standing, 0),
        name = "FreestandingDesync_Standing",
        element = "combo",
    },
    FreestandingDesync_Crouching = {
        _ = group.aa.conditions.crouching:combo("Freestanding Desync", data.FreestandingDesync_Crouching, 0),
        name = "FreestandingDesync_Crouching",
        element = "combo",
    },
    FreestandingDesync_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Freestanding Desync", data.FreestandingDesync_Slowwalk, 0),
        name = "FreestandingDesync_Slowwalk",
        element = "combo",
    },
    FreestandingDesync_Moving = {
        _ = group.aa.conditions.moving:combo("Freestanding Desync", data.FreestandingDesync_Moving, 0),
        name = "FreestandingDesync_Moving",
        element = "combo",
    },
    FreestandingDesync_InAir = {
        _ = group.aa.conditions.in_air:combo("Freestanding Desync", data.FreestandingDesync_InAir, 0),
        name = "FreestandingDesync_InAir",
        element = "combo",
    },
    FreestandingDesync_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Freestanding Desync", data.FreestandingDesync_InAirDuck, 0),
        name = "FreestandingDesync_InAirDuck",
        element = "combo",
    },
    
    --DESYNC ON SHOT
        
    DesyncOnShot_Standing = {
        _ = group.aa.conditions.standing:combo("Desync On Shot", data.DesyncOnShot_Standing, 0),
        name = "DesyncOnShot_Standing",
        element = "combo",
    },       
    DesyncOnShot_Crouching = {
        _ = group.aa.conditions.crouching:combo("Desync On Shot", data.DesyncOnShot_Crouching, 0),
        name = "DesyncOnShot_Crouching",
        element = "combo",
    },       
    DesyncOnShot_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Desync On Shot", data.DesyncOnShot_Slowwalk, 0),
        name = "DesyncOnShot_Slowwalk",
        element = "combo",
    },   
    DesyncOnShot_Moving = {
        _ = group.aa.conditions.moving:combo("Desync On Shot", data.DesyncOnShot_Moving, 0),
        name = "DesyncOnShot_Moving",
        element = "combo",
    },
    DesyncOnShot_InAir = {
        _ = group.aa.conditions.in_air:combo("Desync On Shot", data.DesyncOnShot_InAir, 0),
        name = "DesyncOnShot_InAir",
        element = "combo",
    },
    DesyncOnShot_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Desync On Shot", data.DesyncOnShot_InAirDuck, 0),
        name = "DesyncOnShot_InAirDuck",
        element = "combo",
    },
}
local override_yaw = group.aa.aa:combo("Override Yaw Base", {'Disabled', 'Forward', 'Left', 'Right', 'Backward'})
local conditions = group.aa.aa:combo("Current Condition", {'Standing', 'Crouching', 'Slowwalk', 'Moving', 'In Air', 'In Air + Duck'})
local gear = {
    indicators = menu_cyrax.indicators_switch._:create(),
    wm = menu_cyrax.watermark_switch._:create(),
    scope = menu_cyrax.scope_switch._:create(),
    logs = menu_cyrax.logs_switch._:create(),
    aa = menu_aa.Switch_AntiAim._:create(),
    anim = menu_cyrax.animbreaker_switch._:create(),
    solus = menu_cyrax.solus_switch._:create(),
}

local gear_opt = {
    indicators_type = gear.indicators:combo('', data.indicators_styles),
    indicators_color = gear.indicators:color_picker('Color', color(194, 187, 250, 255)),
    animate = gear.wm:switch('Animate', false),
    wm_color = gear.wm:color_picker('Color', color(194, 187, 250, 255)),
    wm_color2 = gear.wm:color_picker('Color', color(255, 255, 255, 255)),
    t_style = gear.scope:switch('T Style', false),
    scope_color1 = gear.scope:color_picker('Color #1', color(255, 255, 255 ,255)),
    scope_color2 = gear.scope:color_picker('Color #2', color(0, 0, 0, 0)),
    scope_length = gear.scope:slider('Length', 0, 360, 100),
    scope_offset = gear.scope:slider('Offset', 0, 100, 5),
    screen_logs = gear.logs:switch('On Screen', false),
    logs_hit = gear.logs:color_picker('Color on Hit', color(210, 206, 242)),
    logs_miss = gear.logs:color_picker('Color on Miss', color(210, 206, 242)),
    logs_miss_what = gear.logs:color_picker('Color on Miss', color(255, 255, 255, 255)),
    export = gear.aa:button('Export', true),
    import = gear.aa:button('Import', true),
    default = gear.aa:button('Default Settings', true),
    anim = gear.anim:selectable('', {'Static Legs', 'Leg Breaker'}),
    solus_binds = gear.solus:switch('Keybinds', false),
    solus_watermark = gear.solus:switch('Watermark', false),
    solus_clr = gear.solus:color_picker('Color', color(210, 206, 242, 122)),
    solus_1 = gear.solus:slider('xaxaxa', 0, render.screen_size().x, 120),
    solus_2 = gear.solus:slider('xaxaxa', 0, render.screen_size().x, 120),
}
gear_opt.solus_1:set_visible(false)
gear_opt.solus_2:set_visible(false)

function cyraxUI.visibility()

    if menu_cyrax.visuals_switch._:get() then
        menu_cyrax.indicators_switch._:set_visible(true)
        menu_cyrax.scope_switch._:set_visible(true)
        menu_cyrax.logs_switch._:set_visible(true)
        menu_cyrax.solus_switch._:set_visible(true)
        menu_cyrax.watermark_switch._:set_visible(true)
    else
        menu_cyrax.indicators_switch._:set_visible(false)
        menu_cyrax.scope_switch._:set_visible(false)
        menu_cyrax.logs_switch._:set_visible(false)
        menu_cyrax.solus_switch._:set_visible(false)
        menu_cyrax.watermark_switch._:set_visible(false)
    end

    if menu_cyrax.misc_switch._:get() then
        menu_cyrax.jumpscout_switch._:set_visible(true)
        menu_cyrax.killsay_switch._:set_visible(true)
        menu_cyrax.animbreaker_switch._:set_visible(true)
    else
        menu_cyrax.jumpscout_switch._:set_visible(false)
        menu_cyrax.killsay_switch._:set_visible(false)
        menu_cyrax.animbreaker_switch._:set_visible(false)
    end

    if menu_aa.Switch_AntiAim._:get() then
        override_yaw:set_visible(true)
        conditions:set_visible(true)

        if conditions:get() == 'Standing' then
            menu_aa.Pitch_Standing._:set_visible(true)
            menu_aa.YawBase_Standing._:set_visible(true)
            menu_aa.YawModifier_Standing._:set_visible(true)
            menu_aa.FakeLimitType_Standing._:set_visible(true)
            menu_aa.FakeOptions_Standing._:set_visible(true)
            menu_aa.LBYMode_Standing._:set_visible(true)
            menu_aa.FreestandingDesync_Standing._:set_visible(true)
            menu_aa.DesyncOnShot_Standing._:set_visible(true)
            menu_aa.YawAddLeft_Standing._:set_visible(true)
            menu_aa.YawAddRight_Standing._:set_visible(true)
            menu_aa.LeftLimit_Standing._:set_visible(true)
            menu_aa.RightLimit_Standing._:set_visible(true)
            menu_aa.YawModifierType_Standing._:set_visible(true)
            if menu_aa.YawModifierType_Standing._:get() == 'Default' then
                menu_aa.ModifierDegree_Standing._:set_visible(true)
                menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
                menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
            else
                menu_aa.ModifierDegree_Standing._:set_visible(false)
                menu_aa.ModifierDegreeMin_Standing._:set_visible(true)
                menu_aa.ModifierDegreeMax_Standing._:set_visible(true)
            end
        else
            menu_aa.Pitch_Standing._:set_visible(false)
            menu_aa.YawBase_Standing._:set_visible(false)
            menu_aa.YawModifier_Standing._:set_visible(false)
            menu_aa.FakeLimitType_Standing._:set_visible(false)
            menu_aa.FakeOptions_Standing._:set_visible(false)
            menu_aa.LBYMode_Standing._:set_visible(false)
            menu_aa.FreestandingDesync_Standing._:set_visible(false)
            menu_aa.DesyncOnShot_Standing._:set_visible(false)
            menu_aa.YawAddLeft_Standing._:set_visible(false)
            menu_aa.YawAddRight_Standing._:set_visible(false)
            menu_aa.ModifierDegree_Standing._:set_visible(false)
            menu_aa.LeftLimit_Standing._:set_visible(false)
            menu_aa.RightLimit_Standing._:set_visible(false)
            menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
            menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
            menu_aa.YawModifierType_Standing._:set_visible(false)
        end

        if conditions:get() == 'Crouching' then
            menu_aa.Pitch_Crouching._:set_visible(true)
            menu_aa.YawBase_Crouching._:set_visible(true)
            menu_aa.YawModifier_Crouching._:set_visible(true)
            menu_aa.FakeLimitType_Crouching._:set_visible(true)
            menu_aa.FakeOptions_Crouching._:set_visible(true)
            menu_aa.LBYMode_Crouching._:set_visible(true)
            menu_aa.FreestandingDesync_Crouching._:set_visible(true)
            menu_aa.DesyncOnShot_Crouching._:set_visible(true)
            menu_aa.YawAddLeft_Crouching._:set_visible(true)
            menu_aa.YawAddRight_Crouching._:set_visible(true)
            menu_aa.LeftLimit_Crouching._:set_visible(true)
            menu_aa.RightLimit_Crouching._:set_visible(true)
            menu_aa.YawModifierType_Crouching._:set_visible(true)
            if menu_aa.YawModifierType_Crouching._:get() == 'Default' then
                menu_aa.ModifierDegree_Crouching._:set_visible(true)
                menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
                menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
            else
                menu_aa.ModifierDegree_Crouching._:set_visible(false)
                menu_aa.ModifierDegreeMin_Crouching._:set_visible(true)
                menu_aa.ModifierDegreeMax_Crouching._:set_visible(true)
            end
        else
            menu_aa.Pitch_Crouching._:set_visible(false)
            menu_aa.YawBase_Crouching._:set_visible(false)
            menu_aa.YawModifier_Crouching._:set_visible(false)
            menu_aa.FakeLimitType_Crouching._:set_visible(false)
            menu_aa.FakeOptions_Crouching._:set_visible(false)
            menu_aa.LBYMode_Crouching._:set_visible(false)
            menu_aa.FreestandingDesync_Crouching._:set_visible(false)
            menu_aa.DesyncOnShot_Crouching._:set_visible(false)
            menu_aa.YawAddLeft_Crouching._:set_visible(false)
            menu_aa.YawAddRight_Crouching._:set_visible(false)
            menu_aa.ModifierDegree_Crouching._:set_visible(false)
            menu_aa.LeftLimit_Crouching._:set_visible(false)
            menu_aa.RightLimit_Crouching._:set_visible(false)
            menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
            menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
            menu_aa.YawModifierType_Crouching._:set_visible(false)
        end

        if conditions:get() == 'Slowwalk' then
            menu_aa.Pitch_Slowwalk._:set_visible(true)
            menu_aa.YawBase_Slowwalk._:set_visible(true)
            menu_aa.YawModifier_Slowwalk._:set_visible(true)
            menu_aa.FakeLimitType_Slowwalk._:set_visible(true)
            menu_aa.FakeOptions_Slowwalk._:set_visible(true)
            menu_aa.LBYMode_Slowwalk._:set_visible(true)
            menu_aa.FreestandingDesync_Slowwalk._:set_visible(true)
            menu_aa.DesyncOnShot_Slowwalk._:set_visible(true)
            menu_aa.YawAddLeft_Slowwalk._:set_visible(true)
            menu_aa.YawAddRight_Slowwalk._:set_visible(true)
            menu_aa.LeftLimit_Slowwalk._:set_visible(true)
            menu_aa.RightLimit_Slowwalk._:set_visible(true)
            menu_aa.YawModifierType_Slowwalk._:set_visible(true)
            if menu_aa.YawModifierType_Slowwalk._:get() == 'Default' then
                menu_aa.ModifierDegree_Slowwalk._:set_visible(true)
                menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
                menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
            else
                menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
                menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(true)
                menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(true)
            end
        else
            menu_aa.Pitch_Slowwalk._:set_visible(false)
            menu_aa.YawBase_Slowwalk._:set_visible(false)
            menu_aa.YawModifier_Slowwalk._:set_visible(false)
            menu_aa.FakeLimitType_Slowwalk._:set_visible(false)
            menu_aa.FakeOptions_Slowwalk._:set_visible(false)
            menu_aa.LBYMode_Slowwalk._:set_visible(false)
            menu_aa.FreestandingDesync_Slowwalk._:set_visible(false)
            menu_aa.DesyncOnShot_Slowwalk._:set_visible(false)
            menu_aa.YawAddLeft_Slowwalk._:set_visible(false)
            menu_aa.YawAddRight_Slowwalk._:set_visible(false)
            menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
            menu_aa.LeftLimit_Slowwalk._:set_visible(false)
            menu_aa.RightLimit_Slowwalk._:set_visible(false)
            menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
            menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
            menu_aa.YawModifierType_Slowwalk._:set_visible(false)
        end
        
        if conditions:get() == 'Moving' then
            menu_aa.Pitch_Moving._:set_visible(true)
            menu_aa.YawBase_Moving._:set_visible(true)
            menu_aa.YawModifier_Moving._:set_visible(true)
            menu_aa.FakeLimitType_Moving._:set_visible(true)
            menu_aa.FakeOptions_Moving._:set_visible(true)
            menu_aa.LBYMode_Moving._:set_visible(true)
            menu_aa.FreestandingDesync_Moving._:set_visible(true)
            menu_aa.DesyncOnShot_Moving._:set_visible(true)
            menu_aa.YawAddLeft_Moving._:set_visible(true)
            menu_aa.YawAddRight_Moving._:set_visible(true)
            menu_aa.LeftLimit_Moving._:set_visible(true)
            menu_aa.RightLimit_Moving._:set_visible(true)
            menu_aa.YawModifierType_Moving._:set_visible(true)
            if menu_aa.YawModifierType_Moving._:get() == 'Default' then
                menu_aa.ModifierDegree_Moving._:set_visible(true)
                menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
                menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
            else
                menu_aa.ModifierDegree_Moving._:set_visible(false)
                menu_aa.ModifierDegreeMin_Moving._:set_visible(true)
                menu_aa.ModifierDegreeMax_Moving._:set_visible(true)
            end
        else
            menu_aa.Pitch_Moving._:set_visible(false)
            menu_aa.YawBase_Moving._:set_visible(false)
            menu_aa.YawModifier_Moving._:set_visible(false)
            menu_aa.FakeLimitType_Moving._:set_visible(false)
            menu_aa.FakeOptions_Moving._:set_visible(false)
            menu_aa.LBYMode_Moving._:set_visible(false)
            menu_aa.FreestandingDesync_Moving._:set_visible(false)
            menu_aa.DesyncOnShot_Moving._:set_visible(false)
            menu_aa.YawAddLeft_Moving._:set_visible(false)
            menu_aa.YawAddRight_Moving._:set_visible(false)
            menu_aa.ModifierDegree_Moving._:set_visible(false)
            menu_aa.LeftLimit_Moving._:set_visible(false)
            menu_aa.RightLimit_Moving._:set_visible(false)
            menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
            menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
            menu_aa.YawModifierType_Moving._:set_visible(false)
        end

        if conditions:get() == 'In Air' then
            menu_aa.Pitch_InAir._:set_visible(true)
            menu_aa.YawBase_InAir._:set_visible(true)
            menu_aa.YawModifier_InAir._:set_visible(true)
            menu_aa.FakeLimitType_InAir._:set_visible(true)
            menu_aa.FakeOptions_InAir._:set_visible(true)
            menu_aa.LBYMode_InAir._:set_visible(true)
            menu_aa.FreestandingDesync_InAir._:set_visible(true)
            menu_aa.DesyncOnShot_InAir._:set_visible(true)
            menu_aa.YawAddLeft_InAir._:set_visible(true)
            menu_aa.YawAddRight_InAir._:set_visible(true)
            menu_aa.ModifierDegree_InAir._:set_visible(true)
            menu_aa.LeftLimit_InAir._:set_visible(true)
            menu_aa.RightLimit_InAir._:set_visible(true)
            menu_aa.YawModifierType_InAir._:set_visible(true)
            if menu_aa.YawModifierType_InAir._:get() == 'Default' then
                menu_aa.ModifierDegree_InAir._:set_visible(true)
                menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
                menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
            else
                menu_aa.ModifierDegree_InAir._:set_visible(false)
                menu_aa.ModifierDegreeMin_InAir._:set_visible(true)
                menu_aa.ModifierDegreeMax_InAir._:set_visible(true)
            end
        else
            menu_aa.Pitch_InAir._:set_visible(false)
            menu_aa.YawBase_InAir._:set_visible(false)
            menu_aa.YawModifier_InAir._:set_visible(false)
            menu_aa.FakeLimitType_InAir._:set_visible(false)
            menu_aa.FakeOptions_InAir._:set_visible(false)
            menu_aa.LBYMode_InAir._:set_visible(false)
            menu_aa.FreestandingDesync_InAir._:set_visible(false)
            menu_aa.DesyncOnShot_InAir._:set_visible(false)
            menu_aa.YawAddLeft_InAir._:set_visible(false)
            menu_aa.YawAddRight_InAir._:set_visible(false)
            menu_aa.ModifierDegree_InAir._:set_visible(false)
            menu_aa.LeftLimit_InAir._:set_visible(false)
            menu_aa.RightLimit_InAir._:set_visible(false)
            menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
            menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
            menu_aa.YawModifierType_InAir._:set_visible(false)
        end

        if conditions:get() == 'In Air + Duck' then
            menu_aa.Pitch_InAirDuck._:set_visible(true)
            menu_aa.YawBase_InAirDuck._:set_visible(true)
            menu_aa.YawModifier_InAirDuck._:set_visible(true)
            menu_aa.FakeLimitType_InAirDuck._:set_visible(true)
            menu_aa.FakeOptions_InAirDuck._:set_visible(true)
            menu_aa.LBYMode_InAirDuck._:set_visible(true)
            menu_aa.FreestandingDesync_InAirDuck._:set_visible(true)
            menu_aa.DesyncOnShot_InAirDuck._:set_visible(true)
            menu_aa.YawAddLeft_InAirDuck._:set_visible(true)
            menu_aa.YawAddRight_InAirDuck._:set_visible(true)
            menu_aa.LeftLimit_InAirDuck._:set_visible(true)
            menu_aa.RightLimit_InAirDuck._:set_visible(true)
            menu_aa.YawModifierType_InAirDuck._:set_visible(true)
            if menu_aa.YawModifierType_InAirDuck._:get() == 'Default' then
                menu_aa.ModifierDegree_InAirDuck._:set_visible(true)
                menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
                menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
            else
                menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
                menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(true)
                menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(true)
            end
        else
            menu_aa.Pitch_InAirDuck._:set_visible(false)
            menu_aa.YawBase_InAirDuck._:set_visible(false)
            menu_aa.YawModifier_InAirDuck._:set_visible(false)
            menu_aa.FakeLimitType_InAirDuck._:set_visible(false)
            menu_aa.FakeOptions_InAirDuck._:set_visible(false)
            menu_aa.LBYMode_InAirDuck._:set_visible(false)
            menu_aa.FreestandingDesync_InAirDuck._:set_visible(false)
            menu_aa.DesyncOnShot_InAirDuck._:set_visible(false)
            menu_aa.YawAddLeft_InAirDuck._:set_visible(false)
            menu_aa.YawAddRight_InAirDuck._:set_visible(false)
            menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
            menu_aa.LeftLimit_InAirDuck._:set_visible(false)
            menu_aa.RightLimit_InAirDuck._:set_visible(false)
            menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
            menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
            menu_aa.YawModifierType_InAirDuck._:set_visible(false)
        end

    else
        override_yaw:set_visible(false)
        conditions:set_visible(false)

        menu_aa.Pitch_Standing._:set_visible(false)
        menu_aa.YawBase_Standing._:set_visible(false)
        menu_aa.YawModifier_Standing._:set_visible(false)
        menu_aa.FakeLimitType_Standing._:set_visible(false)
        menu_aa.FakeOptions_Standing._:set_visible(false)
        menu_aa.LBYMode_Standing._:set_visible(false)
        menu_aa.FreestandingDesync_Standing._:set_visible(false)
        menu_aa.DesyncOnShot_Standing._:set_visible(false)
        menu_aa.YawAddLeft_Standing._:set_visible(false)
        menu_aa.YawAddRight_Standing._:set_visible(false)
        menu_aa.ModifierDegree_Standing._:set_visible(false)
        menu_aa.LeftLimit_Standing._:set_visible(false)
        menu_aa.RightLimit_Standing._:set_visible(false)
        menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
        menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
        menu_aa.YawModifierType_Standing._:set_visible(false)

        menu_aa.Pitch_Crouching._:set_visible(false)
        menu_aa.YawBase_Crouching._:set_visible(false)
        menu_aa.YawModifier_Crouching._:set_visible(false)
        menu_aa.FakeLimitType_Crouching._:set_visible(false)
        menu_aa.FakeOptions_Crouching._:set_visible(false)
        menu_aa.LBYMode_Crouching._:set_visible(false)
        menu_aa.FreestandingDesync_Crouching._:set_visible(false)
        menu_aa.DesyncOnShot_Crouching._:set_visible(false)
        menu_aa.YawAddLeft_Crouching._:set_visible(false)
        menu_aa.YawAddRight_Crouching._:set_visible(false)
        menu_aa.ModifierDegree_Crouching._:set_visible(false)
        menu_aa.LeftLimit_Crouching._:set_visible(false)
        menu_aa.RightLimit_Crouching._:set_visible(false)
        menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
        menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
        menu_aa.YawModifierType_Crouching._:set_visible(false)

        menu_aa.Pitch_Slowwalk._:set_visible(false)
        menu_aa.YawBase_Slowwalk._:set_visible(false)
        menu_aa.YawModifier_Slowwalk._:set_visible(false)
        menu_aa.FakeLimitType_Slowwalk._:set_visible(false)
        menu_aa.FakeOptions_Slowwalk._:set_visible(false)
        menu_aa.LBYMode_Slowwalk._:set_visible(false)
        menu_aa.FreestandingDesync_Slowwalk._:set_visible(false)
        menu_aa.DesyncOnShot_Slowwalk._:set_visible(false)
        menu_aa.YawAddLeft_Slowwalk._:set_visible(false)
        menu_aa.YawAddRight_Slowwalk._:set_visible(false)
        menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
        menu_aa.LeftLimit_Slowwalk._:set_visible(false)
        menu_aa.RightLimit_Slowwalk._:set_visible(false)
        menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
        menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
        menu_aa.YawModifierType_Slowwalk._:set_visible(false)

        menu_aa.Pitch_Moving._:set_visible(false)
        menu_aa.YawBase_Moving._:set_visible(false)
        menu_aa.YawModifier_Moving._:set_visible(false)
        menu_aa.FakeLimitType_Moving._:set_visible(false)
        menu_aa.FakeOptions_Moving._:set_visible(false)
        menu_aa.LBYMode_Moving._:set_visible(false)
        menu_aa.FreestandingDesync_Moving._:set_visible(false)
        menu_aa.DesyncOnShot_Moving._:set_visible(false)
        menu_aa.YawAddLeft_Moving._:set_visible(false)
        menu_aa.YawAddRight_Moving._:set_visible(false)
        menu_aa.ModifierDegree_Moving._:set_visible(false)
        menu_aa.LeftLimit_Moving._:set_visible(false)
        menu_aa.RightLimit_Moving._:set_visible(false)
        menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
        menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
        menu_aa.YawModifierType_Moving._:set_visible(false)

        menu_aa.Pitch_InAir._:set_visible(false)
        menu_aa.YawBase_InAir._:set_visible(false)
        menu_aa.YawModifier_InAir._:set_visible(false)
        menu_aa.FakeLimitType_InAir._:set_visible(false)
        menu_aa.FakeOptions_InAir._:set_visible(false)
        menu_aa.LBYMode_InAir._:set_visible(false)
        menu_aa.FreestandingDesync_InAir._:set_visible(false)
        menu_aa.DesyncOnShot_InAir._:set_visible(false)
        menu_aa.YawAddLeft_InAir._:set_visible(false)
        menu_aa.YawAddRight_InAir._:set_visible(false)
        menu_aa.ModifierDegree_InAir._:set_visible(false)
        menu_aa.LeftLimit_InAir._:set_visible(false)
        menu_aa.RightLimit_InAir._:set_visible(false)
        menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
        menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
        menu_aa.YawModifierType_InAir._:set_visible(false)

        menu_aa.Pitch_InAirDuck._:set_visible(false)
        menu_aa.YawBase_InAirDuck._:set_visible(false)
        menu_aa.YawModifier_InAirDuck._:set_visible(false)
        menu_aa.FakeLimitType_InAirDuck._:set_visible(false)
        menu_aa.FakeOptions_InAirDuck._:set_visible(false)
        menu_aa.LBYMode_InAirDuck._:set_visible(false)
        menu_aa.FreestandingDesync_InAirDuck._:set_visible(false)
        menu_aa.DesyncOnShot_InAirDuck._:set_visible(false)
        menu_aa.YawAddLeft_InAirDuck._:set_visible(false)
        menu_aa.YawAddRight_InAirDuck._:set_visible(false)
        menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
        menu_aa.LeftLimit_InAirDuck._:set_visible(false)
        menu_aa.RightLimit_InAirDuck._:set_visible(false)
        menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
        menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
        menu_aa.YawModifierType_InAirDuck._:set_visible(false)
    end
end

local hitgroups = {   
[0] = 'generic',
'head', 'chest', 'stomach',
'left arm', 'right arm',
'left leg', 'right leg',
'neck', 'generic', 'gear'}

function func:centerLogs(e)
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or not menu_cyrax.logs_switch._:get() then return end
    local target = entity.get(e.target)
    local wanted_dmg = e.wanted_damage
    local damage = e.damage
    local wanted_hbx = hitgroups[e.wanted_hitgroup]
    local hitchance = e.hitchance
    local state = e.state
    local bt = e.backtrack
    if not target or target == nil then return end
    local hitbox = hitgroups[e.hitgroup]

    if state == nil then
        color_p("[Cyrax] ", gear_opt.logs_hit:get())
        print_raw(string.format("Hit %s's %s [aimed = %s | damage: %i(%i) | hc: %i | history: %i]", target:get_name(), hitbox, wanted_hbx, damage, wanted_dmg, hitchance, bt))
    else
        color_p("[Cyrax] ", gear_opt.logs_miss:get())
        print_raw(string.format("Missed shot at %s's %s due to %s [hc: %i | history: %i]", target:get_name(), wanted_hbx, state, hitchance, bt))
    end

    if state == nil then
        print_dev(string.format("Hit %s's %s [aimed = %s | damage: %i(%i) | hc: %i | history: %i]", target:get_name(), hitbox, wanted_hbx, damage, wanted_dmg, hitchance, bt))
    else
        print_dev(string.format("Missed shot at %s's %s due to %s [hc: %i | history: %i]", target:get_name(), wanted_hbx, state, hitchance, bt))
    end

end

entity_list_pointer = ffi.cast('void***', utils.create_interface('client.dll', 'VClientEntityList003'))
get_client_entity_fn = ffi.cast('GetClientEntity_4242425_t', entity_list_pointer[0][3])
function get_entity_address(ent_index)
    local addr = get_client_entity_fn(entity_list_pointer, ent_index)
    return addr
end


hook_helper = {
    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
}

buff = {free = {}}
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_helper.virtual_protect(virtual_table + method, 4, 0x4, old_prot)

    virtual_table[method] = ffi.cast('intptr_t', ffi.cast(cast, func))
    hook_helper.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_helper.virtual_protect(virtual_table + method, 4, 0x4, old_prot)
    local alloc_addr = hook_helper.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_helper.copy(alloc_addr, trampoline_bytes, 5)
    virtual_table[method] = ffi.cast('intptr_t', alloc_addr)

    hook_helper.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

conditional_aa.onuseAAEnabled = false
conditional_aa.standingAAEnabled = false
conditional_aa.crouchingAAEnabled = false
conditional_aa.slowwalkAAEnabled = false
conditional_aa.movingAAEnabled = false
conditional_aa.inairAAEnabled = false
conditional_aa.inairAAduckEnabled = false

function conditional_aa.distanceCheck(t)
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false then return end
    local localplayer = entity.get_local_player()
    local origin = localplayer:get_eye_position()
    local vec = vector(origin.x, origin.y, origin.z)

    for _, v in pairs(t) do
        if vec:dist(v.m_vecOrigin) < 100 then return false end
    end

    return true
end

local scope = {}
scope.screen = render.screen_size()
scope.menu = {}
scope.menu.offset = 100
scope.anim_num = 0

function func:jumpscout_fix_f()
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.jumpscout_switch._:get() == false then return end
    local vel = entity.get_local_player().m_vecVelocity
    local speed = math.sqrt(vel.x*vel.x + vel.y*vel.y)
    ui.find("Miscellaneous", "Main", "Movement", "Air Strafe"):set(speed > 15)
end

function func:customscope()

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false then return end

    if not menu_cyrax.scope_switch._:get() or menu_cyrax.visuals_switch._:get() == false then return vars.menu.remove_scope:set('Remove Overlay') end

    vars.menu.remove_scope:set('Remove All')
    local local_player = entity.get_local_player()
    scope.anim_speed = 15

    if not local_player or not local_player:is_alive() or not local_player.m_bIsScoped then
        scope.anim_num = func:lerp(scope.anim_num, 0, scope.anim_speed * globals.frametime)
    else
        scope.anim_num = func:lerp(scope.anim_num, 1, scope.anim_speed * globals.frametime)
    end

    scope.length = gear_opt.scope_length:get() * scope.anim_num
    scope.offset = gear_opt.scope_offset:get() * scope.anim_num

    scope.col_1 = gear_opt.scope_color1:get()
    scope.col_2 = gear_opt.scope_color2:get()

    scope.width = 1

    scope.col_1.a = scope.col_1.a * scope.anim_num
    scope.col_2.a = scope.col_2.a * scope.anim_num

    
    scope.start_x = scope.screen.x / 2
    scope.start_y = scope.screen.y / 2

    --Left
    render.gradient(vector(scope.start_x - scope.offset, scope.start_y), vector(scope.start_x - scope.offset - scope.length, scope.start_y + scope.width), scope.col_1, scope.col_2, scope.col_1, scope.col_2)

    --Right
    render.gradient(vector(scope.start_x + scope.offset, scope.start_y), vector(scope.start_x + scope.offset + scope.length, scope.start_y + scope.width), scope.col_1, scope.col_2, scope.col_1, scope.col_2)

    --Down

    render.gradient(vector(scope.start_x, scope.start_y + scope.offset), vector(scope.start_x + scope.width, scope.start_y + scope.offset + scope.length), scope.col_1, scope.col_1, scope.col_2, scope.col_2)

    --Up
    if not gear_opt.t_style:get() then
        render.gradient(vector(scope.start_x, scope.start_y - scope.offset), vector(scope.start_x + scope.width, scope.start_y - scope.offset - scope.length), scope.col_1, scope.col_1, scope.col_2, scope.col_2)
    end
end

function CheckFlag(player, ...)
    local flagList = {...};
    local flagValues = true;

    if (type(flagList) == "table" and #flagList > 0) then
        for i = 1, #flagList do
            if (type(flagList[i]) == "table") then
                if (bit.band(player.m_fFlags, bit.lshift(1, flagList[i][1])) ~= 0) then flagValues = false; end
            else
                if (bit.band(player.m_fFlags, bit.lshift(1, flagList[i])) == 0) then flagValues = false; end
            end
        end
    end

    return flagValues;
end

local estisus
if func:version() == "Debug" then
    estisus = 3
elseif func:version() == "Beta" then
    estisus = 0
elseif func:version() == "Live" then
    estisus = -2
end

function func:cyrax_ind()

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false     or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax' then return end

    local p = {
        sc = render.screen_size(),
        ver = func:version(),
        alpha = math.clamp(math.abs(1 * math.cos(2 * math.pi * globals.curtime / 5)), 0.5, 1),
        dyntext = "",
        ex = "",
        localplayer = entity.get_local_player(),
        clr = {           
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
    }
    local speed = p.localplayer.m_vecVelocity
    local velocity = speed:length()

    if conditional_aa.onuseAAEnabled then
        vars.ind.lavendu.textu = "using"
    else
        if CheckFlag(p.localplayer, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(p.localplayer, 1) then
                vars.ind.lavendu.textu = "jumping"
            else
                vars.ind.lavendu.textu = "airduck"
            end
        else
            if vars.menu.sw:get() then
                vars.ind.lavendu.textu = "slowwalking"
            else
                if CheckFlag(p.localplayer, 1) then
                    vars.ind.lavendu.textu = "ducking"
                else
                    if velocity >= 1.2 then
                        vars.ind.lavendu.textu = "running"
                    else
                        vars.ind.lavendu.textu = "standing"
                    end
                end
            end
        end
    end

    if vars.menu.dt:get() and vars.menu.hs:get() then
        p.ex = "dt"
    elseif vars.menu.dt:get() and not vars.menu.hs:get() then
        p.ex = "dt"
    elseif not vars.menu.dt:get() and vars.menu.hs:get() then
        p.ex = "os"
    end

    if p.localplayer.m_bIsScoped then
        vars.ind.lavendu.anim[3][1] = func:lerp(vars.ind.lavendu.anim[3][1], 26 + estisus, globals.frametime*15)
        vars.ind.lavendu.anim[3][2] = func:lerp(vars.ind.lavendu.anim[3][2], 5, globals.frametime*15)
        vars.ind.lavendu.anim[3][3] = func:lerp(vars.ind.lavendu.anim[3][3], 10, globals.frametime*15)
        vars.ind.lavendu.anim[2].dt = 0
        vars.ind.lavendu.chestie = 0
    else
        vars.ind.lavendu.anim[3][1] = func:lerp(vars.ind.lavendu.anim[3][1], 0, globals.frametime*15)
        vars.ind.lavendu.anim[3][2] = func:lerp(vars.ind.lavendu.anim[3][2], -texts(vars.font.skeet, 'o', vars.ind.lavendu.textu).x/2, globals.frametime*15)
        vars.ind.lavendu.anim[3][3] = func:lerp(vars.ind.lavendu.anim[3][3], 0, globals.frametime*15)
        vars.ind.lavendu.chestie = 0
    end

    if vars.menu.dt:get() or vars.menu.hs:get() then
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt + 1, 0, 10)
    else
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt - 1, 0, 10)
    end

    if ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() then
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs + 1, 0, 10)

        if vars.menu.dt:get() or vars.menu.hs:get() then
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt + 0.5, 0, 5.5)
            if p.localplayer.m_bIsScoped then
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 10.5)
            else
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
            end
        else
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
            vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs - 0.5, 0, 5.5)
        end

    else
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs - 1, 0, 10.5)
        vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
    end

    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(p.ex, 'o', vars.font.skeet).x/2 - 5 - vars.ind.lavendu.anim[2].dt + vars.ind.lavendu.anim[3][3], p.sc.y/2 + 30 + vars.ind.lavendu.anim[1].dt), color(255, 255, 255, vars.ind.lavendu.anim[1].dt/10*255), nil, p.ex)
    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o', "fs").x/2 + vars.ind.lavendu.anim[2].fs + vars.ind.lavendu.anim[3][3] + vars.ind.lavendu.chestie, p.sc.y/2 + 30 + vars.ind.lavendu.anim[1].fs), color(255, 255, 255, vars.ind.lavendu.anim[1].fs/10*255), nil, "fs")

    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o', "cyrax"..func:version()).x/2 + vars.ind.lavendu.anim[3][1], p.sc.y/2 + 20), color(255, 255, 255, 255), nil, "cyrax")
    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o', "cyrax"..func:version()).x/2 + texts(vars.font.skeet, 'o', "cyrax").x + 1 + vars.ind.lavendu.anim[3][1], p.sc.y/2+ 20), color(p.clr.r, p.clr.g, p.clr.b, p.alpha * 255), nil, p.ver)
    render.text(vars.font.skeet, vector(p.sc.x/2 + vars.ind.lavendu.anim[3][2], p.sc.y/2+ 30), color(255, 255, 255, 122), nil, vars.ind.lavendu.textu)

end

local red = 0
function func:cyrax_ind_2()
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax V2' then return end
    local screen = render.screen_size()
    local t = {
        alpha = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 4)),
        dt_text = "dt",
        lp = entity.get_local_player(),
        color = {
            dt = color(255 - red, red, 0, vars.ind.dt_alpha),
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
        charge = rage.exploit:get(),
        desync = math.floor(aantiaim.get_desync_delta()),
    }
    local speed = t.lp.m_vecVelocity
    local velocity = speed:length()

    if t.lp.m_bIsScoped then
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 1.91, globals.frametime * 11)
    else
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 2, globals.frametime * 11)
    end

    vars.ind.smooth = func:lerp(vars.ind.smooth, t.desync, globals.frametime*8)

    if vars.menu.dt:get() then
        vars.ind.dt_alpha = math.clamp(vars.ind.dt_alpha + 13, 0 , 255)
        if t.charge ~= 1 then
           red = math.clamp(red - 25, 0, 255)
        else
            red = math.clamp(red + 25, 0, 255)
        end
    else
        red = math.clamp(red + 25, 0, 1)
        vars.ind.dt_alpha = math.clamp(vars.ind.dt_alpha - 12, 0 , 255)
    end

    t.alpha = math.clamp(t.alpha, 0.25, 1)

    if vars.menu.dt:get() and vars.menu.qp:get() then
        t.dt_text = "it"
    else
        t.dt_text = "dt"
    end

    if conditional_aa.onuseAAEnabled then
        vars.ind.v2.cond_text = "using"
    else
        if CheckFlag(t.lp, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(t.lp, 1) then
            vars.ind.v2.cond_text = "air"
            else
                vars.ind.v2.cond_text = "air+"
            end
        else
            if vars.menu.sw:get() then
                vars.ind.v2.cond_text = "slowwalk"
            else
                if CheckFlag(t.lp, 1) then
                    vars.ind.v2.cond_text = "duck"
                else
                    if velocity >= 1.2 then
                        vars.ind.v2.cond_text = "running"
                    else
                        vars.ind.v2.cond_text = "standing"
                    end
                end
            end
        end
    end

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax" .. string.lower(func:version())).x/2, screen.y/2 + 16), color(t.color.r, t.color.g, t.color.b, 255), nil, "cyrax")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax" .. string.lower(func:version())).x/2 + texts(vars.font.pixel, 'o', "cyrax").x + 1, screen.y/2 + 16), color(255, 255, 255, t.alpha*255), nil, string.lower(func:version()))

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o',vars.ind.v2.cond_text).x/2, screen.y/2 + 25), color(t.color.r, t.color.g, t.color.b, 255), nil, vars.ind.v2.cond_text)

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', t.dt_text).x/2, screen.y/2 + 34), t.color.dt, nil, t.dt_text)

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 - 3, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255, vars.menu.body:get() ~= 'Default' and 255 or 122), nil, "baim")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o', "baim").x - 1, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255, vars.menu.hs:get() and 255 or 122), nil, "os")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o', "baimos").x + 1, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255,  ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() and 255 or 122), nil, "fs")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o', "baimosfs").x + 3, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255, vars.menu.sp:get() ~= 'Default' and 255 or 122), nil, "sp")
end


function func:cyrax_ind_3()
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax V4' then return end
    local screen = render.screen_size()
    local t = {
        alpha = math.abs(3 * math.cos(1 * math.pi * globals.curtime / 4)) * 255,
        dyn_text = "aggresive",
        dt_text = "dt",
        lp = entity.get_local_player(),
        players = entity.get_players(),
        color = {
            dt = color(255, 255, 255, vars.ind.dt_alpha),
            alpha_side = aantiaim.get_inverter_state() and 255 or 122,
            alpha_side2 = aantiaim.get_inverter_state() and 122 or 255,
            fs_green = vars.menu.fd:get() and 0 or 255,
            fs_blue = vars.menu.fd:get() and 0 or 255,
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
        charge = rage.exploit:get(),
        desync = math.floor(aantiaim.get_desync_delta()),
    }
    local speed = t.lp.m_vecVelocity
    local velocity = speed:length()
    local a = {
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 10 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 8 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 6 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 4 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 2 / 4))),
    }

    if t.lp.m_bIsScoped then
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 1.91, globals.frametime * 11)
    else
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 2, globals.frametime * 11)
    end

    vars.ind.smooth = func:lerp(vars.ind.smooth, t.desync, globals.frametime*8)

    if vars.menu.dt:get() or vars.menu.hs:get() then
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt + 1, 0, 10)
    else
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt - 1, 0, 10)
    end

    if ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() then
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs + 1, 0, 10)

        if vars.menu.dt:get() or vars.menu.hs:get() then
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt + 0.5, 0, 5.5)
            if t.lp.m_bIsScoped then
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
            else
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
            end
        else
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
            vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs - 0.5, 0, 5.5)
        end

    else
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs - 1, 0, 10.5)
        vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
    end

    t.alpha = math.clamp(t.alpha, 25, 255)
    vars.ind.smooth = math.clamp(vars.ind.smooth, 0, 19)

    if vars.menu.fs:get() then
        vars.ind.fs_alpha = math.clamp(vars.ind.fs_alpha + 12, 0 , 255)
    else
        vars.ind.fs_alpha = math.clamp(vars.ind.fs_alpha - 12, 0 , 255)
    end
    local os = 0
    if vars.menu.dt:get() and vars.menu.hs:get() then
        t.dt_text = "dt"
    elseif vars.menu.dt:get() and not vars.menu.hs:get() then
        t.dt_text = "dt"
    elseif not vars.menu.dt:get() and vars.menu.hs:get() then
        t.dt_text = "os"
        os = -1
    end

    if conditional_aa.onuseAAEnabled then
        t.dyn_text = "using"
    else
        if CheckFlag(t.lp, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(t.lp, 1) then
                t.dyn_text = "jumping"
            else
                t.dyn_text = "airduck"
            end
        else
            if vars.menu.sw:get() then
                t.dyn_text = "slowwalk"
            else
                if CheckFlag(t.lp, 1) then
                    t.dyn_text = "ducking"
                else
                    if velocity >= 1.2 then
                        t.dyn_text = "running"
                    else
                        t.dyn_text = "standing"
                    end
                end
            end
        end
    end

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts('os', 'o', vars.font.pixel).x/2 - 5 - vars.ind.lavendu.anim[2].dt + vars.ind.lavendu.anim[3][3] + os, screen.y/2 + 30 + vars.ind.lavendu.anim[1].dt), color(255, 255, 255, vars.ind.lavendu.anim[1].dt/10*255), nil, t.dt_text)
    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "fs").x/2 + vars.ind.lavendu.anim[2].fs + vars.ind.lavendu.anim[3][3] + vars.ind.lavendu.chestie, screen.y/2 + 30 + vars.ind.lavendu.anim[1].fs), color(255, 255, 255, vars.ind.lavendu.anim[1].fs/10*255), nil, "fs")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax").x/2, screen.y/2 + 16), color(255, 255, 255, 255), nil, "cyrax")
    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax").x/2, screen.y/2 + 16), color(255, 255, 255, 255), nil, string.format("\a%sc\a%sy\a%sr\a%sa\a%sx", a[1]:to_hex(), a[2]:to_hex(), a[3]:to_hex(), a[4]:to_hex(), a[5]:to_hex()))

    for i = 1, 5 do
        render.rect_outline(vector(screen.x/vars.ind.scope_smooth - 19 - i, screen.y/2 + 27 - i), vector(screen.x/vars.ind.scope_smooth + 19 + i, screen.y/2 + 31 + i), color(t.color.r, t.color.g, t.color.b, 0.15 * (1 - i / 5) * 255), 1, 5)
    end

    render.rect(vector(screen.x/vars.ind.scope_smooth - 20, screen.y/2 + 27), vector(screen.x/vars.ind.scope_smooth + 20, screen.y/2 + 31), color(0, 0, 0, 122), 1)

    render.gradient(vector(screen.x/vars.ind.scope_smooth - 19, screen.y/2 + 28), vector(screen.x/vars.ind.scope_smooth + vars.ind.smooth, screen.y/2 + 30), color(t.color.r, t.color.g, t.color.b, 255), color(t.color.r, t.color.g, t.color.b, 0), color(t.color.r, t.color.g, t.color.b, 255), color(t.color.r, t.color.g, t.color.b, 0), 1)

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', t.dyn_text).x/2, screen.y/2 + 30), color(t.color.r, t.color.g, t.color.b, t.alpha), nil, t.dyn_text)
            
end


function func:cyrax_ind_4()

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax V3' then return end

    local screen = render.screen_size()
    local localplayer = entity.get_local_player()
    local speed = localplayer.m_vecVelocity
    local velocity = speed:length()
    local t = {
        alpha = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 4)),
        dyn_text = "aggresive",
        charge = rage.exploit:get(),
        desync = math.floor(aantiaim.get_desync_delta()),
        clr = {           
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
        text = func:version(),
        dt = "",
    }

    if conditional_aa.onuseAAEnabled then
        vars.ind.v2.cond_text = "using"
    else
        if CheckFlag(localplayer, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(localplayer, 1) then
                vars.ind.v2.cond_text = "jumping"
            else
                vars.ind.v2.cond_text = "airduck"
            end
        else
            if vars.menu.sw:get() then
                vars.ind.v2.cond_text = "slowwalking"
            else
                if CheckFlag(localplayer, 1) then
                    vars.ind.v2.cond_text = "ducking"
                else
                    if velocity >= 1.2 then
                        vars.ind.v2.cond_text = "running"
                    else
                        vars.ind.v2.cond_text = "standing"
                    end
                end
            end
        end
    end

    if vars.menu.dt:get() then
        if vars.menu.qp:get() then
            t.dt = "idealtick"
        else
            t.dt = "doubletap"
        end
    end

    vars.ind.smooth = func:lerp(vars.ind.smooth, math.clamp(t.desync*8, 0, 30), globals.frametime*8)

    for i = 1, 5 do
        render.rect_outline(vector(screen.x/2 + 4 - i, screen.y/2 + 26 - i), vector(screen.x/2 + 57 + i, screen.y/2 + 31 + i), color(t.clr.r, t.clr.g, t.clr.b, 0.15 * (1 - i / 5) * 255), 1, 5)
    end

    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + 16), color(t.clr.r, t.clr.g, t.clr.b, 255), nil, "Cyrax")
    render.text(vars.font.pixel, vector(screen.x/2 + 5 + texts(vars.font.pixel, 'o', "Cyrax").x, screen.y/2 + 16), color(255, 255, 255, t.alpha * 255), nil, t.text)
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + 30), color(t.clr.r, t.clr.g, t.clr.b, 255), nil, vars.ind.v2.cond_text)
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + vars.ind.v2.p[1] - 1), color(255, 255, 255, vars.ind.v2.a[1][3] * 255), nil, t.dt)
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + vars.ind.v2.p[2] - 1), color(255, 255, 255, vars.ind.v2.a[2] * 255), nil, "hideshots")
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + vars.ind.v2.p[3] - 1), color(255, 255, 255, vars.ind.v2.a[3] * 255), nil, "fakeduck")

    render.rect(vector(screen.x/2 + 5, screen.y/2 + 27), vector(screen.x/2 + 57, screen.y/2 + 32), color(0, 0, 0, 255), 2)
    render.gradient(vector(screen.x/2 + 6, screen.y/2 + 28), vector(screen.x/2 + 25 + vars.ind.smooth, screen.y/2 + 31), color(t.clr.r, t.clr.g, t.clr.b, 255), color(0, 0, 0, 0), color(t.clr.r, t.clr.g, t.clr.b, 255), color(0, 0, 0, 0), 2)
    

    if vars.menu.dt:get() and not vars.menu.fd:get() then
        if t.charge ~= 1 then
            vars.ind.v2.a[1][1] = math.clamp(vars.ind.v2.a[1][1] + 0.036, 0, 1)
            vars.ind.v2.a[1][2] = math.clamp(vars.ind.v2.a[1][2] - 0.036, 0, 1)
        else
            vars.ind.v2.a[1][1] = math.clamp(vars.ind.v2.a[1][1] - 0.036, 0, 1)
            vars.ind.v2.a[1][2] = math.clamp(vars.ind.v2.a[1][2] + 0.036, 0, 1)
        end
        vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 52, globals.frametime*20)
        if rage.exploit:get() == 1 then
            vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] + 0.036, 0, 1)
        else
            vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0.1, 1)
        end
    else
        vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 40, globals.frametime*20)
        vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0, 1)
    end

    if vars.menu.hs:get() and not vars.menu.dt:get() and not vars.menu.fd:get() then
        vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] + 0.036, 0, 1)
    else
        vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] - 0.036, 0, 1)
    end

    if vars.menu.fd:get() then
        vars.ind.v2.a[3] = math.clamp(vars.ind.v2.a[3] + 0.036, 0, 1)
        vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 52, globals.frametime*20)
        vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0, 1)
        vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] - 0.036, 0, 1)
        vars.ind.v2.p[1] = func:lerp(vars.ind.v2.p[1], 52, globals.frametime*20)
    else
        vars.ind.v2.a[3] = math.clamp(vars.ind.v2.a[3] - 0.036, 0, 1)
        vars.ind.v2.p[1] = func:lerp(vars.ind.v2.p[1], 40, globals.frametime*20)
    end

end
gear_opt.logs_miss_what:set_visible(false)
function func:screenLogs(e)
    if globals.is_connected == false or entity.get_local_player():is_alive() == false then return end
    if not menu_cyrax.logs_switch._:get() or not gear_opt.screen_logs:get() then return end
    local target = entity.get(e.target)
    local wanted_dmg = e.wanted_damage
    local damage = e.damage
    local wanted_hbx = hitgroups[e.wanted_hitgroup]
    local hitchance = e.hitchance
    local state = e.state
    local bt = e.backtrack
    local hitbox = hitgroups[e.hitgroup]
    
    if e.state == nil then
        table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sHit %s's \a%s%s \a%s[aimed = %s | damage: %i(%i) | hc: %i | history: %i]", gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex(), target:get_name(), gear_opt.logs_hit:get():to_hex(), hitbox, gear_opt.logs_miss_what:get():to_hex(), wanted_hbx, damage, wanted_dmg, hitchance, bt), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
    else
        table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sMissed shot at %s's \a%s%s \a%sdue to \a%s%s \a%s[hc: %i | history: %i]", gear_opt.logs_miss:get():to_hex(), gear_opt.logs_miss_what:get():to_hex(), target:get_name(), gear_opt.logs_miss:get():to_hex(), wanted_hbx, gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_miss:get():to_hex(), state, gear_opt.logs_miss_what:get():to_hex(), hitchance, bt), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_miss:get()})
    end
end
local cleartbl = function()
    if #tbl ~= 0 then
        if globals.is_connected == false or globals.curtime == 0 then
            table.remove(tbl, #tbl)
        end
        if #tbl > 5 then
            table.remove(tbl, 1)
        end
        for i = 1, #tbl do
            if tbl[i] == nil then
                return
            end
            if tbl[i][1] + 4 > math.floor(globals.curtime) then
                return
            end
            tbl[i][2] = tbl[i][2] - math.floor(globals.frametime * 340)
    
            if tbl[i][2] < 0 then
                table.remove(tbl, i)
            end
        end
    end
end
function func:drawscreenLogs()
    cleartbl()
    local x = render.screen_size().x/2
    local total_width = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
    local used_width = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
    local anim = globals.frametime * 10
    for k, v in pairs(tbl) do
        local c = v.clr or color(255, 255, 255, 255)
        local text_width = texts(1, nil, v.text).x
        total_width[k] = total_width[k] + text_width   
        local in_ = math.min((globals.realtime - v.realtime)*2, 1)
        local out = math.max(((globals.realtime - 3.8) - v.realtime)*3, 0)
        local cur_x = x - total_width[k] / 2 + used_width[k]

        render.rect(vector(cur_x - 8, 897 + k * 30 + (in_-out) * 10), vector(cur_x + text_width + 9, 917 + k * 30 + (in_-out) * 10), color(0, 0, 0, math.clamp((in_-out) * 255, 0, 30)), 5)

        render.text(1, vector(cur_x, 900 + k * 30 + (in_-out) * 10), color(255, 255, 255, (in_-out) * 255), nil, v.text)

        for i = 1, 5 do
            render.rect_outline(vector(cur_x - 8 - i, 897 + k * 30 - i + (in_-out) * 10), vector(cur_x + text_width + 9 + i, 917 + k * 30 + i + (in_-out) * 10), color(c.r, c.g, c.b, (1 - i / 5) * math.clamp((in_-out) * 255, 0, 50)), 1, 10)
        end

        render.rect_outline(vector(cur_x - 8, 897 + k * 30 + (in_-out) * 10), vector(cur_x + text_width + 9, 917 + k * 30 + (in_-out) * 10), color(c.r, c.g, c.b, math.clamp((in_-out) * 255, 0, 255)), 1, 5)
    end
end

local phrases = {
    "dont talking pls",
    "when u miss, cry u dont hev cyrax.tech",
    "you think you are is good but im best 1",
    "fokin dog, get ownet by Создатель js rezolver",
    "if im lose = my team is dog",
    "never talking bad to me again, im always top1",
    "umad that you're miss? hs dog",
    "vico (top1 eu) vs all kelbs on hvh.",
    "you is mad that im ur papi?",
    "im will rape u're mother after i killed you",
    "stay mad that im unhitable",
    "god night brother, cya next raund ;)",
    "get executed from presidend of argentina",
    "you thinking ur have chencse vs boss?",
    "i killed gejmsense, now im kill you",
    "by luckbaysed config, cya twitter bro o/",
    "cy@ https://gamesense.pub/forums/viewforum.php?id=6",
    "╭∩╮(◣_◢)╭∩╮(its fuck)",
    "dont play vs me on train, im live there -.-",
    "by top1 uzbekistan holder umed?",
    "courage for play de_shortnuke vs me, my home there.",
    "bich.. dont test g4ngst3r in me.",
    "im rich princ here, dont toxic dog.",
    "for all thet say gamesense best, im try on parsec and is dog.",
    "WEAK DOG sanchezj vs ru bossman (owned on mein map)",
    "im want gamesense only for animbrejker, neverlose always top.",
    "this dog brandog thinking hes top, but reality say no.",
    "fawk you foking treny",
    "ur think ur good but its falsee.",
    "topdog nepbot get baits 24/7 -.-",
    "who this bot malva? im own him 9-0",
    "im beat all romania dogs with 1 finker",
    "im rejp this dog noobers with no problems",
    "gamesense vico vs all -.-",
    "irelevent dog jompan try to stay popular but fail",
    "im user beta and ur dont, stay mad.",
    "dont talking, no cyrax tech no talk pls",
    "when u miss, cry u dont hev cyrax.tech",
    "you think you are is good but cyrax is best",
    "fkn dog, get own by cyrax js rezolver",
    "if you luse = no cyrax issue",
    "never talking bad to me again, cyrax boosing me to top1",
    "umad that you're miss? get cyrax d0g",
    "stay med that im unhitable ft cyrax",
    "get executed from cyrax technology",
    "you thinking ur have chencse vs cyrax?",
    "first i killed gejmsense, now cyrax kill you",
    "by cyrax boss aa, cya twitter bro o/",
    "cy@ https://en.neverlose.cc/market/item?id=17YLeZ",
    "courage for test resolve me. cyrax always boosting",
}

function func:get_phrase()
    return phrases[utils.random_int(1, #phrases)]:gsub('"', '')
end

function func:killsay(event)
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or not menu_cyrax.killsay_switch._:get() then return end
    local me = entity.get_local_player()
    local attackere = entity.get(event.attacker, true)

    if me == attackere then
        utils.console_exec('say "' .. func:get_phrase() .. '"')
    end
end

function func:anti_aim_bossule(cmd)

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or not menu_aa.Switch_AntiAim._:get() then return end
    local localplayer = entity.get_local_player()
    local speed = localplayer.m_vecVelocity
    local velocity = speed:length()

    if common.is_button_down(0x45) then
        conditional_aa.onuseAAEnabled = true
    else
        conditional_aa.onuseAAEnabled = false
        if CheckFlag(localplayer, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(localplayer, 1) then
                conditional_aa.inairAAEnabled = true
                conditional_aa.inairAAduckEnabled = false
            else
                conditional_aa.inairAAduckEnabled = true
                conditional_aa.inairAAEnabled = false
            end
        else
            conditional_aa.inairAAEnabled = false
            conditional_aa.inairAAduckEnabled = false
            if vars.menu.sw:get() then
                conditional_aa.slowwalkAAEnabled = true
            else
                conditional_aa.slowwalkAAEnabled = false
                if CheckFlag(localplayer, 1) then
                    conditional_aa.crouchingAAEnabled = true
                else
                    conditional_aa.crouchingAAEnabled = false
                    if velocity >= 1.2 then
                        conditional_aa.movingAAEnabled = true
                        conditional_aa.standingAAEnabled = false
                    else
                        conditional_aa.movingAAEnabled = false
                        conditional_aa.standingAAEnabled = true
                    end
                end
            end
        end
    end

    if conditional_aa.standingAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Standing._:get())

        if aantiaim.get_inverter_state() then
            
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Standing._:get())
        else
            
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Standing._:get())
        end
        
        conditional_aa.lbymode:set(menu_aa.LBYMode_Standing._:get())

        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Standing._:get())
        
        if menu_aa.YawModifierType_Standing._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Standing._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Standing._:get(), menu_aa.ModifierDegreeMax_Standing._:get()))
        end
        
        if menu_aa.FakeLimitType_Standing._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Standing._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Standing._:get())
        elseif menu_aa.FakeLimitType_Standing._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Standing._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Standing._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Standing._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Standing._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Standing._:get()))
        end
        
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Standing._:get())
        
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Standing._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Standing._:get())

        if menu_aa.YawBase_Standing._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Standing._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                conditional_aa.yawbase:set('Local View')
                for k, v in pairs(yawbases) do
                    if menu_aa.YawBase_Standing._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end

    end

    if conditional_aa.slowwalkAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Slowwalk._:get())

        if aantiaim.get_inverter_state() then
            
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Slowwalk._:get())
        else
            
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Slowwalk._:get())
        end

        
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Slowwalk._:get())
        
        if menu_aa.YawModifierType_Slowwalk._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Slowwalk._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Slowwalk._:get(), menu_aa.ModifierDegreeMax_Slowwalk._:get()))
        end
        
        if menu_aa.FakeLimitType_Slowwalk._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Slowwalk._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Slowwalk._:get())
        elseif menu_aa.FakeLimitType_Slowwalk._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Slowwalk._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Slowwalk._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Slowwalk._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Slowwalk._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Slowwalk._:get()))
        end
        
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Slowwalk._:get())
        
        conditional_aa.lbymode:set(menu_aa.LBYMode_Slowwalk._:get())
        
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Slowwalk._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Slowwalk._:get())
        
        if menu_aa.YawBase_Slowwalk._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Slowwalk._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_Slowwalk._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.movingAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Moving._:get())

        if aantiaim.get_inverter_state() then
            
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Moving._:get())
        else
            
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Moving._:get())
        end
        
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Moving._:get())
        
        if menu_aa.YawModifierType_Moving._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Moving._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Moving._:get(), menu_aa.ModifierDegreeMax_Moving._:get()))
        end
        
        if menu_aa.FakeLimitType_Moving._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Moving._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Moving._:get())
        elseif menu_aa.FakeLimitType_Moving._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Moving._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Moving._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Moving._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Moving._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Moving._:get()))
        end
        
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Moving._:get())
        
        conditional_aa.lbymode:set(menu_aa.LBYMode_Moving._:get())

        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Moving._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Moving._:get())

        if menu_aa.YawBase_Moving._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Moving._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_Moving._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.inairAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_InAir._:get())

        if aantiaim.get_inverter_state() then
            
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_InAir._:get())
        else
            
            conditional_aa.yawadd:set(menu_aa.YawAddRight_InAir._:get())
        end

        
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_InAir._:get())
        
        if menu_aa.YawModifierType_InAir._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_InAir._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_InAir._:get(), menu_aa.ModifierDegreeMax_InAir._:get()))
        end
        
        if menu_aa.FakeLimitType_InAir._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAir._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAir._:get())
        elseif menu_aa.FakeLimitType_InAir._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAir._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAir._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_InAir._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_InAir._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_InAir._:get()))
        end
        
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_InAir._:get())
        
        conditional_aa.lbymode:set(menu_aa.LBYMode_InAir._:get())

        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_InAir._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_InAir._:get())

        if menu_aa.YawBase_InAir._:get() ~= 'Disabled' then
            if menu_aa.YawBase_InAir._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_InAir._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.inairAAduckEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_InAirDuck._:get())

        if aantiaim.get_inverter_state() then
            
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_InAirDuck._:get())
        else
            
            conditional_aa.yawadd:set(menu_aa.YawAddRight_InAirDuck._:get())
        end
        
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_InAirDuck._:get())
        
        if menu_aa.YawModifierType_InAirDuck._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_InAirDuck._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_InAirDuck._:get(), menu_aa.ModifierDegreeMax_InAirDuck._:get()))
        end
        
        if menu_aa.FakeLimitType_InAirDuck._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAirDuck._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAirDuck._:get())
        elseif menu_aa.FakeLimitType_InAirDuck._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAirDuck._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAirDuck._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_InAirDuck._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_InAirDuck._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_InAirDuck._:get()))
        end
        
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_InAirDuck._:get())

        conditional_aa.lbymode:set(menu_aa.LBYMode_InAirDuck._:get())
        
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_InAirDuck._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_InAirDuck._:get())

        if menu_aa.YawBase_InAirDuck._:get() ~= 'Disabled' then
            if menu_aa.YawBase_InAirDuck._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_InAirDuck._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.crouchingAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Crouching._:get())

        if aantiaim.get_inverter_state() then
            
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Crouching._:get())
        else
            
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Crouching._:get())
        end
    
        conditional_aa.lbymode:set(menu_aa.LBYMode_Crouching._:get())
        
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Crouching._:get())
        
        if menu_aa.YawModifierType_Crouching._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Crouching._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Crouching._:get(), menu_aa.ModifierDegreeMax_Crouching._:get()))
        end
        
        if menu_aa.FakeLimitType_Crouching._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Crouching._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Crouching._:get())
        elseif menu_aa.FakeLimitType_Crouching._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Crouching._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Crouching._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Crouching._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Crouching._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Crouching._:get()))
        end
        
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Crouching._:get())
        
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Crouching._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Crouching._:get())

        if menu_aa.YawBase_Crouching._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Crouching._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_Crouching._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if override_yaw:get() ~= 'Disabled' then
        for k, v in pairs(yawbases) do
            conditional_aa.yawbase:set('Local View')
            if override_yaw:get() == tostring(k) then
                conditional_aa.yawadd:set(v)
            end
        end
    end
    
end

alpha_k = 1
width_k = 0
width_ka = 0
data_k = {
    [''] = {alpha_k = 0}
}
drag = false

local render_window = function(x, y, w, h, coloru, shadow_color, outline_color)
    local r, g, b, a = coloru.r, coloru.g, coloru.b, coloru.a
    local r1, g1, b1, a1 = shadow_color.r, shadow_color.g, shadow_color.b, shadow_color.a
    local r2, g2, b2, a2 = outline_color.r, outline_color.g, outline_color.b, outline_color.a

    render.circle_outline(vector(x + 4, y + 4), color(r, g, b, 255), 4, 165, 0.35, 1)

    render.rect(vector(x + 4, y), vector(w - 5, y+1), color(r, g, b, 255))
    render.circle_outline(vector(w - 4, y + 4), color(r, g, b, 255), 4, 260, 0.35, 1)

    render.gradient(vector(x, y + 4), vector(x + 1, h - 6), color(r, g, b, 255), color(r, g, b, 255), color(r, g, b, 0), color(r, g, b, 0))
    render.gradient(vector(w - 1, y + 4), vector(w, h - 6), color(r, g, b, 255), color(r, g, b, 255), color(r, g, b, 0), color(r, g, b, 0))

    render.rect(vector(x, y), vector(w, h), color(r2, g2, b2, (80 / 255) * gear_opt.solus_clr:get().a), 5)

    for i = 1, 5 do
        render.rect_outline(vector(x - i, y - i), vector(w + i, h + i), color(r, g, b, 0.15 * (1 - i / 5) * 255), 1, 5)
    end
    
    render.rect(vector(x+1, y+1), vector(w-1, h-1), color(0, 0, 0, gear_opt.solus_clr:get().a), 5)
    
end

function func:getbinds()
    local binds = {}
    local cheatbinds = ui.get_binds()
    
    for i = 1, #cheatbinds do
        table.insert(binds, 1, cheatbinds[i])
    end
    return binds
end

local keybind_names = {
    ['Double Tap'] = 'Double tap',
    ['Hide Shots'] = 'On shot anti-aim',
    ['Slow Walk'] = 'Slow motion',
    ['Edge Jump'] = 'Jump at edge',
    ['Fake Ping'] = 'Ping spike',
    ['Override Resolver'] = 'Resolver override',
    ['Fake Duck'] = 'Duck peek assist',
    ['Minimum Damage'] = 'Damage override',
    ['Auto Peek'] = 'Quick peek assist',
    ['Body Aim'] = 'Force body aim',
    ['Safe Points'] = 'Safe points',
    ['Yaw Base'] = 'Yaw base',
    ['Enable Thirdperson'] = 'Thirdperson',
    ['Manual Yaw Base'] = 'Yaw base',
}

function upper_to_lower(str)
    str1 = string.sub(str, 2, #str)
    str2 = string.sub(str, 1, 1)
    return str2:upper()..str1:lower()
end

local render_solus = function(x2, y2, w, h, name, font)
    local name_size = render.measure_text(font, nil, name)
    render_window(x2, y2, x2 + w + 3, y2 + h + 2, color(gear_opt.solus_clr:get().r, gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255), color(gear_opt.solus_clr:get().r, gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255), color(gear_opt.solus_clr:get().r, gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255))
    render.text(font, vector(x2+1 + w / 2 + 1 - name_size.x / 2, y2 + 2), color(255,255,255, 255), nil, name)
end

function func:solus_keybinds()
    if not gear_opt.solus_binds:get() or menu_cyrax.visuals_switch._:get() == false or not menu_cyrax.solus_switch._:get() then return end
    local x_k, y_k = gear_opt.solus_1:get(),gear_opt.solus_2:get()
    local max_width = 0
    local frametime = globals.frametime * 16
    local add_y = 0
    local total_width = 66
    local active_binds = {}
    local bind = func:getbinds()
    for i = 1, #bind do
        local binds = bind[i]
        local bind_name = keybind_names[binds.name] == nil and upper_to_lower(binds.name) or keybind_names[binds.name]

        local bind_state = binds.mode
        if bind_state == 2 then
            bind_state = 'toggled'
        elseif bind_state == 1 then
            bind_state = 'holding'
        end
        if binds.name == "Minimum Damage" then
            bind_state = binds.value
        end
        
        if data_k[bind_name] == nil then
            data_k[bind_name] = {alpha_k = 0}
        end
        --if (ui.get_alpha() > 0.9) then
        --    bind_name = 'Menu toggled'
        --end
        data_k[bind_name].alpha_k = solus_lerp(frametime, data_k[bind_name].alpha_k,binds.active and 1 or 0)
        local bind_state_size = render.measure_text(vars.font.verdana, nil, bind_state)
        local bind_name_size = render.measure_text(vars.font.verdana, nil, bind_name)

        render.text(vars.font.verdana, vector(x_k+4, y_k + 21 + add_y), color(0, 0, 0, data_k[bind_name].alpha_k*255), nil, bind_name)
        render.text(vars.font.verdana, vector(x_k+1 + (width_ka - bind_state_size.x - 8), y_k + 21 + add_y), color(0, 0, 0, data_k[bind_name].alpha_k*255) , nil, '['..bind_state..']')

        render.text(vars.font.verdana, vector(x_k+3, y_k + 20 + add_y), color(255, 255, 255, data_k[bind_name].alpha_k*255), nil, bind_name)
        render.text(vars.font.verdana, vector(x_k + (width_ka - bind_state_size.x- 8), y_k + 20 + add_y), color(255, 255, 255, data_k[bind_name].alpha_k*255), nil , '['..bind_state..']')

        add_y = add_y + 16 * data_k[bind_name].alpha_k

        
        local width_k = bind_state_size.x + bind_name_size.x + 18
        if width_k > 150-11 then
            if width_k > max_width then
                max_width = width_k
            end
        end
        if binds.active then
            table.insert(active_binds, binds)
        end
    end
    alpha_k = solus_lerp(frametime,alpha_k, ((ui.get_alpha() > 0.9) or #active_binds > 0) and 1 or 0)
    width_ka = solus_lerp(frametime,width_ka,math.max(max_width, 150-11))

    if (ui.get_alpha() > 0.5) or #active_binds > 0 then
        render_solus(x_k, y_k, width_ka, 16, 'keybinds', 11, vars.font.verdana)

        local mouse = ui.get_mouse_position()
        if common.is_button_down(1) and (ui.get_alpha() > 0.9) then
            if mouse.x >= x_k and mouse.y >= y_k and mouse.x <= x_k + width_ka and mouse.y <= y_k + 18 or drag then
                if not drag then
                    drag=true
                else
                    gear_opt.solus_1:set(mouse.x - math.floor(width_ka / 2))
                    gear_opt.solus_2:set(mouse.y - 8)
                end
            end
        else
            drag=false
        end
    end
end

func:solus_watermark()
    if not gear_opt.solus_watermark:get() or menu_cyrax.visuals_switch._:get() == false or not menu_cyrax.solus_switch._:get() then return end
    lua_name = string.format("cyrax.tech")
    user_name = common.get_username()
    time = common.get_date("%H:%M:%S")
    watermark_text = string.format("%s | %s | %s", lua_name, user_name, time)

    if globals.is_in_game then
        local ping = utils.net_channel().avg_latency[0]*1000
        final_latency = ('delay: %dms'):format(ping)
        watermark_text = string.format("%s | %s | %s | %s", lua_name, user_name, final_latency, time)
    end

    cock_size = render.measure_text(vars.font.verdana, nil, watermark_text)
    render_solus(render.screen_size().x - cock_size.x - 15, 3, cock_size.x + 5, 16, watermark_text, 11, vars.font.verdana)
end
local function gradient_text(r1, g1, b1, a1, r2, g2, b2, a2, text)
    local output = ''
    local len = #text-1
    local rinc = (r2 - r1) / len
    local ginc = (g2 - g1) / len
    local binc = (b2 - b1) / len
    local ainc = (a2 - a1) / len
    for i=1, len+1 do
        output = output .. ('\a%02x%02x%02x%02x%s'):format(r1, g1, b1, a1, text:sub(i, i))
        r1 = r1 + rinc
        g1 = g1 + ginc
        b1 = b1 + binc
        a1 = a1 + ainc
    end
    return output
end

func:watermark()
    if not menu_cyrax.watermark_switch._:get() or not menu_cyrax.visuals_switch._:get() then return end
    local alpha = math.abs(1 * math.cos(2 * math.pi * (globals.curtime + 3) / 5)) * 255
    local alpha2 = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 5)) * 255
    local amangas = gradient_text(gear_opt.wm_color:get().r, gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, alpha, 255, 255, 255, 0, string.format(' >/cyrax anti aim technologies [%s]/<', string.lower(func:version())))
    local amangas2 = gradient_text(255, 255, 255, 0, gear_opt.wm_color:get().r, gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, alpha2, string.format(' >/cyrax anti aim technologies [%s]/<', string.lower(func:version())))
    local amangas3 = gradient_text(gear_opt.wm_color:get().r, gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, 255, gear_opt.wm_color2:get().r, gear_opt.wm_color2 :get().g, gear_opt.wm_color2:get().b, 255, string.format('>/cyrax anti aim technologies [%s]/<', string.lower(func:version())))
    if gear_opt.animate:get() then
        render.text(1, vector(10, 450), color(0, 0, 0), nil, string.format('>/cyrax anti aim technologies [%s]/<', string.lower(func:version ())))
        render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas)
        render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas2)
        gear_opt.wm_color2:set_visible(false)
    else
        gear_opt.wm_color2:set_visible(true)
        render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas3)
    end
end

local alpha123 = 0
local time = anim_switch:get() and math.floor(globals.realtime) or 0

func:loading()
    local screen = render.screen_size()
    if math.floor(globals.realtime) - time > 8 or not anim_switch:get() then return end

    if globals.realtime - time > 5 then
        alpha123 = math.clamp(alpha123 - 1, 0, 50)
    else
        alpha123 = math.clamp(alpha123 + 1, 0, 50)   
    end
    
    render.rect(vector(0, 0), vector(screen.x, screen.y), color(245, 202, 182, alpha123))   

    render.texture(gif, vector(screen.x/2.8, screen.y/4), vector(540, 540), color(255, 255, 255, alpha123 * 5.5))

end

hooked_function = nil
ground_ticks, end_time = 1, 0
function updateCSA_hk(thisptr, edx)
    if entity.get_local_player() == nil or ffi.cast('uintptr_t', thisptr) == nil then return end
    hooked_function(thisptr, edx)
    if gear_opt.anim:get("Static Legs") and menu_cyrax.animbreaker_switch._:get() then
        ffi.cast('float*', ffi.cast('uintptr_t', thisptr) + 10104)[6] = 1
    end
    if gear_opt.anim:get("Leg Breaker") and menu_cyrax.animbreaker_switch._:get() then
        ffi.cast('float*', ffi.cast('uintptr_t', thisptr) + 10104)[0] = 1
        conditional_aa.legmovement:set('Sliding')
    end
end


function anim_state_hook()
    local local_player = entity.get_local_player()
    if not local_player then return end

    local local_player_ptr = get_entity_address(local_player:get_index())
    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_hk, 224)
end

local handleSaveConfig = {
    switch = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end,

    slider = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end,

    color_picker = function(el)
        local clr = el._:get()
        return {
            name = el.name,
            element = el.element,
            color={
                r = clr.r,
                g = clr.g,
                b = clr.b,
                a = clr.a
            }
        }
    end,

    combo = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end,

    selectable = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end

}

local handleLoadConfig = {
    switch = function(el)
        menu_aa[el.name]._:set(el.value)
    end,

    slider = function(el)
        menu_aa[el.name]._:set(el.value)
    end,

    color_picker = function(el)
        local clr = init(el.color.r, el.color.g, el.color.b, el.color.a)
        menu_aa[el.name]._:set(clr)
    end,

    combo = function(el)
        menu_aa[el.name]._:set(el.value)
    end,

    selectable = function(el)
        pcall(function() return menu_aa[el.name]._:set(el.value) end)
    end

}

gear_opt.export:set_callback(function()

    local config = {}

    for key, el in pairs(menu_aa) do
        if el.element == "Button" then goto continue end
        table.insert(config, handleSaveConfig[el.element](el))
        ::continue::
    end

    clipboard.set(base64.encode(json.stringify(config)))
    print_dev("Cyrax - Config saved to clipboard")

    table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sConfig \a%sExported", gear_opt.logs_hit:get():to_hex(), gear_opt. logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
end)

gear_opt.import:set_callback(function()
    local status, config = pcall(function() return json.parse(base64.decode(clipboard.get())) end)

    if not status or status == nil then     
        color_p("Cyrax: Failed to load config\n", color(1, 0, 0, 1))
        print_dev("Cyrax - Failed to load config")
        table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] Failed \a%sto \a%sImport \a%sConfig", gear_opt.logs_miss:get():to_hex (), gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_miss:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor( globals.curtime), 255, clr = gear_opt.logs_hit:get()})
    return end
    
    for key, el in pairs(config) do
        if el.element == "Button" then goto continue end
        handleLoadConfig[el.element](el)
        ::continue::
    end
    print_dev("Cyrax - Config loaded")
    table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sConfig \a%sImported", gear_opt.logs_hit:get():to_hex(), gear_opt. logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
    menu_aa.YawBase_InAir._:set('At Target')
end)

gear_opt.default:set_callback(function()

    local status, config = pcall(function() return json.parse(base64.decode(network.get('https://pastes.io/raw/7fr1wkdx5e'))) end)

    if not status or status == nil then     
        color_p("Cyrax: Failed to load config\n", color(1, 0, 0, 1))
    return end
    
    for key, el in pairs(config) do
        if el.element == "Button" then goto continue end
        handleLoadConfig[el.element](el)
        ::continue::
    end
    print_dev("Cyrax - Default config loaded")
    menu_aa.YawBase_InAir._:set('At Target')
    table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sDefault Config \a%sLoaded", gear_opt.logs_hit:get():to_hex(), gear_opt .logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor(globals.curtime) , 255, clr = gear_opt.logs_hit:get()})
end)

function callbacks.render()
    func:customscope()
    func:jumpscout_fix_f()
    func:cyrax_ind()
    func:cyrax_ind_2()
    func:cyrax_ind_3()
    func:cyrax_ind_4()
    if globals.realtime > 60 then func:loading() end
    func:funnydog()
    func:solus_keybinds()
    func:drawscreenLogs()
    func:solus_watermark()
    func:watermark()
    local anim = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 14)) * 11
    ui.sidebar("\aFFD5BBFF" .. str:sub(1, anim), 'moon')
end
function callbacks.pre_render()
    cyraxUI.visibility()
end
function callbacks.createmove()
end

function callbacks.player_death(event)
    func:killsay(event)
end

function callbacks.createmove_run(cmd)
    anim_state_hook()
    func:anti_aim_bossule(cmd)
end

function callbacks.aim_fire(e)
end

function callbacks.aim_ack(e)
    func:centerLogs(e)
    func:screenLogs(e)
end

events.render:set(callbacks.render)
events.pre_render:set(callbacks.pre_render)
events.aim_ack:set(callbacks.aim_ack)
events.aim_fire:set(callbacks.aim_fire)
events.player_death:set(callbacks.player_death)
events.createmove:set(callbacks.createmove)
events.createmove_run:set(callbacks.createmove_run)
events.shutdown:set(function()
    for _, reset_function in ipairs(vmt_hook.hooks) do
        reset_function()
    end
end)

 

[Tech1337]

crash

 

[katzen]

local bit = require("bit")
local ffi = require("ffi")
local clipboard = require("neverlose/clipboard")
local base64 = require("neverlose/base64")
local aantiaim = require("neverlose/anti_aim")
local color_p = require("neverlose/color_print")
local texts = render.measure_text
local beta = 'Debug' -- 'Debug' or 'Beta' or 'Live'
local username = common.get_username() -- getting cheat username pls elleqt allow me
local callbacks = {}
local func = {}
local tbl = {}
local str = 'Cyrax.Tech'
local yawbases = {
    Forward = 180,
    Left = -90,
    Right = 90,
    Backward = 0,
}
ffi.cdef[[
   
    typedef struct
    {
        float x;
        float y;
        float z;
    } Vector_t;

    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
    {
        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;

    ]]
local log = {}
local cyraxUI = {}
local conditional_aa = {}
conditional_aa.pitch = ui.find("Aimbot", "Anti Aim", "Angles", "Pitch")
conditional_aa.yawbase = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw")
conditional_aa.yawadd = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset")
conditional_aa.yawmodifier = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier")
conditional_aa.modifierdegree = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier", "Offset")
conditional_aa.fakelimitleft = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Left Limit")
conditional_aa.fakelimitright = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Right Limit")
conditional_aa.fakeoptions = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Options")
conditional_aa.lbymode = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "LBY Mode")
conditional_aa.freestandingdesync = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Freestanding")
conditional_aa.desynconshot = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "On Shot")
conditional_aa.slow_walk = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk")
conditional_aa.legmovement = ui.find("Aimbot", "Anti Aim", "Misc", "Leg Movement")
conditional_aa.freestanding = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding")
conditional_aa.freestanding_setts = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding", "Disable Yaw Modifiers")

local urlmon = ffi.load 'UrlMon'
local wininet = ffi.load 'WinInet'

function func:lerp(a, b, t)
    return a + (b - a) * t
end
local solus_lerp = function(time,a,b)
    return a * (1-time) + b * time
end

panorama.loadstring([[
    return {
        asdstringify: JSON.stringify,
        asdparse: JSON.parse
    };
]], "CSGOMainMenu")()

ffi.cdef[[
    void* __stdcall URLDownloadToFileA(void* LPUNKNOWN, const char* LPCSTR, const char* LPCSTR2, int a, int LPBINDSTATUSCALLBACK);

    bool DeleteUrlCacheEntryA(const char* lpszUrlName);
]]

function func:contains(list, x)
    for _, v in pairs(list) do
        if v == x then return true end
    end
    return false
end
function func:get_neverlose_path()
    return common.get_game_directory():sub(1, -5) .. "nl\\"
end
files.create_folder(common.get_game_directory().."\\sound\\cyrax\\")
function func:Download(from, to)
    wininet.DeleteUrlCacheEntryA(from)
    urlmon.URLDownloadToFileA(nil, from, to, 0,0)
end
function func:file_exists(file, path_id)
    local func_file_exists = ffi.cast("bool (__thiscall*)(void*, const char*, const char*)", ffi.cast(ffi.typeof("void***"), utils.create_interface("filesystem_stdio.dll", "VBaseFileSystem011"))[0][10])
    return func_file_exists(ffi.cast(ffi.typeof("void***"), utils.create_interface("filesystem_stdio.dll", "VBaseFileSystem011")), file, path_id)
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\skeet.tff", "GAME") then
    func:Download('https://github.com/fakeangle/neverlose_bettervisuals/blob/main/Small_Fonts.ttf?raw=true', func:get_neverlose_path().."Cyrax\\skeet.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\smallest.tff", "GAME") then
    func:Download('https://github.com/fakeangle/neverlose_bettervisuals/blob/main/smallest_pixel-7.ttf?raw=true', func:get_neverlose_path().."Cyrax\\smallest.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\code_bold.tff", "GAME") then
    func:Download('https://github.com/lordcristi/whatisthis/blob/main/CODE%20Bold.ttf?raw=true', func:get_neverlose_path().."Cyrax\\code_bold.tff")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\cyrax1.gif", "GAME") then
    func:Download('https://raw.githubusercontent.com/lordcristi/whatisthis/main/21.gif', func:get_neverlose_path().."Cyrax\\cyrax1.gif")
end

if not func:file_exists(func:get_neverlose_path().."Cyrax\\funny_dog.png", "GAME") then
    func:Download('https://raw.githubusercontent.com/lordcristi/whatisthis/main/shaved_cat.png', func:get_neverlose_path().."Cyrax\\funny_dog.png")
end

files.create_folder(func:get_neverlose_path().."Cyrax\\")

local vars = {
    font = {
        pixel = render.load_font(func:get_neverlose_path().."Cyrax\\smallest.tff", 10, 'o'),
        verdana = render.load_font("Verdana", 11),
        verdana_r = render.load_font("Verdana", 11, 'a'),
        calibri = render.load_font("Calibri", 16, 'b'),
        calibri_dog = render.load_font(func:get_neverlose_path().."Cyrax\\code_bold.tff", 35),
        calibri_dog2 = render.load_font(func:get_neverlose_path().."Cyrax\\code_bold.tff", 10),
        skeet = render.load_font(func:get_neverlose_path().."Cyrax\\skeet.tff", 11, 'o')},
    menu = {
        thirdperson = ui.find("Visuals", "World", "Main", "Force Thirdperson"),
        dt = ui.find("Aimbot", "Ragebot", "Main", "Double Tap"),
        hs = ui.find("Aimbot", "Ragebot", "Main", "Hide Shots"),
        fd = ui.find("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
        fs = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"),
        remove_scope = ui.find("Visuals", "World", "Main", "Override Zoom", "Scope Overlay"),
        qp = ui.find("Aimbot", "Ragebot", "Main", "Peek Assist"),
        sw = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk"),
        fl = ui.find("Aimbot", "Anti Aim", "Fake Lag", "Enabled"),
        body = ui.find("Aimbot", "Ragebot", "Safety", "Body Aim"),
        sp = ui.find("Aimbot", "Ragebot", "Safety", "Safe Points")
    },
    da = {
        [1] = true,
        [2] = true,
        [3] = true,
        [4] = true
    },
    sus = {
        [1] = 40,
        [2] = 31,
        [3] = 9,
        [4] = 1
    },
    ind = {
        fs_alpha = 0,
        dt_alpha = 0,
        dmg_alpha = 0,
        dt_bar_alpha = 0,
        hs_pos = 0,
        dmg_pos = 0,
        dmg_val = 0,
        smooth = 0,
        scope_smooth = 2,
        legacy_check = false,
        v2 = {
            a = {          
                [1] = {
                    0,
                    0,
                    0,
                },
                [2] = 0,
                [3] = 0,
                [4] = 0,
            },
            p = {          
                [1] = 40,
                [2] = 40,
                [3] = 40,
            },
            cond_text = "amingus"
        },
        lavendu = {
            textu = "",
            anim = {
                [1] = {
                    dt = 0,
                    fs = 0,
                },
                [2] = {
                    dt = 0,
                    fs = 0,
                },
                [3] = {
                    [1] = 0,
                    [2] = 0,
                    [3] = 0,
                },
            },
            chestie = 0,
        },
    },
    mark = {
       
    },
    pi_divided = math.pi / 180,
}

function func:version()
    return beta
end

local function IsPlayer(player)
    if not player then return false end
    if not player:is_bot() then return true end
end

function func:CanSee(self, entity)
    if not entity then return false end
    if IsPlayer(entity) then return false end

    local hitboxes = {0, 5, 7, 8, 11, 12, 13, 14, 15, 17}

    for i, hitbox in pairs(hitboxes) do
        local trace = utils.trace_line(self:get_eye_position(), entity:get_hitbox_position(hitbox), self, 0x4600400B)
        if trace.hit_entity then
            return IsPlayer(trace.hit_entity)
        end
    end
    return false
end
color_p("cyrax - ", color(255,255,255,255))
color_p("information \n", color(222, 194, 153, 255))
color_p("version - ", color(255,255,255,255))
color_p(string.lower(func:version().."\n"), color(222, 194, 153, 255))
color_p("username - ", color(255,255,255,255))
color_p(username.."\n", color(222, 194, 153, 255))
color_p("discord server - ", color(255,255,255,255))
color_p("https://discord.gg/R5VrugTNbg\n", color(222, 194, 153, 255))

local group = {
    info = {
        gif = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", ""),
        info = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\aFFD5BBFFInformation"),
        cfg = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\aFFD5BBFFConfigs"),
        misc = ui.create("\afbfbfbffI\afbf7f5ffn\afcf3eefff\afcf0e8ffo\afdece1ffr\afde8dbffm\afde4d5ffa\afee0cefft\afeddc8ffi\affd9c1ffo\affd5bbffn", "\aFFD5BBFFMisc"),
    },
    aa = {
        aa = ui.create("\aFFD5BBFFAnti-Aim", "Anti-Aim"),
        conditions = {
            standing = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFStanding"),
            crouching = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFCrouching"),
            slowwalk = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFSlowwalk"),
            moving = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFMoving"),
            in_air = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFIn Air"),
            in_air_d = ui.create("\aFFD5BBFFAnti-Aim", "\aFFD5BBFFIn Air + Duck"),
        },
    },
    settings = {
        visuals = ui.create("\affd5bbffS\affdbc5ffe\affe1cefft\affe7d8fft\affede2ffi\afff3ecffn\afff9f5ffg\affffffffs", "Visuals"),
        misc = ui.create("\affd5bbffS\affdbc5ffe\affe1cefft\affe7d8fft\affede2ffi\afff3ecffn\afff9f5ffg\affffffffs", "Miscellaneous"),
    },
}
print_dev("Cyrax - Welcome, "..username..".")
-- INFORMATION
local gif = render.load_image_from_file(func:get_neverlose_path().."Cyrax\\cyrax1.gif", vector(540, 540))
local dog = render.load_image_from_file(func:get_neverlose_path().."Cyrax\\funny_dog.png", vector(828, 828))
group.info.gif:texture(gif,vector(270, 270), color(255, 255, 255), 'f')
group.info.info:label("User: \aFFD5BBFF"..username)
group.info.info:label("Build: \aFFD5BBFF"..func:version())
group.info.info:label("If you have any issues open a ticket in the discord server or message \aFFD5BBFFcomezo#2441")
group.info.cfg:button("Discord Link", function() panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://discord.gg/R5VrugTNbg") end, true)
group.info.cfg:button("Neverlose Config", function() panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://en.neverlose.cc/market/item?id=yXbDoa") end, true)
local anim_switch = group.info.misc:switch("Loading Animation", true)
local funny_dog = group.info.misc:switch("Funny Dog", true)
local smooth = {0, 0, 0}
function func:funnydog()
    local screen = render.screen_size()

    if funny_dog:get() then
        smooth[1] = func:lerp(smooth[1], 150, globals.frametime * 5)
        smooth[3] = func:lerp(smooth[3], ui.get_position().y - 125, globals.frametime * 5)
    else
        smooth[1] = func:lerp(smooth[1], 0, globals.frametime * 5)
        smooth[3] = func:lerp(smooth[3], screen.y, globals.frametime * 5)
    end
    smooth[2] = func:lerp(smooth[2], ui.get_position().x - 20, globals.frametime * 5)

    render.texture(dog, vector(smooth[2], smooth[3]), vector(smooth[1], smooth[1]), color(255, 255, 255,  smooth[1]*1.7), 'f')

end
local menu_cyrax = {
    visuals_switch = {
        _ = group.settings.visuals:switch("\aFFD5BBFFEnable Visual Options", false),
        name = "visuals_switch",
        element = "switch"
    },
    indicators_switch = {
        _ = group.settings.visuals:switch("Indicators", false),
        name = "indicators_switch",
        element = "switch"
    },
    watermark_switch = {
        _ = group.settings.visuals:switch("Watermark", false),
        name = "watermark_switch",
        element = "switch"
    },
    scope_switch = {
        _ = group.settings.visuals:switch("Custom Scope", false),
        name = "scope_switch",
        element = "switch"
    },
    logs_switch = {
        _ = group.settings.visuals:switch("Aimbot Logging", false),
        name = "logs_switch",
        element = "switch"
    },
    solus_switch = {
        _ = group.settings.visuals:switch("Widgets", false),
        name = "solus_switch",
        element = "switch"
    },
    misc_switch = {
        _ = group.settings.misc:switch("\aFFD5BBFFEnable Miscellaneous Options", false),
        name = "misc_switch",
        element = "switch"
    },
    jumpscout_switch = {
        _ = group.settings.misc:switch("Jumpscout Fix", false),
        name = "jumpscout_switch",
        element = "switch"
    },
    killsay_switch = {
        _ = group.settings.misc:switch("Killsay", false),
        name = "killsay_switch",
        element = "switch"
    },
    animbreaker_switch = {
        _ = group.settings.misc:switch("Anim. Breaker", false),
        name = "animbreaker_switch",
        element = "switch"
    }
}
local data = {

    YawBase_Standing = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_Crouching = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_Slowwalk = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_Moving = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_InAir = {"Forward", "Backward", "Right", "Left", "At Target"},
    YawBase_InAirDuck = {"Forward", "Backward", "Right", "Left", "At Target"},

    Pitch_Standing = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_Crouching = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_Slowwalk = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_Moving = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_InAir = {"Disabled", "Down", "Fake Down", "Fake Up"},
    Pitch_InAirDuck = {"Disabled", "Down", "Fake Down", "Fake Up"},

    YawModifier_Standing = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_Crouching = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_Slowwalk = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_Moving = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_InAir = {"Disabled", "Center", "Offset", "Random", "Spin"},
    YawModifier_InAirDuck = {"Disabled", "Center", "Offset", "Random", "Spin"},

    YawModifierType_Standing = {"Default", "Random"},
    YawModifierType_Crouching = {"Default", "Random"},
    YawModifierType_Slowwalk = {"Default", "Random"},
    YawModifierType_Moving = {"Default", "Random"},
    YawModifierType_InAir = {"Default", "Random"},
    YawModifierType_InAirDuck = {"Default", "Random"},

    FakeLimitType_Standing = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_Crouching = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_Slowwalk = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_Moving = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_InAir = {"Static", "Jitter", "Random Jitter"},
    FakeLimitType_InAirDuck = {"Static", "Jitter", "Random Jitter"},

    FakeOptions_Standing = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_Crouching = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_Slowwalk = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_Moving = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_InAir = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},
    FakeOptions_InAirDuck = {"Avoid Overlap", "Jitter", "Randomize Jitter", "Anti Bruteforce"},

    LBYMode_Standing = {"Disabled", "Opposite", "Sway"},
    LBYMode_Crouching = {"Disabled", "Opposite", "Sway"},
    LBYMode_Slowwalk = {"Disabled", "Opposite", "Sway"},
    LBYMode_Moving = {"Disabled", "Opposite", "Sway"},
    LBYMode_InAir = {"Disabled", "Opposite", "Sway"},
    LBYMode_InAirDuck = {"Disabled", "Opposite", "Sway"},

    FreestandingDesync_Standing = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_Crouching = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_Slowwalk = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_Moving = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_InAir = {"Off", "Peek Fake", "Peek Real"},
    FreestandingDesync_InAirDuck = {"Off", "Peek Fake", "Peek Real"},

    DesyncOnShot_Standing = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_Crouching = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_Slowwalk = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_Moving = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_InAir = {"Disabled", "Opposite", "Freestanding", "Switch"},
    DesyncOnShot_InAirDuck = {"Disabled", "Opposite", "Freestanding", "Switch"},

    indicators_styles = {"Cyrax", "Cyrax V2", "Cyrax V3", "Cyrax V4"},

    sparg = {"Static Legs In Air", "Leg Breaker"},

}
local menu_aa = {

    Switch_AntiAim = {
        _ = group.aa.aa:switch("\aFFD5BBFFEnable Custom Anti Aim", false),
        name = "Switch_AntiAim",
        element = "switch"
    },

    --YAW BASE
   
    YawBase_Standing = {
        _ = group.aa.conditions.standing:combo("Yaw Base", data.YawBase_Standing, 0),
        name = "YawBase_Standing",
        element = "combo"
    },
    YawBase_Crouching = {
        _ = group.aa.conditions.crouching:combo("Yaw Base", data.YawBase_Crouching, 0),
        name = "YawBase_Crouching",
        element = "combo"
    },
    YawBase_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Yaw Base", data.YawBase_Slowwalk, 0),
        name = "YawBase_Slowwalk",
        element = "combo"
    },
    YawBase_Moving = {
        _ = group.aa.conditions.moving:combo("Yaw Base", data.YawBase_Moving, 0),
        name = "YawBase_Moving",
        element = "combo"
    },
    YawBase_InAir = {
        _ = group.aa.conditions.in_air:combo("Yaw Base", data.YawBase_InAir, 0),
        name = "YawBase_InAirDuck",
        element = "combo"
    },
    YawBase_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Yaw Base", data.YawBase_InAirDuck, 0),
        name = "YawBase_InAirDuck",
        element = "combo"
    },
   
    --YAW ADD LEFT
   
    YawAddLeft_Standing = {
        _ = group.aa.conditions.standing:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Standing",
        element = "slider"
    },
    YawAddLeft_Crouching = {
        _ = group.aa.conditions.crouching:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Crouching",
        element = "slider"
    },
    YawAddLeft_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Slowwalk",
        element = "slider"
    },
    YawAddLeft_Moving = {
        _ = group.aa.conditions.moving:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_Moving",
        element = "slider"
    },
    YawAddLeft_InAir = {
        _ = group.aa.conditions.in_air:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_InAir",
        element = "slider"
    },
    YawAddLeft_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Yaw Add Left", -180, 180, 0),
        name = "YawAddLeft_InAirDuck",
        element = "slider"
    },
   
    --YAW ADD RIGHT
   
    YawAddRight_Standing = {
        _ = group.aa.conditions.standing:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Standing",
        element = "slider"
    },
    YawAddRight_Crouching = {
        _ = group.aa.conditions.crouching:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Crouching",
        element = "slider"
    },
    YawAddRight_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Slowwalk",
        element = "slider"
    },
    YawAddRight_Moving = {
        _ = group.aa.conditions.moving:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_Moving",
        element = "slider"
    },
    YawAddRight_InAir = {
        _ = group.aa.conditions.in_air:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_InAir",
        element = "slider"
    },
    YawAddRight_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Yaw Add Right", -180, 180, 0),
        name = "YawAddRight_InAirDuck",
        element = "slider"
    },
   
    --PITCH
   
    Pitch_Standing = {
        _ = group.aa.conditions.standing:combo("Pitch", data.Pitch_Standing, 0),
        name = "Pitch_Standing",
        element = "combo"
    },
    Pitch_Crouching = {
        _ = group.aa.conditions.crouching:combo("Pitch", data.Pitch_Crouching, 0),
        name = "Pitch_Crouching",
        element = "combo"
    },
    Pitch_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Pitch", data.Pitch_Slowwalk, 0),
        name = "Pitch_Slowwalk",
        element = "combo"
    },
    Pitch_Moving = {
        _ = group.aa.conditions.moving:combo("Pitch", data.Pitch_Moving, 0),
        name = "Pitch_Moving",
        element = "combo"
    },
    Pitch_InAir = {
        _ = group.aa.conditions.in_air:combo("Pitch", data.Pitch_InAir, 0),
        name = "Pitch_InAir",
        element = "combo"
    },
    Pitch_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Pitch", data.Pitch_InAirDuck, 0),
        name = "Pitch_InAirDuck",
        element = "combo"
    },
   
    --YAW MODIFIER
   
    YawModifier_Standing = {
        _ = group.aa.conditions.standing:combo("Yaw Modifier", data.YawModifier_Standing, 0),
        name = "YawModifier_Standing",
        element = "combo"
    },      
    YawModifier_Crouching = {
        _ = group.aa.conditions.crouching:combo("Yaw Modifier", data.YawModifier_Crouching, 0),
        name = "YawModifier_Crouching",
        element = "combo"
    },      
    YawModifier_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Yaw Modifier", data.YawModifier_Slowwalk, 0),
        name = "YawModifier_Slowwalk",
        element = "combo"
    },      
    YawModifier_Moving = {
        _ = group.aa.conditions.moving:combo("Yaw Modifier", data.YawModifier_Moving, 0),
        name = "YawModifier_Moving",
        element = "combo"
    },
    YawModifier_InAir = {
        _ = group.aa.conditions.in_air:combo("Yaw Modifier", data.YawModifier_InAir, 0),
        name = "YawModifier_InAir",
        element = "combo"
    },
    YawModifier_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Yaw Modifier", data.YawModifier_InAirDuck, 0),
        name = "YawModifier_InAirDuck",
        element = "combo"
    },
   
    --YAW MODIFIER TYPE
   
    YawModifierType_Standing = {
        _ = group.aa.conditions.standing:combo("Yaw Modifier Type", data.YawModifierType_Standing, 0),
        name = "YawModifierType_Standing",
        element = "combo"
    },      
    YawModifierType_Crouching = {
        _ = group.aa.conditions.crouching:combo("Yaw Modifier Type", data.YawModifierType_Crouching, 0),
        name = "YawModifierType_Crouching",
        element = "combo"
    },      
    YawModifierType_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Yaw Modifier Type", data.YawModifierType_Slowwalk, 0),
        name = "YawModifierType_Slowwalk",
        element = "combo"
    },      
    YawModifierType_Moving = {
        _ = group.aa.conditions.moving:combo("Yaw Modifier Type", data.YawModifierType_Moving, 0),
        name = "YawModifierType_Moving",
        element = "combo"
    },
    YawModifierType_InAir = {
        _ = group.aa.conditions.in_air:combo("Yaw Modifier Type", data.YawModifierType_InAir, 0),
        name = "YawModifierType_InAir",
        element = "combo"
    },
    YawModifierType_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Yaw Modifier Type", data.YawModifierType_InAirDuck, 0),
        name = "YawModifierType_InAirDuck",
        element = "combo"
    },
   
    --MODIFIER DEGREE  
   
    ModifierDegree_Standing = {
        _ = group.aa.conditions.standing:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Standing",
        element = "slider"
    },
    ModifierDegree_Crouching = {
        _ = group.aa.conditions.crouching:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Crouching",
        element = "slider"
    },
    ModifierDegree_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Slowwalk",
        element = "slider"
    },
    ModifierDegree_Moving = {
        _ = group.aa.conditions.moving:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_Moving",
        element = "slider"
    },
    ModifierDegree_InAir = {
        _ = group.aa.conditions.in_air:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_InAir",
        element = "slider"
    },
    ModifierDegree_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Modifier Degree", -180, 180, 0),
        name = "ModifierDegree_InAirDuck",
        element = "slider"
    },
   
    --MODIFIER DEGREE MINMINUM
   
    ModifierDegreeMin_Standing = {
        _ = group.aa.conditions.standing:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Standing",
        element = "slider"
    },
    ModifierDegreeMin_Crouching = {
        _ = group.aa.conditions.crouching:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Crouching",
        element = "slider"
    },
    ModifierDegreeMin_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Slowwalk",
        element = "slider"
    },
    ModifierDegreeMin_Moving = {
        _ = group.aa.conditions.moving:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_Moving",
        element = "slider"
    },
    ModifierDegreeMin_InAir = {
        _ = group.aa.conditions.in_air:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_InAir",
        element = "slider"
    },
    ModifierDegreeMin_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Modifier Degree Min", -180, 180, 0),
        name = "ModifierDegreeMin_InAirDuck",
        element = "slider"
    },
   
    --MODIFIER DEGREE MAXIMUM
   
    ModifierDegreeMax_Standing = {
        _ = group.aa.conditions.standing:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Standing",
        element = "slider"
    },
    ModifierDegreeMax_Crouching = {
        _ = group.aa.conditions.crouching:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Crouching",
        element = "slider"
    },
    ModifierDegreeMax_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Slowwalk",
        element = "slider"
    },
    ModifierDegreeMax_Moving = {
        _ = group.aa.conditions.moving:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_Moving",
        element = "slider"
    },
    ModifierDegreeMax_InAir = {
        _ = group.aa.conditions.in_air:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_InAir",
        element = "slider"
    },
    ModifierDegreeMax_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Modifier Degree Max", -180, 180, 0),
        name = "ModifierDegreeMax_InAirDuck",
        element = "slider"
    },
   
    --FAKE LIMIT TYPE
   
    FakeLimitType_Standing = {
        _ = group.aa.conditions.standing:combo("Fake Limit Type", data.FakeLimitType_Standing, 0),
        name = "FakeLimitType_Standing",
        element = "combo"
    },
    FakeLimitType_Crouching = {
        _ = group.aa.conditions.crouching:combo("Fake Limit Type", data.FakeLimitType_Crouching, 0),
        name = "FakeLimitType_Crouching",
        element = "combo"
    },
    FakeLimitType_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Fake Limit Type", data.FakeLimitType_Slowwalk, 0),
        name = "FakeLimitType_Slowwalk",
        element = "combo"
    },
    FakeLimitType_Moving = {
        _ = group.aa.conditions.moving:combo("Fake Limit Type", data.FakeLimitType_Moving, 0),
        name = "FakeLimitType_Moving",
        element = "combo"
    },
    FakeLimitType_InAir = {
        _ = group.aa.conditions.in_air:combo("Fake Limit Type", data.FakeLimitType_InAir, 0),
        name = "FakeLimitType_InAir",
        element = "combo"
    },
    FakeLimitType_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Fake Limit Type", data.FakeLimitType_InAirDuck, 0),
        name = "FakeLimitType_InAirDuck",
        element = "combo"
    },
   
    --LEFT LIMIT
   
    LeftLimit_Standing = {
        _ = group.aa.conditions.standing:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Standing",
        element = "slider"
    },
    LeftLimit_Crouching = {
        _ = group.aa.conditions.crouching:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Crouching",
        element = "slider"
    },
    LeftLimit_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Slowwalk",
        element = "slider"
    },
    LeftLimit_Moving = {
        _ = group.aa.conditions.moving:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_Moving",
        element = "slider"
    },
    LeftLimit_InAir = {
        _ = group.aa.conditions.in_air:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_InAir",
        element = "slider"
    },
    LeftLimit_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Left Limit", 0, 60, 60),
        name = "LeftLimit_InAirDuck",
        element = "slider"
    },
   
    --RIGHT LIMIT
   
    RightLimit_Standing = {
        _ = group.aa.conditions.standing:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Standing",
        element = "slider"
    },
    RightLimit_Crouching = {
        _ = group.aa.conditions.crouching:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Crouching",
        element = "slider"
    },
    RightLimit_Slowwalk = {
        _ = group.aa.conditions.slowwalk:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Slowwalk",
        element = "slider"
    },
    RightLimit_Moving = {
        _ = group.aa.conditions.moving:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_Moving",
        element = "slider"
    },
    RightLimit_InAir = {
        _ = group.aa.conditions.in_air:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_InAir",
        element = "slider"
    },
    RightLimit_InAirDuck = {
        _ = group.aa.conditions.in_air_d:slider("Right Limit", 0, 60, 60),
        name = "RightLimit_InAirDuck",
        element = "slider"
    },
   
    --FAKE OPTIONS
   
    FakeOptions_Standing = {
        _ = group.aa.conditions.standing:selectable("Fake Options", data.FakeOptions_Standing, 0),
        name = "FakeOptions_Standing",
        element = "selectable"
    },
    FakeOptions_Crouching = {
        _ = group.aa.conditions.crouching:selectable("Fake Options", data.FakeOptions_Crouching, 0),
        name = "FakeOptions_Crouching",
        element = "selectable"
    },
    FakeOptions_Slowwalk = {
        _ = group.aa.conditions.slowwalk:selectable("Fake Options", data.FakeOptions_Slowwalk, 0),
        name = "FakeOptions_Slowwalk",
        element = "selectable"
    },
    FakeOptions_Moving = {
        _ = group.aa.conditions.moving:selectable("Fake Options", data.FakeOptions_Moving, 0),
        name = "FakeOptions_Moving",
        element = "selectable"
    },
    FakeOptions_InAir = {
        _ = group.aa.conditions.in_air:selectable("Fake Options", data.FakeOptions_InAir, 0),
        name = "FakeOptions_InAir",
        element = "selectable"
    },
    FakeOptions_InAirDuck = {
        _ = group.aa.conditions.in_air_d:selectable("Fake Options", data.FakeOptions_InAirDuck, 0),
        name = "FakeOptions_InAirDuck",
        element = "selectable"
    },
   
    --LBY MODE
   
    LBYMode_Standing = {
        _ = group.aa.conditions.standing:combo("LBY Mode", data.LBYMode_Standing, 0),
        name = "LBYMode_Standing",
        element = "combo",
    },
    LBYMode_Crouching = {
        _ = group.aa.conditions.crouching:combo("LBY Mode", data.LBYMode_Crouching, 0),
        name = "LBYMode_Crouching",
        element = "combo",
    },
    LBYMode_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("LBY Mode", data.LBYMode_Slowwalk, 0),
        name = "LBYMode_Slowwalk",
        element = "combo",
    },
    LBYMode_Moving = {
        _ = group.aa.conditions.moving:combo("LBY Mode", data.LBYMode_Moving, 0),
        name = "LBYMode_Moving",
        element = "combo",
    },
    LBYMode_InAir = {
        _ = group.aa.conditions.in_air:combo("LBY Mode", data.LBYMode_InAir, 0),
        name = "LBYMode_InAir",
        element = "combo",
    },
    LBYMode_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("LBY Mode", data.LBYMode_InAirDuck, 0),
        name = "LBYMode_InAirDuck",
        element = "combo",
    },
   
    --FREESTANDING DESYNC
   
    FreestandingDesync_Standing = {
        _ = group.aa.conditions.standing:combo("Freestanding Desync", data.FreestandingDesync_Standing, 0),
        name = "FreestandingDesync_Standing",
        element = "combo",
    },
    FreestandingDesync_Crouching = {
        _ = group.aa.conditions.crouching:combo("Freestanding Desync", data.FreestandingDesync_Crouching, 0),
        name = "FreestandingDesync_Crouching",
        element = "combo",
    },
    FreestandingDesync_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Freestanding Desync", data.FreestandingDesync_Slowwalk, 0),
        name = "FreestandingDesync_Slowwalk",
        element = "combo",
    },
    FreestandingDesync_Moving = {
        _ = group.aa.conditions.moving:combo("Freestanding Desync", data.FreestandingDesync_Moving, 0),
        name = "FreestandingDesync_Moving",
        element = "combo",
    },
    FreestandingDesync_InAir = {
        _ = group.aa.conditions.in_air:combo("Freestanding Desync", data.FreestandingDesync_InAir, 0),
        name = "FreestandingDesync_InAir",
        element = "combo",
    },
    FreestandingDesync_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Freestanding Desync", data.FreestandingDesync_InAirDuck, 0),
        name = "FreestandingDesync_InAirDuck",
        element = "combo",
    },
   
    --DESYNC ON SHOT
       
    DesyncOnShot_Standing = {
        _ = group.aa.conditions.standing:combo("Desync On Shot", data.DesyncOnShot_Standing, 0),
        name = "DesyncOnShot_Standing",
        element = "combo",
    },      
    DesyncOnShot_Crouching = {
        _ = group.aa.conditions.crouching:combo("Desync On Shot", data.DesyncOnShot_Crouching, 0),
        name = "DesyncOnShot_Crouching",
        element = "combo",
    },      
    DesyncOnShot_Slowwalk = {
        _ = group.aa.conditions.slowwalk:combo("Desync On Shot", data.DesyncOnShot_Slowwalk, 0),
        name = "DesyncOnShot_Slowwalk",
        element = "combo",
    },  
    DesyncOnShot_Moving = {
        _ = group.aa.conditions.moving:combo("Desync On Shot", data.DesyncOnShot_Moving, 0),
        name = "DesyncOnShot_Moving",
        element = "combo",
    },
    DesyncOnShot_InAir = {
        _ = group.aa.conditions.in_air:combo("Desync On Shot", data.DesyncOnShot_InAir, 0),
        name = "DesyncOnShot_InAir",
        element = "combo",
    },
    DesyncOnShot_InAirDuck = {
        _ = group.aa.conditions.in_air_d:combo("Desync On Shot", data.DesyncOnShot_InAirDuck, 0),
        name = "DesyncOnShot_InAirDuck",
        element = "combo",
    },
}
local override_yaw = group.aa.aa:combo("Override Yaw Base", {'Disabled', 'Forward', 'Left', 'Right', 'Backward'})
local conditions = group.aa.aa:combo("Current Condition", {'Standing', 'Crouching', 'Slowwalk', 'Moving', 'In Air', 'In Air + Duck'})
local gear = {
    indicators = menu_cyrax.indicators_switch._:create(),
    wm = menu_cyrax.watermark_switch._:create(),
    scope = menu_cyrax.scope_switch._:create(),
    logs = menu_cyrax.logs_switch._:create(),
    aa = menu_aa.Switch_AntiAim._:create(),
    anim = menu_cyrax.animbreaker_switch._:create(),
    solus = menu_cyrax.solus_switch._:create(),
}

local gear_opt = {
    indicators_type = gear.indicators:combo('', data.indicators_styles),
    indicators_color = gear.indicators:color_picker('Color', color(194, 187, 250, 255)),
    animate = gear.wm:switch('Animate', false),
    wm_color = gear.wm:color_picker('Color', color(194, 187, 250, 255)),
    wm_color2 = gear.wm:color_picker('Color', color(255, 255, 255, 255)),
    t_style = gear.scope:switch('T Style', false),
    scope_color1 = gear.scope:color_picker('Color #1', color(255, 255, 255 ,255)),
    scope_color2 = gear.scope:color_picker('Color #2', color(0, 0, 0, 0)),
    scope_length = gear.scope:slider('Length', 0, 360, 100),
    scope_offset = gear.scope:slider('Offset', 0, 100, 5),
    screen_logs = gear.logs:switch('On Screen', false),
    logs_hit = gear.logs:color_picker('Color on Hit', color(210, 206, 242)),
    logs_miss = gear.logs:color_picker('Color on Miss', color(210, 206, 242)),
    logs_miss_what = gear.logs:color_picker('Color on Miss', color(255, 255, 255, 255)),
    export = gear.aa:button('Export', true),
    import = gear.aa:button('Import', true),
    default = gear.aa:button('Default Settings', true),
    anim = gear.anim:selectable('', {'Static Legs', 'Leg Breaker'}),
    solus_binds = gear.solus:switch('Keybinds', false),
    solus_watermark = gear.solus:switch('Watermark', false),
    solus_clr = gear.solus:color_picker('Color', color(210, 206, 242, 122)),
    solus_1 = gear.solus:slider('xaxaxa', 0, render.screen_size().x, 120),
    solus_2 = gear.solus:slider('xaxaxa', 0, render.screen_size().x, 120),
}
gear_opt.solus_1:set_visible(false)
gear_opt.solus_2:set_visible(false)

function cyraxUI.visibility()

    if menu_cyrax.visuals_switch._:get() then
        menu_cyrax.indicators_switch._:set_visible(true)
        menu_cyrax.scope_switch._:set_visible(true)
        menu_cyrax.logs_switch._:set_visible(true)
        menu_cyrax.solus_switch._:set_visible(true)
        menu_cyrax.watermark_switch._:set_visible(true)
    else
        menu_cyrax.indicators_switch._:set_visible(false)
        menu_cyrax.scope_switch._:set_visible(false)
        menu_cyrax.logs_switch._:set_visible(false)
        menu_cyrax.solus_switch._:set_visible(false)
        menu_cyrax.watermark_switch._:set_visible(false)
    end

    if menu_cyrax.misc_switch._:get() then
        menu_cyrax.jumpscout_switch._:set_visible(true)
        menu_cyrax.killsay_switch._:set_visible(true)
        menu_cyrax.animbreaker_switch._:set_visible(true)
    else
        menu_cyrax.jumpscout_switch._:set_visible(false)
        menu_cyrax.killsay_switch._:set_visible(false)
        menu_cyrax.animbreaker_switch._:set_visible(false)
    end

    if menu_aa.Switch_AntiAim._:get() then
        override_yaw:set_visible(true)
        conditions:set_visible(true)

        if conditions:get() == 'Standing' then
            menu_aa.Pitch_Standing._:set_visible(true)
            menu_aa.YawBase_Standing._:set_visible(true)
            menu_aa.YawModifier_Standing._:set_visible(true)
            menu_aa.FakeLimitType_Standing._:set_visible(true)
            menu_aa.FakeOptions_Standing._:set_visible(true)
            menu_aa.LBYMode_Standing._:set_visible(true)
            menu_aa.FreestandingDesync_Standing._:set_visible(true)
            menu_aa.DesyncOnShot_Standing._:set_visible(true)
            menu_aa.YawAddLeft_Standing._:set_visible(true)
            menu_aa.YawAddRight_Standing._:set_visible(true)
            menu_aa.LeftLimit_Standing._:set_visible(true)
            menu_aa.RightLimit_Standing._:set_visible(true)
            menu_aa.YawModifierType_Standing._:set_visible(true)
            if menu_aa.YawModifierType_Standing._:get() == 'Default' then
                menu_aa.ModifierDegree_Standing._:set_visible(true)
                menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
                menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
            else
                menu_aa.ModifierDegree_Standing._:set_visible(false)
                menu_aa.ModifierDegreeMin_Standing._:set_visible(true)
                menu_aa.ModifierDegreeMax_Standing._:set_visible(true)
            end
        else
            menu_aa.Pitch_Standing._:set_visible(false)
            menu_aa.YawBase_Standing._:set_visible(false)
            menu_aa.YawModifier_Standing._:set_visible(false)
            menu_aa.FakeLimitType_Standing._:set_visible(false)
            menu_aa.FakeOptions_Standing._:set_visible(false)
            menu_aa.LBYMode_Standing._:set_visible(false)
            menu_aa.FreestandingDesync_Standing._:set_visible(false)
            menu_aa.DesyncOnShot_Standing._:set_visible(false)
            menu_aa.YawAddLeft_Standing._:set_visible(false)
            menu_aa.YawAddRight_Standing._:set_visible(false)
            menu_aa.ModifierDegree_Standing._:set_visible(false)
            menu_aa.LeftLimit_Standing._:set_visible(false)
            menu_aa.RightLimit_Standing._:set_visible(false)
            menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
            menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
            menu_aa.YawModifierType_Standing._:set_visible(false)
        end

        if conditions:get() == 'Crouching' then
            menu_aa.Pitch_Crouching._:set_visible(true)
            menu_aa.YawBase_Crouching._:set_visible(true)
            menu_aa.YawModifier_Crouching._:set_visible(true)
            menu_aa.FakeLimitType_Crouching._:set_visible(true)
            menu_aa.FakeOptions_Crouching._:set_visible(true)
            menu_aa.LBYMode_Crouching._:set_visible(true)
            menu_aa.FreestandingDesync_Crouching._:set_visible(true)
            menu_aa.DesyncOnShot_Crouching._:set_visible(true)
            menu_aa.YawAddLeft_Crouching._:set_visible(true)
            menu_aa.YawAddRight_Crouching._:set_visible(true)
            menu_aa.LeftLimit_Crouching._:set_visible(true)
            menu_aa.RightLimit_Crouching._:set_visible(true)
            menu_aa.YawModifierType_Crouching._:set_visible(true)
            if menu_aa.YawModifierType_Crouching._:get() == 'Default' then
                menu_aa.ModifierDegree_Crouching._:set_visible(true)
                menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
                menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
            else
                menu_aa.ModifierDegree_Crouching._:set_visible(false)
                menu_aa.ModifierDegreeMin_Crouching._:set_visible(true)
                menu_aa.ModifierDegreeMax_Crouching._:set_visible(true)
            end
        else
            menu_aa.Pitch_Crouching._:set_visible(false)
            menu_aa.YawBase_Crouching._:set_visible(false)
            menu_aa.YawModifier_Crouching._:set_visible(false)
            menu_aa.FakeLimitType_Crouching._:set_visible(false)
            menu_aa.FakeOptions_Crouching._:set_visible(false)
            menu_aa.LBYMode_Crouching._:set_visible(false)
            menu_aa.FreestandingDesync_Crouching._:set_visible(false)
            menu_aa.DesyncOnShot_Crouching._:set_visible(false)
            menu_aa.YawAddLeft_Crouching._:set_visible(false)
            menu_aa.YawAddRight_Crouching._:set_visible(false)
            menu_aa.ModifierDegree_Crouching._:set_visible(false)
            menu_aa.LeftLimit_Crouching._:set_visible(false)
            menu_aa.RightLimit_Crouching._:set_visible(false)
            menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
            menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
            menu_aa.YawModifierType_Crouching._:set_visible(false)
        end

        if conditions:get() == 'Slowwalk' then
            menu_aa.Pitch_Slowwalk._:set_visible(true)
            menu_aa.YawBase_Slowwalk._:set_visible(true)
            menu_aa.YawModifier_Slowwalk._:set_visible(true)
            menu_aa.FakeLimitType_Slowwalk._:set_visible(true)
            menu_aa.FakeOptions_Slowwalk._:set_visible(true)
            menu_aa.LBYMode_Slowwalk._:set_visible(true)
            menu_aa.FreestandingDesync_Slowwalk._:set_visible(true)
            menu_aa.DesyncOnShot_Slowwalk._:set_visible(true)
            menu_aa.YawAddLeft_Slowwalk._:set_visible(true)
            menu_aa.YawAddRight_Slowwalk._:set_visible(true)
            menu_aa.LeftLimit_Slowwalk._:set_visible(true)
            menu_aa.RightLimit_Slowwalk._:set_visible(true)
            menu_aa.YawModifierType_Slowwalk._:set_visible(true)
            if menu_aa.YawModifierType_Slowwalk._:get() == 'Default' then
                menu_aa.ModifierDegree_Slowwalk._:set_visible(true)
                menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
                menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
            else
                menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
                menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(true)
                menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(true)
            end
        else
            menu_aa.Pitch_Slowwalk._:set_visible(false)
            menu_aa.YawBase_Slowwalk._:set_visible(false)
            menu_aa.YawModifier_Slowwalk._:set_visible(false)
            menu_aa.FakeLimitType_Slowwalk._:set_visible(false)
            menu_aa.FakeOptions_Slowwalk._:set_visible(false)
            menu_aa.LBYMode_Slowwalk._:set_visible(false)
            menu_aa.FreestandingDesync_Slowwalk._:set_visible(false)
            menu_aa.DesyncOnShot_Slowwalk._:set_visible(false)
            menu_aa.YawAddLeft_Slowwalk._:set_visible(false)
            menu_aa.YawAddRight_Slowwalk._:set_visible(false)
            menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
            menu_aa.LeftLimit_Slowwalk._:set_visible(false)
            menu_aa.RightLimit_Slowwalk._:set_visible(false)
            menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
            menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
            menu_aa.YawModifierType_Slowwalk._:set_visible(false)
        end
       
        if conditions:get() == 'Moving' then
            menu_aa.Pitch_Moving._:set_visible(true)
            menu_aa.YawBase_Moving._:set_visible(true)
            menu_aa.YawModifier_Moving._:set_visible(true)
            menu_aa.FakeLimitType_Moving._:set_visible(true)
            menu_aa.FakeOptions_Moving._:set_visible(true)
            menu_aa.LBYMode_Moving._:set_visible(true)
            menu_aa.FreestandingDesync_Moving._:set_visible(true)
            menu_aa.DesyncOnShot_Moving._:set_visible(true)
            menu_aa.YawAddLeft_Moving._:set_visible(true)
            menu_aa.YawAddRight_Moving._:set_visible(true)
            menu_aa.LeftLimit_Moving._:set_visible(true)
            menu_aa.RightLimit_Moving._:set_visible(true)
            menu_aa.YawModifierType_Moving._:set_visible(true)
            if menu_aa.YawModifierType_Moving._:get() == 'Default' then
                menu_aa.ModifierDegree_Moving._:set_visible(true)
                menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
                menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
            else
                menu_aa.ModifierDegree_Moving._:set_visible(false)
                menu_aa.ModifierDegreeMin_Moving._:set_visible(true)
                menu_aa.ModifierDegreeMax_Moving._:set_visible(true)
            end
        else
            menu_aa.Pitch_Moving._:set_visible(false)
            menu_aa.YawBase_Moving._:set_visible(false)
            menu_aa.YawModifier_Moving._:set_visible(false)
            menu_aa.FakeLimitType_Moving._:set_visible(false)
            menu_aa.FakeOptions_Moving._:set_visible(false)
            menu_aa.LBYMode_Moving._:set_visible(false)
            menu_aa.FreestandingDesync_Moving._:set_visible(false)
            menu_aa.DesyncOnShot_Moving._:set_visible(false)
            menu_aa.YawAddLeft_Moving._:set_visible(false)
            menu_aa.YawAddRight_Moving._:set_visible(false)
            menu_aa.ModifierDegree_Moving._:set_visible(false)
            menu_aa.LeftLimit_Moving._:set_visible(false)
            menu_aa.RightLimit_Moving._:set_visible(false)
            menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
            menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
            menu_aa.YawModifierType_Moving._:set_visible(false)
        end

        if conditions:get() == 'In Air' then
            menu_aa.Pitch_InAir._:set_visible(true)
            menu_aa.YawBase_InAir._:set_visible(true)
            menu_aa.YawModifier_InAir._:set_visible(true)
            menu_aa.FakeLimitType_InAir._:set_visible(true)
            menu_aa.FakeOptions_InAir._:set_visible(true)
            menu_aa.LBYMode_InAir._:set_visible(true)
            menu_aa.FreestandingDesync_InAir._:set_visible(true)
            menu_aa.DesyncOnShot_InAir._:set_visible(true)
            menu_aa.YawAddLeft_InAir._:set_visible(true)
            menu_aa.YawAddRight_InAir._:set_visible(true)
            menu_aa.ModifierDegree_InAir._:set_visible(true)
            menu_aa.LeftLimit_InAir._:set_visible(true)
            menu_aa.RightLimit_InAir._:set_visible(true)
            menu_aa.YawModifierType_InAir._:set_visible(true)
            if menu_aa.YawModifierType_InAir._:get() == 'Default' then
                menu_aa.ModifierDegree_InAir._:set_visible(true)
                menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
                menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
            else
                menu_aa.ModifierDegree_InAir._:set_visible(false)
                menu_aa.ModifierDegreeMin_InAir._:set_visible(true)
                menu_aa.ModifierDegreeMax_InAir._:set_visible(true)
            end
        else
            menu_aa.Pitch_InAir._:set_visible(false)
            menu_aa.YawBase_InAir._:set_visible(false)
            menu_aa.YawModifier_InAir._:set_visible(false)
            menu_aa.FakeLimitType_InAir._:set_visible(false)
            menu_aa.FakeOptions_InAir._:set_visible(false)
            menu_aa.LBYMode_InAir._:set_visible(false)
            menu_aa.FreestandingDesync_InAir._:set_visible(false)
            menu_aa.DesyncOnShot_InAir._:set_visible(false)
            menu_aa.YawAddLeft_InAir._:set_visible(false)
            menu_aa.YawAddRight_InAir._:set_visible(false)
            menu_aa.ModifierDegree_InAir._:set_visible(false)
            menu_aa.LeftLimit_InAir._:set_visible(false)
            menu_aa.RightLimit_InAir._:set_visible(false)
            menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
            menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
            menu_aa.YawModifierType_InAir._:set_visible(false)
        end

        if conditions:get() == 'In Air + Duck' then
            menu_aa.Pitch_InAirDuck._:set_visible(true)
            menu_aa.YawBase_InAirDuck._:set_visible(true)
            menu_aa.YawModifier_InAirDuck._:set_visible(true)
            menu_aa.FakeLimitType_InAirDuck._:set_visible(true)
            menu_aa.FakeOptions_InAirDuck._:set_visible(true)
            menu_aa.LBYMode_InAirDuck._:set_visible(true)
            menu_aa.FreestandingDesync_InAirDuck._:set_visible(true)
            menu_aa.DesyncOnShot_InAirDuck._:set_visible(true)
            menu_aa.YawAddLeft_InAirDuck._:set_visible(true)
            menu_aa.YawAddRight_InAirDuck._:set_visible(true)
            menu_aa.LeftLimit_InAirDuck._:set_visible(true)
            menu_aa.RightLimit_InAirDuck._:set_visible(true)
            menu_aa.YawModifierType_InAirDuck._:set_visible(true)
            if menu_aa.YawModifierType_InAirDuck._:get() == 'Default' then
                menu_aa.ModifierDegree_InAirDuck._:set_visible(true)
                menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
                menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
            else
                menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
                menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(true)
                menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(true)
            end
        else
            menu_aa.Pitch_InAirDuck._:set_visible(false)
            menu_aa.YawBase_InAirDuck._:set_visible(false)
            menu_aa.YawModifier_InAirDuck._:set_visible(false)
            menu_aa.FakeLimitType_InAirDuck._:set_visible(false)
            menu_aa.FakeOptions_InAirDuck._:set_visible(false)
            menu_aa.LBYMode_InAirDuck._:set_visible(false)
            menu_aa.FreestandingDesync_InAirDuck._:set_visible(false)
            menu_aa.DesyncOnShot_InAirDuck._:set_visible(false)
            menu_aa.YawAddLeft_InAirDuck._:set_visible(false)
            menu_aa.YawAddRight_InAirDuck._:set_visible(false)
            menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
            menu_aa.LeftLimit_InAirDuck._:set_visible(false)
            menu_aa.RightLimit_InAirDuck._:set_visible(false)
            menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
            menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
            menu_aa.YawModifierType_InAirDuck._:set_visible(false)
        end

    else
        override_yaw:set_visible(false)
        conditions:set_visible(false)

        menu_aa.Pitch_Standing._:set_visible(false)
        menu_aa.YawBase_Standing._:set_visible(false)
        menu_aa.YawModifier_Standing._:set_visible(false)
        menu_aa.FakeLimitType_Standing._:set_visible(false)
        menu_aa.FakeOptions_Standing._:set_visible(false)
        menu_aa.LBYMode_Standing._:set_visible(false)
        menu_aa.FreestandingDesync_Standing._:set_visible(false)
        menu_aa.DesyncOnShot_Standing._:set_visible(false)
        menu_aa.YawAddLeft_Standing._:set_visible(false)
        menu_aa.YawAddRight_Standing._:set_visible(false)
        menu_aa.ModifierDegree_Standing._:set_visible(false)
        menu_aa.LeftLimit_Standing._:set_visible(false)
        menu_aa.RightLimit_Standing._:set_visible(false)
        menu_aa.ModifierDegreeMin_Standing._:set_visible(false)
        menu_aa.ModifierDegreeMax_Standing._:set_visible(false)
        menu_aa.YawModifierType_Standing._:set_visible(false)

        menu_aa.Pitch_Crouching._:set_visible(false)
        menu_aa.YawBase_Crouching._:set_visible(false)
        menu_aa.YawModifier_Crouching._:set_visible(false)
        menu_aa.FakeLimitType_Crouching._:set_visible(false)
        menu_aa.FakeOptions_Crouching._:set_visible(false)
        menu_aa.LBYMode_Crouching._:set_visible(false)
        menu_aa.FreestandingDesync_Crouching._:set_visible(false)
        menu_aa.DesyncOnShot_Crouching._:set_visible(false)
        menu_aa.YawAddLeft_Crouching._:set_visible(false)
        menu_aa.YawAddRight_Crouching._:set_visible(false)
        menu_aa.ModifierDegree_Crouching._:set_visible(false)
        menu_aa.LeftLimit_Crouching._:set_visible(false)
        menu_aa.RightLimit_Crouching._:set_visible(false)
        menu_aa.ModifierDegreeMin_Crouching._:set_visible(false)
        menu_aa.ModifierDegreeMax_Crouching._:set_visible(false)
        menu_aa.YawModifierType_Crouching._:set_visible(false)

        menu_aa.Pitch_Slowwalk._:set_visible(false)
        menu_aa.YawBase_Slowwalk._:set_visible(false)
        menu_aa.YawModifier_Slowwalk._:set_visible(false)
        menu_aa.FakeLimitType_Slowwalk._:set_visible(false)
        menu_aa.FakeOptions_Slowwalk._:set_visible(false)
        menu_aa.LBYMode_Slowwalk._:set_visible(false)
        menu_aa.FreestandingDesync_Slowwalk._:set_visible(false)
        menu_aa.DesyncOnShot_Slowwalk._:set_visible(false)
        menu_aa.YawAddLeft_Slowwalk._:set_visible(false)
        menu_aa.YawAddRight_Slowwalk._:set_visible(false)
        menu_aa.ModifierDegree_Slowwalk._:set_visible(false)
        menu_aa.LeftLimit_Slowwalk._:set_visible(false)
        menu_aa.RightLimit_Slowwalk._:set_visible(false)
        menu_aa.ModifierDegreeMin_Slowwalk._:set_visible(false)
        menu_aa.ModifierDegreeMax_Slowwalk._:set_visible(false)
        menu_aa.YawModifierType_Slowwalk._:set_visible(false)

        menu_aa.Pitch_Moving._:set_visible(false)
        menu_aa.YawBase_Moving._:set_visible(false)
        menu_aa.YawModifier_Moving._:set_visible(false)
        menu_aa.FakeLimitType_Moving._:set_visible(false)
        menu_aa.FakeOptions_Moving._:set_visible(false)
        menu_aa.LBYMode_Moving._:set_visible(false)
        menu_aa.FreestandingDesync_Moving._:set_visible(false)
        menu_aa.DesyncOnShot_Moving._:set_visible(false)
        menu_aa.YawAddLeft_Moving._:set_visible(false)
        menu_aa.YawAddRight_Moving._:set_visible(false)
        menu_aa.ModifierDegree_Moving._:set_visible(false)
        menu_aa.LeftLimit_Moving._:set_visible(false)
        menu_aa.RightLimit_Moving._:set_visible(false)
        menu_aa.ModifierDegreeMin_Moving._:set_visible(false)
        menu_aa.ModifierDegreeMax_Moving._:set_visible(false)
        menu_aa.YawModifierType_Moving._:set_visible(false)

        menu_aa.Pitch_InAir._:set_visible(false)
        menu_aa.YawBase_InAir._:set_visible(false)
        menu_aa.YawModifier_InAir._:set_visible(false)
        menu_aa.FakeLimitType_InAir._:set_visible(false)
        menu_aa.FakeOptions_InAir._:set_visible(false)
        menu_aa.LBYMode_InAir._:set_visible(false)
        menu_aa.FreestandingDesync_InAir._:set_visible(false)
        menu_aa.DesyncOnShot_InAir._:set_visible(false)
        menu_aa.YawAddLeft_InAir._:set_visible(false)
        menu_aa.YawAddRight_InAir._:set_visible(false)
        menu_aa.ModifierDegree_InAir._:set_visible(false)
        menu_aa.LeftLimit_InAir._:set_visible(false)
        menu_aa.RightLimit_InAir._:set_visible(false)
        menu_aa.ModifierDegreeMin_InAir._:set_visible(false)
        menu_aa.ModifierDegreeMax_InAir._:set_visible(false)
        menu_aa.YawModifierType_InAir._:set_visible(false)

        menu_aa.Pitch_InAirDuck._:set_visible(false)
        menu_aa.YawBase_InAirDuck._:set_visible(false)
        menu_aa.YawModifier_InAirDuck._:set_visible(false)
        menu_aa.FakeLimitType_InAirDuck._:set_visible(false)
        menu_aa.FakeOptions_InAirDuck._:set_visible(false)
        menu_aa.LBYMode_InAirDuck._:set_visible(false)
        menu_aa.FreestandingDesync_InAirDuck._:set_visible(false)
        menu_aa.DesyncOnShot_InAirDuck._:set_visible(false)
        menu_aa.YawAddLeft_InAirDuck._:set_visible(false)
        menu_aa.YawAddRight_InAirDuck._:set_visible(false)
        menu_aa.ModifierDegree_InAirDuck._:set_visible(false)
        menu_aa.LeftLimit_InAirDuck._:set_visible(false)
        menu_aa.RightLimit_InAirDuck._:set_visible(false)
        menu_aa.ModifierDegreeMin_InAirDuck._:set_visible(false)
        menu_aa.ModifierDegreeMax_InAirDuck._:set_visible(false)
        menu_aa.YawModifierType_InAirDuck._:set_visible(false)
    end
end

local hitgroups = {  
[0] = 'generic',
'head', 'chest', 'stomach',
'left arm', 'right arm',
'left leg', 'right leg',
'neck', 'generic', 'gear'}

function func:centerLogs(e)
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or not menu_cyrax.logs_switch._:get() then return end
    local target = entity.get(e.target)
    local wanted_dmg = e.wanted_damage
    local damage = e.damage
    local wanted_hbx = hitgroups[e.wanted_hitgroup]
    local hitchance = e.hitchance
    local state = e.state
    local bt = e.backtrack
    if not target or target == nil then return end
    local hitbox = hitgroups[e.hitgroup]

    if state == nil then
        color_p("[Cyrax] ", gear_opt.logs_hit:get())
        print_raw(string.format("Hit %s's %s [aimed = %s | damage: %i(%i) | hc: %i | history: %i]", target:get_name(), hitbox, wanted_hbx, damage, wanted_dmg, hitchance, bt))
    else
        color_p("[Cyrax] ", gear_opt.logs_miss:get())
        print_raw(string.format("Missed shot at %s's %s due to %s [hc: %i | history: %i]", target:get_name(), wanted_hbx, state, hitchance, bt))
    end

    if state == nil then
        print_dev(string.format("Hit %s's %s [aimed = %s | damage: %i(%i) | hc: %i | history: %i]", target:get_name(), hitbox, wanted_hbx, damage, wanted_dmg, hitchance, bt))
    else
        print_dev(string.format("Missed shot at %s's %s due to %s [hc: %i | history: %i]", target:get_name(), wanted_hbx, state, hitchance, bt))
    end

end

entity_list_pointer = ffi.cast('void***', utils.create_interface('client.dll', 'VClientEntityList003'))
get_client_entity_fn = ffi.cast('GetClientEntity_4242425_t', entity_list_pointer[0][3])
function get_entity_address(ent_index)
    local addr = get_client_entity_fn(entity_list_pointer, ent_index)
    return addr
end


hook_helper = {
    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
}

buff = {free = {}}
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_helper.virtual_protect(virtual_table + method, 4, 0x4, old_prot)

    virtual_table[method] = ffi.cast('intptr_t', ffi.cast(cast, func))
    hook_helper.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_helper.virtual_protect(virtual_table + method, 4, 0x4, old_prot)
    local alloc_addr = hook_helper.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_helper.copy(alloc_addr, trampoline_bytes, 5)
    virtual_table[method] = ffi.cast('intptr_t', alloc_addr)

    hook_helper.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

conditional_aa.onuseAAEnabled = false
conditional_aa.standingAAEnabled = false
conditional_aa.crouchingAAEnabled = false
conditional_aa.slowwalkAAEnabled = false
conditional_aa.movingAAEnabled = false
conditional_aa.inairAAEnabled = false
conditional_aa.inairAAduckEnabled = false

function conditional_aa.distanceCheck(t)
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false then return end
    local localplayer = entity.get_local_player()
    local origin = localplayer:get_eye_position()
    local vec = vector(origin.x, origin.y, origin.z)

    for _, v in pairs(t) do
        if vec:dist(v.m_vecOrigin) < 100 then return false end
    end

    return true
end

local scope = {}
scope.screen = render.screen_size()
scope.menu = {}
scope.menu.offset = 100
scope.anim_num = 0

function func:jumpscout_fix_f()
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.jumpscout_switch._:get() == false then return end
    local vel = entity.get_local_player().m_vecVelocity
    local speed = math.sqrt(vel.x*vel.x + vel.y*vel.y)
    ui.find("Miscellaneous", "Main", "Movement", "Air Strafe"):set(speed > 15)
end

function func:customscope()

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false then return end

    if not menu_cyrax.scope_switch._:get() or menu_cyrax.visuals_switch._:get() == false then return vars.menu.remove_scope:set('Remove Overlay') end

    vars.menu.remove_scope:set('Remove All')
    local local_player = entity.get_local_player()
    scope.anim_speed = 15

    if not local_player or not local_player:is_alive() or not local_player.m_bIsScoped then
        scope.anim_num = func:lerp(scope.anim_num, 0, scope.anim_speed * globals.frametime)
    else
        scope.anim_num = func:lerp(scope.anim_num, 1, scope.anim_speed * globals.frametime)
    end

    scope.length = gear_opt.scope_length:get() * scope.anim_num
    scope.offset = gear_opt.scope_offset:get() * scope.anim_num

    scope.col_1 = gear_opt.scope_color1:get()
    scope.col_2 = gear_opt.scope_color2:get()

    scope.width = 1

    scope.col_1.a = scope.col_1.a * scope.anim_num
    scope.col_2.a = scope.col_2.a * scope.anim_num

   
    scope.start_x = scope.screen.x / 2
    scope.start_y = scope.screen.y / 2

    --Left
    render.gradient(vector(scope.start_x - scope.offset, scope.start_y), vector(scope.start_x - scope.offset - scope.length, scope.start_y + scope.width), scope.col_1, scope.col_2, scope.col_1, scope.col_2)

    --Right
    render.gradient(vector(scope.start_x + scope.offset, scope.start_y), vector(scope.start_x + scope.offset + scope.length, scope.start_y + scope.width), scope.col_1, scope.col_2, scope.col_1, scope.col_2)

    --Down

    render.gradient(vector(scope.start_x, scope.start_y + scope.offset), vector(scope.start_x + scope.width, scope.start_y + scope.offset + scope.length), scope.col_1, scope.col_1, scope.col_2, scope.col_2)

    --Up
    if not gear_opt.t_style:get() then
        render.gradient(vector(scope.start_x, scope.start_y - scope.offset), vector(scope.start_x + scope.width, scope.start_y - scope.offset - scope.length), scope.col_1, scope.col_1, scope.col_2, scope.col_2)
    end
end

function CheckFlag(player, ...)
    local flagList = {...};
    local flagValues = true;

    if (type(flagList) == "table" and #flagList > 0) then
        for i = 1, #flagList do
            if (type(flagList[i]) == "table") then
                if (bit.band(player.m_fFlags, bit.lshift(1, flagList[i][1])) ~= 0) then flagValues = false; end
            else
                if (bit.band(player.m_fFlags, bit.lshift(1, flagList[i])) == 0) then flagValues = false; end
            end
        end
    end

    return flagValues;
end

local estisus
if func:version() == "Debug" then
    estisus = 3
elseif func:version() == "Beta" then
    estisus = 0
elseif func:version() == "Live" then
    estisus = -2
end

function func:cyrax_ind()

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false     or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax' then return end

    local p = {
        sc = render.screen_size(),
        ver = func:version(),
        alpha = math.clamp(math.abs(1 * math.cos(2 * math.pi * globals.curtime / 5)), 0.5, 1),
        dyntext = "",
        ex = "",
        localplayer = entity.get_local_player(),
        clr = {          
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
    }
    local speed = p.localplayer.m_vecVelocity
    local velocity = speed:length()

    if conditional_aa.onuseAAEnabled then
        vars.ind.lavendu.textu = "using"
    else
        if CheckFlag(p.localplayer, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(p.localplayer, 1) then
                vars.ind.lavendu.textu = "jumping"
            else
                vars.ind.lavendu.textu = "airduck"
            end
        else
            if vars.menu.sw:get() then
                vars.ind.lavendu.textu = "slowwalking"
            else
                if CheckFlag(p.localplayer, 1) then
                    vars.ind.lavendu.textu = "ducking"
                else
                    if velocity >= 1.2 then
                        vars.ind.lavendu.textu = "running"
                    else
                        vars.ind.lavendu.textu = "standing"
                    end
                end
            end
        end
    end

    if vars.menu.dt:get() and vars.menu.hs:get() then
        p.ex = "dt"
    elseif vars.menu.dt:get() and not vars.menu.hs:get() then
        p.ex = "dt"
    elseif not vars.menu.dt:get() and vars.menu.hs:get() then
        p.ex = "os"
    end

    if p.localplayer.m_bIsScoped then
        vars.ind.lavendu.anim[3][1] = func:lerp(vars.ind.lavendu.anim[3][1], 26 + estisus, globals.frametime*15)
        vars.ind.lavendu.anim[3][2] = func:lerp(vars.ind.lavendu.anim[3][2], 5, globals.frametime*15)
        vars.ind.lavendu.anim[3][3] = func:lerp(vars.ind.lavendu.anim[3][3], 10, globals.frametime*15)
        vars.ind.lavendu.anim[2].dt = 0
        vars.ind.lavendu.chestie = 0
    else
        vars.ind.lavendu.anim[3][1] = func:lerp(vars.ind.lavendu.anim[3][1], 0, globals.frametime*15)
        vars.ind.lavendu.anim[3][2] = func:lerp(vars.ind.lavendu.anim[3][2], -texts(vars.font.skeet, 'o', vars.ind.lavendu.textu).x/2, globals.frametime*15)
        vars.ind.lavendu.anim[3][3] = func:lerp(vars.ind.lavendu.anim[3][3], 0, globals.frametime*15)
        vars.ind.lavendu.chestie = 0
    end

    if vars.menu.dt:get() or vars.menu.hs:get() then
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt + 1, 0, 10)
    else
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt - 1, 0, 10)
    end

    if ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() then
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs + 1, 0, 10)

        if vars.menu.dt:get() or vars.menu.hs:get() then
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt + 0.5, 0, 5.5)
            if p.localplayer.m_bIsScoped then
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 10.5)
            else
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
            end
        else
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
            vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs - 0.5, 0, 5.5)
        end

    else
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs - 1, 0, 10.5)
        vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
    end

    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(p.ex, 'o', vars.font.skeet).x/2 - 5 - vars.ind.lavendu.anim[2].dt + vars.ind.lavendu.anim[3][3], p.sc.y/2 + 30 + vars.ind.lavendu.anim[1].dt), color(255, 255, 255, vars.ind.lavendu.anim[1].dt/10*255), nil, p.ex)
    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o', "fs").x/2 + vars.ind.lavendu.anim[2].fs + vars.ind.lavendu.anim[3][3] + vars.ind.lavendu.chestie, p.sc.y/2 + 30 + vars.ind.lavendu.anim[1].fs), color(255, 255, 255, vars.ind.lavendu.anim[1].fs/10*255), nil, "fs")

    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o', "cyrax"..func:version()).x/2 + vars.ind.lavendu.anim[3][1], p.sc.y/2 + 20), color(255, 255, 255, 255), nil, "cyrax")
    render.text(vars.font.skeet, vector(p.sc.x/2 - texts(vars.font.skeet, 'o', "cyrax"..func:version()).x/2 + texts(vars.font.skeet, 'o', "cyrax").x + 1 + vars.ind.lavendu.anim[3][1], p.sc.y/2+ 20), color(p.clr.r, p.clr.g, p.clr.b, p.alpha * 255), nil, p.ver)
    render.text(vars.font.skeet, vector(p.sc.x/2 + vars.ind.lavendu.anim[3][2], p.sc.y/2+ 30), color(255, 255, 255, 122), nil, vars.ind.lavendu.textu)

end

local red = 0
function func:cyrax_ind_2()
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax V2' then return end
    local screen = render.screen_size()
    local t = {
        alpha = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 4)),
        dt_text = "dt",
        lp = entity.get_local_player(),
        color = {
            dt = color(255 - red, red, 0, vars.ind.dt_alpha),
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
        charge = rage.exploit:get(),
        desync = math.floor(aantiaim.get_desync_delta()),
    }
    local speed = t.lp.m_vecVelocity
    local velocity = speed:length()

    if t.lp.m_bIsScoped then
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 1.91, globals.frametime * 11)
    else
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 2, globals.frametime * 11)
    end

    vars.ind.smooth = func:lerp(vars.ind.smooth, t.desync, globals.frametime*8)

    if vars.menu.dt:get() then
        vars.ind.dt_alpha = math.clamp(vars.ind.dt_alpha + 13, 0 , 255)
        if t.charge ~= 1 then
           red = math.clamp(red - 25, 0, 255)
        else
            red = math.clamp(red + 25, 0, 255)
        end
    else
        red = math.clamp(red + 25, 0, 1)
        vars.ind.dt_alpha = math.clamp(vars.ind.dt_alpha - 12, 0 , 255)
    end

    t.alpha = math.clamp(t.alpha, 0.25, 1)

    if vars.menu.dt:get() and vars.menu.qp:get() then
        t.dt_text = "it"
    else
        t.dt_text = "dt"
    end

    if conditional_aa.onuseAAEnabled then
        vars.ind.v2.cond_text = "using"
    else
        if CheckFlag(t.lp, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(t.lp, 1) then
            vars.ind.v2.cond_text = "air"
            else
                vars.ind.v2.cond_text = "air+"
            end
        else
            if vars.menu.sw:get() then
                vars.ind.v2.cond_text = "slowwalk"
            else
                if CheckFlag(t.lp, 1) then
                    vars.ind.v2.cond_text = "duck"
                else
                    if velocity >= 1.2 then
                        vars.ind.v2.cond_text = "running"
                    else
                        vars.ind.v2.cond_text = "standing"
                    end
                end
            end
        end
    end

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax" .. string.lower(func:version())).x/2, screen.y/2 + 16), color(t.color.r, t.color.g, t.color.b, 255), nil, "cyrax")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax" .. string.lower(func:version())).x/2 + texts(vars.font.pixel, 'o', "cyrax").x + 1, screen.y/2 + 16), color(255, 255, 255, t.alpha*255), nil, string.lower(func:version()))

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o',vars.ind.v2.cond_text).x/2, screen.y/2 + 25), color(t.color.r, t.color.g, t.color.b, 255), nil, vars.ind.v2.cond_text)

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', t.dt_text).x/2, screen.y/2 + 34), t.color.dt, nil, t.dt_text)

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 - 3, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255, vars.menu.body:get() ~= 'Default' and 255 or 122), nil, "baim")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o', "baim").x - 1, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255, vars.menu.hs:get() and 255 or 122), nil, "os")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o', "baimos").x + 1, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255,  ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() and 255 or 122), nil, "fs")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "baimosfssp").x/2 + texts(vars.font.pixel, 'o', "baimosfs").x + 3, screen.y/2 + 34 + vars.ind.dt_alpha / 28), color(255, 255, 255, vars.menu.sp:get() ~= 'Default' and 255 or 122), nil, "sp")
end


function func:cyrax_ind_3()
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax V4' then return end
    local screen = render.screen_size()
    local t = {
        alpha = math.abs(3 * math.cos(1 * math.pi * globals.curtime / 4)) * 255,
        dyn_text = "aggresive",
        dt_text = "dt",
        lp = entity.get_local_player(),
        players = entity.get_players(),
        color = {
            dt = color(255, 255, 255, vars.ind.dt_alpha),
            alpha_side = aantiaim.get_inverter_state() and 255 or 122,
            alpha_side2 = aantiaim.get_inverter_state() and 122 or 255,
            fs_green = vars.menu.fd:get() and 0 or 255,
            fs_blue = vars.menu.fd:get() and 0 or 255,
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
        charge = rage.exploit:get(),
        desync = math.floor(aantiaim.get_desync_delta()),
    }
    local speed = t.lp.m_vecVelocity
    local velocity = speed:length()
    local a = {
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 10 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 8 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 6 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 4 / 4))),
        color(t.color.r, t.color.g, t.color.b, 255 * math.abs(1 * math.cos(2 * math.pi * globals.curtime + 2 / 4))),
    }

    if t.lp.m_bIsScoped then
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 1.91, globals.frametime * 11)
    else
        vars.ind.scope_smooth = func:lerp(vars.ind.scope_smooth, 2, globals.frametime * 11)
    end

    vars.ind.smooth = func:lerp(vars.ind.smooth, t.desync, globals.frametime*8)

    if vars.menu.dt:get() or vars.menu.hs:get() then
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt + 1, 0, 10)
    else
        vars.ind.lavendu.anim[1].dt = math.clamp(vars.ind.lavendu.anim[1].dt - 1, 0, 10)
    end

    if ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"):get() then
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs + 1, 0, 10)

        if vars.menu.dt:get() or vars.menu.hs:get() then
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt + 0.5, 0, 5.5)
            if t.lp.m_bIsScoped then
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
            else
                vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs + 0.5, 0, 5.5)
            end
        else
            vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
            vars.ind.lavendu.anim[2].fs = math.clamp(vars.ind.lavendu.anim[2].fs - 0.5, 0, 5.5)
        end

    else
        vars.ind.lavendu.anim[1].fs = math.clamp(vars.ind.lavendu.anim[1].fs - 1, 0, 10.5)
        vars.ind.lavendu.anim[2].dt = math.clamp(vars.ind.lavendu.anim[2].dt - 0.5, 0, 5.5)
    end

    t.alpha = math.clamp(t.alpha, 25, 255)
    vars.ind.smooth = math.clamp(vars.ind.smooth, 0, 19)

    if vars.menu.fs:get() then
        vars.ind.fs_alpha = math.clamp(vars.ind.fs_alpha + 12, 0 , 255)
    else
        vars.ind.fs_alpha = math.clamp(vars.ind.fs_alpha - 12, 0 , 255)
    end
    local os = 0
    if vars.menu.dt:get() and vars.menu.hs:get() then
        t.dt_text = "dt"
    elseif vars.menu.dt:get() and not vars.menu.hs:get() then
        t.dt_text = "dt"
    elseif not vars.menu.dt:get() and vars.menu.hs:get() then
        t.dt_text = "os"
        os = -1
    end

    if conditional_aa.onuseAAEnabled then
        t.dyn_text = "using"
    else
        if CheckFlag(t.lp, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(t.lp, 1) then
                t.dyn_text = "jumping"
            else
                t.dyn_text = "airduck"
            end
        else
            if vars.menu.sw:get() then
                t.dyn_text = "slowwalk"
            else
                if CheckFlag(t.lp, 1) then
                    t.dyn_text = "ducking"
                else
                    if velocity >= 1.2 then
                        t.dyn_text = "running"
                    else
                        t.dyn_text = "standing"
                    end
                end
            end
        end
    end

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts('os', 'o', vars.font.pixel).x/2 - 5 - vars.ind.lavendu.anim[2].dt + vars.ind.lavendu.anim[3][3] + os, screen.y/2 + 30 + vars.ind.lavendu.anim[1].dt), color(255, 255, 255, vars.ind.lavendu.anim[1].dt/10*255), nil, t.dt_text)
    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "fs").x/2 + vars.ind.lavendu.anim[2].fs + vars.ind.lavendu.anim[3][3] + vars.ind.lavendu.chestie, screen.y/2 + 30 + vars.ind.lavendu.anim[1].fs), color(255, 255, 255, vars.ind.lavendu.anim[1].fs/10*255), nil, "fs")

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax").x/2, screen.y/2 + 16), color(255, 255, 255, 255), nil, "cyrax")
    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', "cyrax").x/2, screen.y/2 + 16), color(255, 255, 255, 255), nil, string.format("\a%sc\a%sy\a%sr\a%sa\a%sx", a[1]:to_hex(), a[2]:to_hex(), a[3]:to_hex(), a[4]:to_hex(), a[5]:to_hex()))

    for i = 1, 5 do
        render.rect_outline(vector(screen.x/vars.ind.scope_smooth - 19 - i, screen.y/2 + 27 - i), vector(screen.x/vars.ind.scope_smooth + 19 + i, screen.y/2 + 31 + i), color(t.color.r, t.color.g, t.color.b, 0.15 * (1 - i / 5) * 255), 1, 5)
    end

    render.rect(vector(screen.x/vars.ind.scope_smooth - 20, screen.y/2 + 27), vector(screen.x/vars.ind.scope_smooth + 20, screen.y/2 + 31), color(0, 0, 0, 122), 1)

    render.gradient(vector(screen.x/vars.ind.scope_smooth - 19, screen.y/2 + 28), vector(screen.x/vars.ind.scope_smooth + vars.ind.smooth, screen.y/2 + 30), color(t.color.r, t.color.g, t.color.b, 255), color(t.color.r, t.color.g, t.color.b, 0), color(t.color.r, t.color.g, t.color.b, 255), color(t.color.r, t.color.g, t.color.b, 0), 1)

    render.text(vars.font.pixel, vector(screen.x/vars.ind.scope_smooth - texts(vars.font.pixel, 'o', t.dyn_text).x/2, screen.y/2 + 30), color(t.color.r, t.color.g, t.color.b, t.alpha), nil, t.dyn_text)
           
end


function func:cyrax_ind_4()

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or menu_cyrax.visuals_switch._:get() == false or menu_cyrax.indicators_switch._:get() == false or gear_opt.indicators_type:get() ~= 'Cyrax V3' then return end

    local screen = render.screen_size()
    local localplayer = entity.get_local_player()
    local speed = localplayer.m_vecVelocity
    local velocity = speed:length()
    local t = {
        alpha = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 4)),
        dyn_text = "aggresive",
        charge = rage.exploit:get(),
        desync = math.floor(aantiaim.get_desync_delta()),
        clr = {          
            r = gear_opt.indicators_color:get().r,
            g = gear_opt.indicators_color:get().g,
            b = gear_opt.indicators_color:get().b,
        },
        text = func:version(),
        dt = "",
    }

    if conditional_aa.onuseAAEnabled then
        vars.ind.v2.cond_text = "using"
    else
        if CheckFlag(localplayer, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(localplayer, 1) then
                vars.ind.v2.cond_text = "jumping"
            else
                vars.ind.v2.cond_text = "airduck"
            end
        else
            if vars.menu.sw:get() then
                vars.ind.v2.cond_text = "slowwalking"
            else
                if CheckFlag(localplayer, 1) then
                    vars.ind.v2.cond_text = "ducking"
                else
                    if velocity >= 1.2 then
                        vars.ind.v2.cond_text = "running"
                    else
                        vars.ind.v2.cond_text = "standing"
                    end
                end
            end
        end
    end

    if vars.menu.dt:get() then
        if vars.menu.qp:get() then
            t.dt = "idealtick"
        else
            t.dt = "doubletap"
        end
    end

    vars.ind.smooth = func:lerp(vars.ind.smooth, math.clamp(t.desync*8, 0, 30), globals.frametime*8)

    for i = 1, 5 do
        render.rect_outline(vector(screen.x/2 + 4 - i, screen.y/2 + 26 - i), vector(screen.x/2 + 57 + i, screen.y/2 + 31 + i), color(t.clr.r, t.clr.g, t.clr.b, 0.15 * (1 - i / 5) * 255), 1, 5)
    end

    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + 16), color(t.clr.r, t.clr.g, t.clr.b, 255), nil, "Cyrax")
    render.text(vars.font.pixel, vector(screen.x/2 + 5 + texts(vars.font.pixel, 'o', "Cyrax").x, screen.y/2 + 16), color(255, 255, 255, t.alpha * 255), nil, t.text)
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + 30), color(t.clr.r, t.clr.g, t.clr.b, 255), nil, vars.ind.v2.cond_text)
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + vars.ind.v2.p[1] - 1), color(255, 255, 255, vars.ind.v2.a[1][3] * 255), nil, t.dt)
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + vars.ind.v2.p[2] - 1), color(255, 255, 255, vars.ind.v2.a[2] * 255), nil, "hideshots")
    render.text(vars.font.pixel, vector(screen.x/2 + 5, screen.y/2 + vars.ind.v2.p[3] - 1), color(255, 255, 255, vars.ind.v2.a[3] * 255), nil, "fakeduck")

    render.rect(vector(screen.x/2 + 5, screen.y/2 + 27), vector(screen.x/2 + 57, screen.y/2 + 32), color(0, 0, 0, 255), 2)
    render.gradient(vector(screen.x/2 + 6, screen.y/2 + 28), vector(screen.x/2 + 25 + vars.ind.smooth, screen.y/2 + 31), color(t.clr.r, t.clr.g, t.clr.b, 255), color(0, 0, 0, 0), color(t.clr.r, t.clr.g, t.clr.b, 255), color(0, 0, 0, 0), 2)
   

    if vars.menu.dt:get() and not vars.menu.fd:get() then
        if t.charge ~= 1 then
            vars.ind.v2.a[1][1] = math.clamp(vars.ind.v2.a[1][1] + 0.036, 0, 1)
            vars.ind.v2.a[1][2] = math.clamp(vars.ind.v2.a[1][2] - 0.036, 0, 1)
        else
            vars.ind.v2.a[1][1] = math.clamp(vars.ind.v2.a[1][1] - 0.036, 0, 1)
            vars.ind.v2.a[1][2] = math.clamp(vars.ind.v2.a[1][2] + 0.036, 0, 1)
        end
        vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 52, globals.frametime*20)
        if rage.exploit:get() == 1 then
            vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] + 0.036, 0, 1)
        else
            vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0.1, 1)
        end
    else
        vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 40, globals.frametime*20)
        vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0, 1)
    end

    if vars.menu.hs:get() and not vars.menu.dt:get() and not vars.menu.fd:get() then
        vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] + 0.036, 0, 1)
    else
        vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] - 0.036, 0, 1)
    end

    if vars.menu.fd:get() then
        vars.ind.v2.a[3] = math.clamp(vars.ind.v2.a[3] + 0.036, 0, 1)
        vars.ind.v2.p[2] = func:lerp(vars.ind.v2.p[2], 52, globals.frametime*20)
        vars.ind.v2.a[1][3] = math.clamp(vars.ind.v2.a[1][3] - 0.036, 0, 1)
        vars.ind.v2.a[2] = math.clamp(vars.ind.v2.a[2] - 0.036, 0, 1)
        vars.ind.v2.p[1] = func:lerp(vars.ind.v2.p[1], 52, globals.frametime*20)
    else
        vars.ind.v2.a[3] = math.clamp(vars.ind.v2.a[3] - 0.036, 0, 1)
        vars.ind.v2.p[1] = func:lerp(vars.ind.v2.p[1], 40, globals.frametime*20)
    end

end
gear_opt.logs_miss_what:set_visible(false)
function func:screenLogs(e)
    if globals.is_connected == false or entity.get_local_player():is_alive() == false then return end
    if not menu_cyrax.logs_switch._:get() or not gear_opt.screen_logs:get() then return end
    local target = entity.get(e.target)
    local wanted_dmg = e.wanted_damage
    local damage = e.damage
    local wanted_hbx = hitgroups[e.wanted_hitgroup]
    local hitchance = e.hitchance
    local state = e.state
    local bt = e.backtrack
    local hitbox = hitgroups[e.hitgroup]
   
    if e.state == nil then
        table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sHit %s's \a%s%s \a%s[aimed = %s | damage: %i(%i) | hc: %i | history: %i]", gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex(), target:get_name(), gear_opt.logs_hit:get():to_hex(), hitbox, gear_opt.logs_miss_what:get():to_hex(), wanted_hbx, damage, wanted_dmg, hitchance, bt), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
    else
        table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sMissed shot at %s's \a%s%s \a%sdue to \a%s%s \a%s[hc: %i | history: %i]", gear_opt.logs_miss:get():to_hex(), gear_opt.logs_miss_what:get():to_hex(), target:get_name(), gear_opt.logs_miss:get():to_hex(), wanted_hbx, gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_miss:get():to_hex(), state, gear_opt.logs_miss_what:get():to_hex(), hitchance, bt), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_miss:get()})
    end
end
local cleartbl = function()
    if #tbl ~= 0 then
        if globals.is_connected == false or globals.curtime == 0 then
            table.remove(tbl, #tbl)
        end
        if #tbl > 5 then
            table.remove(tbl, 1)
        end
        for i = 1, #tbl do
            if tbl[i] == nil then
                return
            end
            if tbl[i][1] + 4 > math.floor(globals.curtime) then
                return
            end
            tbl[i][2] = tbl[i][2] - math.floor(globals.frametime * 340)
   
            if tbl[i][2] < 0 then
                table.remove(tbl, i)
            end
        end
    end
end
function func:drawscreenLogs()
    cleartbl()
    local x = render.screen_size().x/2
    local total_width = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
    local used_width = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
    local anim = globals.frametime * 10
    for k, v in pairs(tbl) do
        local c = v.clr or color(255, 255, 255, 255)
        local text_width = texts(1, nil, v.text).x
        total_width[k] = total_width[k] + text_width  
        local in_ = math.min((globals.realtime - v.realtime)*2, 1)
        local out = math.max(((globals.realtime - 3.8) - v.realtime)*3, 0)
        local cur_x = x - total_width[k] / 2 + used_width[k]

        render.rect(vector(cur_x - 8, 897 + k * 30 + (in_-out) * 10), vector(cur_x + text_width + 9, 917 + k * 30 + (in_-out) * 10), color(0, 0, 0, math.clamp((in_-out) * 255, 0, 30)), 5)

        render.text(1, vector(cur_x, 900 + k * 30 + (in_-out) * 10), color(255, 255, 255, (in_-out) * 255), nil, v.text)

        for i = 1, 5 do
            render.rect_outline(vector(cur_x - 8 - i, 897 + k * 30 - i + (in_-out) * 10), vector(cur_x + text_width + 9 + i, 917 + k * 30 + i + (in_-out) * 10), color(c.r, c.g, c.b, (1 - i / 5) * math.clamp((in_-out) * 255, 0, 50)), 1, 10)
        end

        render.rect_outline(vector(cur_x - 8, 897 + k * 30 + (in_-out) * 10), vector(cur_x + text_width + 9, 917 + k * 30 + (in_-out) * 10), color(c.r, c.g, c.b, math.clamp((in_-out) * 255, 0, 255)), 1, 5)
    end
end

local phrases = {
    "dont talking pls",
    "when u miss, cry u dont hev cyrax.tech",
    "you think you are is good but im best 1",
    "fokin dog, get ownet by Создатель js rezolver",
    "if im lose = my team is dog",
    "never talking bad to me again, im always top1",
    "umad that you're miss? hs dog",
    "vico (top1 eu) vs all kelbs on hvh.",
    "you is mad that im ur papi?",
    "im will rape u're mother after i killed you",
    "stay mad that im unhitable",
    "god night brother, cya next raund ;)",
    "get executed from presidend of argentina",
    "you thinking ur have chencse vs boss?",
    "i killed gejmsense, now im kill you",
    "by luckbaysed config, cya twitter bro o/",
    "cy@ https://gamesense.pub/forums/viewforum.php?id=6",
    "╭∩╮(◣_◢)╭∩╮(its fuck)",
    "dont play vs me on train, im live there -.-",
    "by top1 uzbekistan holder umed?",
    "courage for play de_shortnuke vs me, my home there.",
    "bich.. dont test g4ngst3r in me.",
    "im rich princ here, dont toxic dog.",
    "for all thet say gamesense best, im try on parsec and is dog.",
    "WEAK DOG sanchezj vs ru bossman (owned on mein map)",
    "im want gamesense only for animbrejker, neverlose always top.",
    "this dog brandog thinking hes top, but reality say no.",
    "fawk you foking treny",
    "ur think ur good but its falsee.",
    "topdog nepbot get baits 24/7 -.-",
    "who this bot malva? im own him 9-0",
    "im beat all romania dogs with 1 finker",
    "im rejp this dog noobers with no problems",
    "gamesense vico vs all -.-",
    "irelevent dog jompan try to stay popular but fail",
    "im user beta and ur dont, stay mad.",
    "dont talking, no cyrax tech no talk pls",
    "when u miss, cry u dont hev cyrax.tech",
    "you think you are is good but cyrax is best",
    "fkn dog, get own by cyrax js rezolver",
    "if you luse = no cyrax issue",
    "never talking bad to me again, cyrax boosing me to top1",
    "umad that you're miss? get cyrax d0g",
    "stay med that im unhitable ft cyrax",
    "get executed from cyrax technology",
    "you thinking ur have chencse vs cyrax?",
    "first i killed gejmsense, now cyrax kill you",
    "by cyrax boss aa, cya twitter bro o/",
    "cy@ https://en.neverlose.cc/market/item?id=17YLeZ",
    "courage for test resolve me. cyrax always boosting",
}

function func:get_phrase()
    return phrases[utils.random_int(1, #phrases)]:gsub('"', '')
end

function func:killsay(event)
    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or not menu_cyrax.killsay_switch._:get() then return end
    local me = entity.get_local_player()
    local attackere = entity.get(event.attacker, true)

    if me == attackere then
        utils.console_exec('say "' .. func:get_phrase() .. '"')
    end
end

function func:anti_aim_bossule(cmd)

    if globals.is_connected == false or entity.get_local_player() == nil or entity.get_local_player():is_alive() == false or not menu_aa.Switch_AntiAim._:get() then return end
    local localplayer = entity.get_local_player()
    local speed = localplayer.m_vecVelocity
    local velocity = speed:length()

    if common.is_button_down(0x45) then
        conditional_aa.onuseAAEnabled = true
    else
        conditional_aa.onuseAAEnabled = false
        if CheckFlag(localplayer, {0}) or common.is_button_down(0x20) then
            if not CheckFlag(localplayer, 1) then
                conditional_aa.inairAAEnabled = true
                conditional_aa.inairAAduckEnabled = false
            else
                conditional_aa.inairAAduckEnabled = true
                conditional_aa.inairAAEnabled = false
            end
        else
            conditional_aa.inairAAEnabled = false
            conditional_aa.inairAAduckEnabled = false
            if vars.menu.sw:get() then
                conditional_aa.slowwalkAAEnabled = true
            else
                conditional_aa.slowwalkAAEnabled = false
                if CheckFlag(localplayer, 1) then
                    conditional_aa.crouchingAAEnabled = true
                else
                    conditional_aa.crouchingAAEnabled = false
                    if velocity >= 1.2 then
                        conditional_aa.movingAAEnabled = true
                        conditional_aa.standingAAEnabled = false
                    else
                        conditional_aa.movingAAEnabled = false
                        conditional_aa.standingAAEnabled = true
                    end
                end
            end
        end
    end

    if conditional_aa.standingAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Standing._:get())

        if aantiaim.get_inverter_state() then
           
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Standing._:get())
        else
           
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Standing._:get())
        end
       
        conditional_aa.lbymode:set(menu_aa.LBYMode_Standing._:get())

        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Standing._:get())
       
        if menu_aa.YawModifierType_Standing._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Standing._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Standing._:get(), menu_aa.ModifierDegreeMax_Standing._:get()))
        end
       
        if menu_aa.FakeLimitType_Standing._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Standing._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Standing._:get())
        elseif menu_aa.FakeLimitType_Standing._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Standing._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Standing._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Standing._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Standing._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Standing._:get()))
        end
       
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Standing._:get())
       
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Standing._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Standing._:get())

        if menu_aa.YawBase_Standing._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Standing._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                conditional_aa.yawbase:set('Local View')
                for k, v in pairs(yawbases) do
                    if menu_aa.YawBase_Standing._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end

    end

    if conditional_aa.slowwalkAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Slowwalk._:get())

        if aantiaim.get_inverter_state() then
           
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Slowwalk._:get())
        else
           
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Slowwalk._:get())
        end

       
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Slowwalk._:get())
       
        if menu_aa.YawModifierType_Slowwalk._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Slowwalk._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Slowwalk._:get(), menu_aa.ModifierDegreeMax_Slowwalk._:get()))
        end
       
        if menu_aa.FakeLimitType_Slowwalk._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Slowwalk._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Slowwalk._:get())
        elseif menu_aa.FakeLimitType_Slowwalk._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Slowwalk._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Slowwalk._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Slowwalk._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Slowwalk._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Slowwalk._:get()))
        end
       
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Slowwalk._:get())
       
        conditional_aa.lbymode:set(menu_aa.LBYMode_Slowwalk._:get())
       
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Slowwalk._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Slowwalk._:get())
       
        if menu_aa.YawBase_Slowwalk._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Slowwalk._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_Slowwalk._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.movingAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Moving._:get())

        if aantiaim.get_inverter_state() then
           
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Moving._:get())
        else
           
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Moving._:get())
        end
       
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Moving._:get())
       
        if menu_aa.YawModifierType_Moving._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Moving._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Moving._:get(), menu_aa.ModifierDegreeMax_Moving._:get()))
        end
       
        if menu_aa.FakeLimitType_Moving._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Moving._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Moving._:get())
        elseif menu_aa.FakeLimitType_Moving._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Moving._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Moving._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Moving._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Moving._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Moving._:get()))
        end
       
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Moving._:get())
       
        conditional_aa.lbymode:set(menu_aa.LBYMode_Moving._:get())

        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Moving._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Moving._:get())

        if menu_aa.YawBase_Moving._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Moving._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_Moving._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.inairAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_InAir._:get())

        if aantiaim.get_inverter_state() then
           
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_InAir._:get())
        else
           
            conditional_aa.yawadd:set(menu_aa.YawAddRight_InAir._:get())
        end

       
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_InAir._:get())
       
        if menu_aa.YawModifierType_InAir._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_InAir._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_InAir._:get(), menu_aa.ModifierDegreeMax_InAir._:get()))
        end
       
        if menu_aa.FakeLimitType_InAir._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAir._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAir._:get())
        elseif menu_aa.FakeLimitType_InAir._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAir._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAir._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_InAir._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_InAir._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_InAir._:get()))
        end
       
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_InAir._:get())
       
        conditional_aa.lbymode:set(menu_aa.LBYMode_InAir._:get())

        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_InAir._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_InAir._:get())

        if menu_aa.YawBase_InAir._:get() ~= 'Disabled' then
            if menu_aa.YawBase_InAir._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_InAir._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.inairAAduckEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_InAirDuck._:get())

        if aantiaim.get_inverter_state() then
           
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_InAirDuck._:get())
        else
           
            conditional_aa.yawadd:set(menu_aa.YawAddRight_InAirDuck._:get())
        end
       
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_InAirDuck._:get())
       
        if menu_aa.YawModifierType_InAirDuck._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_InAirDuck._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_InAirDuck._:get(), menu_aa.ModifierDegreeMax_InAirDuck._:get()))
        end
       
        if menu_aa.FakeLimitType_InAirDuck._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAirDuck._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAirDuck._:get())
        elseif menu_aa.FakeLimitType_InAirDuck._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_InAirDuck._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_InAirDuck._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_InAirDuck._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_InAirDuck._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_InAirDuck._:get()))
        end
       
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_InAirDuck._:get())

        conditional_aa.lbymode:set(menu_aa.LBYMode_InAirDuck._:get())
       
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_InAirDuck._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_InAirDuck._:get())

        if menu_aa.YawBase_InAirDuck._:get() ~= 'Disabled' then
            if menu_aa.YawBase_InAirDuck._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_InAirDuck._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if conditional_aa.crouchingAAEnabled then

        conditional_aa.pitch:set(menu_aa.Pitch_Crouching._:get())

        if aantiaim.get_inverter_state() then
           
            conditional_aa.yawadd:set(menu_aa.YawAddLeft_Crouching._:get())
        else
           
            conditional_aa.yawadd:set(menu_aa.YawAddRight_Crouching._:get())
        end
   
        conditional_aa.lbymode:set(menu_aa.LBYMode_Crouching._:get())
       
        conditional_aa.yawmodifier:set(menu_aa.YawModifier_Crouching._:get())
       
        if menu_aa.YawModifierType_Crouching._:get() == 'Default' then
            conditional_aa.modifierdegree:set(menu_aa.ModifierDegree_Crouching._:get())
        else
            conditional_aa.modifierdegree:set(utils.random_int(menu_aa.ModifierDegreeMin_Crouching._:get(), menu_aa.ModifierDegreeMax_Crouching._:get()))
        end
       
        if menu_aa.FakeLimitType_Crouching._:get() == 'Static' then
            conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Crouching._:get())
            conditional_aa.fakelimitright:set(menu_aa.RightLimit_Crouching._:get())
        elseif menu_aa.FakeLimitType_Crouching._:get() == 'Jitter' then
            if utils.random_int(0,1) == 1 then
                conditional_aa.fakelimitleft:set(menu_aa.LeftLimit_Crouching._:get())
                conditional_aa.fakelimitright:set(menu_aa.RightLimit_Crouching._:get())
            else
                conditional_aa.fakelimitleft:set(18)
                conditional_aa.fakelimitright:set(18)
            end
        elseif menu_aa.FakeLimitType_Crouching._:get() == 'Random Jitter' then
            conditional_aa.fakelimitleft:set(utils.random_int(0, menu_aa.LeftLimit_Crouching._:get()))
            conditional_aa.fakelimitright:set(utils.random_int(0, menu_aa.RightLimit_Crouching._:get()))
        end
       
        conditional_aa.fakeoptions:set(menu_aa.FakeOptions_Crouching._:get())
       
        conditional_aa.freestandingdesync:set(menu_aa.FreestandingDesync_Crouching._:get())
        conditional_aa.desynconshot:set(menu_aa.DesyncOnShot_Crouching._:get())

        if menu_aa.YawBase_Crouching._:get() ~= 'Disabled' then
            if menu_aa.YawBase_Crouching._:get() == 'At Target' then
                conditional_aa.yawbase:set('At Target')
            else
                for k, v in pairs(yawbases) do
                    conditional_aa.yawbase:set('Local View')
                    if menu_aa.YawBase_Crouching._:get() == tostring(k) then
                        conditional_aa.yawadd:set(v)
                    end
                end
            end
        end
    end

    if override_yaw:get() ~= 'Disabled' then
        for k, v in pairs(yawbases) do
            conditional_aa.yawbase:set('Local View')
            if override_yaw:get() == tostring(k) then
                conditional_aa.yawadd:set(v)
            end
        end
    end
   
end

alpha_k = 1
width_k = 0
width_ka = 0
data_k = {
    [''] = {alpha_k = 0}
}
drag = false

local render_window = function(x, y, w, h, coloru, shadow_color, outline_color)
    local r, g, b, a = coloru.r, coloru.g, coloru.b, coloru.a
    local r1, g1, b1, a1 = shadow_color.r, shadow_color.g, shadow_color.b, shadow_color.a
    local r2, g2, b2, a2 = outline_color.r, outline_color.g, outline_color.b, outline_color.a

    render.circle_outline(vector(x + 4, y + 4), color(r, g, b, 255), 4, 165, 0.35, 1)

    render.rect(vector(x + 4, y), vector(w - 5, y+1), color(r, g, b, 255))
    render.circle_outline(vector(w - 4, y + 4), color(r, g, b, 255), 4, 260, 0.35, 1)

    render.gradient(vector(x, y + 4), vector(x + 1, h - 6), color(r, g, b, 255), color(r, g, b, 255), color(r, g, b, 0), color(r, g, b, 0))
    render.gradient(vector(w - 1, y + 4), vector(w, h - 6), color(r, g, b, 255), color(r, g, b, 255), color(r, g, b, 0), color(r, g, b, 0))

    render.rect(vector(x, y), vector(w, h), color(r2, g2, b2, (80 / 255) * gear_opt.solus_clr:get().a), 5)

    for i = 1, 5 do
        render.rect_outline(vector(x - i, y - i), vector(w + i, h + i), color(r, g, b, 0.15 * (1 - i / 5) * 255), 1, 5)
    end
   
    render.rect(vector(x+1, y+1), vector(w-1, h-1), color(0, 0, 0, gear_opt.solus_clr:get().a), 5)
   
end

function func:getbinds()
    local binds = {}
    local cheatbinds = ui.get_binds()
   
    for i = 1, #cheatbinds do
        table.insert(binds, 1, cheatbinds[i])
    end
    return binds
end

local keybind_names = {
    ['Double Tap'] = 'Double tap',
    ['Hide Shots'] = 'On shot anti-aim',
    ['Slow Walk'] = 'Slow motion',
    ['Edge Jump'] = 'Jump at edge',
    ['Fake Ping'] = 'Ping spike',
    ['Override Resolver'] = 'Resolver override',
    ['Fake Duck'] = 'Duck peek assist',
    ['Minimum Damage'] = 'Damage override',
    ['Auto Peek'] = 'Quick peek assist',
    ['Body Aim'] = 'Force body aim',
    ['Safe Points'] = 'Safe points',
    ['Yaw Base'] = 'Yaw base',
    ['Enable Thirdperson'] = 'Thirdperson',
    ['Manual Yaw Base'] = 'Yaw base',
}

function upper_to_lower(str)
    str1 = string.sub(str, 2, #str)
    str2 = string.sub(str, 1, 1)
    return str2:upper()..str1:lower()
end

local render_solus = function(x2, y2, w, h, name, font)
    local name_size = render.measure_text(font, nil, name)
    render_window(x2, y2, x2 + w + 3, y2 + h + 2, color(gear_opt.solus_clr:get().r, gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255), color(gear_opt.solus_clr:get().r, gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255), color(gear_opt.solus_clr:get().r, gear_opt.solus_clr:get().g, gear_opt.solus_clr:get().b, 255))
    render.text(font, vector(x2+1 + w / 2 + 1 - name_size.x / 2, y2 + 2), color(255,255,255, 255), nil, name)
end

function func:solus_keybinds()
    if not gear_opt.solus_binds:get() or menu_cyrax.visuals_switch._:get() == false or not menu_cyrax.solus_switch._:get() then return end
    local x_k, y_k = gear_opt.solus_1:get(),gear_opt.solus_2:get()
    local max_width = 0
    local frametime = globals.frametime * 16
    local add_y = 0
    local total_width = 66
    local active_binds = {}
    local bind = func:getbinds()
    for i = 1, #bind do
        local binds = bind[i]
        local bind_name = keybind_names[binds.name] == nil and upper_to_lower(binds.name) or keybind_names[binds.name]

        local bind_state = binds.mode
        if bind_state == 2 then
            bind_state = 'toggled'
        elseif bind_state == 1 then
            bind_state = 'holding'
        end
        if binds.name == "Minimum Damage" then
            bind_state = binds.value
        end
       
        if data_k[bind_name] == nil then
            data_k[bind_name] = {alpha_k = 0}
        end
        --if (ui.get_alpha() > 0.9) then
        --    bind_name = 'Menu toggled'
        --end
        data_k[bind_name].alpha_k = solus_lerp(frametime, data_k[bind_name].alpha_k,binds.active and 1 or 0)
        local bind_state_size = render.measure_text(vars.font.verdana, nil, bind_state)
        local bind_name_size = render.measure_text(vars.font.verdana, nil, bind_name)

        render.text(vars.font.verdana, vector(x_k+4, y_k + 21 + add_y), color(0, 0, 0, data_k[bind_name].alpha_k*255), nil, bind_name)
        render.text(vars.font.verdana, vector(x_k+1 + (width_ka - bind_state_size.x - 8), y_k + 21 + add_y), color(0, 0, 0, data_k[bind_name].alpha_k*255) , nil, '['..bind_state..']')

        render.text(vars.font.verdana, vector(x_k+3, y_k + 20 + add_y), color(255, 255, 255, data_k[bind_name].alpha_k*255), nil, bind_name)
        render.text(vars.font.verdana, vector(x_k + (width_ka - bind_state_size.x- 8), y_k + 20 + add_y), color(255, 255, 255, data_k[bind_name].alpha_k*255), nil , '['..bind_state..']')

        add_y = add_y + 16 * data_k[bind_name].alpha_k

       
        local width_k = bind_state_size.x + bind_name_size.x + 18
        if width_k > 150-11 then
            if width_k > max_width then
                max_width = width_k
            end
        end
        if binds.active then
            table.insert(active_binds, binds)
        end
    end
    alpha_k = solus_lerp(frametime,alpha_k, ((ui.get_alpha() > 0.9) or #active_binds > 0) and 1 or 0)
    width_ka = solus_lerp(frametime,width_ka,math.max(max_width, 150-11))

    if (ui.get_alpha() > 0.5) or #active_binds > 0 then
        render_solus(x_k, y_k, width_ka, 16, 'keybinds', 11, vars.font.verdana)

        local mouse = ui.get_mouse_position()
        if common.is_button_down(1) and (ui.get_alpha() > 0.9) then
            if mouse.x >= x_k and mouse.y >= y_k and mouse.x <= x_k + width_ka and mouse.y <= y_k + 18 or drag then
                if not drag then
                    drag=true
                else
                    gear_opt.solus_1:set(mouse.x - math.floor(width_ka / 2))
                    gear_opt.solus_2:set(mouse.y - 8)
                end
            end
        else
            drag=false
        end
    end
end

func:solus_watermark()
    if not gear_opt.solus_watermark:get() or menu_cyrax.visuals_switch._:get() == false or not menu_cyrax.solus_switch._:get() then return end
    lua_name = string.format("cyrax.tech")
    user_name = common.get_username()
    time = common.get_date("%H:%M:%S")
    watermark_text = string.format("%s | %s | %s", lua_name, user_name, time)

    if globals.is_in_game then
        local ping = utils.net_channel().avg_latency[0]*1000
        final_latency = ('delay: %dms'):format(ping)
        watermark_text = string.format("%s | %s | %s | %s", lua_name, user_name, final_latency, time)
    end

    cock_size = render.measure_text(vars.font.verdana, nil, watermark_text)
    render_solus(render.screen_size().x - cock_size.x - 15, 3, cock_size.x + 5, 16, watermark_text, 11, vars.font.verdana)
end
local function gradient_text(r1, g1, b1, a1, r2, g2, b2, a2, text)
    local output = ''
    local len = #text-1
    local rinc = (r2 - r1) / len
    local ginc = (g2 - g1) / len
    local binc = (b2 - b1) / len
    local ainc = (a2 - a1) / len
    for i=1, len+1 do
        output = output .. ('\a%02x%02x%02x%02x%s'):format(r1, g1, b1, a1, text:sub(i, i))
        r1 = r1 + rinc
        g1 = g1 + ginc
        b1 = b1 + binc
        a1 = a1 + ainc
    end
    return output
end

func:watermark()
    if not menu_cyrax.watermark_switch._:get() or not menu_cyrax.visuals_switch._:get() then return end
    local alpha = math.abs(1 * math.cos(2 * math.pi * (globals.curtime + 3) / 5)) * 255
    local alpha2 = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 5)) * 255
    local amangas = gradient_text(gear_opt.wm_color:get().r, gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, alpha, 255, 255, 255, 0, string.format(' >/cyrax anti aim technologies [%s]/<', string.lower(func:version())))
    local amangas2 = gradient_text(255, 255, 255, 0, gear_opt.wm_color:get().r, gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, alpha2, string.format(' >/cyrax anti aim technologies [%s]/<', string.lower(func:version())))
    local amangas3 = gradient_text(gear_opt.wm_color:get().r, gear_opt.wm_color:get().g, gear_opt.wm_color:get().b, 255, gear_opt.wm_color2:get().r, gear_opt.wm_color2 :get().g, gear_opt.wm_color2:get().b, 255, string.format('>/cyrax anti aim technologies [%s]/<', string.lower(func:version())))
    if gear_opt.animate:get() then
        render.text(1, vector(10, 450), color(0, 0, 0), nil, string.format('>/cyrax anti aim technologies [%s]/<', string.lower(func:version ())))
        render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas)
        render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas2)
        gear_opt.wm_color2:set_visible(false)
    else
        gear_opt.wm_color2:set_visible(true)
        render.text(1, vector(10, 450), color(0, 0, 0), nil, amangas3)
    end
end

local alpha123 = 0
local time = anim_switch:get() and math.floor(globals.realtime) or 0

func:loading()
    local screen = render.screen_size()
    if math.floor(globals.realtime) - time > 8 or not anim_switch:get() then return end

    if globals.realtime - time > 5 then
        alpha123 = math.clamp(alpha123 - 1, 0, 50)
    else
        alpha123 = math.clamp(alpha123 + 1, 0, 50)  
    end
   
    render.rect(vector(0, 0), vector(screen.x, screen.y), color(245, 202, 182, alpha123))  

    render.texture(gif, vector(screen.x/2.8, screen.y/4), vector(540, 540), color(255, 255, 255, alpha123 * 5.5))

end

hooked_function = nil
ground_ticks, end_time = 1, 0
function updateCSA_hk(thisptr, edx)
    if entity.get_local_player() == nil or ffi.cast('uintptr_t', thisptr) == nil then return end
    hooked_function(thisptr, edx)
    if gear_opt.anim:get("Static Legs") and menu_cyrax.animbreaker_switch._:get() then
        ffi.cast('float*', ffi.cast('uintptr_t', thisptr) + 10104)[6] = 1
    end
    if gear_opt.anim:get("Leg Breaker") and menu_cyrax.animbreaker_switch._:get() then
        ffi.cast('float*', ffi.cast('uintptr_t', thisptr) + 10104)[0] = 1
        conditional_aa.legmovement:set('Sliding')
    end
end


function anim_state_hook()
    local local_player = entity.get_local_player()
    if not local_player then return end

    local local_player_ptr = get_entity_address(local_player:get_index())
    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_hk, 224)
end

local handleSaveConfig = {
    switch = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end,

    slider = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end,

    color_picker = function(el)
        local clr = el._:get()
        return {
            name = el.name,
            element = el.element,
            color={
                r = clr.r,
                g = clr.g,
                b = clr.b,
                a = clr.a
            }
        }
    end,

    combo = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end,

    selectable = function(el)
        return {
            name = el.name,
            element = el.element,
            value = el._:get()
        }
    end

}

local handleLoadConfig = {
    switch = function(el)
        menu_aa[el.name]._:set(el.value)
    end,

    slider = function(el)
        menu_aa[el.name]._:set(el.value)
    end,

    color_picker = function(el)
        local clr = init(el.color.r, el.color.g, el.color.b, el.color.a)
        menu_aa[el.name]._:set(clr)
    end,

    combo = function(el)
        menu_aa[el.name]._:set(el.value)
    end,

    selectable = function(el)
        pcall(function() return menu_aa[el.name]._:set(el.value) end)
    end

}

gear_opt.export:set_callback(function()

    local config = {}

    for key, el in pairs(menu_aa) do
        if el.element == "Button" then goto continue end
        table.insert(config, handleSaveConfig[el.element](el))
        ::continue::
    end

    clipboard.set(base64.encode(json.stringify(config)))
    print_dev("Cyrax - Config saved to clipboard")

    table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sConfig \a%sExported", gear_opt.logs_hit:get():to_hex(), gear_opt. logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
end)

gear_opt.import:set_callback(function()
    local status, config = pcall(function() return json.parse(base64.decode(clipboard.get())) end)

    if not status or status == nil then    
        color_p("Cyrax: Failed to load config\n", color(1, 0, 0, 1))
        print_dev("Cyrax - Failed to load config")
        table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] Failed \a%sto \a%sImport \a%sConfig", gear_opt.logs_miss:get():to_hex (), gear_opt.logs_miss_what:get():to_hex(), gear_opt.logs_miss:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor( globals.curtime), 255, clr = gear_opt.logs_hit:get()})
    return end
   
    for key, el in pairs(config) do
        if el.element == "Button" then goto continue end
        handleLoadConfig[el.element](el)
        ::continue::
    end
    print_dev("Cyrax - Config loaded")
    table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sConfig \a%sImported", gear_opt.logs_hit:get():to_hex(), gear_opt. logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor(globals.curtime), 255, clr = gear_opt.logs_hit:get()})
    menu_aa.YawBase_InAir._:set('At Target')
end)

gear_opt.default:set_callback(function()

    local status, config = pcall(function() return json.parse(base64.decode(network.get('https://pastes.io/raw/7fr1wkdx5e'))) end)

    if not status or status == nil then    
        color_p("Cyrax: Failed to load config\n", color(1, 0, 0, 1))
    return end
   
    for key, el in pairs(config) do
        if el.element == "Button" then goto continue end
        handleLoadConfig[el.element](el)
        ::continue::
    end
    print_dev("Cyrax - Default config loaded")
    menu_aa.YawBase_InAir._:set('At Target')
    table.insert(tbl, #tbl+1, {text = string.format("\a%s[Cyrax] \a%sDefault Config \a%sLoaded", gear_opt.logs_hit:get():to_hex(), gear_opt .logs_miss_what:get():to_hex(), gear_opt.logs_hit:get():to_hex(), gear_opt.logs_miss_what:get():to_hex()), realtime = globals.realtime, math.floor(globals.curtime) , 255, clr = gear_opt.logs_hit:get()})
end)

function callbacks.render()
    func:customscope()
    func:jumpscout_fix_f()
    func:cyrax_ind()
    func:cyrax_ind_2()
    func:cyrax_ind_3()
    func:cyrax_ind_4()
    if globals.realtime > 60 then func:loading() end
    func:funnydog()
    func:solus_keybinds()
    func:drawscreenLogs()
    func:solus_watermark()
    func:watermark()
    local anim = math.abs(1 * math.cos(2 * math.pi * globals.curtime / 14)) * 11
    ui.sidebar("\aFFD5BBFF" .. str:sub(1, anim), 'moon')
end
function callbacks.pre_render()
    cyraxUI.visibility()
end
function callbacks.createmove()
end

function callbacks.player_death(event)
    func:killsay(event)
end

function callbacks.createmove_run(cmd)
    anim_state_hook()
    func:anti_aim_bossule(cmd)
end

function callbacks.aim_fire(e)
end

function callbacks.aim_ack(e)
    func:centerLogs(e)
    func:screenLogs(e)
end

events.render:set(callbacks.render)
events.pre_render:set(callbacks.pre_render)
events.aim_ack:set(callbacks.aim_ack)
events.aim_fire:set(callbacks.aim_fire)
events.player_death:set(callbacks.player_death)
events.createmove:set(callbacks.createmove)
events.createmove_run:set(callbacks.createmove_run)
events.shutdown:set(function()
    for _, reset_function in ipairs(vmt_hook.hooks) do
        reset_function()
    end
end)

IS THIS SHIT BOTS THINK THEY CAN PLAY VS US? **COMEZO , SANCHEZJ, JOPPO, ONEJ** UR TIME IS UP. TIME TO MAKE HISTORY WITH EPHEMERAL.LUA

 

[znez]

IS THIS SHIT BOTS THINK THEY CAN PLAY VS US? **COMEZO , SANCHEZJ, JOPPO, ONEJ** UR TIME IS UP. TIME TO MAKE HISTORY WITH EPHEMERAL.LUA

TOTAL DESTROCUTION

 

[krytoiz]

зачем

 

[maxizxyz]

зачем

Страна свободная, делают че хотят, хули доебался?
(Шутка, я сам не понимаю зачем)

 

[fire_]

зачем

Что зачем, чтобы был

 

[krytoiz]

Что зачем, чтобы был

спасибо

 

[bananerlolker]

IS THIS SHIT BOTS THINK THEY CAN PLAY VS US? **COMEZO , SANCHEZJ, JOPPO, ONEJ** UR TIME IS UP. TIME TO MAKE HISTORY WITH EPHEMERAL.LUA

TOTAL DESTROCUTION

 

[krytoiz]

please delete this xyuna

 

[bananerlolker]

please delete this xyuna

is not xyuna, is visokotechnologichnaya pasta🥱