Axidtech.lua

-- Downloaded from https://github.com/s0daa/CSGO-HVH-LUAS

--- const
local OBEX = obex_fetch and obex_fetch() or {
    discord = "unknown",
    username = "admin",
    build = "beta"
}

if not LPH_OBFUSCATED then
    LPH_NO_VIRTUALIZE = function(...) return ... end
end

local USERNAME = OBEX.username
local BUILD = OBEX.build == 'User' and 'beta' or 'stable'

--- declarations
local merge = table.concat
local f = string.format

--- modules
local ffi = require "ffi"
local vector = require "vector"
local http = require "gamesense/http"
local inspect = require 'gamesense/inspect'
local base64 = require "gamesense/base64"
local websockets = require 'gamesense/websockets'
local c_entity = require "gamesense/entity"
local csgo_weapons = require "gamesense/csgo_weapons"

local clipboard do
    clipboard = { }

    local GetClipboardTextCount = vtable_bind('vgui2.dll', 'VGUI_System010', 7, 'int(__thiscall*)(void*)')
    local SetClipboardText = vtable_bind('vgui2.dll', 'VGUI_System010', 9, 'void(__thiscall*)(void*, const char*, int)')
    local GetClipboardText = vtable_bind('vgui2.dll', 'VGUI_System010', 11, 'int(__thiscall*)(void*, int, const char*, int)')

    local function set(...)
        local text = tostring(table.concat({ ... }))

        SetClipboardText(text, string.len(text))
    end

    local function get()
        local len = GetClipboardTextCount()

        if len > 0 then
            local char_arr = ffi.typeof('char[?]')(len)
            GetClipboardText(0, char_arr, len)
            local text = ffi.string(char_arr, len - 1)

            local text_end do
                text_end = text:find('_acid')

                if text_end then
                    text = text:sub(1, text_end)
                end
            end

            return text
        end
    end

    clipboard.set = set
    clipboard.get = get
end


local oprint = print
local function print(...)
    local res = ""

    for _, str in ipairs({...}) do
        res = res .. tostring(str) .. "\t"
    end

    oprint(res)
end

local function print_raw(r, g, b, ...)
    client.color_log(r, g, b, 'AcidTech\0')
    client.color_log(150, 150, 150, ' · \0')
    client.color_log(255, 255, 255, f(...))
end

--- defines
local function contains(list, value)
    for i = 1, #list do
        if list[i] == value then
            return true
        end
    end

    return false
end

--- enumerations
local e_statement = {
    [0]  = "Main",
    [1]  = "Standing",
    [2]  = "Moving",
    [3]  = "Slow Walk",
    [4]  = "Crouched",
    [5]  = "Move Crouched",
    [6]  = "Air",
    [7]  = "Air Crouched",
    [8]  = "Fake Lag"
}

local e_hotkey_mode = {
    [0] = "Always on",
    [1] = "On hotkey",
    [2] = "Toggle",
    [3] = "Off hotkey"
}

local e_hitgroup = {
    [0]  = "generic",
    [1]  = "head",
    [2]  = "chest",
    [3]  = "stomach",
    [4]  = "left arm",
    [5]  = "right arm",
    [6]  = "left leg",
    [7]  = "right leg",
    [8]  = "neck",
    [10] = "gear"
}

--- regions
local utils = { }
local software = { }
local override = { }

local iengineclient = { }
local inetchannel = { }

local ceasar = { }

local menu = { }
local gui = { }

local motion = { }
local windows = { }

local graphics = { }
local decorations = { }

local exploit = { }
local localplayer = { }
local statement = { }

local antiaim = { }
local widgets = { }
local settings = { }

local angles = { }
local defensive = { }
local fast_ladder = { }
local anim_breakers = { }

local disablers = { }
local avoid_backstab = { }
local air_exploit = { }
local safe_head = { }
local fs_disablers = { }
local delay_data_all = { }

local yaw_direction = { }
local manual_direction = { }
local hitchance = { }
local log_aimbot_shots = { }

local aa_tweaks = { }
local eventlogs = { }
local watermark = { }
local keybinds = { }
local indicators = { }
local arrows = { }
local velocity_warning = { }
local con_filter_text = { }
local ctx_bebra = { }
local custom_scope = { }

local clientside_nickname = { }
local trashtalk = { }
local tab_to_game = { }
local buy_bot = { }
local auto_peek = { }
local hit_marker = { }
local unmute = { }
local shared = { }

--- region utils
do
    local escape = {
        ["="] = true,
        ["0"] = true,
        ["1"] = true,
        ["2"] = true,
        ["3"] = true,
        ["4"] = true,
        ["5"] = true,
        ["6"] = true,
        ["7"] = true,
        ["8"] = true,
        ["9"] = true
    }

    local colors = {
        ['black'] = { 0, 0, 0, 0 },
        ['nick'] = { 255, 62, 62, 255 },
        ['default'] = { 198, 203, 209, 255 },
        ['highlight'] = { 151, 177, 187, 255 },
        ['miss'] = { 154, 255, 154, 255 },
        ['idle'] = { 137, 137, 137, 255 }
    }

    utils.unmute = vtable_bind('client.dll', 'GameClientExports001', 3, 'void(__thiscall*)(void*, int)')

    function utils.keys(list)
        local keys = { }

        for k, v in pairs(list) do
            keys[v] = k
        end

        return keys
    end

    function utils.collect_keys(tbl, init)
        local keys = init or { }
        for item, value in next, tbl do
            keys[#keys+1] = item
        end

        return keys
    end

    function utils.clamp(x, min, max)
        return math.max(min, math.min(x, max))
    end

    function utils.round(x)
        if x < 0 then
            return math.ceil(x - 0.5)
        end

        return math.floor(x + 0.5)
    end

    function utils.lerp(a, b, t)
        return a + t * (b - a)
    end

    function utils.inverse_lerp(a, b, v)
        return (v - a) / (b - a)
    end

    function utils.to_hex(r, g, b, a)
        return f("%02x%02x%02x%02x", r, g, b, a)
    end

    function utils.format(str, r, g, b, a)
        if type(str) ~= 'string' then
            return str
        end

        str = string.gsub(str, '[\v\r]', {
            ['\v'] = '\a' .. utils.to_hex(r, g, b, a),
            ['\r'] = '\aFFFFFFFF'
        })

        str = string.gsub(str, "\a%[(.-)%]", function (col)
            local r, g, b, a = unpack(colors[col])
            return '\a' .. utils.to_hex(r, g, b, a)
        end)

        return str
    end

    function utils.map(v, in_a, in_b, out_a, out_b, clamped)
        if clamped then
            v = utils.clamp(v, in_a, in_b)
        end

        return utils.lerp(out_a, out_b, utils.inverse_lerp(in_a, in_b, v))
    end

    function utils.normalize(x, min, max)
        local delta = max - min

        while x < min do
            x = x + delta
        end

        while x > max do
            x = x - delta
        end

        return x
    end

    function utils.normalize_yaw(x)
        return utils.normalize(x, -180, 180)
    end

    function utils.breathe(x)
        x = x % 2.0

        if x > 1.0 then
            x = 2.0 - x
        end

        return x
    end

    function utils.color_lerp(r1, g1, b1, a1, r2, g2, b2, a2, t)
        local r = utils.lerp(r1, r2, t)
        local g = utils.lerp(g1, g2, t)
        local b = utils.lerp(b1, b2, t)
        local a = utils.lerp(a1, a2, t)

        return r, g, b, a
    end

    function utils.win11_fix(input)
        local result = ""

        for i = 1, #input do
            local char = input:sub(i, i)
            local byte = string.byte(char)

            if escape[char] or (byte >= 65 and byte <= 122) then
                result = result .. char
            end
        end

        return result
    end

    function utils.get_eye_position(ent)
        local x1, y1, z1 = entity.get_origin(ent)
        if x1 == nil then return end

        local x2, y2, z2 = entity.get_prop(ent, "m_vecViewOffset")
        if x2 == nil then return end

        return x1 + x2, y1 + y2, z1 + z2
    end
end

local memory do
    memory = { }

    function memory.pattern_scan(module, signature, add)
        local buff = ffi.new("char[1024]")

        local c = 0

        for char in string.gmatch(signature, "..%s?") do
            if char == "? " or char == "?? " then
                buff[c] = 0xcc
            else
                buff[c] = tonumber("0x" .. char)
            end

            c = c + 1
        end

        local result = ffi.cast("uintptr_t", client.find_signature(module, ffi.string(buff)))

        if add and tonumber(result) ~= 0 then
            result = ffi.cast("uintptr_t", tonumber(result) + add)
        end

        return result
    end

    function memory.rel_jmp(addr, pattern)
        if pattern then
            addr = memory.pattern_scan(addr, pattern)
        end

        addr = ffi.cast("uint8_t*", addr)

        local jmp_addr = ffi.cast("uintptr_t", addr)
        local jmp_disp = ffi.cast("int32_t*", jmp_addr + 0x1)[0]

        return ffi.cast("uintptr_t", jmp_addr + 0x5 + jmp_disp)
    end

    function memory.addr_to_num(in_addr)
        return tonumber(ffi.cast("int", in_addr))
    end

    local jmp_ecx = client.find_signature("engine.dll", "\xFF\xE1")
    local fnGetModuleHandle = ffi.cast("uint32_t(__fastcall*)(unsigned int, unsigned int, const char*)", jmp_ecx)
    local fnGetProcAddress = ffi.cast("uint32_t(__fastcall*)(unsigned int, unsigned int, uint32_t, const char*)", jmp_ecx)

    local pGetProcAddress = ffi.cast("uint32_t**", ffi.cast("uint32_t", client.find_signature("engine.dll", "\xFF\x15\xCC\xCC\xCC\xCC\xA3\xCC\xCC\xCC\xCC\xEB\x05")) + 2)[0][0]
    local pGetModuleHandle = ffi.cast("uint32_t**", ffi.cast("uint32_t", client.find_signature("engine.dll", "\xFF\x15\xCC\xCC\xCC\xCC\x85\xC0\x74\x0B")) + 2)[0][0]

    function memory.get_export(module, func, typedef)
        local ctype = ffi.typeof(typedef)

        local fn = fnGetProcAddress(pGetProcAddress, 0, fnGetModuleHandle(pGetModuleHandle, 0, module), func)

        return function (...)
            return ffi.cast(ctype, jmp_ecx)(fn, 0, ...)
        end
    end
end

--- region software

LPH_NO_VIRTUALIZE(function ()
    do
        software.rage = {
            weapon = {
                weapon_type = ui.reference("Rage", "Weapon type", "Weapon type")
            },

            aimbot = {
                enabled = { ui.reference("Rage", "Aimbot", "Enabled") },
                target_selection = ui.reference("Rage", "Aimbot", "Target selection"),
                minimum_damage = ui.reference("Rage", "Aimbot", "Minimum damage"),
                hitchance = ui.reference('Rage', 'Aimbot', 'Minimum hit chance'),
                auto_scope = ui.reference('Rage', 'Aimbot', 'Automatic Scope'),
                minimum_damage_override = { ui.reference("Rage", "Aimbot", "Minimum damage override") },
                prefer_safe_point = ui.reference("Rage", "Aimbot", "Prefer safe point"),
                force_safe_point = ui.reference("Rage", "Aimbot", "Force safe point"),
                force_body_aim = ui.reference("Rage", "Aimbot", "Force body aim"),
                double_tap = { ui.reference("Rage", "Aimbot", "Double tap") }
            },

            other = {
                quick_peek_assist = { ui.reference("Rage", "Other", "Quick peek assist") },
                duck_peek_assist = ui.reference("Rage", "Other", "Duck peek assist")
            }
        }

        software.aa = {
            angles = {
                enabled = ui.reference("AA", "Anti-aimbot angles", "Enabled"),
                pitch = { ui.reference("AA", "Anti-aimbot angles", "Pitch") },
                yaw_base = ui.reference("AA", "Anti-aimbot angles", "Yaw base"),
                yaw = { ui.reference("AA", "Anti-aimbot angles", "Yaw") },
                yaw_jitter = { ui.reference("AA", "Anti-aimbot angles", "Yaw jitter") },
                body_yaw = { ui.reference("AA", "Anti-aimbot angles", "Body yaw") },
                freestanding_body_yaw = ui.reference("AA", "Anti-aimbot angles", "Freestanding body yaw"),
                edge_yaw = ui.reference("AA", "Anti-aimbot angles", "Edge yaw"),
                freestanding = { ui.reference("AA", "Anti-aimbot angles", "Freestanding") },
                roll = ui.reference("AA", "Anti-aimbot angles", "Roll")
            },

            fakelag = {
                enabled = { ui.reference("AA", "Fake lag", "Enabled") },
                amount = ui.reference("AA", "Fake lag", "Amount"),
                variance = ui.reference("AA", "Fake lag", "Variance"),
                limit = ui.reference("AA", "Fake lag", "Limit")
            },

            other = {
                slow_motion = { ui.reference("AA", "Other", "Slow motion") },
                leg_movement = ui.reference("AA", "Other", "Leg movement"),
                on_shot_antiaim = { ui.reference("AA", "Other", "On shot anti-aim") },
                fake_peek = { ui.reference("AA", "Other", "Fake peek") }
            }
        }

        software.visuals = {
            scope_overlay = ui.reference('VISUALS', 'Effects', 'Remove scope overlay')
        }

        software.misc = {
            miscellaneous = {
                clan_tag_spammer = { ui.reference("Misc", "Miscellaneous", "Clan tag spammer") },
                ping_spike = { ui.reference("Misc", "Miscellaneous", "Ping spike") }
            },

            settings = {
                menu_color = ui.reference("Misc", "Settings", "Menu color"),
                output = ui.reference("Misc", "Miscellaneous", "Draw console output"),
                dpi_scale = ui.reference("Misc", "Settings", "DPI scale"),
                sv_maxusrcmdprocessticks = ui.reference("Misc", "Settings", "sv_maxusrcmdprocessticks2")
            }
        }

        function software.is_double_tap()
            return ui.get(software.rage.aimbot.double_tap[1])
                and ui.get(software.rage.aimbot.double_tap[2])
        end

        function software.is_minimum_damage_override()
            return ui.get(software.rage.aimbot.minimum_damage_override[1])
                and ui.get(software.rage.aimbot.minimum_damage_override[2])
        end

        function software.is_force_body_aim()
            return ui.get(software.rage.aimbot.force_body_aim)
        end

        function software.is_force_safe_point()
            return ui.get(software.rage.aimbot.force_safe_point)
        end

        function software.is_quick_peek_assist()
            return ui.get(software.rage.other.quick_peek_assist[1])
                and ui.get(software.rage.other.quick_peek_assist[2])
        end

        function software.is_freestanding()
            return ui.get(software.aa.angles.freestanding[1])
                and ui.get(software.aa.angles.freestanding[2])
        end

        function software.is_duck_peek_assist()
            return ui.get(software.rage.other.duck_peek_assist)
        end

        function software.is_on_shot_antiaim()
            return ui.get(software.aa.other.on_shot_antiaim[1])
                and ui.get(software.aa.other.on_shot_antiaim[2])
        end

        function software.is_slow_motion()
            return ui.get(software.aa.other.slow_motion[1])
                and ui.get(software.aa.other.slow_motion[2])
        end

        function software.is_edge()
            return ui.get(software.aa.angles.edge_yaw)
        end

        function software.get_color()
            return ui.get(software.misc.settings.menu_color)
        end

        function software.get_dpi_scale()
            local value = ui.get(software.misc.settings.dpi_scale)
            local unit = string.match(value, "(%d+)%%")

            return unit * 0.01
        end

        function software.get_minimum_damage()
            if software.is_minimum_damage_override() then
                return ui.get(software.rage.aimbot.minimum_damage_override[3]), true
            end

            return ui.get(software.rage.aimbot.minimum_damage), false
        end
    end
end)()

--- region override
do
    local data = { }

    local function get_value(ref)
        local value = { ui.get(ref) }
        local typeof = ui.type(ref)

        if typeof == "hotkey" then
            return { e_hotkey_mode[value[2]] }
        end

        return value
    end

    function override.get(ref, ...)
        local value = data[ref]

        if value == nil then
            return
        end

        return unpack(value)
    end

    function override.set(ref, ...)
        if data[ref] == nil then
            data[ref] = get_value(ref)
        end

        ui.set(ref, ...)
    end

    function override.unset(ref)
        if data[ref] == nil then
            return
        end

        ui.set(ref, unpack(data[ref]))
        data[ref] = nil
    end
end

--- region iengineclient
do
    local native_GetNetChannelInfo = vtable_bind("engine.dll", "VEngineClient014", 78, "void*(__thiscall*)(void*)")

    function iengineclient.get_net_channel_info()
        return native_GetNetChannelInfo()
    end
end

--- region inetchannel
do
    local native_IsLoopback = vtable_thunk(6, "bool(__thiscall*)(void*)")
    local native_IsTimingOut = vtable_thunk(7, "bool(__thiscall*)(void*)")

    local native_GetLatency = vtable_thunk(9, "float(__thiscall*)(void*, int flow)")
    local native_GetAvgLatency = vtable_thunk(10, "float(__thiscall*)(void*, int flow)")

    local native_GetRemoteFramerate = vtable_thunk(25, "void(__thiscall*)(void*, float *pflFrameTime, float *pflFrameTimeStdDeviation, float *pflFrameStartTimeStdDeviation)")

    local pflFrameTime = ffi.new "float[1]"
    local pflFrameTimeStdDeviation = ffi.new "float[1]"
    local pflFrameStartTimeStdDeviation = ffi.new "float[1]"

    local function get_remote_framerate(inetchannelinfo)
        if inetchannelinfo == nil then
            return 0, 0
        end

        local server_var = 0
        local server_framerate = 0

        native_GetRemoteFramerate(inetchannelinfo, pflFrameTime, pflFrameTimeStdDeviation, pflFrameStartTimeStdDeviation)

        if pflFrameTime[0] > 0 then
            server_framerate = pflFrameTime[0] * 1000
            server_var = pflFrameStartTimeStdDeviation[0] * 1000
        end

        return server_framerate, server_var
    end

    function inetchannel.is_loopback(inetchannelinfo)
        return native_IsLoopback(inetchannelinfo)
    end

    function inetchannel.is_timing_out(inetchannelinfo)
        return native_IsTimingOut(inetchannelinfo)
    end

    function inetchannel.get_latency(inetchannelinfo, flow)
        return native_GetLatency(inetchannelinfo, flow)
    end

    function inetchannel.get_avg_latency(inetchannelinfo, flow)
        return native_GetAvgLatency(inetchannelinfo, flow)
    end

    function inetchannel.get_remote_framerate(inetchannelinfo)
        return get_remote_framerate(inetchannelinfo)
    end
end

--- region ceaser
do
    local function ascii_base(s)
        if string.lower(s) == s then
            return string.byte("a")
        end

        return string.byte("A")
    end

    function ceasar.cipher(s, key)
        local result = string.gsub(s, "%a", function(char)
            local base = ascii_base(s)
            local byte = string.byte(char)

            return string.char(base + (byte - base + key) % 26)
        end)

        return result
    end

    function ceasar.decipher(s, key)
        return ceasar.cipher(s, -key)
    end
end

--- region menu

LPH_NO_VIRTUALIZE(function ()
    do
        local items = { }
        local records = { }

        local callbacks = { }

        local function get_value(ref)
            local value = { pcall(ui.get, ref) }
            if not value[1] then return end

            return unpack(value, 2)
        end

        local function get_keys(value)
            if type(value[1]) == "table" then
                return utils.keys(value[1])
            end

            return { }
        end

        local function update_items()
            for i = 1, #callbacks do
                callbacks[i]()
            end

            for i = 1, #items do
                local item = items[i]

                ui.set_visible(item.ref, item.is_visible)
                item.is_visible = false
            end
        end

        local c_item = { } do
            function c_item:new()
                return setmetatable({ }, self)
            end

            function c_item:init()
                local function callback(ref)
                    self:update_value(ref)
                    self:invoke_callback(ref)

                    update_items()
                end

                ui.set_callback(self.ref, callback)
            end

            function c_item:get()
                return unpack(self.value)
            end

            function c_item:set(...)
                local ref = self.ref

                ui.set(ref, ...)
                self:update_value(ref)
            end

            function c_item:have_key(key)
                return self.keys[key] ~= nil
            end

            function c_item:rawget()
                return ui.get(self.ref)
            end

            function c_item:reset()
                pcall(ui.set, self.ref, unpack(self.default))
            end

            function c_item:record(tab, name)
                if records[tab] == nil then
                    records[tab] = { }
                end

                self.is_recorded = true
                records[tab][name] = self

                return self
            end

            function c_item:save()
                if not self.is_recorded then
                    error("unable to save unrecorded item")
                    return
                end

                self.is_saved = true
                return self
            end

            function c_item:display()
                self.is_visible = true
            end

            function c_item:config_ignore()
                self.saveable = false
                return self
            end

            function c_item:set_callback(callback)
                self.callbacks[#self.callbacks + 1] = callback
            end

            function c_item:update_value(ref)
                local value = { get_value(ref) }
                self.keys = get_keys(value)

                self.value = value
            end

            function c_item:invoke_callback(...)
                for i = 1, #self.callbacks do
                    self.callbacks[i](...)
                end
            end

            function c_item:get_ref()
                return self.ref
            end

            c_item.__index = c_item
        end

        function menu.new_item(fn, ...)
            local ref = fn(...)

            local value = { get_value(ref) }
            local typeof = ui.type(ref)

            local item = c_item:new()

            item.ref = ref
            item.name = select(3, ...)

            item.value = value
            item.default = value

            item.keys = get_keys(value)
            item.callbacks = { }

            item.is_saved = false
            item.is_visible = false
            item.is_recorded = false

            item.saveable = true

            if typeof == "button" then
                item.callbacks[#item.callbacks + 1] = select(4, ...)
            end

            item:init()
            items[#items + 1] = item

            return item
        end

        function menu.get_items()
            return items
        end

        function menu.get_records()
            return records
        end

        function menu.set_callback(callback)
            callbacks[#callbacks + 1] = callback
        end

        function menu.update()
            update_items()
        end

        function menu.get_items()
            return items
        end
    end
end)()

local qhouss_config_system do
    qhouss_config_system = { }

    local function resolve_item_export(item)
        if not item.saveable then
            return
        end

        if ui.type(item.ref) == "label" or ui.type(item.ref) == "hotkey" then
            return
        end

        return item.value
    end

    local function resolve_item_import(item, data)
        if ui.type(item.ref) == "label" or ui.type(item.ref) == "hotkey" then
            return true
        end

        if not item.saveable then
            return true
        end

        if data == nil then
            return false
        end

        item:set(unpack(data))

        return true
    end

    function qhouss_config_system.export_to_str()
        local config_result = { }

        for _, item in ipairs(menu.get_items()) do
            config_result[item.name] = resolve_item_export(item)
        end

        cvar.play:invoke_callback("buttons\\blip1")

        return base64.encode(json.stringify(config_result)) .. '_acid'
    end

    function qhouss_config_system.import_from_str(str)
        str = str:gsub('_acid', '')
        local status, config = pcall(base64.decode, str)
        if not status then
            print_raw(255, 100, 100, "Failed to decode config")
            return
        end

        status, config = pcall(json.parse, config)
        if not status then
            print_raw(255, 100, 100, "Failed to parse config")
            return
        end

        for _, item in ipairs(menu.get_items()) do
            local imported = resolve_item_import(item, config[item.name])

            if not imported then
                --print_raw(255, 100, 100, merge { "Failed to import ", item.name:gsub("\n", "") })
            end
        end

        cvar.play:invoke_callback("buttons\\blip2")
    end
end

--- region gui
do
    local function set_native_ui(visible)
        local pitch_val = ui.get(software.aa.angles.pitch[1])
        local yaw_val = ui.get(software.aa.angles.yaw[1])
        local yaw_jitter_val = ui.get(software.aa.angles.yaw_jitter[1])
        local body_yaw_val = ui.get(software.aa.angles.body_yaw[1])

        ui.set_visible(software.aa.angles.enabled, visible)
        ui.set_visible(software.aa.angles.pitch[1], visible)
        ui.set_visible(software.aa.angles.yaw_base, visible)
        ui.set_visible(software.aa.angles.yaw[1], visible)
        ui.set_visible(software.aa.angles.body_yaw[1], visible)
        ui.set_visible(software.aa.angles.edge_yaw, visible)
        ui.set_visible(software.aa.angles.freestanding[1], visible)
        ui.set_visible(software.aa.angles.freestanding[2], visible)
        ui.set_visible(software.aa.angles.roll, visible)

        if pitch_val == "Custom" then
            ui.set_visible(software.aa.angles.pitch[2], visible)
        end

        if yaw_val ~= "Off" then
            ui.set_visible(software.aa.angles.yaw[2], visible)
            ui.set_visible(software.aa.angles.yaw_jitter[1], visible)

            if yaw_jitter_val ~= "Off" then
                ui.set_visible(software.aa.angles.yaw_jitter[2], visible)
            end
        end

        if body_yaw_val ~= "Off" then
            if body_yaw_val ~= "Opposite" then
                ui.set_visible(software.aa.angles.body_yaw[2], visible)
            end

            ui.set_visible(software.aa.angles.freestanding_body_yaw, visible)
        end
    end

    do
        gui.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", string.format('\a%sAcidTech', utils.to_hex(182, 182, 101, 255)))
        : record("gui", "enabled")

        gui.enabled:set(true)
    end

    shared.online_label = menu.new_item(ui.new_label, 'AA', 'Anti-aimbot angles', 'Connecting...')

    gui.selection = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "\n", "gui.selection" }, { "Home", "Settings", "Anti-aim" })
    : record("gui", "selection")

    function gui.shutdown()
        set_native_ui(true)
    end

    function gui.frame()
        set_native_ui(not gui.enabled:get())
    end
end

--- region motion
do
    local function linear(t, b, c, d)
        return c * t / d + b
    end

    local function get_deltatime()
        return globals.frametime()
    end

    local function solve(easing_fn, prev, new, clock, duration)
        if clock <= 0 then return new end
        if clock >= duration then return new end

        prev = easing_fn(clock, prev, new - prev, duration)

        if type(prev) == "number" then
            if math.abs(new - prev) < 0.001 then
                return new
            end

            local remainder = math.fmod(prev, 1.0)

            if remainder < 0.001 then
                return math.floor(prev)
            end

            if remainder > 0.999 then
                return math.ceil(prev)
            end
        end

        return prev
    end

    function motion.interp(a, b, t, easing_fn)
        easing_fn = easing_fn or linear

        if type(b) == "boolean" then
            b = b and 1 or 0
        end

        return solve(easing_fn, a, b, get_deltatime(), t)
    end
end

LPH_NO_VIRTUALIZE(function ()
    --- region windows
    do
        local data = { }
        local queue = { }

        local mouse_pos = vector()
        local mouse_pos_prev = vector()

        local mouse_down = false
        local mouse_clicked = false

        local mouse_down_duration = 0
        local dragging_smth = false

        local mouse_delta = vector()
        local mouse_clicked_pos = vector()

        local hovered_window
        local foreground_window

        local c_window = { } do
            function c_window:new(name)
                local window = { }

                window.name = name

                window.pos = vector()
                window.size = vector()

                window.anchor = vector(0.0, 0.0)

                window.updated = false
                window.dragging = false

                data[name] = window
                queue[#queue + 1] = window

                setmetatable(window, self)
                return window
            end

            function c_window:set_pos(pos)
                local screen = vector(client.screen_size())
                local new_pos = pos:clone()

                new_pos.x = utils.clamp(new_pos.x, 0, screen.x - self.size.x)
                new_pos.y = utils.clamp(new_pos.y, 0, screen.y - self.size.y)

                self.pos = new_pos
            end

            function c_window:set_size(size)
                local size_delta = size - self.size

                self.size = size
                self:set_pos(self.pos - size_delta * self.anchor)
            end

            function c_window:set_anchor(anchor)
                self.anchor = anchor
            end

            function c_window:is_hovering()
                return self.hovering
            end

            function c_window:is_dragging()
                return self.dragging
            end

            function c_window:update()
                self.updated = true
            end

            c_window.__index = c_window
        end

        local function is_collided(point, a, b)
            return point.x >= a.x and point.y >= a.y
                and point.x <= b.x and point.y <= b.y
        end

        local function update_mouse_inputs()
            local cursor = vector(ui.mouse_position())
            local is_down = client.key_state(0x01)

            local delta_time = globals.frametime()

            mouse_pos = cursor
            mouse_delta = mouse_pos - mouse_pos_prev

            mouse_pos_prev = mouse_pos

            mouse_down = is_down
            mouse_clicked = is_down and mouse_down_duration < 0

            mouse_down_duration = is_down and (mouse_down_duration < 0 and 0 or mouse_down_duration + delta_time) or -1

            if mouse_clicked then
                mouse_clicked_pos = mouse_pos
            end
        end

        local function appear_all_windows()
            for i = 1, #queue do
                local window = queue[i]

                local pos = window.pos
                local size = window.size

                local r, g, b, a = 0, 0, 0, 255

                renderer.rectangle(pos.x, pos.y, size.x, size.y, r, g, b, a)
            end
        end

        local function find_hovered_window()
            local found_window = nil

            if ui.is_menu_open() then
                for i = 1, #queue do
                    local window = queue[i]

                    local pos = window.pos
                    local size = window.size

                    if not window.updated then
                        goto continue
                    end

                    if not is_collided(mouse_pos, pos, pos + size) then
                        goto continue
                    end

                    found_window = window
                    ::continue::
                end
            end

            hovered_window = found_window
        end

        local function find_foreground_window()
            if mouse_down then
                if mouse_clicked and hovered_window ~= nil then
                    for i = 1, #queue do
                        local window = queue[i]

                        if window == hovered_window then
                            table.remove(queue, i)
                            table.insert(queue, window)

                            break
                        end
                    end

                    foreground_window = hovered_window
                    return
                end

                return
            end

            foreground_window = nil
        end

        local function update_all_windows()
            for i = 1, #queue do
                local window = queue[i]

                window.updated = false

                window.hovering = false
                window.dragging = false
            end
        end

        local function update_hovered_window()
            if hovered_window == nil then
                return
            end

            hovered_window.hovering = true
        end

        local function update_foreground_window()
            dragging_smth = false
            if foreground_window == nil then
                return
            end

            local new_position = foreground_window.pos + mouse_delta

            foreground_window:set_pos(new_position)
            foreground_window.dragging = true
            dragging_smth = true
        end

        function windows.new(name, x, y)
            local window = data[name]
                or c_window:new(name)

            local screen = vector(client.screen_size())
            window:set_pos(screen * vector(x, y))

            return window
        end

        function windows.frame()
            -- appear_all_windows()
            update_mouse_inputs()

            find_hovered_window()
            find_foreground_window()

            update_all_windows()

            update_hovered_window()
            update_foreground_window()
        end

        client.set_event_callback('setup_command', function (cmd)
            if dragging_smth or hovered_window then
                cmd.in_attack = false
                cmd.in_attack2 = false
            end
        end)
    end
end)()

--- region graphics
do
    local alpha_unit = 1 / 255

    local function string_alpha_mod(s, alpha)
        local result = s:gsub("\a(%x%x%x%x%x%x)(%x%x)", function(rgb, a)
            return f("\a%s%02x", rgb, tonumber(a, 16) * alpha)
        end)

        return result
    end

    --shared.online_label = menu.new_item(ui.new_label, 'AA', 'Anti-aimbot angles', 'Connecting...')

    graphics.config_export = menu.new_item(ui.new_button, "AA", "Anti-aimbot angles", "Export Configuration", function ()
        clipboard.set(qhouss_config_system.export_to_str())
    end):config_ignore()

    graphics.config_import = menu.new_item(ui.new_button, "AA", "Anti-aimbot angles", "Import Configuration", function ()
        qhouss_config_system.import_from_str(clipboard.get())
    end):config_ignore()

    graphics.config_default = menu.new_item(ui.new_button, "AA", "Anti-aimbot angles", "Default Configuration", function ()
        qhouss_config_system.import_from_str(
            '{"Body yaw\ncustom_body_yaw_Standing":["Off"],"Utility weapon":[{}],"\ncustom_yaw_180lr_mode_Fake Lag":["Side based"],"- Options":[["Disable on Warmup","Disable While No Enemies","Avoid Backstab","Fast Ladder","Edge Yaw on FD"]],"Yaw base\ncustom_yaw_base_Fake Lag":["Local view"],"\nPosition":[50],"- State\ndefensive::state":[["Air","Standing","Crouched"]],"\ncustom_yaw_offset_Standing":[0],"Delay\ncustom_Delay_Crouched":[5],"Right offset\ncustom_yaw_right_Standing":[0],"\ncustom_yaw_180lr_mode_Main":["Side based"],"Randomization\ncustom_jitter_randomization_Standing":[0],"Yaw\ncustom_yaw_Moving":["Off"],"\ncustom_yaw_offset_Slow Walk":[0],"\ngui.selection":["Home"],"\ncustom_body_yaw_offset_Fake Lag":[0],"Pitch\ncustom_pitch_Moving":["Off"],"Delay\ncustom_Delay_Moving":[5],"Right offset\ncustom_yaw_right_Crouched":[0],"- Items\nwidgets::items":[["Watermark","Keybinds","Velocity Warning","Crosshair Indicator","Damage Indicator","On-Screen Logs","Hit Rate"]],"Left offset\ncustom_yaw_left_Fake Lag":[0],"Randomization\ncustom_jitter_randomization_Air Crouched":[0],"Yaw\ncustom_yaw_Standing":["Off"],"\ncustom_yaw_offset_Moving":[0],"\ncustom_yaw_offset_Air":[0],"\ncustom_jitter_mode_Slow Walk":["2-Way"],"Yaw base\ncustom_yaw_base_Crouched":["Local view"],"Yaw jitter\ncustom_yaw_jitter_Standing":["Off"],"Jitter offset\ncustom_jitter_offset_Air Crouched":[0],"\ncustom_body_yaw_offset_Crouched":[0],"Widgets":[true],"\ncustom_pitch_offset_Move Crouched":[0],"Manual Color":[113,152,255,255],"- Pitch\ndefensive::pitch":["Up Switch"],"\ncustom_jitter_mode_Air":["2-Way"],"Delay\ncustom_Delay_Air Crouched":[5],"Tweaks":[true],"Body yaw\ncustom_body_yaw_Slow Walk":["Off"],"Pitch\ncustom_pitch_Standing":["Off"],"Left offset\ncustom_yaw_left_Standing":[0],"Safe Head":[true],"Body yaw\ncustom_body_yaw_Air":["Off"],"Shared Logo":[true],"Yaw\ncustom_yaw_Slow Walk":["Off"],"Freestanding body yaw\ncustom_freestanding_body_yaw_Slow Walk":[false],"Yaw jitter\ncustom_yaw_jitter_Air":["Off"],"Pitch\ncustom_pitch_Air":["Off"],"Yaw base\ncustom_yaw_base_Main":["Local view"],"Left offset\ncustom_yaw_left_Slow Walk":[0],"State":["Main"],"- Disable On\nfs_disablers::states":[{}],"Manual Yaw":[true],"Color":[255,255,255,255],"Yaw\ncustom_yaw_Move Crouched":["Off"],"Enable Slow Walk":[false],"Left offset\ncustom_yaw_left_Crouched":[0],"\ncustom_yaw_180lr_mode_Crouched":["Side based"],"Freestanding body yaw\ncustom_freestanding_body_yaw_Moving":[false],"\ncustom_pitch_offset_Fake Lag":[0],"Body yaw\ncustom_body_yaw_Main":["Off"],"Left offset\ncustom_yaw_left_Move Crouched":[0],"Right offset\ncustom_yaw_right_Move Crouched":[0],"Left offset\ncustom_yaw_left_Air Crouched":[0],"Pitch\ncustom_pitch_Move Crouched":["Off"],"Keybinds":[false],"Randomization\ncustom_jitter_randomization_Main":[0],"Delay\ncustom_Delay_Air":[5],"Mode":["Default"],"Enable Fake Lag":[false],"Body yaw\ncustom_body_yaw_Moving":["Off"],"Yaw\ncustom_yaw_Main":["Off"],"Freestanding body yaw\ncustom_freestanding_body_yaw_Air Crouched":[false],"Right offset\ncustom_yaw_right_Air Crouched":[0],"\ncustom_jitter_mode_Move Crouched":["2-Way"],"Custom Name":[false],"Freestanding body yaw\ncustom_freestanding_body_yaw_Fake Lag":[false],"\ncustom_body_yaw_offset_Moving":[0],"\ncustom_jitter_mode_Crouched":["2-Way"],"Jitter offset\ncustom_jitter_offset_Main":[0],"Body yaw\ncustom_body_yaw_Fake Lag":["Off"],"Yaw jitter\ncustom_yaw_jitter_Fake Lag":["Off"],"Randomization\ncustom_jitter_randomization_Fake Lag":[0],"Freestanding body yaw\ncustom_freestanding_body_yaw_Standing":[false],"Jitter offset\ncustom_jitter_offset_Move Crouched":[0],"Jitter offset\ncustom_jitter_offset_Fake Lag":[0],"\ncustom_jitter_mode_Fake Lag":["2-Way"],"Pitch\ncustom_pitch_Fake Lag":["Off"],"Client-Side Nickname":[false],"\ncustom_pitch_offset_Air Crouched":[0],"Right offset\ncustom_yaw_right_Fake Lag":[0],"Randomization\ncustom_jitter_randomization_Crouched":[0],"Custom Scope Overlay":[false],"\ncustom_jitter_mode_Air Crouched":["2-Way"],"Yaw\ncustom_yaw_Fake Lag":["Off"],"Secondary weapon":["None"],"Apply":{},"\ncustom_pitch_offset_Air":[0],"\ncustom_body_yaw_offset_Air Crouched":[0],"Body yaw\ncustom_body_yaw_Air Crouched":["Off"],"\ncustom_yaw_offset_Main":[0],"\ncustom_yaw_180lr_mode_Standing":["Side based"],"Yaw jitter\ncustom_yaw_jitter_Move Crouched":["Off"],"Yaw jitter\ncustom_yaw_jitter_Air Crouched":["Off"],"Body yaw\ncustom_body_yaw_Crouched":["Off"],"Freestanding body yaw\ncustom_freestanding_body_yaw_Air":[false],"\ncustom_yaw_offset_Air Crouched":[0],"Animation Breakers":[true],"- Color\nwidgets::color_picker":[113,152,255,255],"Jitter offset\ncustom_jitter_offset_Crouched":[0],"\ncustom_yaw_offset_Move Crouched":[0],"Yaw\ncustom_yaw_Air Crouched":["Off"],"Yaw base\ncustom_yaw_base_Move Crouched":["Local view"],"Yaw base\ncustom_yaw_base_Air":["Local view"],"\ncustom_jitter_mode_Standing":["2-Way"],"Randomization\ncustom_jitter_randomization_Moving":[0],"Right offset\ncustom_yaw_right_Air":[0],"Pitch\ncustom_pitch_Air Crouched":["Off"],"Jitter offset\ncustom_jitter_offset_Standing":[0],"\ncustom_yaw_180lr_mode_Move Crouched":["Side based"],"- States\nsafe_head::states":[["Air Knife","Standing","Crouched"]],"Enable Air Crouched":[false],"Defensive AA":[true],"Enable Crouched":[false],"\ncustom_yaw_180lr_mode_Air Crouched":["Side based"],"\ncustom_yaw_180lr_mode_Air":["Side based"],"Yaw\ncustom_yaw_Air":["Off"],"Randomization\ncustom_jitter_randomization_Air":[0],"Primary weapon":["None"],"Yaw base\ncustom_yaw_base_Air Crouched":["Local view"],"Yaw base\ncustom_yaw_base_Slow Walk":["Local view"],"- Yaw\ndefensive::yaw":["5-Way"],"Left offset\ncustom_yaw_left_Air":[0],"\ncustom_body_yaw_offset_Move Crouched":[0],"\ncustom_body_yaw_offset_Air":[0],"Enable Air":[false],"- Mode\ndefensive::mode":[["On Shot Anti Aim","Double Tap"]],"\ncustom_pitch_offset_Main":[0],"Freestanding body yaw\ncustom_freestanding_body_yaw_Move Crouched":[false],"\ncustom_pitch_offset_Slow Walk":[0],"Randomization\ncustom_jitter_randomization_Move Crouched":[0],"- Functions\nsettings::tweaks":[["Log Aimbot Shots","Trashtalk","Unmute Silenced Players","Console Filter","Damage Marker"]],"Delay\ncustom_Delay_Fake Lag":[5],"- Options\nmanual_direction::options":[["Disable Yaw Modifiers","Freestanding Body Yaw","Duck Exploit"]],"Delay\ncustom_Delay_Move Crouched":[5],"Delay\ncustom_Delay_Slow Walk":[5],"Yaw base\ncustom_yaw_base_Standing":["Local view"],"Buy Bot":[false],"Enable Moving":[false],"Left offset\ncustom_yaw_left_Moving":[0],"Right offset\ncustom_yaw_right_Main":[0],"\ncustom_body_yaw_offset_Slow Walk":[0],"Delay\ncustom_Delay_Standing":[5],"\nOffset":[10],"Yaw jitter\ncustom_yaw_jitter_Main":["Off"],"Delay\ncustom_Delay_Main":[5],"Yaw base\ncustom_yaw_base_Moving":["Local view"],"Enable Standing":[false],"Right offset\ncustom_yaw_right_Slow Walk":[0],"Manual Arrows":[true],"Anti Aim Builder":["Recommended"],"\ncustom_yaw_180lr_mode_Slow Walk":["Side based"],"Pitch\ncustom_pitch_Crouched":["Off"],"Right offset\ncustom_yaw_right_Moving":[0],"Yaw jitter\ncustom_yaw_jitter_Moving":["Off"],"Nickname":[""],"Yaw jitter\ncustom_yaw_jitter_Crouched":["Off"],"Jitter offset\ncustom_jitter_offset_Moving":[0],"Pitch\ncustom_pitch_Main":["Off"],"\ncustom_yaw_180lr_mode_Moving":["Side based"],"\ncustom_yaw_offset_Fake Lag":[0],"- Display\nwidgets::display":[["Username","Latency","Time","FPS","Server frametime"]],"Freestanding body yaw\ncustom_freestanding_body_yaw_Main":[false],"Randomization\ncustom_jitter_randomization_Slow Walk":[0],"\ncustom_pitch_offset_Moving":[0],"Left offset\ncustom_yaw_left_Main":[0],"- Leg Movement":["Static"],"\ncustom_body_yaw_offset_Standing":[0],"Jitter offset\ncustom_jitter_offset_Air":[0],"\ncustom_body_yaw_offset_Main":[0],"Body yaw\ncustom_body_yaw_Move Crouched":["Off"],"Features":[true],"Yaw\ncustom_yaw_Crouched":["Off"],"\ncustom_pitch_offset_Standing":[0],"\ncustom_jitter_mode_Main":["2-Way"],"\ncustom_jitter_mode_Moving":["2-Way"],"Jitter offset\ncustom_jitter_offset_Slow Walk":[0],"\u0007b6b665ffAcidTech":[true],"Yaw jitter\ncustom_yaw_jitter_Slow Walk":["Off"],"\ncustom_yaw_offset_Crouched":[0],"\ncustom_pitch_offset_Crouched":[0],"- In Air":["Static"],"Pitch\ncustom_pitch_Slow Walk":["Off"],"Freestanding body yaw\ncustom_freestanding_body_yaw_Crouched":[false],"Enable Move Crouched":[false]}_acid'
        )
    end):config_ignore()

    function graphics.text(x, y, r, g, b, a, flags, max_width, ...)
        local text = string_alpha_mod(merge {...}, a * alpha_unit)
        renderer.text(x, y, r, g, b, a, flags, max_width, text)
    end

    function graphics.rectangle(x, y, w, h, r, g, b, a, radius)
        if radius ~= nil and radius > 1 then
            local offset = radius * 2

            renderer.rectangle(x + radius, y, w - offset, h, r, g, b, a)

            renderer.rectangle(x, y + radius, radius, h - offset, r, g, b, a)
            renderer.rectangle(x + w, y + radius, -radius, h - offset, r, g, b, a)

            renderer.circle(x + radius, y + radius, r, g, b, a, radius, 180, 0.25)
            renderer.circle(x + radius, y + h - radius, r, g, b, a, radius, 270, 0.25)
            renderer.circle(x + w - radius, y + h - radius, r, g, b, a, radius, 0, 0.25)
            renderer.circle(x + w - radius, y + radius, r, g, b, a, radius, 90, 0.25)

            return
        end

        renderer.rectangle(x, y, w, h, r, g, b, a)
    end

    function graphics.rectangle_outline(x, y, w, h, r, g, b, a, radius, thickness)
        radius = radius or 0
        thickness = thickness or 1

        renderer.rectangle(x + radius, y, w - radius * 2, thickness, r, g, b, a)
        renderer.rectangle(x + radius, y + h - thickness, w - radius * 2, thickness, r, g, b, a)

        renderer.rectangle(x, y + radius, thickness, h - radius * 2, r, g, b, a)
        renderer.rectangle(x + w - thickness, y + radius, thickness, h - radius * 2, r, g, b, a)

        renderer.circle_outline(x + radius, y + radius, r, g, b, a, radius, 180, 0.25, thickness)
        renderer.circle_outline(x + radius, y + h - radius, r, g, b, a, radius, 90, 0.25, thickness)
        renderer.circle_outline(x + w - radius, y + h - radius, r, g, b, a, radius, 0, 0.25, thickness)
        renderer.circle_outline(x + w - radius, y + radius, r, g, b, a, radius, 270, 0.25, thickness)
    end

    function graphics.blur(x, y, w, h)
        -- if true then
        --     return
        -- end

        -- renderer.blur(x, y, w, h)
    end

    function graphics.header(x, y, w, thickness, rounding, r, g, b, a)
        renderer.rectangle(x + rounding, y - thickness, w - (rounding + thickness), thickness, r, g, b, a)

        if rounding ~= 0 then
            -- outer rounding
            local add_rounding = vector(rounding, rounding)
            renderer.circle_outline(x + rounding, y + rounding, r, g, b, a, rounding + thickness, -180, 0.25, thickness)
            renderer.circle_outline(x + w - rounding, y + rounding, r, g, b, a, rounding + thickness, -90, 0.25, thickness)

            -- gradient lines
            local thickness_dv = thickness / 2 - 1
            renderer.gradient(x - thickness, y + rounding, thickness, rounding + 7, r, g, b, a, r, g, b, 0, false)
            renderer.gradient(x + w, y + rounding, thickness, rounding + 7, r, g, b, a, r, g, b, 0, false)
        end
    end

    function graphics.glow(x, y, w, h, r, g, b, a, thickness, radius)
        -- if graphics.low_fps_mitigations:have_key("Glow") then
        -- if true then
        --     return
        -- end

        -- if radius == nil then
        --     return
        -- end

        -- if radius < 1 then
        --     radius = 1
        -- end

        -- thickness = thickness / 2

        -- local t = 1.0
        -- local step = 1 / (thickness - 1)

        -- local offset = radius * 2

        -- renderer.gradient(x + radius, y, w - offset, -thickness, r, g, b, a, r, g, b, 0, false)
        -- renderer.gradient(x + radius, y + h, w - offset, thickness, r, g, b, a, r, g, b, 0, false)
        -- renderer.gradient(x, y + radius, -thickness, h - offset, r, g, b, a, r, g, b, 0, true)
        -- renderer.gradient(x + w, y + radius, thickness, h - offset, r, g, b, a, r, g, b, 0, true)

        -- for i = 1, thickness do
        --     local opacity = a * t

        --     renderer.circle_outline(x + w - radius, y + h - radius, r, g, b, opacity, radius + i, 0, 0.25, 1)
        --     renderer.circle_outline(x + radius, y + h - radius, r, g, b, opacity, radius + i, 90, 0.25, 1)
        --     renderer.circle_outline(x + radius, y + radius, r, g, b, opacity, radius + i, 180, 0.25, 1)
        --     renderer.circle_outline(x + w - radius, y + radius, r, g, b, opacity, radius + i, 270, 0.25, 1)

        --     t = t - step
        -- end
    end
end

--- region decorations
do
    local function u8(s)
        return string.gsub(s, "[\128-\191]", "")
    end

    function decorations.wave(s, clock, r1, g1, b1, a1, r2, g2, b2, a2)
        local buffer = { }

        local len = #u8(s)
        local div = 1 / (len - 1)

        local add_r = r2 - r1
        local add_g = g2 - g1
        local add_b = b2 - b1
        local add_a = a2 - a1

        for char in string.gmatch(s, ".[\128-\191]*") do
            local t = utils.breathe(clock)

            local r = r1 + add_r * t
            local g = g1 + add_g * t
            local b = b1 + add_b * t
            local a = a1 + add_a * t

            buffer[#buffer + 1] = "\a"
            buffer[#buffer + 1] = utils.to_hex(r, g, b, a)
            buffer[#buffer + 1] = char

            clock = clock + div
        end

        return merge(buffer)
    end
end

--- region exploit
do
    local LAG_COMPENSATION_TELEPORTED_DISTANCE_SQR = 64 * 64

    local data = {
        old_origin = vector(),
        old_simtime = 0.0,

        shift = false,
        breaking_lc = false,

        defensive = {
            begin = 0,
            duration = 0
        },

        lagcompensation = {
            distance = 0.0,
            teleport = false
        },

        defensive_tk = 0
    }

    local function update_tickbase(me)
        local tickcount = globals.tickcount()
        local m_nTickBase = entity.get_prop(me, "m_nTickBase")

        data.shift = tickcount > m_nTickBase
    end

    local function update_defensive(tick)
        data.breaking_lc = true

        data.defensive.begin = globals.tickcount()
        data.defensive.duration = tick
    end

    local function update_teleport(old_origin, new_origin)
        local delta = new_origin - old_origin
        local distance = delta:lengthsqr()

        local is_teleport = distance > LAG_COMPENSATION_TELEPORTED_DISTANCE_SQR

        data.breaking_lc = is_teleport

        data.lagcompensation.distance = distance
        data.lagcompensation.teleport = is_teleport
    end

    local function update_lagcompensation(me)
        local old_origin = data.old_origin
        local old_simtime = data.old_simtime

        local origin = vector(entity.get_origin(me))
        local simtime = toticks(entity.get_prop(me, "m_flSimulationTime"))

        if old_simtime ~= nil then
            local delta = simtime - old_simtime

            if delta < 0 or delta > 0 and delta <= 64 then
                local tick = delta - 1

                update_teleport(old_origin, origin)

                if delta < 0 then
                    update_defensive(math.abs(tick))
                end
            end
        end

        data.old_origin = origin
        data.old_simtime = simtime
    end

    function exploit.get()
        return data
    end

    function exploit.setup_command(cmd)
        local me = entity.get_local_player()
        update_tickbase(me)
    end

    function exploit.net_update()
        local me = entity.get_local_player()

        if me == nil then
            return
        end

        update_lagcompensation(me)
    end

    local native_GetClientEntity = vtable_bind('client.dll', 'VClientEntityList003', 3, 'void*(__thiscall*)(void*, int)')

    function exploit.handle_defensive()
        local lp = entity.get_local_player()

        if lp == nil or not entity.is_alive(lp) then
            return
        end

        local Entity = native_GetClientEntity(lp)
        local m_flOldSimulationTime = ffi.cast("float*", ffi.cast("uintptr_t", Entity) + 0x26C)[0]
        local m_flSimulationTime = entity.get_prop(lp, "m_flSimulationTime")

        local delta = m_flOldSimulationTime - m_flSimulationTime

        if delta > 0 then
            data.defensive_tk = globals.tickcount() + toticks(delta - client.real_latency())
            return
        end
    end
end

--- region localplayer
do
    local MOVING_LIMIT = 1.1 * 3.3
    local DUCK_PEEK_LIMIT = 0.79

    local pre_flags = 0
    local post_flags = 0

    local function get_body_yaw(animstate)
        local body_yaw = animstate.eye_angles_y - animstate.goal_feet_yaw
        body_yaw = utils.normalize_yaw(body_yaw)

        return body_yaw
    end

    localplayer.flags = 0
    localplayer.packets = 0
    localplayer.choking = 1
    localplayer.choking_bool = false

    localplayer.body_yaw = 0
    localplayer.duck_amount = 0

    localplayer.movetype = 0
    localplayer.velocity = 0

    localplayer.is_onground = false
    localplayer.is_crouched = false

    localplayer.is_moving = false
    localplayer.is_landing = false
    localplayer.is_airborne = false

    function localplayer.pre_predict_command(e)
        local me = entity.get_local_player()
        pre_flags = entity.get_prop(me, "m_fFlags")
    end

    function localplayer.predict_command(e)
        local me = entity.get_local_player()
        post_flags = entity.get_prop(me, "m_fFlags")
    end

    function localplayer.net_update()
        local me = entity.get_local_player()
        if me == nil then return end

        local my_data = c_entity(me)
        if my_data == nil then return end

        local animstate = c_entity.get_anim_state(my_data)
        if animstate == nil then return end

        local chokedcommands = globals.chokedcommands()

        local m_fFlags = entity.get_prop(me, "m_fFlags")
        local m_movetype = entity.get_prop(me, "m_movetype")
        local m_flDuckAmount = entity.get_prop(me, "m_flDuckAmount")

        localplayer.flags = m_fFlags
        localplayer.movetype = m_movetype
        localplayer.velocity = animstate.m_velocity

        if chokedcommands == 0 then
            localplayer.packets = localplayer.packets + 1
            localplayer.choking = localplayer.choking * -1
            localplayer.choking_bool = not localplayer.choking_bool

            localplayer.body_yaw = get_body_yaw(animstate)
            localplayer.duck_amount = m_flDuckAmount
        end

        localplayer.is_onground = animstate.on_ground
        localplayer.is_crouched = localplayer.duck_amount > DUCK_PEEK_LIMIT

        localplayer.is_moving = localplayer.velocity > MOVING_LIMIT
        localplayer.is_landing = animstate.hit_in_ground_animation
        localplayer.is_airborne = bit.band(pre_flags, post_flags, 1) == 0
    end
end

--- region statement
do
    local list = { }

    local function add(state)
        list[#list + 1] = state
    end

    local function update_onground()
        if localplayer.is_moving then
            add "Moving"

            if localplayer.is_crouched then
                return
            end

            if localplayer.is_airborne then
                return
            end

            if software.is_slow_motion() then
                add "Slow Walk"
            end

            return
        end

        add "Standing"
    end

    local function update_crouched()
        if not localplayer.is_crouched then
            return
        end

        add "Crouched"

        if localplayer.is_moving then
            add "Move Crouched"
        end
    end

    local function update_airborne()
        if not localplayer.is_airborne then
            return
        end

        add "Air"

        if localplayer.is_crouched then
            add "Air Crouched"
        end
    end

    local function update_exploit()
        if exploit.get().shift or (software.is_double_tap() or software.is_on_shot_antiaim()) then
            return
        end

        add "Fake Lag"
    end

    function statement.get()
        return list
    end

    function statement.add(state)
        add(state)
    end

    function statement.setup_command()
        table.clear(list)

        update_onground()
        update_crouched()
        update_airborne()
        update_exploit()
    end
end

--- region antiaim
do
    local ctx = { }

    local acidyaw_ways = {
        ["2-Way"] = { -0.5, 0.5 },
        ["3-Way"] = { -0.5, 0, 0.5 },
        ["5-Way"] = { -0.75, 1, 0, 0.4, -0.25 }
    }

    local function calculate_jitter_way(n, offset)
        local fmod = localplayer.packets % n
        local center = n / 2

        if n % 2 ~= 0 then
            center = math.floor(center)
        elseif fmod >= center then
            fmod = fmod + 1
        end

        local delta = fmod - center
        local weight = delta / center

        if weight ~= weight or weight == 0 then
            return 0
        end

        return offset * weight
    end

    local function get_statement()
        if not exploit.get().shift and not (software.is_double_tap() or software.is_on_shot_antiaim()) then
            return 'Fake Lag'
        end

        if localplayer.is_airborne then
            return localplayer.is_crouched and "Air Crouched" or 'Air'
        end

        if localplayer.is_crouched then
            return localplayer.is_moving and "Move Crouched" or 'Crouched'
        end

        if localplayer.is_moving then
            return software.is_slow_motion() and 'Slow Walk' or "Moving"
        end

        return 'Standing'
    end

    local function modify_yaw()
        if ctx.yaw == "180 LR" then
            ctx.yaw = "180"

            if ctx.yaw_left == nil then return end
            if ctx.yaw_right == nil then return end

            if ctx.yaw_offset == nil then
                ctx.yaw_offset = 0
            end

            local inverted = localplayer.body_yaw < 0

            if ctx.yaw_180lr_mode == "Switch delay" then
                local delay = ctx.yaw_delay
                local target = delay * 2

                inverted = (localplayer.packets % target) >= delay

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = inverted and
                    1 or -1
            end

            local yaw_add = inverted and
                ctx.yaw_right or ctx.yaw_left

            ctx.yaw_offset = ctx.yaw_offset + yaw_add
            return
        end
    end

    local safe_head_presets = {
        [1] = {
            [3] = {
                -- base = "At Target" !!!
                offset = 15,

                inverter = false,

                left_limit = 24,
                right_limit = 24
            },

            [2] = {
                offset = 15,

                inverter = false,

                left_limit = 24,
                right_limit = 24
            }
        },
    }

    local randomized
    local val = 180
    local function modify_jitter()
        if ctx.jitter_randomization ~= nil then
            if localplayer.packets % 2 == 0 or randomized == nil then
                randomized = client.random_int(0, (ctx.jitter_offset > 0 and 1 or -1) * ctx.jitter_randomization)
            end

            ctx.jitter_offset = utils.normalize_yaw(ctx.jitter_offset + randomized)
        end

        if ctx.body_yaw == 'Randomize Jitter' then
            ctx.body_yaw = 'Static'

            if localplayer.choking_bool then
                local rand = client.random_int(0, 1)
                val = rand == 1 and 180 or -180
            end

            ctx.body_yaw_offset = val
        end

        if ctx.yaw_jitter == "AcidTech" then
            local yaw = ctx.yaw_offset
            local state = get_statement()
            local delay_data = delay_data_all[state]

            delay_data.ticks = delay_data.ticks + 1

            local acid_mode  = ctx.jitter_mode
            local acid_cycle = ctx.acid_cycle
            local acid_delay = ctx.acid_delay

            local ways = acidyaw_ways[acid_mode]
            local way = ways[(localplayer.packets % #ways) + 1]

            -- god ( qhose ) forgive me for the piece of code below
            --- region lulz diagnostics disable@

            local byaw = localplayer.body_yaw

            if acid_cycle ~= 4 and not delay_data.is_delay and delay_data.ticks % acid_cycle == 0 then
                delay_data.is_delay = true
            end

            local ignore_yaw = false
            if delay_data.is_delay then
                if delay_data.current < acid_delay then
                    delay_data.current = delay_data.current + 1

                    if ctx.acid_safe then
                        local lp = entity.get_local_player()
                        local current_preset = safe_head_presets[1]
                        local preset_for_team = current_preset[entity.get_prop(lp, 'm_iTeamNum')]

                        yaw = 0 --preset_for_team.offset
                        ctx.body_yaw = 'Static'
                        ctx.body_yaw_offset = 0

                        ignore_yaw = true
                    end

                   yaw = yaw
                else
                    delay_data.is_delay = false
                    delay_data.ticks = 0
                    delay_data.current = 0
                    delay_data.previous_angle = 0
                end
            else
                local angle = 0
                if acid_mode == "2-Way" and (ctx.body_yaw == "Jitter" or ctx.body_yaw == 'Randomize Jitter') then
                    angle = utils.normalize_yaw(yaw + (byaw < 0 and ctx.jitter_offset / 2 or ctx.jitter_offset * -1 / 2))
                else
                    angle = utils.normalize_yaw(yaw + ctx.jitter_offset * way)
                end


                delay_data.previous_angle = angle
            end

            if not ignore_yaw then
                yaw = delay_data.previous_angle
            end

            ctx.yaw_offset = yaw
            ctx.yaw_jitter = 'Off'
        end

    end

    local function shutdown()
        override.unset(software.aa.angles.enabled)
        override.unset(software.aa.angles.pitch[1])
        override.unset(software.aa.angles.pitch[2])

        override.unset(software.aa.angles.yaw_base)

        override.unset(software.aa.angles.yaw[1])
        override.unset(software.aa.angles.yaw[2])

        override.unset(software.aa.angles.yaw_jitter[1])
        override.unset(software.aa.angles.yaw_jitter[2])

        override.unset(software.aa.angles.body_yaw[1])
        override.unset(software.aa.angles.body_yaw[2])

        override.unset(software.aa.angles.freestanding_body_yaw)

        override.unset(software.aa.angles.edge_yaw)

        override.unset(software.aa.angles.freestanding[1])
        override.unset(software.aa.angles.freestanding[2])

        override.unset(software.aa.angles.roll)
    end

    local function setup()
        yaw_direction.is_freestanding = false
        if ctx.enabled ~= nil then
            override.set(software.aa.angles.enabled, ctx.enabled)
        else
            override.set(software.aa.angles.enabled, true)
        end

        if ctx.pitch ~= nil then
            override.set(software.aa.angles.pitch[1], ctx.pitch)
        end

        if ctx.yaw_base ~= nil then
            override.set(software.aa.angles.yaw_base, ctx.yaw_base)
        end

        if ctx.yaw ~= nil then
            override.set(software.aa.angles.yaw[1], ctx.yaw)
        end

        if ctx.body_yaw ~= nil then
            override.set(software.aa.angles.body_yaw[1], ctx.body_yaw)
        end

        if ctx.edge_yaw ~= nil then
            override.set(software.aa.angles.edge_yaw, ctx.edge_yaw)
        end

        if ctx.freestanding ~= nil then
            yaw_direction.is_freestanding = ctx.freestanding
            override.set(software.aa.angles.freestanding[1], ctx.freestanding)
            override.set(software.aa.angles.freestanding[2], ctx.freestanding and
                "Always on" or "On hotkey")
        end

        if ctx.roll ~= nil then
            override.set(software.aa.angles.roll, ctx.roll)
        end

        local pitch_value = ui.get(software.aa.angles.pitch[1])
        local yaw_value = ui.get(software.aa.angles.yaw[1])
        local body_yaw_value = ui.get(software.aa.angles.body_yaw[1])

        if pitch_value == "Custom" then
            if ctx.pitch_offset ~= nil then
                override.set(software.aa.angles.pitch[2], utils.clamp(ctx.pitch_offset, -89, 89))
            end
        end

        if yaw_value ~= "Off" then
            if ctx.yaw_offset ~= nil then
                override.set(software.aa.angles.yaw[2], utils.normalize_yaw(ctx.yaw_offset))
            end

            if ctx.yaw_jitter ~= nil then
                override.set(software.aa.angles.yaw_jitter[1], ctx.yaw_jitter)
            end

            local yaw_jitter_val = ui.get(software.aa.angles.yaw_jitter[1])

            if yaw_jitter_val ~= "Off" then
                if ctx.jitter_offset ~= nil then
                    override.set(software.aa.angles.yaw_jitter[2], utils.normalize_yaw(ctx.jitter_offset))
                end
            end
        end

        if body_yaw_value ~= "Off" then
            if body_yaw_value ~= "Opposite" then
                if ctx.body_yaw_offset ~= nil then
                    override.set(software.aa.angles.body_yaw[2], utils.normalize_yaw(ctx.body_yaw_offset))
                end
            end

            if ctx.freestanding_body_yaw ~= nil then
                override.set(software.aa.angles.freestanding_body_yaw, ctx.freestanding_body_yaw)
            end
        end
    end

    local function think(e)
        -- break_lc.think(e)
    end

    local function update(e)
        angles.update(ctx)
        yaw_direction.update(ctx)
        auto_peek.perform(ctx)
        manual_direction.update(ctx)

        safe_head.update(e, ctx)
        defensive.handle(e, ctx)
        air_exploit.handle(ctx, e)
        avoid_backstab.update(ctx)
        disablers.update(e, ctx)
        fs_disablers.update(ctx)
    end

    function antiaim.shutdown()
        shutdown()
    end

    function antiaim.setup_command(e)
        if not gui.enabled:get() then
            return
        end

        table.clear(ctx)
        shutdown()

        think(e)
        update(e)

        modify_yaw()
        modify_jitter()

        setup()
    end

    gui.enabled:set_callback(function(item)
        if not ui.get(item) then
            shutdown()
        end
    end)
end

---region settings tweaks
do
    settings.tweaks_enable = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Features")
    : record("settings", "settings::tweaks_enable")
    : save()

    settings.tweaks = menu.new_item(ui.new_multiselect, 'AA', 'Anti-aimbot angles', merge { "- Functions", "\n", "settings::tweaks" }, { 'Log Aimbot Shots', 'Trashtalk', 'Unmute Silenced Players', 'Console Filter', 'Damage Marker' })
    : record("settings", "settings::tweaks")
    : save()
end

--- region widgets
do
    widgets.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Widgets")
    : record("visuals", "widgets::enabled")
    : save()

    widgets.color_picker = menu.new_item(ui.new_color_picker, "AA", "Anti-aimbot angles", merge { "- Color", "\n", "widgets::color_picker" }, 113, 152, 255, 255)
    : record("visuals", "keybinds::color_picker")
    : save()

    widgets.items = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { "- Items", "\n", "widgets::items" }, { "Watermark", "Keybinds", "Velocity Warning", "Crosshair Indicator", "Damage Indicator", "On-Screen Logs", 'Hit Rate' })
    : record("visuals", "widgets::items")
    : save()

    widgets.display = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { "- Display", "\n", "widgets::display" }, { "Username", "Latency", "Time", "FPS", "Server frametime" })
    : record("visuals", "widgets::display")
    : save()

    widgets.custom_name = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Custom Name", { "Username", "Latency", "Time", "FPS", "Server frametime" })
    : record("visuals", "widgets::custom_name")
    : save()

    widgets.custom_name_value = menu.new_item(ui.new_textbox, "AA", "Anti-aimbot angles", "Nickname")
    : record("visuals", "widgets::custom_name_value")
    : save()
end

--- region fast ladder
do
    aa_tweaks.enable = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Tweaks")
    : record("settings", "aa_tweaks::enable")
    : save()

    aa_tweaks.items = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", "- Options", { 'Disable on Warmup', 'Disable While No Enemies', 'Avoid Backstab', 'Fast Ladder', 'Edge Yaw on FD', "Auto Peek Improvements" })
    : record("aa", "aa_tweaks::items")
    : save()

    client.set_event_callback('setup_command', function (cmd)
        if not aa_tweaks.enable:get() then
            return
        end

        if not aa_tweaks.items:have_key('Fast Ladder') then
            return
        end

        local lp = entity.get_local_player()
        if lp == nil then
            return
        end

        if entity.get_prop(lp, 'm_MoveType') ~= 9 then
            return
        end

        local weapon = entity.get_player_weapon(lp)
        if weapon == nil then
            return
        end

        local throw_time = entity.get_prop(weapon, 'm_fThrowTime')

        if throw_time ~= nil and throw_time ~= 0 then
            return
        end

        if cmd.forwardmove > 0 then
            if cmd.pitch < 45 then
                cmd.pitch = 89
                cmd.in_moveright = 1
                cmd.in_moveleft = 0
                cmd.in_forward = 0
                cmd.in_back = 1

                if cmd.sidemove == 0 then
                    cmd.yaw = cmd.yaw + 90
                end

                if cmd.sidemove < 0 then
                    cmd.yaw = cmd.yaw + 150
                end

                if cmd.sidemove > 0 then
                    cmd.yaw = cmd.yaw + 30
                end
            end
        elseif cmd.forwardmove < 0 then
            cmd.pitch = 89
            cmd.in_moveleft = 1
            cmd.in_moveright = 0
            cmd.in_forward = 1
            cmd.in_back = 0

            if cmd.sidemove == 0 then
                cmd.yaw = cmd.yaw + 90
            end

            if cmd.sidemove > 0 then
                cmd.yaw = cmd.yaw + 150
            end

            if cmd.sidemove < 0 then
                cmd.yaw = cmd.yaw + 30
            end
        end
    end)
end

--- region idiot
do
    air_exploit.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Air Lag Exploit", 1, 30, 18, true, 't')
    : record("aa", "air_exploit::enabled")
    : save()

    air_exploit.key = menu.new_item(ui.new_hotkey, "AA", "Anti-aimbot angles", "\nAir Lag Exploit", true)
    : record("aa", "air_exploit::key")
    : save()

    air_exploit.ticks = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", "- Ticks", 1, 30, 10, true, 't')
    : record("aa", "air_exploit::ticks")
    : save()


    air_exploit.reset = false

    local weapons = { "Global", "G3SG1 / SCAR-20", "SSG 08", "AWP", "R8 Revolver", "Desert Eagle", "Pistol", "Zeus", "Rifle", "Shotgun", "SMG", "Machine gun" }

    function air_exploit.backups()
        if air_exploit.reset then
            local prev = ui.get(software.rage.weapon.weapon_type)

            for _, weapon in next, weapons do
                ui.set(software.rage.weapon.weapon_type, weapon)
                ui.set(software.rage.aimbot.enabled[1], true)
            end

            ui.set(software.rage.weapon.weapon_type, prev)

            override.unset(software.rage.other.duck_peek_assist)
            override.unset(software.aa.fakelag.limit)
            override.unset(software.misc.settings.sv_maxusrcmdprocessticks)
            air_exploit.reset = false
        end
    end

    function air_exploit.handle(ctx, cmd)
        if not air_exploit.enabled:get() then
            return air_exploit.backups()
        end

        local is_active = air_exploit.key:rawget()
        if not is_active then
            return air_exploit.backups()
        end

        if not software.is_double_tap() then
            return air_exploit.backups()
        end

        if not localplayer.is_airborne then
            return air_exploit.backups()
        end

        local exploit = exploit.get()

        override.set(software.misc.settings.sv_maxusrcmdprocessticks, 19)
        override.set(software.aa.fakelag.limit, 17)

        if exploit.shift then
            ui.set(software.rage.aimbot.enabled[1], true)
            cmd.discharge_pending = true
        else
            ui.set(software.rage.aimbot.enabled[1], false)
            override.set(software.rage.other.duck_peek_assist, globals.tickcount() % air_exploit.ticks:get() == 0 and 'Always on' or 'On hotkey')
        end

        air_exploit.reset = true
    end
end

--- region defensive
do
    local function get_statement()
        if localplayer.is_airborne then
            return "Air";
        end

        if localplayer.is_crouched then
            return "Crouched";
        end

        if localplayer.is_moving then
            if software.is_slow_motion() then
                return "Slow Walk";
            end

            return "Moving";
        end

        return "Standing"
    end

    defensive.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Defensive AA")
    : record("aa", "defensive::enabled")
    : save()

    defensive.mode = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { "- Mode", "\n", "defensive::mode" }, { "On Shot Anti Aim", "Double Tap" })
    : record("aa", "defensive::mode")
    : save()

    defensive.state = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { "- State", "\n", "defensive::state" }, { "Air", "Standing", "Moving", "Slow Walk", "Crouched", "On Peek" })
    : record("aa", "defensive::state")
    : save()

    defensive.pitch = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "- Pitch", "\n", "defensive::pitch" }, { "Default", "Zero", "Up", "Up Switch", "Down Switch", "Random" })
    : record("aa", "defensive::pitch")
    : save()

    defensive.yaw = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "- Yaw", "\n", "defensive::yaw" }, { "Default", "Sideways", "Forward", "Spinbot", "3-Way", "5-Way", "Random" })
    : record("aa", "defensive::pitch")
    : save()

    local modes = {
        ['Double Tap'] = software.is_double_tap,
        ['On Shot Anti Aim'] = software.is_on_shot_antiaim
    }

    local manual_bebra = {
        [0] = 90,
        [1] = -90,
        [2] = 0
    }

    local defensive_3_way = { 90, 180, -90, 180, 90 }
    local defensive_5_way = { 90, 135, 180, 225, 270 }

    function defensive.handle(cmd, ctx)
        if not defensive.enabled:get() then
            return
        end

        local lp = entity.get_local_player()
        if lp == nil then
            return
        end

        local work_on_mode = false
        for idx, mode in next, defensive.mode:get() do
            if modes[ mode ] and modes[ mode ]() then
                work_on_mode = true
                break
            end
        end

        local double_tap = exploit.get()
        if not work_on_mode or not double_tap.shift then
            return
        end

        local lp_state = get_statement()

        local should_work = false
        local on_peek = false
        for _, condition in next, defensive.state:get() do
            if condition == 'On Peek' then
                should_work = true
                on_peek = true
                break
            else
                if condition == lp_state then
                    should_work = true
                    break
                end
            end
        end

        if not should_work then
            return
        end

        local weapon = entity.get_player_weapon(lp)
        if weapon == nil then
            return
        end

        local wpn_info = csgo_weapons(weapon)
        if wpn_info == nil then
            return
        end

        if wpn_info.is_revolver then
            return
        end

        if not on_peek then
            cmd.force_defensive = true
        end

        local freestanding = yaw_direction.is_freestanding
        local manual_yaw = manual_direction.get()
        local should_flick = lp_state == 'Crouched' and manual_direction.options:have_key('Duck Exploit')
        local should_ignore = freestanding or (manual_yaw ~= nil and not should_flick)

        if should_flick then
            ctx.body_yaw = 'Static'
            ctx.body_yaw_offset = 180
        end

        local pitch_value, pitch_mode = 0, 'Default'
        do
            local val = defensive.pitch:get()
            if val == 'Zero' then
                pitch_value, pitch_mode = 0, 'Custom'
            elseif val == 'Up' then
                pitch_value, pitch_mode = 0, 'Up'
            elseif val == 'Up Switch' then
                pitch_value, pitch_mode = client.random_float(45, 60) * -1, 'Custom'
            elseif val == 'Down Switch' then
                pitch_value, pitch_mode = client.random_float(45, 60), 'Custom'
            elseif val == 'Random' then
                pitch_value, pitch_mode = client.random_float(-89, 89), 'Custom'
            end

            if manual_yaw ~= nil and should_flick then
                pitch_value, pitch_mode = client.random_float(-5, 10), 'Custom'
            end
        end

        local yaw_value, yaw_mode = 0, '180'
        do
            local val = defensive.yaw:get()
            if val == 'Sideways' then
                yaw_value = localplayer.choking * 90 + client.random_float(-30, 30)
            elseif val == 'Forward' then
                yaw_value = localplayer.choking * 180 + client.random_float(-30, 30)
            elseif val == 'Spinbot' then
                yaw_value = -180 + (globals.tickcount() % 9) * 40 + client.random_float(-30, 30)
            elseif val == '3-Way' then
                yaw_value = defensive_3_way[localplayer.packets % 5 + 1] + client.random_float(-15, 15)
            elseif val == '5-Way' then
                yaw_value = defensive_5_way[localplayer.packets % 5 + 1] + client.random_float(-15, 15)
            elseif val == 'Random' then
                yaw_value = utils.normalize(math.random(-180, 180), -180, 180)
            end

            if manual_yaw ~= nil and should_flick then
                yaw_value = manual_bebra[ manual_yaw ] + client.random_float(0, 10)
            end
        end

        -- client.color_log(255, 255, 255, f('\nDefensive: %s\nShould Ignore: %s\nAvoid Backstab: %s\nForce Defensive: %s\nFreestanding: %s', globals.tickcount() > double_tap.defensive_tk - 2, should_ignore, avoid_backstab.get(), cmd.force_defensive, software.is_freestanding()))

        if globals.tickcount() > double_tap.defensive_tk - 2 then
            return
        end

        if avoid_backstab.get() or should_ignore then
            return
        end

        ctx.pitch = pitch_mode
        ctx.pitch_offset = pitch_value
        ctx.yaw = yaw_mode
        ctx.yaw_offset = yaw_value
    end
end

---region disable on warmup
do

    function disablers.count_alive()
        local alive = 0

        for i = 1, globals.maxplayers() do
            if entity.get_classname(i) ~= 'CCSPlayer' then
                goto skip
            end

            if not entity.is_alive(i) or not entity.is_enemy(i) then
                goto skip
            end

            alive = alive + 1
            ::skip::
        end

        return alive
    end


    function disablers.update(cmd, ctx)
        local lp = entity.get_local_player()
        if lp == nil then
            return
        end

        if not aa_tweaks.enable:get() then
            return
        end

        local game_rules = entity.get_game_rules()
        if game_rules == nil then
            return
        end

        local should_disable = false

        if aa_tweaks.items:have_key('Disable on Warmup') and entity.get_prop(game_rules, 'm_bWarmupPeriod') == 1 then
            should_disable = true
        end

        local players = disablers.count_alive()

        if aa_tweaks.items:have_key('Disable While No Enemies') and players == 0 and cmd.in_use ~= 1 then
            should_disable = true
        end

        if not should_disable then
            return
        end

        ctx.enabled = false
    end
end

--- region avoid_backstab
do
    local is_active = false
    local AVOID_BACKSTAB_MAX_DISTANCE_SQR = 220 * 220

    local function get_enemies_with_knife()
        local enemies = entity.get_players(true)
        if next(enemies) == nil then return { } end

        local list = { }

        for i = 1, #enemies do
            local enemy = enemies[i]
            local wpn = entity.get_player_weapon(enemy)

            if wpn == nil then
                goto continue
            end

            local wpn_class = entity.get_classname(wpn)

            if wpn_class == "CKnife" then
                list[#list + 1] = enemy
            end

            ::continue::
        end

        return list
    end

    local function get_closest_target(me)
        local targets = get_enemies_with_knife()
        if next(targets) == nil then return end

        local best_delta
        local best_target

        local my_origin = vector(entity.get_origin(me))
        local best_distance = AVOID_BACKSTAB_MAX_DISTANCE_SQR

        for i = 1, #targets do
            local target = targets[i]

            local origin = vector(entity.get_origin(target))
            local delta = origin - my_origin

            local distance = delta:lengthsqr()

            if distance < best_distance then
                best_delta = delta
                best_target = target

                best_distance = distance
            end
        end

        return best_target, best_delta
    end

    function avoid_backstab.get()
        return is_active
    end

    function avoid_backstab.update(ctx)
        is_active = false
        if not aa_tweaks.enable:get() then
            return
        end

        if not aa_tweaks.items:have_key('Avoid Backstab') then
            return
        end

        local me = entity.get_local_player()
        local target, delta = get_closest_target(me)

        if target == nil then return end
        if delta == nil then return end

        local view = vector(client.camera_angles())
        local angle = vector(delta:angles())

        local yaw = angle.y - view.y + 180

        if ctx.yaw_offset == nil then
            ctx.yaw_offset = 0
        end

        ctx.yaw_base = "Local view"
        ctx.yaw_offset = ctx.yaw_offset + yaw

        ctx.edge_yaw = false
        ctx.freestanding = false
        is_active = true
    end
end

--- region safe_head
do
    local is_active = false

    local presets = {
        ["Standing"] = {
            [2] = function(e, ctx, me)
                ctx.yaw_offset = -6

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 0
            end,

            [3] = function(e, ctx, me)
                ctx.yaw_offset = 8

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 0
            end
        },

        ["Crouched"] = {
            [2] = function(e, ctx, me)
                ctx.yaw_offset = 0

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 0
            end,

            [3] = function(e, ctx, me)
                ctx.yaw_offset = 40

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 180
            end
        },

        ["Crouched Air"] = {
            [2] = function(e, ctx, me)
                ctx.yaw_offset = 0

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = -120
            end,

            [3] = function(e, ctx, me)
                ctx.yaw_offset = 0

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 120
            end
        },

        ["Air Knife"] = {
            [2] = function(e, ctx, me)
                ctx.yaw_offset = 45

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 180
            end,

            [3] = function(e, ctx, me)
                ctx.yaw_offset = 35

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 180
            end
        },

        ["Air Zeus"] = {
            [2] = function(e, ctx, me)
                ctx.yaw_offset = 23

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 0
            end,

            [3] = function(e, ctx, me)
                ctx.yaw_offset = 10

                ctx.body_yaw = "Static"
                ctx.body_yaw_offset = 0
            end
        }
    }

    local sv_gravity = cvar.sv_gravity
    local function extrapolate_entity(ent, pos)
        local tick_interval = globals.tickinterval()

        local velocity = vector(entity.get_prop(ent, "m_vecVelocity"))
        local new_pos = pos:clone()

        local ticks = 25
        if #velocity < 32 then
            ticks = 40
        end

        new_pos.x = new_pos.x + velocity.x * tick_interval * ticks
        new_pos.y = new_pos.y + velocity.y * tick_interval * ticks

        if entity.get_prop(ent, "m_hGroundEntity") == nil then
            new_pos.z = new_pos.z + velocity.z * tick_interval * ticks - sv_gravity:get_float() * tick_interval
        end

        return new_pos
    end

    local function get_statement(me)
        if localplayer.is_airborne then
            local wpn = entity.get_player_weapon(me)
            if wpn == nil then return end

            local classname = entity.get_classname(wpn)

            if classname == "CKnife" then
                return "Air Knife"
            end

            if classname == "CWeaponTaser" then
                return "Air Zeus"
            end

            if localplayer.duck_amount == 1.0 then
                return "Crouched Air"
            end

            return nil
        end

        if localplayer.is_crouched then
            return "Crouched"
        end

        if not localplayer.is_moving then
            return "Standing"
        end

        return nil
    end

    safe_head.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Safe Head")
    : record("aa", "safe_head::enabled")
    : save()

    safe_head.states = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { "- States", "\n", "safe_head::states" }, { "Air Knife", "Air Zeus", "Standing", "Crouched", "Crouched Air" })
    : record("aa", "safe_head::states")
    : save()

    function safe_head.get()
        return is_active
    end

    function safe_head.update(e, ctx)
        is_active = false

        if not safe_head.enabled:get() then
            return
        end

        local me = entity.get_local_player()

        if manual_direction.get() then
            return
        end

        local team = entity.get_prop(me, "m_iTeamNum")
        if team == nil then
            return
        end

        local wpn = entity.get_player_weapon(me)
        if wpn == nil then
            return
        end

        local threat = client.current_threat()
        if threat == nil then
            return
        end

        local statement = get_statement(me)
        if statement == nil then
            return
        end

        if not safe_head.states:have_key(statement) then
            return
        end

        local should_continue = false
        if statement == "Air Zeus" or statement == "Air Knife" then
            should_continue = true
        else
            local eye_pos = extrapolate_entity(threat, vector(utils.get_eye_position(threat)))
            local head_pos = vector(entity.hitbox_position(me, 0))

            eye_pos.z = eye_pos.z + 5

            if head_pos.z > eye_pos.z then
                local entindex, damage = client.trace_bullet(threat, eye_pos.x, eye_pos.y, eye_pos.z, head_pos.x, head_pos.y, head_pos.z + 6, threat)

                should_continue = damage > 0
            end
        end

        if not should_continue then
            return
        end

        local preset = presets[statement]
        if preset == nil then
            return
        end

        local fn = preset[team]
        if fn == nil then
            return
        end

        ctx.pitch = "Default"
        ctx.yaw_base = "At targets"

        ctx.yaw = "180"
        ctx.yaw_offset = 22

        ctx.yaw_jitter = "Off"

        ctx.body_yaw = "Static"
        ctx.body_yaw_offset = 120

        ctx.freestanding_body_yaw = false

        fn(e, ctx, me)

        is_active = true
    end
end

--- region manual_yaw
do
    local LEFT    = 0
    local RIGHT   = 1
    local FORWARD = 2

    local idx
    local data = { }

    local directions = {
        [LEFT]    = -90,
        [RIGHT]   = 90,
        [FORWARD] = 180
    }

    local function get_value(ref)
        local prev_active = data[ref]
        local active, mode, key = ui.get(ref)

        if prev_active == nil then
            data[ref] = active
            return
        end

        if mode == 0 then return end
        if mode == 3 then return end
        if key == nil then return end

        if prev_active ~= active then
            data[ref] = active
            return active, mode, key
        end
    end

    local function update_hotkey(ref, value)
        local active, mode = get_value(ref)
        if active == nil then return end

        if mode == 1 then
            if not active then
                idx = nil
                return
            end

            idx = value
            return
        end

        if mode == 2 then
            if idx == value then
                idx = nil
                return
            end

            idx = value
            return
        end
    end

    local function think()
        if get_value(manual_direction.disabled_manual.ref) ~= nil then
            idx = nil
            return
        end

        update_hotkey(manual_direction.left_manual.ref, LEFT)
        update_hotkey(manual_direction.right_manual.ref, RIGHT)
        update_hotkey(manual_direction.forward_manual.ref, FORWARD)
    end

    manual_direction.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Manual Yaw")
    : record("aa", "manual_direction::enabled")

    manual_direction.arrows = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Manual Arrows")
    : record("aa", "manual_direction::arrows")
    : save()

    manual_direction.color = menu.new_item(ui.new_color_picker, "AA", "Anti-aimbot angles", "Manual Color")
    : record("aa", "manual_direction::color")
    : save()

    manual_direction.options = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { "- Options", "\n", "manual_direction::options" }, {
        "Disable Yaw Modifiers",
        "Freestanding Body Yaw",
        'Duck Exploit'
    })
    : record("aa", "manual_direction::options")
    : save()

    manual_direction.left_manual = menu.new_item(ui.new_hotkey, "AA", "Anti-aimbot angles", merge { "- Left Manual", "\n", "manual_direction::left_manual" })
    : record("aa", "manual_direction::left_manual")

    manual_direction.right_manual = menu.new_item(ui.new_hotkey, "AA", "Anti-aimbot angles", merge { "- Right Manual", "\n", "manual_direction::right_manual" })
    : record("aa", "manual_direction::right_manual")

    manual_direction.forward_manual = menu.new_item(ui.new_hotkey, "AA", "Anti-aimbot angles", merge { "- Forward Manual", "\n", "manual_direction::forward_manual" })
    : record("aa", "manual_direction::forward_manual")

    manual_direction.disabled_manual = menu.new_item(ui.new_hotkey, "AA", "Anti-aimbot angles", merge { "- Disabled Manual", "\n", "manual_direction::disabled_manual" })
    : record("aa", "manual_direction::disabled_manual")

    manual_direction.left_manual:set("Toggle")
    manual_direction.right_manual:set("Toggle")
    manual_direction.forward_manual:set("Toggle")
    manual_direction.disabled_manual:set("Toggle")

    function manual_direction.get()
        return idx
    end

    function manual_direction.frame()
        think()
    end

    function manual_direction.update(ctx)
        if idx == nil then
            return false
        end

        if avoid_backstab.get() then
            return false
        end

        local offset = directions[idx]

        if offset == nil then
            return false
        end

        if ctx.yaw_offset == nil then
            ctx.yaw_offset = 0
        end

        ctx.yaw_base = "Local view"
        ctx.yaw_offset = offset

        if manual_direction.options:have_key("Disable Yaw Modifiers") then
            ctx.yaw_jitter = "Off"
            ctx.body_yaw = "Static"
        end

        if manual_direction.options:have_key("Freestanding Body Yaw") then
            ctx.body_yaw = "Static"
            ctx.body_yaw_offset = 120

            ctx.freestanding_body_yaw = true
        end

        ctx.edge_yaw = false
        ctx.freestanding = false

        return true
    end
end

--- region log_aimbot_shots
do
    local DURATION = 7.0

    local inferno = { }
    local regular = { }

    local function draw_event_log(...)
        if not settings.tweaks_enable:get() then
            return
        end

        eventlogs.add(...)
    end

    local function push_event_log(data)
        if #regular > 8 then
            table.remove(regular, 1)
        end

        regular[#regular + 1] = data
    end

    local function weapon_to_action(weapon)
        if weapon == "knife" then
            return "Knifed"
        end

        if weapon == "hegrenade" then
            return "Naded"
        end

        return "Hit"
    end

    local function find_inferno_info(ent)
        for i = 1, #inferno do
            local data = inferno[i]

            if data.entity == ent then
                return data
            end
        end

        return nil
    end

    local function get_miss_color(reason)
        if reason == "spread" then
            return eventlogs.spread_color_picker:rawget()
        end

        if reason == "death" or reason == "unregistered shot" then
            return eventlogs.unregistered_color_picker:rawget()
        end

        return eventlogs.miss_color_picker:rawget()
    end

    local function create_event_message(action, hitgroup, ent, damage)
        local name = entity.get_player_name(ent)
        local hitgroup_name = e_hitgroup[hitgroup]

        if action == "Hit" then
            return f(
                "%s ${%s} in the ${%s} for ${%s} damage",
                action, name, hitgroup_name, damage
            )
        end

        return f(
            "%s ${%s} for ${%s} damage",
            action, name, damage
        )
    end

    local function create_inferno_info(ent, damage)
        local data = { }

        data.entity = ent
        data.damage = damage

        data.alpha = 0.0
        data.duration = 7.0

        data.flash_amount = 1.0

        return data
    end

    local function create_event_info(action, hitgroup, ent, damage)
        local data = { }

        data.msg = create_event_message(action, hitgroup, ent, damage)

        data.alpha = 0.0
        data.duration = 7.0

        return data
    end

    local function create_miss_info(reason)
        if reason == "?" then
            reason = "correction"
        end

        local data = { }

        data.msg = f(
            "Missed shot due to ${%s}",
            reason
        )

        data.reason = reason

        data.alpha = 0.0
        data.duration = 7.0

        return data
    end

    local function update_inferno_logs(dt)
        local r, g, b = widgets.color_picker:rawget()

        for i = #inferno, 1, -1 do
            local data = inferno[i]

            data.duration = math.max(0, data.duration - dt)
            data.alpha = motion.interp(data.alpha, data.duration > 0, 0.045)

            if data.alpha <= 0 then
                table.remove(inferno, i)
            end
        end

        for i = 1, #inferno do
            local data = inferno[i]

            local name = entity.get_player_name(data.entity)
            local damage = data.damage

            draw_event_log(r, g, b, 255 * data.alpha, f("Burned ${%s} for ${%d} damage", name, damage))
        end
    end

    local function update_regular_logs(dt)
        local r, g, b = widgets.color_picker:rawget()

        for i = #regular, 1, -1 do
            local data = regular[i]

            data.duration = math.max(0, data.duration - dt)
            data.alpha = motion.interp(data.alpha, data.duration > 0, 0.045)

            if data.alpha <= 0 then
                table.remove(regular, i)
            end
        end

        for i = 1, #regular do
            local data = regular[i]

            local col_r = r
            local col_g = g
            local col_b = b

            if data.reason ~= nil then
                col_r, col_g, col_b = get_miss_color(data.reason)
            end

            draw_event_log(col_r, col_g, col_b, 255 * data.alpha, data.msg)
        end
    end

    local function handle_input()
        if not settings.tweaks_enable:get() then
            return
        end

        if settings.tweaks:have_key('Log Aimbot Shots') then
            override.set(software.misc.settings.output, false)
        else
            override.unset(software.misc.settings.output)
        end
    end

    settings.tweaks:set_callback(handle_input)
    settings.tweaks_enable:set_callback(handle_input)
    ui.set_callback(software.misc.settings.output, handle_input)
    handle_input()

    function log_aimbot_shots.player_hurt(e)
        if not settings.tweaks_enable:get() then
            return
        end

        local me = entity.get_local_player()

        local userid = client.userid_to_entindex(e.userid)
        local attacker = client.userid_to_entindex(e.attacker)

        local weapon = e["weapon"]
        local damage = e["dmg_health"]

        local hitgroup = e["hitgroup"]

        if userid == me or attacker ~= me then
            return
        end

        if weapon == "inferno" then
            local data = find_inferno_info(userid)

            if data ~= nil then
                data.damage = data.damage + damage
                data.duration = DURATION

                data.flash_amount = 1.0

                return
            end

            inferno[#inferno + 1] = create_inferno_info(userid, damage)
            return
        end

        local action = weapon_to_action(weapon)
        push_event_log(create_event_info(action, hitgroup, userid, damage))
    end

    function log_aimbot_shots.aim_miss(e)
        if not settings.tweaks_enable:get() then
            return
        end

        push_event_log(create_miss_info(e.reason))
    end

    function log_aimbot_shots.frame()
        local dt = globals.frametime()

        update_inferno_logs(dt)
        update_regular_logs(dt)
    end
end

--- region eventlogs
do
    local ALPHA_UNIT = 1 / 255

    local queue = { }
    local preview_alpha = 0.0

    local function replacement(s, col_a, col_b)
        local hex_a = utils.to_hex(unpack(col_a))
        local hex_b = utils.to_hex(unpack(col_b))

        local repl = f("\a%s%%1\a%s", hex_a, hex_b)
        local result = string.gsub(s, "${(.-)}", repl)

        return result
    end

    local function update_preview()
        local can_show_preview = widgets.enabled:get() and ui.is_menu_open() and #queue == 0
        preview_alpha = motion.interp(preview_alpha, can_show_preview, 0.045)

        if preview_alpha > 0.0 then
            local alpha = 255 * preview_alpha

            -- hit example
            do
                local r, g, b = widgets.color_picker:rawget()

                eventlogs.add(r, g, b, alpha, "Hit ${vladislav} for ${10} damage")
                eventlogs.add(r, g, b, alpha, "Hit ${monster} in the ${head} for ${103} damage")
            end

            -- miss example
            do
                local r, g, b = eventlogs.miss_color_picker:rawget()

                eventlogs.add(r, g, b, alpha, "Missed shot due to ${correction}")
                eventlogs.add(r, g, b, alpha, "Missed shot due to ${prediction error}")
                eventlogs.add(r, g, b, alpha, "Missed shot due to ${lagcomp failure}")
            end

            -- spread example
            do
                local r, g, b = eventlogs.spread_color_picker:rawget()

                eventlogs.add(r, g, b, alpha, "Missed shot due to ${spread}")
            end

            -- network example
            do
                local r, g, b = eventlogs.unregistered_color_picker:rawget()

                eventlogs.add(r, g, b, alpha, "Missed shot due to ${unregistered shot}")
                eventlogs.add(r, g, b, alpha, "Missed shot due to ${player death}")
                eventlogs.add(r, g, b, alpha, "Missed shot due to ${death}")
            end
        end
    end

    local widget = windows.new("##Event Logs", .55, 0.78)
    widget:set_size(vector(330, 125))

    local hovered_alpha = 0

    local function draw_eventlogs()
        if not widgets.enabled:get() or not widgets.items:have_key("On-Screen Logs") then
            return
        end

        local screen = vector(client.screen_size())
        local flags = "d"

        local window = widget
        window.pos.x = screen.x * .5 - 165

        local pos = window.pos:clone()
        local size = window.size:clone()

        local position = vector(pos.x + size.x / 2, pos.y)

        hovered_alpha = motion.interp(hovered_alpha, ui.is_menu_open() and window:is_hovering(), 0.095)
        if hovered_alpha ~= 0 then
            renderer.text(pos.x + size.x * .5, pos.y - 10, 255, 255, 255, 255 * hovered_alpha, 'c', nil, 'You can drag widget vertically.')
            renderer.rectangle(pos.x + 50, pos.y - 2, size.x - 103, 1, 255, 255, 255, 100 * hovered_alpha)
        end

        for i = 1, #queue do
            local log = queue[i]

            local r, g, b, a = log.r, log.g, log.b, log.a
            local alpha = a * ALPHA_UNIT

            local text = log.msg do
                text = replacement(text, { r, g, b, 255 }, { 255, 255, 255, 255 })
            end

            local text_size = vector(renderer.measure_text(flags, text))
            local rect_size = vector(text_size.x, text_size.y)

            local text_position = vector(position.x - text_size.x * 0.5, position.y)
            -- local rect_position = vector(position.x - rect_size.x * 0.5, position.y + text_size.y * 0.5)

            -- graphics.glow(rect_position.x, rect_position.y - 2, rect_size.x, 4, r, g, b, a * 0.1, 10, 1)
            -- renderer.rectangle(rect_position.x, rect_position.y - 2, rect_size.x, 4, r, g, b, a * 0.1)

            graphics.text(text_position.x, text_position.y, 255, 255, 255, 255 * alpha, flags, 0, text)

            position.y = position.y + (text_size.y + 1) * alpha
        end

        window:update()
    end

    local function get_color(self)
        return self.r, self.g, self.b
    end

    local wr, wg, wb = widgets.color_picker:rawget()

    eventlogs.hit_color_picker = {
        r = wr, g = wg, b = wb,

        rawget = get_color
    }

    eventlogs.spread_color_picker = {
        r = 255, g = 225, b = 115,

        rawget = get_color
    }

    eventlogs.miss_color_picker = {
        r = 255, g = 98, b = 98,

        rawget = get_color
    }

    eventlogs.unregistered_color_picker = {
        r = 100, g = 100, b = 255,

        rawget = get_color
    }

    function eventlogs.add(r, g, b, a, text)
        local log = { }

        log.r = r
        log.g = g
        log.b = b
        log.a = a

        log.msg = text

        table.insert(queue, log)
        return log
    end

    function eventlogs.pre_frame()
        table.clear(queue)
    end

    function eventlogs.post_frame()
        update_preview()
        draw_eventlogs()
    end
end


local print_dev = { }

LPH_NO_VIRTUALIZE(function ()
    print_dev.data = { }

    function print_dev.add(text, time)
        print_dev.data[#print_dev.data+1] = {
            text = text,
            time = time + globals.realtime(),
            alpha = 0.01,
            offset = 0
        }
    end

    client.set_event_callback('paint', function ()
        local realtime = globals.realtime()
        local frametime = globals.frametime()
        local offset = 0

        for i = #print_dev.data, 1, -1 do
            local log = print_dev.data[i]
            if not log then
                goto skip
            end

            if log.offset ~= offset then
                log.offset = utils.clamp(log.offset < offset and log.offset + (200 * frametime) or offset, 0, offset)
            end

            local difference = log.time - realtime
            log.alpha = motion.interp(log.alpha, difference > 0, 0.045)
            if log.alpha <= 0 and difference < 0 then
                table.remove(print_dev.data, i)
                goto skip
            end

            local text_sz = vector(renderer.measure_text('d', log.text))

            graphics.text(8, 5 + log.offset, 255, 255, 255, 255 * log.alpha, 'd', nil, log.text)

            offset = offset + text_sz.y + 1
            ::skip::
        end

        for i = 1, #print_dev.data do
            local log_count = #print_dev.data - i

            if log_count > 7 then
                print_dev.data[ i ].time = 0
            end
        end
    end)

    client.set_event_callback('round_prestart', function ()
        print_dev.data = { }
    end)

    setmetatable(print_dev, {
        __call = function (self, ...)
            print_dev.add(...)
        end
    })
end)()

---region log aim 4ots
do
    local hitgroup_str = {
        [0] = 'generic',
        'head', 'chest', 'stomach',
        'left arm', 'right arm',
        'left leg', 'right leg',
        'neck', 'generic', 'gear'
    }

    local weapon_verb = {
        ['hegrenade'] = 'Naded',
        ['inferno'] = 'Burned',
        ['knife'] = 'Knifed',
    }

    local hex_to_rgb = function( hex )
        hex = hex:gsub('#', '')
        return tonumber('0x' .. hex:sub(1, 2)), tonumber('0x' .. hex:sub(3, 4)), tonumber('0x' .. hex:sub(5, 6))
    end

    local function clean_up(str)
        local text = str:gsub('(\a%x%x%x%x%x%x)%x%x', '%1')
        return text
    end

	local function printc(...)
		for i, v in ipairs{...} do
			local r = "\aD9D9D9" .. v
			for col, text in r:gmatch("\a(%x%x%x%x%x%x)([^\a]*)") do
                local r, g, b = hex_to_rgb(col)
				client.color_log(r, g, b, string.format('%s\0', text))
			end
            client.color_log(255, 255, 255, '\n\0')
		end
	end

    local wanted_damage, wanted_hitgroup, backtrack = 0, 0, 0

    client.set_event_callback("aim_fire", function (e)
        if not settings.tweaks_enable:get() then
            return
        end

        if not settings.tweaks:have_key('Log Aimbot Shots') then
            return
        end

        wanted_damage = e.damage
        wanted_hitgroup = e.hitgroup
        backtrack = globals.tickcount() - e.tick
    end)

    client.set_event_callback('aim_hit', function (shot)
        if not settings.tweaks_enable:get() then
            return
        end

        if not settings.tweaks:have_key('Log Aimbot Shots') then
            return
        end

        local target = shot.target
        if target == nil then
            return
        end

        local info = {
            '\rHit ',
            f('\a[nick]%s\r\'s ', entity.get_player_name(target)),
            'in the ',
            shot.hitgroup ~= wanted_hitgroup and f('\a[highlight]%s\r(\a[highlight]%s\r) ', hitgroup_str[ shot.hitgroup ], hitgroup_str[ wanted_hitgroup ]) or f('\a[highlight]%s\r ', hitgroup_str[ shot.hitgroup ]),
            'for ',
            shot.damage ~= wanted_damage and f('\a[highlight]%d\r(\a[highlight]%d\r) ', shot.damage, wanted_damage) or f('\a[highlight]%d\r ', shot.damage),
            'damage ',
            f('(hc: \a[highlight]%d%% \a[idle]· \rhistory: \a[highlight]%dt\r)', shot.hit_chance, backtrack)
        }

        local str = utils.format(table.concat(info, ''), 255, 255, 255, 255)
        printc(f('\aB6E717[gamesense] \aFFFFFF%s', clean_up(str)))
        print_dev(str, 8)
    end)

    client.set_event_callback('aim_miss', function (shot)
        if not settings.tweaks_enable:get() then
            return
        end

        if not settings.tweaks:have_key('Log Aimbot Shots') then
            return
        end

        local target = shot.target
        if target == nil then
            return
        end

        local info = {
            '\rMissed ',
            f('\a[nick]%s\r\'s ', entity.get_player_name(target)),
            f('\a[highlight]%s\r ', hitgroup_str[ shot.hitgroup ]),
            'due to ',
            f('\a[miss]%s\r ', shot.reason),
            f('(hc: \a[highlight]%d%% \a[idle]· \rhistory: \a[highlight]%dt\r)', shot.hit_chance, backtrack)
        }

        local str = utils.format(table.concat(info, ''), 255, 255, 255, 255)
        printc(f('\aB6E717[gamesense] \aFFFFFF%s', clean_up(str)))
        print_dev(str, 8)
    end)

    client.set_event_callback('player_hurt', function (e)
        if not settings.tweaks_enable:get() then
            return
        end

        if not settings.tweaks:have_key('Log Aimbot Shots') then
            return
        end

        local lp = entity.get_local_player()
        local victim = client.userid_to_entindex(e.userid)
        local attacker = client.userid_to_entindex(e.attacker)
        if victim == nil or attacker == nil or victim == lp or attacker ~= lp then
            return
        end

        local hitgroup = hitgroup_str[ e.hitgroup ]

        local verb = weapon_verb[ e.weapon ]
        if verb == nil then
            return
        end

        local info = {
            '\r' .. verb,
            f(' \a[nick]%s\r ', entity.get_player_name(victim)),
            'for ',
            f('\a[highlight]%d \rdamage ', e.dmg_health or 0),
            f('(\a[highlight]%d \rhealth remaining)', e.health or 0)
        }

        local str = utils.format(table.concat(info, ''), 255, 255, 255, 255)
        printc(f('\aB6E717[gamesense] \aFFFFFF%s', clean_up(str)))
        print_dev(str, 8)
    end)
end

-- --region hitchance
-- do
--     hitchance.reset = false
--     hitchance.weapons = { 'G3SG1 / SCAR-20', 'AWP', 'SSG 08', 'R8 Revolver', 'Pistol' }

--     hitchance.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Custom Hit Chance")
--     : record("rage", "hitchance::enabled")
--     : save()

--     hitchance.weapon_list = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", "- Weapons", hitchance.weapons)
--     : record("rage", "hitchance::weapons")
--     : save()

--     for _, weapon in next, hitchance.weapons do
--         hitchance['Enabled_' .. weapon] = menu.new_item(ui.new_checkbox, 'AA', 'Anti-aimbot angles', f('Enable %s', weapon))
--         : record("rage", "hitchance::enable::" .. weapon)
--         : save()

--         hitchance['Modes_' .. weapon] = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { 'Modes', '\n', weapon }, { 'No Scope', 'In Air' })
--         : record("rage", "hitchance::modes::" .. weapon)
--         : save()

--         hitchance['Distance_' .. weapon] = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { 'Distance', '\n', weapon }, 100, 1001, 500, true, 'm', 0.01, { [1001] = 'Inf.' })
--         : record("rage", "hitchance::distance::" .. weapon)
--         : save()

--         hitchance['No Scope_' .. weapon] = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { 'No Scope', '\n', weapon }, 1, 100, 50, true, '%')
--         : record("rage", "hitchance::noscope::" .. weapon)
--         : save()

--         hitchance['In Air_' .. weapon] = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { 'In Air', '\n', weapon }, 1, 100, 50, true, '%')
--         : record("rage", "hitchance::inair::" .. weapon)
--         : save()
--     end

--     function hitchance.backups()
--         if hitchance.reset then
--             override.unset(software.rage.aimbot.hitchance)
--             override.unset(software.rage.aimbot.auto_scope)
--             hitchance.reset = false
--         end
--     end

--     function hitchance.distance(ent, distance)
--         local my_origin = vector(entity.get_origin(ent))
--         if my_origin == nil then
--             return
--         end

--         local target = client.current_threat()
--         if target == nil then
--             return
--         end

--         local enemy_origin = vector(entity.get_origin(target))
--         if enemy_origin == nil then
--             return
--         end

--         if distance == 1001 then
--             return 'Inf.'
--         end

--         return my_origin:dist(enemy_origin) <= distance
--     end

--     local noscope_ignore = {
--         ['R8 Revolver'] = true,
--         ['Pistol'] = true
--     }

--     client.set_event_callback('setup_command', function (cmd)
--         if not hitchance.enabled:get() then
--             return hitchance.backups()
--         end

--         local lp = entity.get_local_player()
--         if lp == nil then
--             return hitchance.backups()
--         end

--         local wpn = entity.get_player_weapon(lp)
--         if wpn == nil then
--             return hitchance.backups()
--         end

--         if ui.is_menu_open() then
--             return hitchance.backups()
--         end

--         local weapon = ui.get(software.rage.weapon.weapon_type)

--         if not hitchance['Enabled_' .. weapon] then
--             return hitchance.backups()
--         end

--         if not hitchance['Enabled_' .. weapon]:get() then
--             return hitchance.backups()
--         end

--         local distance = hitchance.distance(lp, hitchance[ 'Distance_' .. weapon ]:get())
--         local conditions = hitchance[ 'Modes_' .. weapon ]
--         local is_pistol = noscope_ignore[ weapon ] or false

--         if conditions:have_key('In Air') and localplayer.is_airborne then
--             override.set(software.rage.aimbot.hitchance, hitchance[ 'In Air_' .. weapon]:get())
--         elseif conditions:have_key('No Scope') and entity.get_prop(lp, 'm_bIsScoped') == 0 and distance and not is_pistol then
--             override.set(software.rage.aimbot.hitchance, hitchance[ 'No Scope_' .. weapon]:get())
--             override.set(software.rage.aimbot.auto_scope, false)
--         else
--             return hitchance.backups()
--         end

--         if distance == 'Inf.' then
--             override.unset(software.rage.aimbot.auto_scope)
--         end

--         hitchance.reset = true
--     end)
-- end

---region неопознан
do
    local shots do
        shots = {
            total = 0,
            hits = 0,

            reasons = {
                ['prediction error'] = true,
                ['death'] = true
            }
        }

        client.set_event_callback('aim_fire', function (shot)
            shots.total = shots.total + 1
        end)

        client.set_event_callback('aim_hit', function (shot)
            shots.hits = shots.hits + 1
        end)

        client.set_event_callback('player_connect_full', function (e)
            if client.userid_to_entindex(e['userid']) ~= entity.get_local_player() then
                return
            end

            shots.hits = 0
            shots.total = 0
        end)
    end

    client.set_event_callback('paint_ui', function ()
        local lp = entity.get_local_player()
        if lp == nil then
            return
        end

        if not widgets.enabled:get() or not widgets.items:have_key('Hit Rate') then
            return
        end

        local hit_rate = shots.total ~= 0 and (shots.hits / shots.total * 100) or 100

        renderer.indicator(255, 255, 255, 200, f('%s%d%%', hit_rate <= 50 and '◣_◢ ' or '', hit_rate))
    end)

end

---region trashtalk
do
    local phrases = {
        "₁", "１", "𝟷", "𝟭", "𝟏", '(☞ ͡° ͜ʖ ͡°)☞ 1 ♥♥', '✴.·´¯`·.·★  🎀1🎀  ★·.·`¯´·.✴', '❚█══1══█❚',
        '»»» 𝟭 ¯\\_(ツ)_/¯', '¯`·.¸¸.·´¯`·.¸¸.1.¸¸.·`¯´·.¸¸.·`¯💣', '»»»»1»»»»', '∙∙·▫▫ᵒᴼᵒ▫ₒₒ▫ᵒᴼ①ᴼᵒ▫ₒₒ▫ᵒᴼᵒ▫▫·∙∙'
    }

    local function talk()
        client.exec("say " .. phrases[globals.tickcount() % #phrases + 1])
    end

    local my_killer = -1
    client.set_event_callback('player_death', function (event)
        if not settings.tweaks_enable:get() then
            return
        end

        if not settings.tweaks:have_key('Trashtalk') then
            return
        end

        local game_rules = entity.get_game_rules()
        if not game_rules then
            return
        end

        if entity.get_prop(game_rules, 'm_bWarmupPeriod') == 1 then
            return
        end

        local lp = entity.get_local_player()
        if lp == nil then
            return
        end

        local victim, attacker = client.userid_to_entindex(event["userid"]), client.userid_to_entindex(event["attacker"])
        if victim == attacker then
            return
        end

        do
            if victim == lp then
                my_killer = attacker
            end

            if my_killer ~= -1 and attacker ~= lp then
                if my_killer == victim then
                    talk()
                    my_killer = -1
                end
            end
        end

        if attacker == lp then
            talk()
        end
    end)

    client.set_event_callback('round_prestart', function ()
        my_killer = -1
    end)
end

--- region unmute
do
    local function handle_unmute()
        if not settings.tweaks_enable:get() then
            return
        end

        if not settings.tweaks:have_key('Unmute Silenced Players') then
            return
        end

        for i = 1, globals.maxplayers() do
            if entity.get_classname(i) ~= 'CCSPlayer' then
                goto skip
            end

            utils.unmute(i)
            ::skip::
        end
    end

    settings.tweaks:set_callback(handle_unmute)
    settings.tweaks_enable:set_callback(handle_unmute)
    client.set_event_callback('player_connect_full', handle_unmute)
end

---region autopeek
do
    function auto_peek.perform(ctx)
        if not aa_tweaks.enable:get() then
            return
        end

        if not aa_tweaks.items:have_key('Auto Peek Improvements')  then
            return
        end

        if not software.is_quick_peek_assist() then
            return
        end

        ctx.yaw_offset = 0
        ctx.yaw_jitter = 'Off'
        ctx.body_yaw = 'Off'
        ctx.freestanding = true
    end
end

LPH_NO_VIRTUALIZE(function ()
        --- region watermark
    do
        local FRAMERATE_AVG_FRAC = 0.9

        local cl_updaterate = cvar["cl_updaterate"]

        local alpha = 0.0
        local offset = vector(6, 5)

        local timer = 0.0
        local framerate = 0.0

        local last_ping = 0.0
        local last_framerate = 1 / globals.absoluteframetime()

        local last_server_framerate = 0.0
        local last_server_var = 0.0

        local texture do
            http.get("https://i.imgur.com/6viN9T2.png", function(status, response)
                if not status then
                    return
                end

                local code = response.status

                if code >= 200 and code < 300 then
                    texture = renderer.load_png(response.body, 22, 22)
                end
            end)
        end

        local function get_flags()
            return "d"
        end

        local function get_ping(nci)
            if inetchannel.is_loopback(nci) then
                return nil
            end

            local ping = math.max(0, last_ping * 1000)
            ping = math.floor(ping)

            return f("%dms", ping)
        end

        local function get_framerate()
            framerate = FRAMERATE_AVG_FRAC * framerate + (1.0 - FRAMERATE_AVG_FRAC) * globals.absoluteframetime()
            return last_framerate
        end

        local function get_remote_framerate()
            return last_server_framerate, last_server_var
        end

        local function update_timer(nci, dt)
            timer = timer - dt
            if timer > 0 then return end

            do
                local latency = inetchannel.get_latency(nci, 0)
                local update_rate = cl_updaterate:get_float()

                if update_rate > 0.001 then
                    local adjustment = -0.5 / update_rate
                    latency = latency + adjustment
                end

                last_ping = latency
            end

            last_server_framerate, last_server_var = inetchannel.get_remote_framerate(nci)
            last_framerate = framerate > 0 and framerate or 1

            timer = timer + 1.0
        end

        function watermark.frame()
            local can_show_watermark = widgets.enabled:get() and widgets.items:have_key("Watermark")
            alpha = motion.interp(alpha, can_show_watermark, 0.045)

            if alpha <= 0 then
                return
            end

            local lp = entity.get_local_player()
            if lp == nil then
                return
            end

            local nci = iengineclient.get_net_channel_info()
            update_timer(nci, globals.frametime())

            if nci == nil then
                return
            end

            local screen = vector(client.screen_size())
            local pos = vector(screen.x - 9, 9)

            local flags = get_flags()
            local r, g, b = widgets.color_picker:rawget()

            local a = 255

            local radius = 5

            local drawlist = { }

            do
                local label = "AcidTech"
                local build = BUILD

                if texture ~= nil then
                    label = ""
                end

                if build == 'beta' then        
                    build = f("[%s]", build)
                    build = decorations.wave(build, globals.realtime(), 255, 255, 255, 255, r, g, b, a)
                    build = f("%s\affffffff", build)
                    
                    drawlist[#drawlist + 1] = merge({ label, build }, "\x20")
                else    
                    drawlist[#drawlist + 1] = label
                end
            end

            if widgets.display:have_key("Username") then
                local nickname = USERNAME

                if widgets.custom_name:get() then
                    local chosen_nickname = ui.get(widgets.custom_name_value:get_ref())

                    if #chosen_nickname ~= 0 then
                        nickname = chosen_nickname
                    end
                end

                drawlist[#drawlist + 1] = nickname
            end

            if widgets.display:have_key("Latency") then
                drawlist[#drawlist + 1] = get_ping(nci)
            end

            if widgets.display:have_key("FPS") then
                drawlist[#drawlist + 1] = f("%dfps", 1 / get_framerate())
            end

            if widgets.display:have_key("Server frametime") then
                drawlist[#drawlist + 1] = f("sv: %.1f (%.1fms)", get_remote_framerate())
            end

            if widgets.display:have_key("Time") then
                drawlist[#drawlist + 1] = f("%02d:%02d", client.system_time())
            end

            local left_padding = 0

            if texture ~= nil then
                left_padding = 20
            end

            local text = merge(drawlist, " ∙ ")
            local text_size = vector(renderer.measure_text(flags, text))

            local rect_size = vector(text_size.x + offset.x * 2, text_size.y + offset.y * 2)
            rect_size.x = rect_size.x + left_padding

            pos.x = pos.x - rect_size.x

            graphics.header(pos.x, pos.y, rect_size.x, 2, 5, r, g, b, a * alpha)
            --graphics.glow(pos.x, pos.y, rect_size.x, rect_size.y, r, g, b, a * 0.3 * alpha, thickness, radius)
            graphics.rectangle(pos.x, pos.y, rect_size.x, rect_size.y, 0, 0, 0, 100 * alpha, radius)

            if texture ~= nil then
                renderer.texture(texture, pos.x + offset.x - 1, pos.y + (rect_size.y - 21) * 0.5, 22, 22, 255, 255, 255, 255 * alpha, "f")
            end

            graphics.text(
                pos.x + left_padding + offset.x - 1,
                pos.y + (rect_size.y - text_size.y) * 0.5,
                255, 255, 255, 255 * alpha,
                flags, 0, text
            )
        end
    end

        --- region keybinds
    do
        local alpha = 0.0
        local width = 0.0
        local holding = 0.0

        local all_hotkeys = {
    		{
    			ref = { ui.reference("Legit", "Aimbot", "Enabled") },
    			name = "Legit Aimbot",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Legit", "Triggerbot", "Enabled") },
    			name = "Legit Triggerbot",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Rage", "Aimbot", "Enabled") },
    			name = "Rage Aimbot",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Rage", "Aimbot", "Minimum damage override") },
    			name = "Minimum Damage",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Rage", "Aimbot", "Force safe point") },
    			name = "Safe Point",
    			offset = 1
    		},

            {
    			ref = { ui.reference("Rage", "Aimbot", "Force body aim") },
    			name = "Force Body Aim",
    			offset = 1
    		},

    		{
    			ref = { ui.reference("Rage", "Aimbot", "Double tap") },
    			name = "Double Tap",
    			offset = 2
    		},

            {
    			ref = { ui.reference("Rage", "Aimbot", "Quick stop") },
    			name = "Quick Stop",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Rage", "Other", "Quick peek assist") },
    			name = "Quick Peek Assist",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Rage", "Other", "Duck peek assist") },
    			name = "Duck Peek Assist",
    			offset = 1
    		},

    		{
    			ref = { ui.reference("AA", "Anti-aimbot angles", "Freestanding") },
    			name = "Freestanding",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("AA", "Other", "Slow motion") },
    			name = "Slow Motion",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("AA", "Other", "On shot anti-aim") },
    			name = "On Shot Anti-aim",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("AA", "Other", "Fake peek") },
    			name = "Fake Peek",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Misc", "Movement", "Z-Hop") },
    			name = "Z-Hop",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Misc", "Movement", "Pre-speed") },
    			name = "Pre-speed",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Misc", "Movement", "Blockbot") },
    			name = "Blockbot",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Misc", "Movement", "Jump at edge") },
    			name = "Jump At Edge",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Misc", "Miscellaneous", "Last second defuse") },
    			name = "Last Second Defuse",
    			offset = 1
    		},

    		{
    			ref = { ui.reference("Misc", "Miscellaneous", "Free look") },
    			name = "Free Look",
    			offset = 1
    		},

    		{
    			ref = { ui.reference("Misc", "Miscellaneous", "Ping spike") },
    			name = "Ping Spike",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Misc", "Miscellaneous", "Automatic grenade release") },
    			name = "Grenade Release",
    			offset = 2
    		},

    		{
    			ref = { ui.reference("Visuals", "Player ESP", "Activation type") },
    			name = "Visuals",
    			offset = 1
    		}
        }

        local active_keys = { }
        local hotkey_modes = { "holding", "toggled", "disabled" }

        local function get_flags()
            return "d"
        end

        local function get_handle()
            local flags = get_flags()
            local existent_keys = { }

            local all_active = false
            local name_width, mode_width = 0, 0

            for i = 1, #all_hotkeys do
                local hotkey = all_hotkeys[i]
                local unique_id = hotkey.ref[1]

                local name = hotkey.name
                local offset = hotkey.offset or 1

                local active = true
                local collected = { }

                for j = 1, offset do
                    collected[j] = hotkey.ref[j]
                end

                for j = 1, offset do
                    if not ui.get(collected[j]) then
                        active = false
                        break
                    end
                end

                if active then
                    existent_keys[unique_id] = true
                    all_active = true
                end

                local _, mode = ui.get(collected[#collected])
                if mode == 0 then goto continue end

                mode = hotkey_modes[mode] or "~"
                mode = merge { "[", mode, "]" }

                if active_keys[unique_id] == nil then
                    active_keys[unique_id] = {
                        alpha = 0,
                        height = 0,

                        name_width = 0,
                        mode_width = 0,

                        name = name,
                        mode = mode
                    }
                end

                local value = active_keys[unique_id] do
                    local name_size = vector(renderer.measure_text(flags, name))
                    local mode_width = vector(renderer.measure_text(flags, mode))

                    value.name = name
                    value.mode = mode

                    value.height = math.max(name_size.y, mode_width.y)

                    value.name_width = name_size.x
                    value.mode_width = mode_width.x
                end

                ::continue::
            end

            for k, v in pairs(active_keys) do
                local active = existent_keys[k] ~= nil

                v.alpha = motion.interp(v.alpha, active, 0.045)

                if v.alpha <= 0 then
                    active_keys[k] = nil
                elseif active or v.alpha >= 0.25 then
                    if name_width < v.name_width then
                        name_width = v.name_width
                    end

                    if mode_width < v.mode_width then
                        mode_width = v.mode_width
                    end
                end
            end

            return active_keys, all_active, name_width, mode_width
        end

        keybinds.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Keybinds")
        : record("visuals", "keybinds::enabled")
        : save()

        keybinds.window = windows.new("##keybinds", 0.025, 0.415)
        keybinds.window:set_size(vector(125, 22))

        function keybinds.frame()
            local me = entity.get_local_player()
            if me == nil then return end

            local window = keybinds.window
            local hotkeys, all_active, name_width, mode_width = get_handle()

            local menu_check = ui.is_menu_open() or (next(hotkeys) ~= nil and all_active)
            local can_show_hotkeys = widgets.enabled:get() and widgets.items:have_key("Keybinds") and menu_check

            alpha = motion.interp(alpha, can_show_hotkeys, 0.045)
            holding = motion.interp(holding, (can_show_hotkeys and window:is_dragging()) and 0.6 or 1.0, 0.045)

            if alpha <= 0 then
                return
            end

            local flags = get_flags()
            local r, g, b = widgets.color_picker:get()

            local a = 255

            local radius = 5
            local thickness = 10

            local offset_ins = vector(10, 5)

            local keyval_gap = 20
            local keyval_rounding = math.floor(radius * .5)

            -- header
            local pos = window.pos

            local text = "keybinds"
            local text_size = vector(renderer.measure_text(flags, text))
            local text_size_base = vector(renderer.measure_text(flags, "\v"))

            width = motion.interp(width, math.max(
                offset_ins.x * 4 + text_size.x * (text_size.y / text_size_base.y),
                keyval_rounding * 2 + name_width + mode_width + keyval_gap,
                125
            ), 0.045)

            local max_width = math.floor(width + 0.85)
            local rect_size = vector(max_width, text_size.y + offset_ins.y * 2)

            if alpha > 0.5 then
                graphics.blur(pos.x, pos.y, rect_size.x, rect_size.y)
            end

            graphics.header(pos.x, pos.y, rect_size.x, 2, 5, r, g, b, a * alpha * holding)
            graphics.glow(pos.x, pos.y, rect_size.x, rect_size.y, r, g, b, a * 0.3 * alpha * holding, thickness, radius)
            graphics.rectangle(pos.x, pos.y, rect_size.x, rect_size.y, 0, 0, 0, 100 * alpha * holding, radius)

            renderer.text(
                pos.x + (rect_size.x - text_size.x) * 0.5,
                pos.y + (rect_size.y - text_size.y) * 0.5,
                255, 255, 255, 255 * alpha * holding,
                flags, 0, text
            )

            -- contents
            local offset = 2

            for _, v in pairs(active_keys) do
                local alpha = alpha * v.alpha
                local text_size, text_alpha = vector(v.name_width, v.height), 0

                if alpha >= 0.25 then
                    text_alpha = math.min(1.0, utils.map(alpha, 0.25, 1.0, 0.0, 1.2))
                end

                local text_position = vector(pos.x + keyval_rounding, pos.y + rect_size.y + 4 + offset)

                local value_start = rect_size.x - v.mode_width
                local value_alpha = utils.map(value_start - v.name_width, 0.0, keyval_gap, 0.0, 1.0, true)

                local h_alpha = text_alpha * holding

                renderer.text(text_position.x, text_position.y, 255, 255, 255, 255 * h_alpha, flags, 0, v.name)
                renderer.text(text_position.x + rect_size.x - keyval_rounding * 2 - v.mode_width, text_position.y, 255, 255, 255, 255 * h_alpha * value_alpha, flags, 0, v.mode)

                offset = offset + text_alpha * (text_size.y + text_size.y * 0.35)
            end

            window:set_size(rect_size)
            window:update()
        end
    end

        --- region indicators
    do
        local alpha = 0.0
        local align = 0.0

        local damage_alpha = 0.0
        local damage_value = 0.0
        local damage_moving = 0.0
        local damage_holding = 0.0

        local screen = vector(client.screen_size())
        local window = windows.new("##damage", 0.5 + 15 / screen.x, 0.5 - 15 / screen.y)

        window:set_anchor(vector(0.0, 1.0))
        window:set_size(vector(22, 22))

        local features = {
            {
                get = software.is_double_tap,
                text = "DT",
                alpha = 0
            },

            {
                get = software.is_on_shot_antiaim,
                text = "HS",
                alpha = 0
            },

            {
                get = software.is_duck_peek_assist,
                text = "FD",
                alpha = 0
            },

            {
                get = software.is_minimum_damage_override,
                text = "DMG",
                alpha = 0
            }
        }

        local function get_statement()
            if software.is_edge() then
                return 'EDGE'
            end

            if safe_head.get() then
                return "SAFE"
            end

            if localplayer.is_airborne then
                return "AIR"
            end

            if localplayer.is_crouched then
                return "CROUCH"
            end

            if localplayer.is_moving then
                if software.is_slow_motion() then
                    return "S.WALK"
                end

                return "RUN"
            end

            return "STAND"
        end

        ctx_bebra.condition = get_statement

        function indicators.frame()
            local me = entity.get_local_player()
            if me == nil then return end

            local wpn = entity.get_player_weapon(me)
            if wpn == nil then return end

            local wpn_info = csgo_weapons(wpn)
            if wpn_info == nil then return end

            local menu_check = ui.is_menu_open()
            local alive_check = entity.is_alive(me)

            local scoped_check = entity.get_prop(me, "m_bIsScoped")
            local grenade_check = wpn_info.weapon_type_int == 9

            local damage = software.get_minimum_damage()

            local can_show_indicators = widgets.enabled:get() and widgets.items:have_key("Crosshair Indicator") and alive_check
            local can_move_indicators = can_show_indicators and scoped_check == 1

            local can_show_damage = widgets.enabled:get() and widgets.items:have_key("Damage Indicator") and not (wpn_info.weapon_type_int == 0 or wpn_info.weapon_type_int == 9)
            local can_move_damage = can_show_damage and menu_check

            alpha = motion.interp(alpha, can_show_indicators and (grenade_check and 0.4 or 1.0) or 0.0, 0.045)
            align = motion.interp(align, can_move_indicators, 0.045)

            damage_alpha = motion.interp(damage_alpha, can_show_damage, 0.045)
            damage_value = motion.interp(damage_value, damage, 0.045)
            damage_moving = motion.interp(damage_moving, can_move_damage, 0.045)
            damage_holding = motion.interp(damage_holding, (can_move_damage and window:is_dragging()) and 0.6 or 1.0, 0.045)

            local flags = "-d"
            local clock = globals.realtime()

            local screen = vector(client.screen_size())
            local center = screen * 0.5

            local r1, g1, b1 = widgets.color_picker:rawget()
            local r2, g2, b2, a2 = 255, 255, 255, 255

            local r, g, b, a = utils.color_lerp(
                r1, g1, b1, 255,
                r2, g2, b2, a2,
                utils.breathe(clock + 0.5 - 0.5 * align)
            )

            -- damage
            if damage_alpha > 0 then
                local value = utils.round(damage_value)
                local text = f("%d", value)

                if damage == 0 then
                    text = "AUTO"
                end

                if value > 100 then
                    text = f("HP +%d", value - 100)
                end

                local measure = vector(renderer.measure_text(flags, text))
                measure.x = measure.x + 1

                local pos = window.pos:clone()
                local rect_size = vector(measure.x + 18, measure.y + 16)

                local text_position = pos:clone()

                text_position.x = text_position.x + (rect_size.x - measure.x) * 0.5
                text_position.y = text_position.y + (rect_size.y - measure.y) * 0.5

                if damage_moving > 0 then
                    graphics.rectangle_outline(pos.x, pos.y, rect_size.x, rect_size.y, 255, 255, 255, 128 * damage_moving * damage_holding, 7)
                end

                local r3, g3, b3 = r, g, b
                if not can_show_indicators then
                    r3 = r1
                    g3 = g1
                    b3 = b1
                end

                renderer.text(text_position.x - 1, text_position.y, r3, g3, b3, a * damage_alpha * damage_holding, flags, 0, text)

                window:set_size(rect_size)
                window:update()
            end

            if alpha <= 0 then
                return
            end

            -- header
            local pos = center:clone()

            pos.x = pos.x + utils.round(10 * align)
            pos.y = pos.y + 20

            do
                local text = "A C I D T E C H"

                local measure = vector(renderer.measure_text(flags, text))
                measure.x = measure.x + 1

                local text_position = pos:clone()
                local text_offset = (measure.x * 0.5) * (1 - align)

                text_position.x = text_position.x - utils.round(text_offset)

                -- graphics.glow(text_position.x + 1, text_position.y + 2, measure.x, 4, r, g, b, a * alpha * 0.1, 10, 1)
                -- renderer.rectangle(text_position.x + 1, text_position.y + 2, measure.x, 4, r, g, b, a * alpha * 0.1)

                text = decorations.wave(text, clock, r1, g1, b1, 255, r2, g2, b2, a2)
                graphics.text(text_position.x, text_position.y, r, g, b, a * alpha, flags, 0, text)

                pos.y = pos.y + measure.y
            end

            do
                local text = get_statement()

                local measure = vector(renderer.measure_text(flags, text))
                measure.x = measure.x + 1

                local text_position = pos:clone()
                local text_offset = (measure.x * 0.5) * (1 - align)

                text_position.x = text_position.x - utils.round(text_offset)

                renderer.text(text_position.x, text_position.y, r, g, b, a * alpha, flags, 0, text)
                pos.y = pos.y + measure.y
            end

            for i = 1, #features do
                local feature = features[i]

                local value_check = feature.get()
                local can_show_feature = can_show_indicators and value_check

                feature.alpha = motion.interp(feature.alpha, can_show_feature, 0.045)

                if feature.alpha <= 0 then
                    goto continue
                end

                local text = feature.text
                local alpha = feature.alpha * alpha

                local measure = vector(renderer.measure_text(flags, text))
                measure.x = measure.x + 1

                local text_position = pos:clone()
                local text_offset = (measure.x * 0.5) * (1 - align)

                text_position.x = text_position.x - utils.round(text_offset)

                renderer.text(text_position.x, text_position.y, r, g, b, a * alpha, flags, 0, text)
                pos.y = pos.y + utils.round(measure.y * feature.alpha)

                ::continue::
            end
        end
    end

        ---region arrows
    do
        local alpha = 0
        local left_alpha = 0
        local right_alpha = 0

        local screen = vector(client.screen_size()) * .5

        function arrows.frame()
            local lp = entity.get_local_player()
            if lp == nil then
                return
            end

            local wpn = entity.get_player_weapon(lp)
            if wpn == nil then return end

            local wpn_info = csgo_weapons(wpn)
            if wpn_info == nil then return end

            local can_show_arrows = manual_direction.enabled:get() and manual_direction.arrows:get() and entity.is_alive(lp)
            local can_move_indicators = can_show_indicators and scoped_check == 1

            alpha = motion.interp(alpha, can_show_arrows and (wpn_info.weapon_type_int == 9 and 0.4 or 1.0) or 0.0, 0.045)
            if alpha <= 0 then
                return
            end

            local r, g, b, a = manual_direction.color:rawget()
            a = 255 * alpha

            local manual_direction = manual_direction.get()

            left_alpha = motion.interp(left_alpha, manual_direction == 0 and 1 or 0, 0.045)
            if left_alpha ~= 0 then
                renderer.text(screen.x - 50, screen.y - 16, r, g, b, a * left_alpha, '+', nil, '<')
            end

            right_alpha = motion.interp(right_alpha, manual_direction == 1 and 1 or 0, 0.045)
            if right_alpha ~= 0 then
                renderer.text(screen.x + 39, screen.y - 16, r, g, b, a * right_alpha, '+', nil, '>')
            end
        end
    end

        --- region velocity_warning
    do
        local alpha = 0.0
        local holding = 0.0
        local hovering = 0.0

        local function renderer_bar(x, y, w, h, r, g, b, a, pct)
            --graphics.glow(x, y, w, h, r, g, b, a * 0.15, 222, h * 0.5)
            renderer.rectangle(x, y, w, h, 0, 0, 0, a)
            renderer.rectangle(x + 1, y + 1, (w - 2) * pct, h - 2, r, g, b, a)
        end

        velocity_warning.window = windows.new("##velocity_warning", 0.5, 0.3)

        velocity_warning.window:set_anchor(vector(0.5, 0.0))
        velocity_warning.window:set_size(vector(180, 4))

        function velocity_warning.frame()
            local me = entity.get_local_player()
            if me == nil then return end

            local window = velocity_warning.window
            local modifier = entity.get_prop(me, "m_flVelocityModifier")

            local menu_check = ui.is_menu_open()

            local alive_check = entity.is_alive(me)
            local velocity_check = modifier < 1.0

            local is_dragging = window:is_dragging()
            local is_hovering = window:is_hovering()

            local can_show_warning = widgets.enabled:get() and widgets.items:have_key("Velocity Warning") and ((alive_check and velocity_check) or menu_check)

            alpha = motion.interp(alpha, can_show_warning, 0.045)
            holding = motion.interp(holding, (can_show_warning and is_dragging) and 0.6 or 1.0, 0.045)
            hovering = motion.interp(hovering, (can_show_warning and is_hovering and not is_dragging) and 1.0 or 0.0, 0.045)

            if alpha <= 0 then
                return
            end

            if menu_check and (not velocity_check or not alive_check) then
                modifier = math.min(1, globals.tickcount() % 200 / 150)
            end

            local flags = "d"
            local percent = (1 - modifier) * 100

            local r, g, b = widgets.color_picker:get()

            local a = 255

            if modifier < 1.0 then
                r = utils.lerp(255, r, modifier)
                g = utils.lerp(75, g, modifier)
                b = utils.lerp(75, b, modifier)
            end

            -- indication
            local pos = window.pos:clone()
            local size = window.size:clone()

            local text = f("Max velocity was reduced by %d%%", percent)
            local text_size = vector(renderer.measure_text(flags, text))

            renderer.text(
                pos.x + (size.x - text_size.x) * 0.5,
                pos.y,
                255, 255, 255, 255 * alpha * holding,
                flags, 0, text
            )

            pos.y = pos.y + text_size.y
            pos.y = pos.y + 5

            local bar_pos = pos:clone()
            local bar_size = vector(text_size.x + 28, 4)

            renderer_bar(bar_pos.x, bar_pos.y, bar_size.x, bar_size.y, r, g, b, a * alpha * holding, modifier)
            pos.y = pos.y + bar_size.y + 5

            if hovering > 0 then
                renderer.text(
                    pos.x,
                    pos.y,
                    255, 255, 255, 255 * alpha * hovering,
                    flags, 0, "Press M2 to center."
                )
            end

            local window_size = vector(math.max(text_size.x, bar_size.x), text_size.y + bar_size.y + 5)

            if is_hovering and not is_dragging and client.key_state(0x02) then
                local screen = vector(client.screen_size())

                window:set_pos(vector(
                    (screen.x - size.x) * 0.5,
                    window.pos.y
                ))
            end

            window:set_size(window_size)
            window:update()
        end
    end

        --- region custom scope
    do
        custom_scope.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Custom Scope Overlay")
        : record("aa", "custom_scope::enabled")
        : save()

        custom_scope.color = menu.new_item(ui.new_color_picker, "AA", "Anti-aimbot angles", "Color", 255, 255, 255, 255)
        : record("aa", "custom_scope::color")
        : save()

        custom_scope.mode = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", "Mode", { 'Default', 'T' })
        : record("aa", "custom_scope::mode")
        : save()

        custom_scope.position = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", "\nPosition", 0, 500, 50, true, 'px')
        : record("aa", "custom_scope::position")
        : save()

        custom_scope.offset = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", "\nOffset", 0, 500, 10, true, 'px')
        : record("aa", "custom_scope::offset")
        : save()

        local alpha = 0
        client.set_event_callback('paint_ui', function ()
            ui.set(software.visuals.scope_overlay, true)
        end)

        client.set_event_callback('paint', function ()
            if not custom_scope.enabled:get() then
                return
            end

            ui.set(software.visuals.scope_overlay, false)

            local lp = entity.get_local_player()
            if lp == nil then
                return
            end

            local width, height = client.screen_size()
            local offset, position = custom_scope.offset:get() * height / 1080, custom_scope.position:get() * height / 1080

            local condition = entity.get_prop(lp, 'm_bIsScoped') == 1 and entity.get_prop(lp, 'm_bResumeZoom') == 0
            alpha = motion.interp(alpha, condition, 0.045)
            if alpha < 0.001 then
                return
            end

            local clr = { custom_scope.color:rawget() }

            local clr1 = { clr[1], clr[2], clr[3], 0 }
            local clr2 = { clr[1], clr[2], clr[3], clr[4] * alpha }
            local mode = custom_scope.mode:get()

            if mode ~= 'T' then
                renderer.gradient(
                    width / 2, height / 2 - position + 2,
                    1, position - offset,
                    clr1[1], clr1[2], clr1[3], clr1[4],
                    clr2[1], clr2[2], clr2[3], clr2[4],
                    false
                )
            end

            renderer.gradient(
                width / 2, height / 2 + offset,
                1, position - offset,
                clr2[1], clr2[2], clr2[3], clr2[4],
                clr1[1], clr1[2], clr1[3], clr1[4],
                false
            )

            renderer.gradient(
                width / 2 - position + 2, height / 2,
                position - offset, 1,
                clr1[1], clr1[2], clr1[3], clr1[4],
                clr2[1], clr2[2], clr2[3], clr2[4],
                true
            )

            renderer.gradient(
                width / 2 + offset, height / 2,
                position - offset, 1,
                clr2[1], clr2[2], clr2[3], clr2[4],
                clr1[1], clr1[2], clr1[3], clr1[4],
                true
            )
        end)

        defer(function ()
            ui.set_visible(software.visuals.scope_overlay, true)
        end)
    end

    --- hit marker acidtech
    do
        local ctx = {
            target = 0,
            pos = vector()
        }

        local pending_markers = { }

        function hit_marker.frame()
            if not settings.tweaks_enable:get() then
                return
            end

            if not settings.tweaks:have_key('Damage Marker') then
                return
            end

            local realtime = globals.realtime()
            for i, data in ipairs(pending_markers) do
                local diff = data[3] - realtime

                local alpha = math.min(1, diff)--diff < 1 and math.max(0, diff) or 1

                local x, y = renderer.world_to_screen(data[1].x, data[1].y, data[1].z)

                local r, g, b = unpack(data[4])
                renderer.text(x, y, r, g, b, 255 * alpha, "c", nil, data[2])

                if data[3] < realtime then
                    table.remove(pending_markers, i)
                end
            end
        end

        function hit_marker.aim_fire(e)
            if not settings.tweaks_enable:get() then
                return
            end

            if not settings.tweaks:have_key('Damage Marker') then
                return
            end

            ctx.target = e.target
            ctx.pos = vector(e.x, e.y, e.z)
        end

        function hit_marker.aim_hit(e)
            if not settings.tweaks_enable:get() then
                return
            end

            if not settings.tweaks:have_key('Damage Marker') then
                return
            end

            if ctx.target == e.target then
                table.insert(
                    pending_markers,
                    {
                        ctx.pos, tostring(e.damage),
                        globals.realtime() + 3,
                        e.hitgroup == 1 and { widgets.color_picker:rawget() } or { 240, 240, 240 }
                    }
                )
            end
        end

        function hit_marker.round_prestart()
            table.clear(pending_markers)
        end
    end

        ---region reatdfdfsd
    do
        local kills = 0

        client.set_event_callback('player_death', function (e)
            if client.userid_to_entindex(e.attacker) ~= entity.get_local_player() then
                return
            end

            kills = kills + 1
        end)

        local x, y = client.screen_size()

        client.set_event_callback('paint', function ()
            local enabled = widgets.enabled:get() and (widgets.items:have_key('Watermark') or widgets.items:have_key('Crosshair Indicator'))
            if enabled then
                return
            end

            if kills < 2 then
                return
            end

            local r, g, b, a = widgets.color_picker:rawget()

            local str = decorations.wave('AcidTech', globals.realtime(), r, g, b, 200, 255, 255, 255, 200)

            renderer.text(x * .5, y - 15, 255, 255, 255, a, 'cd', nil, str)
        end)

        client.set_event_callback('round_end', function (e)
            kills = 0
        end)
    end
end)()

--- region console filter
do
    cvar.con_filter_text:set_string("[gamesense]")

    local function apply_con_filter()
        cvar.con_filter_enable:set_raw_int(
            (settings.tweaks_enable:get() and settings.tweaks:have_key('Console Filter'))
                and 1 or 0
        )
    end

    settings.tweaks:set_callback(apply_con_filter)
    settings.tweaks_enable:set_callback(apply_con_filter)
    apply_con_filter()

    defer(function ()
        cvar.con_filter_enable:set_raw_int(0)
    end)
end

---region anim_breakers
do
    anim_breakers.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Animation Breakers")
    : record("aa", "anim_breakers::enabled")
    : save()

    anim_breakers.ground = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", '- Leg Movement', { "Default", 'Static', 'Walking' })
    : record("aa", "anim_breakers::ground")
    : save()

    anim_breakers.air = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", '- In Air', { "Default", 'Static', 'Walking' })
    : record("aa", "anim_breakers::air")
    : save()

    local native_GetClientEntity = vtable_bind('client.dll', 'VClientEntityList003', 3, 'void*(__thiscall*)(void*, int)')

    local char_ptr = ffi.typeof('char*')
    local nullptr = ffi.new('void*')
    local class_ptr = ffi.typeof('void***')

    local animation_layer_t = ffi.typeof([[
        struct {										char pad0[0x18];
            uint32_t	sequence;
            float		prev_cycle;
            float		weight;
            float		weight_delta_rate;
            float		playback_rate;
            float		cycle;
            void		*entity;						char pad1[0x4];
        } **
    ]])

    client.set_event_callback('net_update_end', function ()
        if not anim_breakers.enabled:get() then
            override.unset(software.aa.other.leg_movement)
            return
        end

        local lp = entity.get_local_player()
        if lp == nil then
            return
        end

        local player_ptr = ffi.cast(class_ptr, native_GetClientEntity(lp))
        if player_ptr == nullptr then
            return
        end

        local anim_layers = ffi.cast(animation_layer_t, ffi.cast(char_ptr, player_ptr) + 0x2990)[0]

        do
            local mode = anim_breakers.ground:get()
            if mode ~= 'Disabled' then
                if mode == 'Static' then
                    entity.set_prop(lp, 'm_flPoseParameter', 1, 0)
                    override.set(software.aa.other.leg_movement, 'Always slide')
                elseif mode == 'Walking' then
                    entity.set_prop(lp, 'm_flPoseParameter', 0.5, 7)
                    override.set(software.aa.other.leg_movement, 'Never slide')
                end
            else
                override.unset(software.aa.other.leg_movement)
            end
        end

        do
            local mode = anim_breakers.air:get()
            if mode ~= 'Disabled' and ctx_bebra.condition() == 'AIR' then
                if mode == 'Static' then
                    entity.set_prop(lp, 'm_flPoseParameter', 1, 6)
                elseif mode == 'Walking' then
                    anim_layers[6]['weight'] = 1
                end
            end
        end
    end)
end

client.set_event_callback('setup_command', function (cmd)
    local lp = entity.get_local_player()
    if lp == nil then
        return
    end

    local weapon = entity.get_player_weapon(lp)
    if weapon == nil then
        return
    end

    if entity.get_classname(weapon) == 'CC4' then
        return
    end

    if entity.get_prop(lp, 'm_bInBombZone') == 1 then
        cmd.in_use = 0
    end
end)

--- region angles
do
    local function set_custom_list(ctx, list)
        if list.pitch ~= nil then
            ctx.pitch = list.pitch:get()
            ctx.pitch_offset = list.pitch_offset:get()
        end

        if list.yaw_base ~= nil then
            ctx.yaw_base = list.yaw_base:get()
        end

        ctx.yaw = list.yaw:get()
        ctx.yaw_offset = list.yaw_offset:get()

        if ctx.yaw == "180 LR" then
            ctx.yaw_offset = 0
        end

        ctx.yaw_180lr_mode = list.yaw_180lr_mode:get()
        ctx.yaw_delay = list.yaw_delay:get()
        ctx.yaw_left = list.yaw_left:get()
        ctx.yaw_right = list.yaw_right:get()

        ctx.yaw_jitter = list.yaw_jitter:get()
        ctx.jitter_mode = list.jitter_mode:get()
        ctx.acid_cycle = list.acid_cycle:get()
        ctx.acid_delay = list.acid_delay:get()
        ctx.acid_safe = list.acid_safe:get()
        ctx.jitter_offset = list.jitter_offset:get()
        ctx.jitter_randomization = list.jitter_randomization:get()

        ctx.body_yaw = list.body_yaw:get()
        ctx.body_yaw_offset = list.body_yaw_offset:get()
        ctx.freestanding_body_yaw = list.freestanding_body_yaw:get()
    end

    angles.type = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", "Anti Aim Builder", {
        "Off",
        "Custom",
        "Recommended"
    })
    : record("aa", "angles::type")
    : save()

    local conds = { 'Standing', 'Moving', 'Slow Walk', 'Crouched', 'Move Crouched', 'Air', 'Air Crouched', 'Fake Lag'}

    local function reset_delay()
        for _, condition in next, conds do
            delay_data_all[condition] = {
                ticks = 0,
                is_active = false,
                current = 0,
                previous_angle = 0
            }
        end
    end

    reset_delay()

    angles.custom = { } do
        angles.custom.state = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", "State", { unpack(e_statement, 0) })
        : record("aa", "custom::state")

        for i = 0, #e_statement do
            local list = { }
            local state = e_statement[i]

            if i ~= 0 then
                list.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", merge { "Enable", "\x20", state })
                : record("aa", merge { "custom", "::", state, "::", "enabled" })
                : save()
            end

            if i ~= 10 then
                local pitch_list = { "Off", "Default", "Up", "Down", "Minimal", "Random", "Custom" }

                list.pitch = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "Pitch", "\n", "custom_", "pitch_", state }, pitch_list)
                : record("aa", merge { "custom", "::", state, "::", "pitch" })
                : save()

                list.pitch_offset = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "\n", "custom_", "pitch_offset_", state }, -89, 89, 0, true, "°")
                : record("aa", merge { "custom", "::", state, "::", "pitch_offset" })
                : save()

                list.yaw_base = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "Yaw base", "\n", "custom_", "yaw_base_", state }, { "Local view", "At targets" })
                : record("aa", merge { "custom", "::", state, "::", "yaw_base" })
                : save()
            end

            list.yaw = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "Yaw", "\n", "custom_", "yaw_", state }, { "Off", "180", "Spin", "Static", "180 Z", "Crosshair", "180 LR" })
            : record("aa", merge { "custom", "::", state, "::", "yaw" })
            : save()

            list.yaw_offset = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "\n", "custom_", "yaw_offset_", state }, -180, 180, 0, true, "°")
            : record("aa", merge { "custom", "::", state, "::", "yaw_offset" })
            : save()

            list.yaw_180lr_mode = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "\n", "custom_", "yaw_180lr_mode_", state }, { "Side based", "Switch delay" })
            : record("aa", merge { "custom", "::", state, "::", "yaw_180lr_mode" })
            : save()

            list.yaw_left = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "Left offset", "\n", "custom_", "yaw_left_", state }, -180, 180, 0, true, "°")
            : record("aa", merge { "custom", "::", state, "::", "yaw_left" })
            : save()

            list.yaw_right = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "Right offset", "\n", "custom_", "yaw_right_", state }, -180, 180, 0, true, "°")
            : record("aa", merge { "custom", "::", state, "::", "yaw_right" })
            : save()

            list.yaw_delay = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "Delay", "\n", "custom_", "Delay_", state }, 2, 10, 5, true, "t")
            : record("aa", merge { "custom", "::", state, "::", "yaw_delay" })
            : save()

            list.yaw_jitter = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "Yaw jitter", "\n", "custom_", "yaw_jitter_", state }, { "Off", "Offset", "Center", "Random", "Skitter", "AcidTech" })
            : record("aa", merge { "custom", "::", state, "::", "yaw_jitter" })
            : save()

            list.jitter_mode = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "\n", "custom_", "jitter_mode_", state }, { "2-Way", "3-Way", "5-Way" })
            : record("aa", merge { "custom", "::", state, "::", "jitter_mode" })
            : save()

            list.jitter_offset = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "\nJitter offset", "\n", "custom_", "jitter_offset_", state }, -180, 180, 0, true, "°")
            : record("aa", merge { "custom", "::", state, "::", "jitter_offset" })
            : save()

            list.jitter_randomization = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "Randomization", "\n", "custom_", "jitter_randomization_", state }, 0, 180, 0, true, "°", 1, { [0] = "Off" })
            : record("aa", merge { "custom", "::", state, "::", "jitter_randomization" })
            : save()

            list.acid_cycle = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "Delay Cycle", "\n", "custom_", "delay_cycle_", state }, 5, 200, 50, true, '', 1, { [5] = "Off" })
            : record("aa", merge { "custom", "::", state, "::", "acid_cycle" })
            : save()

            list.acid_delay = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "Delay Time", "\n", "custom_", "acid_delay", state }, 5, 30, 15)
            : record("aa", merge { "custom", "::", state, "::", "acid_delay" })
            : save()

            list.acid_safe = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", merge { "Safe Yaw", "\n", "custom_", "safe_yaw_", state })
            : record("aa", merge { "custom", "::", state, "::", "acid_safe" })
            : save()

            list.body_yaw = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", merge { "Body yaw", "\n", "custom_", "body_yaw_", state }, { "Off", "Opposite", "Jitter", "Static", 'Randomize Jitter' })
            : record("aa", merge { "custom", "::", state, "::", "body_yaw" })
            : save()

            list.body_yaw_offset = menu.new_item(ui.new_slider, "AA", "Anti-aimbot angles", merge { "\n", "custom_", "body_yaw_offset_", state }, -180, 180, 0, true, "°")
            : record("aa", merge { "custom", "::", state, "::", "body_yaw_offset" })
            : save()

            list.freestanding_body_yaw = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", merge { "Freestanding body yaw", "\n", "custom_", "freestanding_body_yaw_", state })
            : record("aa", merge { "custom", "::", state, "::", "freestanding_body_yaw" })
            : save()


            list.acid_safe:set_callback(reset_delay)
            list.acid_delay:set_callback(reset_delay)
            list.acid_cycle:set_callback(reset_delay)

            angles.custom[state] = list
        end
    end

    angles.recommended = {
        ['Standing'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 10
            ctx.yaw_jitter = 'Skitter'
            ctx.jitter_offset = 35
            ctx.body_yaw = 'Jitter'
            ctx.body_yaw_offset = -40
        end,

        ['Moving'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 10
            ctx.yaw_jitter = 'Center'
            ctx.jitter_offset = 60
            ctx.body_yaw = 'Jitter'
            ctx.body_yaw_offset = -40
        end,

        ['Slow Walk'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 10
            ctx.yaw_jitter = 'AcidTech'
            ctx.jitter_mode = '2-Way'
            ctx.jitter_offset = 60
            ctx.jitter_randomization = 15
            ctx.acid_cycle = 32
            ctx.acid_delay = 18
            ctx.acid_safe = true
            ctx.body_yaw = 'Jitter'
            ctx.body_yaw_offset = -40
        end,

        ['Crouched'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 10
            ctx.yaw_jitter = 'Center'
            ctx.jitter_offset = 70
            ctx.body_yaw = 'Jitter'
            ctx.body_yaw_offset = -40
        end,

        ['Move Crouched'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 10
            ctx.yaw_jitter = 'Center'
            ctx.jitter_offset = 60
            ctx.body_yaw = 'Jitter'
            ctx.body_yaw_offset = -40
        end,

        ['Air'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 0
            ctx.yaw_jitter = 'Off'
            ctx.jitter_offset = 0
            ctx.body_yaw = 'Opposite'
            ctx.body_yaw_offset = 0
            ctx.freestanding_body_yaw = true
        end,

        ['Air Crouched'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 0
            ctx.yaw_jitter = 'Off'
            ctx.jitter_offset = 0
            ctx.body_yaw = 'Opposite'
            ctx.body_yaw_offset = 0
            ctx.freestanding_body_yaw = true
        end,

        ['Fake Lag'] = function (ctx)
            ctx.pitch = 'Default'
            ctx.yaw_base = 'At targets'
            ctx.yaw = '180'
            ctx.yaw_offset = 0
            ctx.yaw_jitter = 'Off'
            ctx.jitter_offset = 0
            ctx.body_yaw = 'Opposite'
            ctx.body_yaw_offset = 0
            ctx.freestanding_body_yaw = true
        end
    }

    function angles.set(ctx, state)
        if angles.type:get() == "Custom" then
            local list = angles.custom[state]

            if list ~= nil then
                -- if not enabled in menu
                if list.enabled ~= nil then
                    if not list.enabled:get() then
                        return false
                    end
                end

                set_custom_list(ctx, list)
                return true
            end

            return false
        end

        if angles.type:get() == "Recommended" then
            local fn = angles.recommended[state]

            if fn ~= nil then
                fn(ctx)
                return true
            end

            return false
        end

        return false
    end

    function angles.update(ctx)
        local list = statement.get()

        for i = #list, 1, -1 do
            local state = list[i]

            if angles.set(ctx, state) then
                return
            end
        end

        angles.set(ctx, "Main")
    end
end

--- region yaw_direction
do

    yaw_direction.edge_yaw = menu.new_item(ui.new_hotkey, "AA", "Anti-aimbot angles", merge { "Edge Yaw", "\n", "yaw_direction::edge_yaw" })
    : record("aa", "yaw_direction::edge_yaw")

    yaw_direction.freestanding = menu.new_item(ui.new_hotkey, "AA", "Anti-aimbot angles", merge { "Freestanding", "\n", "yaw_direction::freestanding" })
    : record("aa", "yaw_direction::freestanding")

    fs_disablers.states = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", merge { "- Disable On", "\n", "fs_disablers::states" }, {"Standing", "Moving", "Slow Walk", "Crouched", "Air" })
    : record("aa", "fs_disablers::states")
    : save()

    function yaw_direction.update(ctx)
        if not aa_tweaks.enable:get() then
            return
        end

        if aa_tweaks.items:have_key('Edge Yaw on FD') and software.is_duck_peek_assist() then
            ctx.edge_yaw = true, 1
        else
            ctx.edge_yaw = yaw_direction.edge_yaw:rawget()
        end

        ctx.freestanding = yaw_direction.freestanding:rawget()
    end
end

--- region freestqand disaskdfkskd
do
    local function get_statement()
        if localplayer.is_airborne then
            return "Air"
        end

        if localplayer.is_crouched then
            return "Crouched"
        end

        if localplayer.is_moving then
            if software.is_slow_motion() then
                return "Slow Walk"
            end

            return "Moving"
        end

        return "Standing"
    end

    function fs_disablers.update(ctx)
        local state = get_statement()
        if state == nil then
            return
        end

        if not fs_disablers.states:have_key(state) then
            return
        end

        ctx.freestanding = false
    end
end

--- clientside nickname
do
    clientside_nickname.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Client-Side Nickname")
    : record("visuals", "clientside_nickname::enabled")
    : save()

    clientside_nickname.nickname = menu.new_item(ui.new_textbox, "AA", "Anti-aimbot angles", "Nickname")
    : record("visuals", "clientside_nickname::nickname")
    : save()

    local panorama = panorama.open()

    local native_BaseLocalClient_base = ffi.cast("uintptr_t**", memory.pattern_scan("engine.dll", "A1 ? ? ? ? 0F 28 C1 F3 0F 5C 80 ? ? ? ? F3 0F 11 45 ? A1 ? ? ? ? 56 85 C0 75 04 33 F6 EB 26 80 78 14 00 74 F6 8B 4D 08 33 D2 E8 ? ? ? ? 8B F0 85 F6", 1))

    local player_info_t = ffi.typeof([[
        struct {
            int64_t         unknown;
            int64_t         steamID64;
            char            szName[128];
            int             userId;
            char            szSteamID[20];
            char            pad_0x00A8[0x10];
            unsigned long   iSteamID;
            char            szFriendsName[128];
            bool            fakeplayer;
            bool            ishltv;
            unsigned int    customfiles[4];
            unsigned char   filesdownloaded;
        }
    ]])

    local native_GetStringUserData = vtable_thunk(11, ffi.typeof("$*(__thiscall*)(void*, int, int*)", player_info_t))

    local previous_name
    local function apply_nickname(name)
        local local_player = entity.get_local_player()
        if not local_player then
            return
        end

        local native_BaseLocalClient = native_BaseLocalClient_base[0][0]
        if not native_BaseLocalClient then
            return
        end

        local native_UserInfoTable = ffi.cast("void***", native_BaseLocalClient + 0x52C0)[0]
        if not native_UserInfoTable then
            return
        end

        local data = native_GetStringUserData(native_UserInfoTable, local_player - 1, nil)
        if not data then
            return
        end

        local this_name = ffi.string(data[0].szName)
        if name ~= this_name and previous_name == nil then
            previous_name = this_name
        end

        data[0].szName = ffi.new("char[128]", name)
    end

    local was_applied = false
    local function callback()
        local chosen_nick = ui.get(clientside_nickname.nickname:get_ref()):sub(0, 32)
        clientside_nickname.nickname:set(chosen_nick)

        if not clientside_nickname.enabled:get() or #chosen_nick == 0 then
            if was_applied then
                was_applied = false
                apply_nickname(previous_name or panorama["MyPersonaAPI"]["GetName"]())
                previous_name = nil
            end

            return
        end

        was_applied = true

        apply_nickname(chosen_nick)
    end

    clientside_nickname.apply = menu.new_item(ui.new_button, "AA", "Anti-aimbot angles", "Apply", callback)
    : record("visuals", "clientside_nickname::apply")

    clientside_nickname.enabled:set_callback(callback)

    client.set_event_callback('round_prestart', callback)
    client.set_event_callback('player_connect_full', callback)

    callback()
end

-- --- tab to game
-- do
--     tab_to_game.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Tab to Game")
--     : record("visuals", "tab_to_game::enabled")
--     : save()

--     local api_ShowWindow          = memory.get_export("user32.dll", "ShowWindow", "int(__fastcall*)(unsigned int, unsigned int, void*, int)")
--     local api_GetForegroundWindow = memory.get_export("user32.dll", "GetForegroundWindow", "int(__fastcall*)(unsigned int, unsigned int)")
--     local api_SetForegroundWindow = memory.get_export("user32.dll", "SetForegroundWindow", "int(__fastcall*)(unsigned int, unsigned int, void*)")

--     local csgo_hwnd_raw = memory.pattern_scan("engine.dll", "8B 0D ? ? ? ? 85 C9 74 16 8B 01 8B")
--     local hwnd = ffi.cast("void*", ((ffi.cast("uintptr_t***", ffi.cast("uintptr_t", csgo_hwnd_raw) + 2)[0])[0] + 2)[0])

--     local function show_window()
--         api_ShowWindow(hwnd, 3)
--         api_SetForegroundWindow(hwnd)
--     end

--     function tab_to_game.round_prestart()
--         if tab_to_game.enabled:get() then
--             show_window()
--         end
--     end
-- end


--- region shared
do
    shared.enabled = menu.new_item(ui.new_checkbox, 'AA', 'Anti-aimbot angles', 'Shared Logo')
    :record('settings', 'shared::enabled')
    :save()

    shared.socket = nil
    shared.data = { }
    shared.icon_data = { }
    shared.link = "wss://exscord.dev/acid_ws"
    shared.failed_connections = 0

    local scoreboard = panorama.loadstring([[
        let _get_xuid = function(entity_index) {
            let xuid = GameStateAPI.GetPlayerXuidStringFromEntIndex(entity_index);
            return xuid;
        }

        let _set_icon = function(entity_index, icon) {
            let xuid = GameStateAPI.GetPlayerXuidStringFromEntIndex(entity_index);
            let context_panel = $.GetContextPanel();
            let ctx = context_panel.FindChildTraverse('ScoreboardContainer').FindChildTraverse('Scoreboard') || context_panel.FindChildTraverse('id-eom-scoreboard-container').FindChildTraverse('Scoreboard')
            if (ctx == null)
                return;

            ctx.FindChildrenWithClassTraverse('sb-row').forEach(function(e) {
                if (e.m_xuid != xuid)
                    return false;

                e.Children().forEach(function(child) {
                    let attribute = child.GetAttributeString('data-stat', '');
                    if (attribute != 'rank')
                        return false;

                    var image = child.FindChildTraverse('image');
                    if (!image || !image.IsValid())
                        return false;

                    image.SetImage(icon === null ? '' : icon)
                    return true;
                })
            })

            return xuid;
        }

        return {
            xuid: _get_xuid,
            set_icon: _set_icon
        }
    ]], 'CSGOHud')()

    local panorama = panorama.open()

    shared.retrieve = function ()
        local info = json.stringify({
            steam = tostring(panorama.MyPersonaAPI.GetXuid()),
            logo = 'bebra'
        })

        return base64.encode(info)
    end

    shared.callbacks = {
        open = function(ws)
            ws:send(shared.retrieve())

            shared.socket = ws
        end,

        message = function(ws, data)
            local success, data = pcall(base64.decode, data)
            if not success or type(data) ~= 'string' then
                return
            end

            local success, data = pcall(json.parse, data)
            if not success then
                return
            end

            local online = 0

            for _, object in next, data do
                if type(object) == 'string' then
                    online = online + 1
                end
            end

            shared.online_label:set(string.format('Current Online: %d', online))

            shared.data = data
        end,

        close = function (ws)
            shared.socket = nil
            client.delay_call(10, websockets.connect, shared.link, shared.callbacks)
        end
    }

    shared.send = function ()
        if not shared.socket then
            return
        end

        shared.socket:send(shared.retrieve())
    end

    shared.attach = function (condition)
        local enabled = shared.enabled:get() and not condition

        for i = 1, globals.maxplayers() do
            if entity.get_classname(i) ~= 'CCSPlayer' then
                goto skip
            end

            local steam_id = scoreboard.xuid(i)

            if not enabled then
                if not shared.icon_data[ steam_id ] then
                    scoreboard.set_icon(i)
                    shared.icon_data[ steam_id ] = true
                end

                goto skip
            end

            local logo_id = shared.data[ steam_id ]

            if logo_id then
                scoreboard.set_icon(i, string.format("https://exscord.dev/acid/icons/%s.png", logo_id))
                shared.icon_data[ steam_id ] = false
            else
                if not shared.icon_data[ steam_id ] then
                    scoreboard.set_icon(i)
                    shared.icon_data[ steam_id ] = true
                end
            end

            ::skip::
        end
    end

    shared.init = function ()
        websockets.connect(shared.link, shared.callbacks)

        shared.send()
        shared.enabled:set_callback(shared.send)
        client.delay_call(2, shared.send)

        client.set_event_callback('paint', function ()
            shared.attach()
        end)

        client.set_event_callback('shutdown', function ()
            shared.attach(true)
        end)
    end

    shared.init()
end

--- region buy bot
do
    local primary_console = {
        ["Autosnipers"] = "scar20",
        ["Scout"] = "ssg08",
        ["AWP"] = "awp",
        ["AK-47 / M4"]  = "ak47",
        ["AUG / SG553"] = "sg556",
        ['Famas'] = 'famas',
        ["Negev"] = "negev",
        ['M249'] = 'm249',
        ['MP7 / MP5'] = 'mp7',
        ['MP9 / Mac-10'] = 'mp9',
        ['UMP-45'] = 'ump45',
        ['P90'] = 'p90',
        ['Bizon'] = 'bizon',
        ['Nova'] = 'nova',
        ['XM1014'] = 'XM1014',
        ['Mag7 / Sawed-Off'] = 'mag7'
    }

    local secondary_console = {
        ["R8 / Deagle"] = "deagle",
        ["Tec-9 / Five-S / CZ-75"] = "tec9",
        ["P-250"] = "p250",
        ["Duals"] = "elite"
    }

    local utility_console = {
        ["Kevlar"] = "vest",
        ['Helmet'] = 'vesthelm',
        ["Defuser"] = "defuser",
        ["Taser"] = "taser",
        ["HE"] = "hegrenade",
        ["Molotov"] = "molotov",
        ["Smoke"] = "smokegrenade",
        ["Flashbang"] = "flashbang",
        ["Decoy"] = "decoy"
    }

    buy_bot.enabled = menu.new_item(ui.new_checkbox, "AA", "Anti-aimbot angles", "Buy Bot")
    : record("settings", "buy_bot::enabled")
    : save()

    buy_bot.primary = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", 'Primary weapon', { 'None', 'Autosnipers', 'Scout', 'AWP', 'AK-47 / M4',  'AUG / SG553', 'Famas', 'Negev', 'M249', 'MP7 / MP5', 'MP9 / Mac-10', 'UMP-45', 'P90', 'Bizon', 'Nova', 'XM1014', 'Mag7 / Sawed-Off' })
    : record("settings", "buy_bot::primary")
    : save()

    buy_bot.secondary = menu.new_item(ui.new_combobox, "AA", "Anti-aimbot angles", 'Secondary weapon', { 'None', 'R8 / Deagle', 'Tec-9 / Five-S / CZ-75', 'P-250', 'Duals' })
    : record("settings", "buy_bot::secondary")
    : save()

    buy_bot.utility = menu.new_item(ui.new_multiselect, "AA", "Anti-aimbot angles", 'Utility weapon', { 'Kevlar', 'Helmet', 'Defuser', 'Taser', 'HE', 'Molotov', 'Smoke', 'Flashbang', 'Decoy' })
    : record("settings", "buy_bot::utility")
    : save()

    client.set_event_callback("round_end_upload_stats", function ()
        local money = entity.get_prop(entity.get_local_player(), "m_iAccount")

        if not buy_bot.enabled:get() or money <= 800 then
            return
        end

        local buy = ''
        local primary = buy_bot.primary:get()
        local secondary = buy_bot.secondary:get()
        local util = buy_bot.utility:get()

        buy = primary == 'None' and buy or buy .. 'buy ' .. primary_console[primary] .. '; '
        buy = secondary == 'None' and buy or buy .. 'buy ' .. secondary_console[secondary] .. '; '

        for i = 1, #util do
            local item = utility_console[ util[i] ]
            buy = buy .. "buy " .. item .. "; "
        end

        if buy == '' then
            return
        end

        client.exec(buy)
    end)
end

client.set_event_callback("net_update_end", exploit.handle_defensive)
client.set_event_callback("net_update_end", exploit.net_update)
client.set_event_callback("net_update_end", localplayer.net_update)
client.set_event_callback("shutdown", gui.shutdown)
client.set_event_callback("shutdown", antiaim.shutdown)

client.set_event_callback("paint_ui", gui.frame)
client.set_event_callback("paint_ui", windows.frame)

client.set_event_callback("paint_ui", manual_direction.frame)

client.set_event_callback("paint_ui", watermark.frame)
client.set_event_callback("paint_ui", keybinds.frame)
client.set_event_callback("paint_ui", indicators.frame)
client.set_event_callback("paint_ui", arrows.frame)
client.set_event_callback("paint_ui", velocity_warning.frame)
client.set_event_callback("paint_ui", hit_marker.frame)

client.set_event_callback("paint_ui", eventlogs.pre_frame)
client.set_event_callback("paint_ui", log_aimbot_shots.frame)
client.set_event_callback("paint_ui", eventlogs.post_frame)

client.set_event_callback("pre_predict_command", localplayer.pre_predict_command)
client.set_event_callback("predict_command", localplayer.predict_command)

client.set_event_callback("setup_command", exploit.setup_command)
client.set_event_callback("setup_command", statement.setup_command)
client.set_event_callback("setup_command", antiaim.setup_command)

client.set_event_callback("aim_miss", log_aimbot_shots.aim_miss)

client.set_event_callback("aim_hit", hit_marker.aim_hit)
client.set_event_callback("aim_fire", hit_marker.aim_fire)

client.set_event_callback("player_hurt", log_aimbot_shots.player_hurt)
--client.set_event_callback("round_prestart", tab_to_game.round_prestart)
client.set_event_callback("round_prestart", hit_marker.round_prestart)

client.set_event_callback('paint', function ()
    print(gcinfo())
end)

menu.set_callback(function()
    gui.enabled:display()

    if not gui.enabled:get() then
        return
    end

    shared.online_label:display()
    gui.selection:display()

    if gui.selection:get() == "Home" then

        graphics.config_export:display()
        graphics.config_import:display()
        graphics.config_default:display()
    end

    if gui.selection:get() == "Settings" then

        air_exploit.enabled:display()

        if air_exploit.enabled:get() then
            air_exploit.key:display()
            air_exploit.ticks:display()
        end

        settings.tweaks_enable:display()

        if settings.tweaks_enable:get() then
            settings.tweaks:display()
        end

        -- do
        --     hitchance.enabled:display()

        --     if hitchance.enabled:get() then
        --         hitchance.weapon_list:display()

        --         for _, weapon in next, hitchance.weapons do
        --             if hitchance.weapon_list:get() == weapon then
        --                 hitchance['Enabled_' .. weapon]:display()

        --                 if hitchance['Enabled_' .. weapon]:get() then
        --                     hitchance['Modes_' .. weapon]:display()

        --                     if hitchance['Modes_' .. weapon]:have_key('No Scope') then
        --                         hitchance['Distance_' .. weapon]:display()
        --                         hitchance['No Scope_' .. weapon]:display()
        --                     end

        --                     if hitchance['Modes_' .. weapon]:have_key('In Air') then
        --                         hitchance['In Air_' .. weapon]:display()
        --                     end
        --                 end
        --             end
        --         end
        --     end
        -- end

        shared.enabled:display()

        widgets.enabled:display()

        if widgets.enabled:get() then
            widgets.items:display()

            if widgets.items:have_key("Watermark") then
                widgets.display:display()
                widgets.custom_name:display()

                if widgets.custom_name:get() then
                    widgets.custom_name_value:display()
                end
            end

            if #widgets.items:get() > 0 then
                widgets.color_picker:display()
            end
        end

        custom_scope.enabled:display()

        if custom_scope.enabled:get() then
            custom_scope.color:display()
            custom_scope.mode:display()
            custom_scope.position:display()
            custom_scope.offset:display()
        end

        buy_bot.enabled:display()

        if buy_bot.enabled:get() then
            buy_bot.primary:display()
            buy_bot.secondary:display()
            buy_bot.utility:display()
        end

        clientside_nickname.enabled:display()

        if clientside_nickname.enabled:get() then
            clientside_nickname.nickname:display()
            clientside_nickname.apply:display()
        end

       -- tab_to_game.enabled:display()
    end

    if gui.selection:get() == "Anti-aim" then

        safe_head.enabled:display()

        aa_tweaks.enable:display()
        if aa_tweaks.enable:get() then
            aa_tweaks.items:display()
        end


        fs_disablers.states:display()

        if safe_head.enabled:get() then
            safe_head.states:display()
        end

        yaw_direction.edge_yaw:display()
        yaw_direction.freestanding:display()

        manual_direction.enabled:display()

        if manual_direction.enabled:get() then
            manual_direction.options:display()
            manual_direction.arrows:display()

            if manual_direction.arrows:get() then
                manual_direction.color:display()
            end

            manual_direction.left_manual:display()
            manual_direction.right_manual:display()
            manual_direction.forward_manual:display()
            manual_direction.disabled_manual:display()
        end

        defensive.enabled:display()
        anim_breakers.enabled:display()


        if anim_breakers.enabled:get() then
            anim_breakers.ground:display()
            anim_breakers.air:display()
        end

        if defensive.enabled:get() then
            defensive.mode:display()
            defensive.state:display()
            defensive.pitch:display()
            defensive.yaw:display()
        end

        angles.type:display()

        if angles.type:get() == "Custom" then
            angles.custom.state:display()

            local state = angles.custom.state:get()
            local list = angles.custom[state]

            if list.enabled ~= nil then
                list.enabled:display()

                if not list.enabled:get() then
                    goto continue
                end
            end

            if list.pitch ~= nil then
                local pitch = list.pitch:get()
                list.pitch:display()

                if pitch == "Custom" then
                    list.pitch_offset:display()
                end
            end

            if list.yaw_base ~= nil then
                list.yaw_base:display()
            end

            local yaw_value = list.yaw:get()
            list.yaw:display()

            if yaw_value ~= "Off" then

                if yaw_value == '180 LR' then
                    list.yaw_180lr_mode:display()
                    list.yaw_left:display()
                    list.yaw_right:display()

                    if list.yaw_180lr_mode:get() == 'Switch delay' then
                        list.yaw_delay:display()
                    end
                else
                    list.yaw_offset:display()
                end

                list.yaw_jitter:display()

                if list.yaw_jitter:get() ~= "Off" then
                    list.jitter_offset:display()
                    list.jitter_randomization:display()

                    if list.yaw_jitter:get() == "AcidTech" then
                        list.jitter_mode:display()
                        list.acid_safe:display()
                        list.acid_cycle:display()
                        list.acid_delay:display()

                        ui.set_enabled(list.acid_delay.ref, list.acid_cycle:get() ~= 5)
                    end
                end
            end

            local body_yaw = list.body_yaw:get()
            list.body_yaw:display()

            if body_yaw ~= "Off" then
                if body_yaw ~= "Opposite" then
                    list.body_yaw_offset:display()
                end

                list.freestanding_body_yaw:display()
            end

            ::continue::
        end
    end
end)

menu.update()