-- ============================================================================
-- Cynicism | Super Anti-Aim System
-- Integrated from: Bounty, GODAA, Emberlash, Riseabove, Horus, Suroh
-- Target platform: GameSense Lua only. Keep runtime APIs GS-compatible.
-- ============================================================================

-- ===================== DEPENDENCIES =====================
local function try_require(mod, msg)
    local ok, res = pcall(require, mod)
    if ok then return res else return error(msg) end
end

local vector = try_require("vector", "Missing vector library")
local ffi = require("ffi")
local anti_aim_f = try_require("gamesense/antiaim_funcs", "Missing antiaim_funcs")
local c_entity = try_require("gamesense/entity", "Missing gamesense/entity")
local base64 = try_require("gamesense/base64", "Missing base64")
local clipboard = try_require("gamesense/clipboard", "Missing clipboard: https://gamesense.pub/forums/viewtopic.php?id=28678")
local csgo_weapons = try_require("gamesense/csgo_weapons", "Missing csgo_weapons: https://gamesense.pub/forums/viewtopic.php?id=18807")

-- ===================== CACHED GLOBALS =====================
local bit_band = bit.band
local math_abs, math_floor, math_ceil = math.abs, math.floor, math.ceil
local math_sin, math_cos, math_rad, math_deg = math.sin, math.cos, math.rad, math.deg
local math_max, math_min, math_sqrt, math_atan2 = math.max, math.min, math.sqrt, math.atan2
local ui_get, ui_set = ui.get, ui.set
local entity_get_local_player = entity.get_local_player
local entity_get_prop = entity.get_prop
local entity_get_players = entity.get_players
local entity_is_alive = entity.is_alive
local entity_is_enemy = entity.is_enemy
local entity_get_player_weapon = entity.get_player_weapon
local entity_get_classname = entity.get_classname
local entity_get_origin = entity.get_origin
local entity_hitbox_position = entity.hitbox_position
local client_eye_position = client.eye_position
local client_camera_angles = client.camera_angles
local client_screen_size = client.screen_size
local client_trace_line = client.trace_line
local client_current_threat = client.current_threat
local client_set_event_callback = client.set_event_callback
local globals_curtime = globals.curtime
local globals_realtime = globals.realtime
local globals_frametime = globals.frametime
local globals_tickcount = globals.tickcount
local globals_tickinterval = globals.tickinterval
local globals_chokedcommands = globals.chokedcommands
local renderer_text = renderer.text
local renderer_rectangle = renderer.rectangle
local renderer_gradient = renderer.gradient
local renderer_circle = renderer.circle
local renderer_circle_outline = renderer.circle_outline
local renderer_line = renderer.line
local renderer_measure_text = renderer.measure_text

-- ===================== UTILITY FUNCTIONS =====================
local function lerp(a, b, t)
    return a + (b - a) * t
end

local function clamp(val, lo, hi)
    return math_max(lo, math_min(hi, val))
end

local function normalize_yaw(x)
    if x == nil then return 0 end
    x = (x % 360 + 360) % 360
    return x > 180 and x - 360 or x
end

local function rgba_to_hex(r, g, b, a)
    return string.format("%.2x%.2x%.2x%.2x", math_floor(r + 0.5), math_floor(g + 0.5), math_floor(b + 0.5), math_floor(a + 0.5))
end

local function angle_to_forward(pitch, yaw)
    local sy = math_sin(math_rad(yaw))
    local cy = math_cos(math_rad(yaw))
    local sp = math_sin(math_rad(pitch))
    local cp = math_cos(math_rad(pitch))
    return cp * cy, cp * sy, -sp
end

local function animate_text(time, str, r1, g1, b1, a1, r2, g2, b2, a2)
    local out = {}
    local r_d, g_d, b_d, a_d = r2 - r1, g2 - g1, b2 - b1, a2 - a1
    for i = 1, #str do
        local iter = (i - 1) / (#str - 1) + time
        local c = math_abs(math_cos(iter))
        out[#out + 1] = "\\a" .. rgba_to_hex(r1 + r_d * c, g1 + g_d * c, b1 + b_d * c, a1 + a_d * c)
        out[#out + 1] = str:sub(i, i)
    end
    return table.concat(out)
end

local function safe_ui_get(ref)
    if ref == nil then return nil end
    local ok, value = pcall(ui_get, ref)
    return ok and value or nil
end

local function ref_active(ref_tbl)
    if ref_tbl == nil or ref_tbl[1] == nil then return false end
    local ok, value = pcall(ui_get, ref_tbl[1])
    if not ok then return false end
    if type(value) == "boolean" then return value end
    if type(value) == "table" then return #value > 0 end
    if type(value) == "number" then return value ~= 0 end
    if type(value) == "string" then return value ~= "" and value ~= "Off" end
    return value ~= nil
end

local function ref_color_or(ref_tbl, fr, fg, fb, fa)
    if ref_tbl == nil or ref_tbl[2] == nil then
        return fr, fg, fb, fa
    end
    local ok, r, g, b, a = pcall(ui_get, ref_tbl[2])
    if not ok then
        return fr, fg, fb, fa
    end
    if type(r) ~= "number" or type(g) ~= "number" or type(b) ~= "number" then
        return fr, fg, fb, fa
    end
    if type(a) ~= "number" then
        a = fa
    end
    return r, g, b, a
end

local function draw_text_shadow(x, y, r, g, b, a, flags, width, text)
    renderer_text(x + 1, y + 1, 0, 0, 0, math_floor((a or 255) * 0.45), flags or "", width or 0, text)
    renderer_text(x, y, r, g, b, a, flags or "", width or 0, text)
end

local function draw_blur(x, y, w, h, a, amount)
    if renderer.blur == nil then return end
    pcall(renderer.blur, x, y, w, h, a or 255, amount or 4)
end

local function draw_ring(x, y, r, g, b, a, radius, start_deg, pct, thickness)
    if renderer_circle_outline == nil then return end
    pcall(renderer_circle_outline, x, y, r, g, b, a, radius, start_deg or 0, pct or 1, thickness or 1)
end

local function draw_round_rect(x, y, w, h, r, g, b, a, radius)
    radius = clamp(math_floor(radius or 0), 0, math_floor(math_min(w, h) * 0.5))
    if radius <= 0 then
        renderer_rectangle(x, y, w, h, r, g, b, a)
        return
    end

    renderer_rectangle(x + radius, y, w - radius - radius, h, r, g, b, a)
    renderer_rectangle(x, y + radius, radius, h - radius - radius, r, g, b, a)
    renderer_rectangle(x + w - radius, y + radius, radius, h - radius - radius, r, g, b, a)
    renderer_circle(x + radius, y + radius, r, g, b, a, radius, 180, 0.25)
    renderer_circle(x + w - radius, y + radius, r, g, b, a, radius, 90, 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)
end

local function draw_glass_panel(x, y, w, h, ar, ag, ab, aa, compact)
    local bg_a = math_floor((compact and 128 or 146) * aa)
    local fill_a = math_floor((compact and 58 or 72) * aa)
    local shine_a = math_floor((compact and 14 or 20) * aa)
    local line_a = math_floor((compact and 72 or 100) * aa)
    local edge_a = math_floor((compact and 46 or 58) * aa)
    local radius = compact and 5 or 7
    draw_blur(x - 2, y - 2, w + 4, h + 4, math_floor((compact and 128 or 156) * aa), compact and 4 or 6)
    draw_round_rect(x, y, w, h, 8, 11, 18, bg_a, radius)
    draw_round_rect(x + 1, y + 1, w - 2, h - 2, 13, 16, 25, fill_a, math_max(0, radius - 1))
    renderer_gradient(x, y, w, h, ar, ag, ab, shine_a, 16, 20, 30, 0, false)
    renderer_gradient(x + 1, y + 1, w - 2, math_max(6, math_floor(h * 0.5)), 255, 255, 255, math_floor(18 * aa), 255, 255, 255, 0, false)
    draw_round_rect(x, y, w, 2, ar, ag, ab, line_a, radius)
    draw_round_rect(x, y + h - 1, w, 1, ar, ag, ab, edge_a, radius)
    renderer_gradient(x + 8, y + h - 2, math_max(1, w - 16), 1, ar, ag, ab, 0, ar, ag, ab, math_floor(86 * aa), true)
end

local function get_hud_palette(ar, ag, ab, aa)
    local mul = aa or 1
    return {
        text = { 242, 244, 248, math_floor(236 * mul) },
        soft = { 212, 216, 224, math_floor(206 * mul) },
        dim = { 171, 176, 187, math_floor(174 * mul) },
        faint = { 124, 130, 142, math_floor(138 * mul) },
        accent = { ar, ag, ab, math_floor(255 * mul) },
        accent_soft = {
            math_min(255, math_floor(ar + (255 - ar) * 0.25)),
            math_min(255, math_floor(ag + (255 - ag) * 0.25)),
            math_min(255, math_floor(ab + (255 - ab) * 0.25)),
            math_floor(255 * mul)
        }
    }
end

local function draw_hud_header(x, y, w, title, ar, ag, ab, aa, compact, right_text)
    local pal = get_hud_palette(ar, ag, ab, aa)
    local header_h = compact and 18 or 20
    local dot = compact and 6 or 7
    local dot_y = y + math_floor(header_h * 0.5) - math_floor(dot * 0.5)

    draw_round_rect(x + 4, y + 4, w - 8, header_h, 15, 19, 28, math_floor(154 * aa), compact and 4 or 6)
    draw_round_rect(x + 9, dot_y, dot, dot, ar, ag, ab, pal.accent[4], math_floor(dot * 0.5))
    draw_text_shadow(x + 20, y + (compact and 6 or 7), pal.text[1], pal.text[2], pal.text[3], pal.text[4], "", 0, title)
    if right_text ~= nil and right_text ~= "" then
        draw_text_shadow(x + w - 10, y + (compact and 6 or 7), pal.dim[1], pal.dim[2], pal.dim[3], pal.dim[4], "r", 0, right_text)
    end
    renderer_gradient(x + 10, y + header_h + 4, math_max(1, w - 20), 1, ar, ag, ab, math_floor(118 * aa), ar, ag, ab, 0, true)
    return header_h
end

local function draw_hud_row(x, y, w, h, label, value, ar, ag, ab, aa, compact, value_r, value_g, value_b, dot_a)
    local pal = get_hud_palette(ar, ag, ab, aa)
    local value_cr = value_r or ar
    local value_cg = value_g or ag
    local value_cb = value_b or ab
    local accent_a = dot_a or math_floor(214 * aa)

    draw_round_rect(x, y, w, h, 11, 14, 22, math_floor(140 * aa), compact and 4 or 5)
    draw_round_rect(x + 6, y + math_floor(h * 0.5) - 2, 4, 4, ar, ag, ab, accent_a, 2)
    draw_text_shadow(x + 14, y + (compact and 3 or 4), pal.text[1], pal.text[2], pal.text[3], pal.text[4], "", 0, label)
    if value ~= nil then
        draw_text_shadow(x + w - 10, y + (compact and 3 or 4), value_cr, value_cg, value_cb, math_floor(226 * aa), "r", 0, tostring(value))
    end
end

local function measure_hud_badge(label, value, compact)
    local label_txt = tostring(label or "")
    local value_txt = tostring(value or "")
    local vw = renderer_measure_text("", value_txt)
    local lw = renderer_measure_text("", label_txt)
    local pad_x = compact and 8 or 10
    local h = compact and 20 or 24
    local w = math_max(compact and 86 or 98, lw + vw + pad_x * 3 + 6)
    return w, h
end

local function draw_hud_badge(x, y, label, value, ar, ag, ab, aa, compact)
    local pal = get_hud_palette(ar, ag, ab, aa)
    local label_txt = tostring(label or "")
    local value_txt = tostring(value or "")
    local _, lh = renderer_measure_text("", label_txt)
    local pad_x = compact and 8 or 10
    local w, h = measure_hud_badge(label_txt, value_txt, compact)
    draw_glass_panel(x, y, w, h, ar, ag, ab, aa, compact)
    draw_round_rect(x + 6, y + math_floor(h * 0.5) - 2, 4, 4, ar, ag, ab, math_floor(210 * aa), 2)
    draw_text_shadow(x + pad_x + 6, y + h * 0.5 - lh * 0.5 - 1, pal.dim[1], pal.dim[2], pal.dim[3], math_floor(180 * aa), "", 0, label_txt)
    draw_text_shadow(x + w - pad_x, y + h * 0.5 - lh * 0.5 - 1, pal.text[1], pal.text[2], pal.text[3], math_floor(245 * aa), "r", 0, value_txt)
    return w, h
end

local function ref_hotkey_active(ref_tbl)
    if type(ref_tbl) ~= "table" or ref_tbl[1] == nil then
        return false
    end
    local enabled = safe_ui_get(ref_tbl[1])
    if not enabled then
        return false
    end
    if ref_tbl[2] == nil then
        return enabled and true or false
    end
    local hotkey = safe_ui_get(ref_tbl[2])
    if type(hotkey) == "boolean" then
        return hotkey
    end
    return enabled and true or false
end

local function collect_active_binds()
    local list = {}
    local function push(name, active, state)
        if active then
            list[#list + 1] = { name = name, state = state or "on" }
        end
    end

    push("Double tap", ref_hotkey_active(refs.doubletap), "on")
    push("Fake peek", ref_hotkey_active(refs.fake_peek), "hold")
    push("Slow motion", ref_hotkey_active(refs.slow_motion), "hold")
    push("Fake duck", safe_ui_get(refs.fakeduck), "on")
    push("Freestanding", has_multiselect(misc_features, "Freestanding") and ui_get(freestanding_key), "on")
    push("Legit AA", has_multiselect(misc_features, "Legit AA") and ui_get(legit_aa_key), "on")
    push("Edge yaw", has_multiselect(misc_features, "Edge Yaw") and ui_get(edge_yaw_key) and not vars.manual_dir, "on")
    push("Manual yaw", vars.manual_dir ~= nil, vars.manual_dir and vars.manual_dir:lower() or "on")
    push("Force defensive", ui_get(force_def_key), "hold")
    push("Defensive", exploit_data.def_aa, tostring(exploit_data.defensive.left or 0) .. "t")
    return list
end

local function collect_spectators(local_player)
    local list = {}
    if not local_player then
        return list
    end

    local target = local_player
    local ob_target = entity_get_prop(local_player, "m_hObserverTarget")
    local ob_mode = entity_get_prop(local_player, "m_iObserverMode")
    if ob_target and (ob_mode == 4 or ob_mode == 5) then
        target = ob_target
    end

    for ent = 1, 64 do
        if ent ~= local_player and entity_get_classname(ent) == "CCSPlayer" and not entity_is_alive(ent) then
            local spec_target = entity_get_prop(ent, "m_hObserverTarget")
            local spec_mode = entity_get_prop(ent, "m_iObserverMode")
            if spec_target and spec_target == target and (spec_mode == 4 or spec_mode == 5) then
                list[#list + 1] = entity.get_player_name(ent) or ("spec-" .. ent)
            end
        end
    end

    return list
end

local function get_velocity(ent)
    local x, y, z = entity_get_prop(ent, "m_vecVelocity")
    if x == nil then return 0 end
    return math_sqrt(x*x + y*y + z*z)
end

local function get_velocity_2d(ent)
    local x, y = entity_get_prop(ent, "m_vecVelocity")
    if x == nil then return 0 end
    return math_sqrt(x*x + y*y)
end

local function is_on_ground(ent)
    return bit_band(entity_get_prop(ent, "m_fFlags") or 0, 1) == 1
end

local function is_in_air(ent)
    return bit_band(entity_get_prop(ent, "m_fFlags") or 0, 1) == 0
end

local function is_crouching(ent)
    return bit_band(entity_get_prop(ent, "m_fFlags") or 0, 4) == 4
end

local function is_visible(ent)
    local me = entity_get_local_player()
    local lx, ly, lz = entity_hitbox_position(me, 0)
    local ex, ey, ez = entity_hitbox_position(ent, 0)
    if not lx or not ex then return false end
    local frac = client_trace_line(me, lx, ly, lz, ex, ey, ez)
    return frac > 0.75
end

local function has_multiselect(ref, val)
    if not ref then return false end
    local items = ui_get(ref)
    if type(items) ~= "table" then return false end
    for _, v in ipairs(items) do
        if v == val then return true end
    end
    return false
end

local function time_to_ticks(t)
    return math_floor(0.5 + t / globals_tickinterval())
end

-- ===================== CHEAT REFERENCES =====================
local refs = {
    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"),
    roll = ui.reference("AA", "Anti-aimbot angles", "Roll"),
    freestanding = { ui.reference("AA", "Anti-aimbot angles", "Freestanding") },

    slow_motion = { ui.reference("AA", "Other", "Slow motion") },
    leg_movement = ui.reference("AA", "Other", "Leg movement"),
    fake_peek = { ui.reference("AA", "Other", "Fake peek") },
    on_shot_aa = { ui.reference("AA", "Other", "On shot anti-aim") },
    fakelag_enabled = { ui.reference("AA", "Fake lag", "Enabled") },
    fakelag_amount = ui.reference("AA", "Fake lag", "Amount"),
    fakelag_limit = ui.reference("AA", "Fake lag", "Limit"),
    fakelag_variance = ui.reference("AA", "Fake lag", "Variance"),
    doubletap = { ui.reference("RAGE", "Aimbot", "Double tap") },
    dt_fl_limit = ui.reference("RAGE", "Aimbot", "Double tap fake lag limit"),
    fakeduck = ui.reference("RAGE", "Other", "Duck peek assist"),
    playerlist = ui.reference("Players", "Players", "Player list"),
}

-- ===================== STATE VARIABLES =====================
local SCRIPT_COLOR = { r = 140, g = 120, b = 255 }
local SCRIPT_VERSION = "5.0"


local conditions = { "Global", "Standing", "Moving", "Crouch", "Crouch Move", "Slowwalk", "Air", "Air Duck", "Legit AA", "Manual", "Safe Head", "No Enemy" }

local vars = {
    state = "Global", state_idx = 1,
    manual_dir = nil, manual_yaw = 0,
    legitaa_on = false, fs_disabled = 0,
    aa_dir = 0, last_press_t = 0,
    -- Body yaw flip
    body_packets = 0, body_inverted = false, body_yaw_side = -1, body_yaw_value = 0, body_dynamic_value = 0, body_fake_value = 0,
    body_live_amount = 0, body_overlap = 0,
    body_delay = { left = 0, right = 0, switch_ticks = 0, work_side = "left", switch = false },
    -- Paradise Multiway Body Yaw state
    by_multiway = { way_idx = 1, ticks = 0 },
    -- Jitter
    jitter_offset = 0, def_pitch_jitter_twisted = false, def_yaw_jitter_twisted = false,
    jitter_random_pick = 0, jitter_switch_tick = 0, jitter_switch_state = false, jitter_rand_noise = 0,
    -- Jitter state (Frequence/Randomize)
    flu = { idx = 0, random_val = 0 },
    -- Defensive wave/clock/spin state
    def_wave_phase = 0, def_clock_angle = 0, def_spin_val = 0,
    def_pitch_spin_val = 0, def_rand_static_yaw = 0, def_rand_static_pitch = 0,
    def_state = "Idle",
    def_fake_flick_side = 1, def_fake_flick_tick = 0, def_fake_flick_last_trigger = false, def_fake_flick_cooldown = 0,
    -- Paradise defensive Multiway sequencer state (pitch + yaw)
    def_pitch_way_idx = 1, def_pitch_way_ticks = 0,
    def_yaw_way_idx = 1, def_yaw_way_ticks = 0,
    -- Paradise defensive Sway state (pitch + yaw)
    def_pitch_sway = 0, def_yaw_sway = 0,
    -- Paradise Generation (random-per-phase) cached values
    def_gen_pitch = 0, def_gen_yaw = 0, def_gen_phase = false,
    -- Knife check cache
    def_knife_near = false,
    -- Tick counters
    yaw_tick = 0, yaw_choke = false, sway_stage = 1,
    -- Cathode delay state
    delay_tick = 0,              -- current delay tick counter
    delay_current = 1,          -- resolved delay value for this cycle
    delay_cycle_idx = 1,        -- CycleSpin index
    delay_jitter_switch = false, -- Jitter/JitterTick alternating state
    def_flick_tick = 0,         -- Flick mode: ticks since last def cycle
    def_always_ticks = 0,       -- Flick mode: active window countdown
    def_flick_period_target = 0, -- Flick mode: per-cycle randomized period
    def_flick_window_target = 0, -- Flick mode: per-cycle randomized active window
    def_flick_jitter_switch = false,
    def_flick_advance_idx = 0,
    def_flick_cycle_idx = 1,
    def_flick_random_static = 8,
    def_flick_beta_idx = 0,
    def_trigger_state = false,
    def_trigger_tick = 0,
    def_trigger_counter = 0,
    def_trigger_prev_raw = false,
    def_trigger_cooldown = 0,
    def_check_source = "Tickbase",
    def_source_ticks = 0,
    def_tick_last = 0,
    def_tick_streak = 0,
    def_tick_peak = 0,
    def_mode_last = "",
    def_mode_resolved = "Neverlose",
    def_profile_name = "Legacy",
    def_runtime_name = "Balanced",
    def_guard_name = "Off",
    def_guard_window = 0,
    def_guard_pass = true,
    def_send_packet_state = nil,
    def_release_body = false,
    def_release_follow = true,
    def_pred_active = false,
    def_pred_mode = "Off",
    def_pred_phase = "idle",
    def_pred_target = 0,
    def_pred_extend = 0,
    def_pred_owned = false,
    def_pred_restore = nil,
    def_nchoke_owned = false,
    def_nchoke_restore = nil,
    def_duration_tick = 0,      -- Duration mode: active lifetime counter
    def_duration_target = 0,    -- Duration mode: current selected lifetime
    def_duration_stage_idx = 1, -- Duration mode: stage cycle index
    def_duration_active = false,-- Duration mode: inside defensive window flag
    def_driver_cached = 1,      -- Defensive driver cache for choked cmds
    def_driver_last = 0,        -- Defensive driver last resolved tick
    def_driver_repeat = 0,      -- Defensive driver repeat counter
    def_driver_pressure = 0,    -- Defensive pressure score for debug/state
    -- Fake lag controller runtime
    flctl_mode = "Off",
    flctl_limit = 0,
    flctl_cycle = 0,
    flctl_state = "off",
    flctl_last_shot_time = 0,
    -- Anti bruteforce runtime
    abf_ticks_left = 0,
    abf_side = 1,
    abf_last_reason = "none",
    abf_state = "idle",
    -- Combat alert runtime
    combat_threat = "idle",
    combat_threat_name = "",
    combat_threat_until = 0,
    combat_pred_until = 0,
    combat_last_impact_tick = 0,
    -- Visual HUD runtime
    hud_watermark_w = 220,
    hud_keylist_w = 170,
    hud_speclist_w = 170,
    hud_scope_breathe = 0,
    nondef_drift_phase = 0,
    nondef_drift = 0,
    esp_preview_alpha = 0,
    -- Welcome
    err_clock = {},
    welcome_alpha = 0, welcome_progress = 0, welcome_done = false, welcome_fading = false,
    session_start = client.unix_time(),
    -- State detector hysteresis
    state_detect_idx = 2,
    state_detect_candidate = 2,
    state_detect_ticks = 0,
    -- Per-condition runtime cache for non-def AA paths
    aa_runtime = {},
}

local function get_aa_runtime(idx)
    local key = clamp(tonumber(idx) or 1, 1, #conditions)
    local rt = vars.aa_runtime[key]
    if rt then
        return rt
    end

    rt = {
        jitter_random_pick = 0,
        jitter_switch_tick = 0,
        jitter_switch_state = false,
        jitter_rand_noise = 0,
        flu_idx = 0,
        flu_random_val = 0,
        body_packets = 0,
        body_delay = { left = 0, right = 0, switch_ticks = 0, work_side = "left", switch = false },
        body_dynamic_value = 0,
    }
    vars.aa_runtime[key] = rt
    return rt
end

-- ===================== EXPLOIT / DEFENSIVE DETECTION (abyss-style) =====================
local exploit_data = {
    shift = false, breaking_lc = false, def_aa = false,
    max_tickbase = 0, run_cmd_num = 0,
    old_origin = nil, old_simtime = 0,
    defensive = { force = false, left = 0, max = 0, cmd_left = 0, cmd_max = 0, cmd_num = nil },
    lc = { distance = 0, teleport = false },
}

local BREAK_LC_DIST_SQR = 64 * 64

local function exploit_update_tickbase_shift(me)
    exploit_data.shift = globals_tickcount() > (entity_get_prop(me, "m_nTickBase") or 0)
end

local function exploit_update_teleport(old_ox, old_oy, old_oz, nx, ny, nz)
    local dx, dy, dz = nx - old_ox, ny - old_oy, nz - old_oz
    local dist_sq = dx*dx + dy*dy + dz*dz
    exploit_data.breaking_lc = dist_sq > BREAK_LC_DIST_SQR
    exploit_data.lc.distance = dist_sq
    exploit_data.lc.teleport = dist_sq > BREAK_LC_DIST_SQR
end

local function exploit_update_lagcomp(me)
    local ox, oy, oz = entity_get_prop(me, "m_vecOrigin")
    if not ox then return end
    local st = entity_get_prop(me, "m_flSimulationTime") or 0
    local st_ticks = math_floor(0.5 + st / globals_tickinterval())
    if exploit_data.old_simtime then
        local delta = st_ticks - exploit_data.old_simtime
        if delta < 0 or (delta > 0 and delta <= 64) then
            if exploit_data.old_origin then
                exploit_update_teleport(exploit_data.old_origin[1], exploit_data.old_origin[2], exploit_data.old_origin[3], ox, oy, oz)
            end
        end
    end
    exploit_data.old_origin = {ox, oy, oz}
    exploit_data.old_simtime = st_ticks
end

local function exploit_update_defensive_tick(me)
    local tb = entity_get_prop(me, "m_nTickBase") or 0
    if math_abs(tb - exploit_data.max_tickbase) > 64 then exploit_data.max_tickbase = 0 end
    local dfl = 0
    if tb > exploit_data.max_tickbase then
        exploit_data.max_tickbase = tb
    elseif exploit_data.max_tickbase > tb then
        dfl = math_min(14, math_max(0, exploit_data.max_tickbase - tb - 1))
    end
    if dfl > 0 then
        exploit_data.breaking_lc = true
        exploit_data.defensive.left = dfl
        if exploit_data.defensive.max == 0 then exploit_data.defensive.max = dfl end
        if (vars.def_tick_last or 0) > 0 then
            vars.def_tick_streak = (vars.def_tick_streak or 0) + 1
        else
            vars.def_tick_streak = 1
        end
        vars.def_tick_peak = math_max(vars.def_tick_peak or 0, dfl)
    else
        exploit_data.defensive.left = 0
        exploit_data.defensive.max = 0
        vars.def_tick_streak = 0
        vars.def_tick_peak = 0
    end
    vars.def_tick_last = dfl
end

local function exploit_on_predict(cmd)
    local me = entity_get_local_player()
    if not me then return end
    if cmd.command_number == exploit_data.run_cmd_num then
        exploit_update_defensive_tick(me)
        exploit_data.run_cmd_num = nil
    end
    if exploit_data.defensive.cmd_num and cmd.command_number == exploit_data.defensive.cmd_num then
        local tb = entity_get_prop(me, "m_nTickBase") or 0
        local cmd_max = exploit_data.defensive.cmd_max or 0
        if math_abs(tb - cmd_max) > 64 then cmd_max = 0 end
        exploit_data.defensive.cmd_left = math_abs(tb - cmd_max)
        exploit_data.defensive.cmd_max = math_max(tb, cmd_max)
        exploit_data.defensive.cmd_num = nil
    end
end

local function exploit_on_setup(cmd)
    local me = entity_get_local_player()
    if not me then return end
    exploit_update_tickbase_shift(me)
end

local function exploit_on_run(e)
    exploit_data.run_cmd_num = e.command_number
    exploit_data.defensive.cmd_num = e.command_number
end

local function exploit_on_net_update()
    local me = entity_get_local_player()
    if not me then return end
    exploit_update_lagcomp(me)
end

local function exploit_reset()
    exploit_data.max_tickbase = 0
    exploit_data.defensive.left = 0
    exploit_data.defensive.max = 0
    exploit_data.defensive.cmd_left = 0
    exploit_data.defensive.cmd_max = 0
    exploit_data.defensive.cmd_num = nil
    exploit_data.breaking_lc = false; exploit_data.def_aa = false
    exploit_data.old_origin = nil; exploit_data.old_simtime = 0
    vars.def_driver_cached = 1
    vars.def_driver_last = 0
    vars.def_driver_repeat = 0
    vars.def_driver_pressure = 0
    vars.def_flick_tick = 0
    vars.def_always_ticks = 0
    vars.def_flick_period_target = 0
    vars.def_flick_window_target = 0
    vars.def_flick_jitter_switch = false
    vars.def_flick_advance_idx = 0
    vars.def_flick_cycle_idx = 1
    vars.def_flick_random_static = 8
    vars.def_flick_beta_idx = 0
    vars.def_trigger_state = false
    vars.def_trigger_tick = 0
    vars.def_trigger_counter = 0
    vars.def_trigger_prev_raw = false
    vars.def_trigger_cooldown = 0
    vars.def_check_source = "Tickbase"
    vars.def_source_ticks = 0
    vars.def_tick_last = 0
    vars.def_tick_streak = 0
    vars.def_tick_peak = 0
    vars.def_mode_last = ""
    vars.def_mode_resolved = "Neverlose"
    vars.def_profile_name = "Legacy"
    vars.def_runtime_name = "Balanced"
    vars.def_guard_name = "Off"
    vars.def_guard_window = 0
    vars.def_guard_pass = true
    vars.def_send_packet_state = nil
    vars.def_release_body = false
    vars.def_release_follow = true
    vars.def_pred_active = false
    vars.def_pred_mode = "Off"
    vars.def_pred_phase = "idle"
    vars.def_pred_target = 0
    vars.def_pred_extend = 0
    if vars.def_pred_owned then
        if vars.def_pred_restore ~= nil then
            ui_set(refs.fakelag_enabled[1], vars.def_pred_restore)
        end
    end
    vars.def_pred_owned = false
    vars.def_pred_restore = nil
    if vars.def_nchoke_owned then
        if vars.def_nchoke_restore ~= nil then
            ui_set(refs.fakelag_enabled[1], vars.def_nchoke_restore)
        end
    end
    vars.def_nchoke_owned = false
    vars.def_nchoke_restore = nil
    vars.def_fake_flick_last_trigger = false
    vars.def_fake_flick_cooldown = 0
    vars.def_duration_tick = 0
    vars.def_duration_target = 0
    vars.def_duration_active = false
    vars.flctl_mode = "Off"
    vars.flctl_limit = 0
    vars.flctl_cycle = 0
    vars.flctl_state = "off"
    vars.flctl_last_shot_time = 0
    vars.jitter_random_pick = 0
    vars.jitter_switch_tick = 0
    vars.jitter_switch_state = false
    vars.jitter_rand_noise = 0
    vars.flu.idx = 0
    vars.flu.random_val = 0
    vars.abf_ticks_left = 0
    vars.abf_side = 1
    vars.abf_last_reason = "none"
    vars.abf_state = "idle"
    vars.body_yaw_side = -1
    vars.body_yaw_value = 0
    vars.body_dynamic_value = 0
    vars.body_fake_value = 0
    vars.body_live_amount = 0
    vars.body_overlap = 0
    vars.nondef_drift_phase = 0
    vars.nondef_drift = 0
    vars.state_detect_idx = 2
    vars.state_detect_candidate = 2
    vars.state_detect_ticks = 0
    vars.aa_runtime = {}
    vars.combat_threat = "idle"
    vars.combat_threat_name = ""
    vars.combat_threat_until = 0
    vars.combat_pred_until = 0
    vars.combat_last_impact_tick = 0
end

client_set_event_callback("predict_command", exploit_on_predict)
client_set_event_callback("run_command", exploit_on_run)
client_set_event_callback("net_update_start", exploit_on_net_update)

-- ===================== MENU SYSTEM =====================
local menu_tab = "AA"

-- Navigation in separate container to avoid builder overflow
ui.new_label(menu_tab, "Fake lag", "\\a8C78FFFF•  \\aFFFFFFFFCynicism")
ui.new_label(menu_tab, "Fake lag", "\\a333333FF━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
local active_tab = ui.new_combobox(menu_tab, "Fake lag", "Tabs", { "Anti-Aim", "Visuals", "Misc", "Config" })
local condition_selector = ui.new_combobox(menu_tab, "Fake lag", "Condition", conditions)

-- ===================== PER-CONDITION AA BUILDER =====================
local builder = {}
do
local menu_container = "Anti-aimbot angles"
for i, tag in ipairs(conditions) do
    builder[i] = {
        enabled = ui.new_checkbox(menu_tab, menu_container, "Enable [" .. tag .. "]"),
        -- Pitch
        pitch = ui.new_combobox(menu_tab, menu_container, "Pitch [" .. tag .. "]", { "Off", "Default", "Down", "Minimal", "Up", "Custom", "Random" }),
        custom_pitch = ui.new_slider(menu_tab, menu_container, "Custom Pitch [" .. tag .. "]", -89, 89, 0, true, "deg"),
        -- Yaw
        yaw_base = ui.new_combobox(menu_tab, menu_container, "Yaw Base [" .. tag .. "]", { "At targets", "Local view" }),
        yaw_mode = ui.new_combobox(menu_tab, menu_container, "Yaw Mode [" .. tag .. "]", { "180", "Spin", "Rotation" }),
        global_yaw = ui.new_slider(menu_tab, menu_container, "Global Yaw [" .. tag .. "]", -180, 180, 0, true, "deg"),
        yaw_left = ui.new_slider(menu_tab, menu_container, "Left Yaw [" .. tag .. "]", -180, 180, 0, true, "deg"),
        yaw_right = ui.new_slider(menu_tab, menu_container, "Right Yaw [" .. tag .. "]", -180, 180, 0, true, "deg"),
        spin_speed = ui.new_slider(menu_tab, menu_container, "Spin Speed [" .. tag .. "]", 1, 50, 10, true),
        rotation_steps = ui.new_slider(menu_tab, menu_container, "Rotation Steps [" .. tag .. "]", 2, 6, 3, true),
        -- Jitter (upgraded: Frequence=tick-frequency toggle, Randomize=random-interval toggle)
        jitter_type = ui.new_combobox(menu_tab, menu_container, "Jitter [" .. tag .. "]", { "Off", "Offset", "Center", "Random", "Skitter", "3-Way", "5-Way", "Frequence", "Randomize" }),
        jitter_mode = ui.new_combobox(menu_tab, menu_container, "Jitter Mode [" .. tag .. "]", { "Static", "Switch", "Random", "Spin" }),
        jitter_val1 = ui.new_slider(menu_tab, menu_container, "Jitter Value 1 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        jitter_val2 = ui.new_slider(menu_tab, menu_container, "Jitter Value 2 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        jitter_way1 = ui.new_slider(menu_tab, menu_container, "Way 1 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        jitter_way2 = ui.new_slider(menu_tab, menu_container, "Way 2 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        jitter_way3 = ui.new_slider(menu_tab, menu_container, "Way 3 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        jitter_way4 = ui.new_slider(menu_tab, menu_container, "Way 4 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        jitter_way5 = ui.new_slider(menu_tab, menu_container, "Way 5 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        jitter_rand = ui.new_slider(menu_tab, menu_container, "Jitter Randomize [" .. tag .. "]", 0, 180, 0, true, "deg"),
        -- Frequence/Randomize speed (Paradise-style jitter queue timing)
        jitter_freq_speed = ui.new_slider(menu_tab, menu_container, "Freq Speed [" .. tag .. "]", 1, 20, 4, true, "t"),
        -- Body Yaw
        body_yaw = ui.new_combobox(menu_tab, menu_container, "Body Yaw [" .. tag .. "]", { "Off", "Opposite", "Static", "Jitter" }),
        body_side = ui.new_slider(menu_tab, menu_container, "Body Side [" .. tag .. "]", 0, 1, 0, true, nil, 1, {[0]="Left", [1]="Right"}),
        body_delay_mode = ui.new_combobox(menu_tab, menu_container, "Body Delay [" .. tag .. "]", { "Static", "Switch" }),
        body_delay_ticks = ui.new_slider(menu_tab, menu_container, "Delay Ticks [" .. tag .. "]", 1, 12, 1, true, "t"),
        body_delay_left = ui.new_slider(menu_tab, menu_container, "Left Ticks [" .. tag .. "]", 1, 12, 1, true, "t"),
        body_delay_right = ui.new_slider(menu_tab, menu_container, "Right Ticks [" .. tag .. "]", 1, 12, 1, true, "t"),
        body_delay_switch = ui.new_slider(menu_tab, menu_container, "Switch Ticks [" .. tag .. "]", 0, 50, 0, true, "t"),
        fake_limit_left = ui.new_slider(menu_tab, menu_container, "[L] Fake Limit [" .. tag .. "]", 0, 60, 0, true),
        fake_limit_right = ui.new_slider(menu_tab, menu_container, "[R] Fake Limit [" .. tag .. "]", 0, 60, 0, true),
        -- Roll
        roll_amount = ui.new_slider(menu_tab, menu_container, "Roll [" .. tag .. "]", -45, 45, 0, true, "deg"),
        -- Backstab
        backstab = ui.new_combobox(menu_tab, menu_container, "Backstab [" .. tag .. "]", { "Off", "Forward", "Random" }),
        -- Extra
        height_safe = ui.new_slider(menu_tab, menu_container, "Height Safe [" .. tag .. "]", 25, 250, 50, true),
        fs_body_yaw = ui.new_checkbox(menu_tab, menu_container, "FS Body Yaw [" .. tag .. "]"),
        -- ===== DEFENSIVE BUILDER (Paradise EVO level) =====
        def_enable = ui.new_checkbox(menu_tab, menu_container, "\\a8C78FFFFDefensive Builder [" .. tag .. "]"),
        def_force = ui.new_checkbox(menu_tab, menu_container, "Force Defensive [" .. tag .. "]"),
        def_fake_flick = ui.new_checkbox(menu_tab, menu_container, "Fake Flick [" .. tag .. "]"),
        -- Tick range (Paradise: defrange1/defrange2)
        def_range1 = ui.new_slider(menu_tab, menu_container, "Def Tick Min [" .. tag .. "]", 0, 15, 0, true, "t"),
        def_range2 = ui.new_slider(menu_tab, menu_container, "Def Tick Max [" .. tag .. "]", 0, 15, 15, true, "t"),
        -- Addons (Paradise: Sideflick / Knife skip / Override Bodyyaw)
        def_addons = ui.new_multiselect(menu_tab, menu_container, "Def Addons [" .. tag .. "]", { "Sideflick on LC End", "Disable while Knife", "Override Bodyyaw" }),
        def_ensinv = ui.new_combobox(menu_tab, menu_container, "Bodyyaw Type [" .. tag .. "]", { "Left", "Right", "Jitter", "Overlap", "De-Overlap" }),
        -- Desync mode (Paradise: Independ/ForceStatic/DefAdaptive/NoChoke)
        desync_mode = ui.new_combobox(menu_tab, menu_container, "Desync Mode [" .. tag .. "]", { "Independ", "Force Static", "Def Adaptive", "NoChoke" }),
        desync_inver = ui.new_checkbox(menu_tab, menu_container, "Desync Inverter [" .. tag .. "]"),
        -- Body Yaw Left/Right limits + jitter queue (Paradise style)
        by_l = ui.new_slider(menu_tab, menu_container, "BYaw Left [" .. tag .. "]", 0, 60, 60, true),
        by_r = ui.new_slider(menu_tab, menu_container, "BYaw Right [" .. tag .. "]", 0, 60, 60, true),
        by_jitter_type = ui.new_combobox(menu_tab, menu_container, "BY Jitter Type [" .. tag .. "]", { "Frequence", "Randomize" }),
        by_jitter_que = ui.new_slider(menu_tab, menu_container, "BY Ways [" .. tag .. "]", 1, 8, 1, true),
        by_way1 = ui.new_slider(menu_tab, menu_container, "BY Way1 [" .. tag .. "]", 0, 16, 1, true, "t"),
        by_way2 = ui.new_slider(menu_tab, menu_container, "BY Way2 [" .. tag .. "]", 0, 16, 1, true, "t"),
        by_way3 = ui.new_slider(menu_tab, menu_container, "BY Way3 [" .. tag .. "]", 0, 16, 1, true, "t"),
        by_way4 = ui.new_slider(menu_tab, menu_container, "BY Way4 [" .. tag .. "]", 0, 16, 0, true, "t"),
        by_way5 = ui.new_slider(menu_tab, menu_container, "BY Way5 [" .. tag .. "]", 0, 16, 0, true, "t"),
        by_way6 = ui.new_slider(menu_tab, menu_container, "BY Way6 [" .. tag .. "]", 0, 16, 0, true, "t"),
        by_way7 = ui.new_slider(menu_tab, menu_container, "BY Way7 [" .. tag .. "]", 0, 16, 0, true, "t"),
        by_way8 = ui.new_slider(menu_tab, menu_container, "BY Way8 [" .. tag .. "]", 0, 16, 0, true, "t"),
        def_disablers = ui.new_multiselect(menu_tab, menu_container, "Def Disablers [" .. tag .. "]", { "Body Yaw", "Yaw Jitter" }),
        def_global_offset = ui.new_slider(menu_tab, menu_container, "Def Yaw Offset [" .. tag .. "]", -180, 180, 0, true, "deg"),
        -- Defensive Pitch (Paradise: Jitter/Spin/Sway/Multiway/Generation/Random/Bodyyaw | Eternal: Zero/Up/Randomize Jitter)
        def_pitch = ui.new_combobox(menu_tab, menu_container, "Def Pitch [" .. tag .. "]", { "None", "Jitter", "Spin", "Sway", "Multiway", "Generation", "Random", "Bodyyaw", "Progressive", "Wave", "Random Static", "LC End", "Custom", "Zero", "Up", "Randomize Jitter" }),
        def_pitch_val = ui.new_slider(menu_tab, menu_container, "Def Pitch Value [" .. tag .. "]", -89, 89, 0, true, "deg"),
        def_pitch_speed = ui.new_slider(menu_tab, menu_container, "Def Pitch Speed [" .. tag .. "]", 1, 50, 10, true),
        def_pitch_min = ui.new_slider(menu_tab, menu_container, "Def Pitch Min [" .. tag .. "]", -89, 89, -89, true, "deg"),
        def_pitch_max = ui.new_slider(menu_tab, menu_container, "Def Pitch Max [" .. tag .. "]", -89, 89, 89, true, "deg"),
        def_pitch_que = ui.new_slider(menu_tab, menu_container, "Def Pitch Ways [" .. tag .. "]", 1, 8, 3, true),
        def_pitch_way1 = ui.new_slider(menu_tab, menu_container, "DP Way1 [" .. tag .. "]", -89, 89, -89, true, "deg"),
        def_pitch_way2 = ui.new_slider(menu_tab, menu_container, "DP Way2 [" .. tag .. "]", -89, 89, 0, true, "deg"),
        def_pitch_way3 = ui.new_slider(menu_tab, menu_container, "DP Way3 [" .. tag .. "]", -89, 89, 89, true, "deg"),
        def_pitch_way4 = ui.new_slider(menu_tab, menu_container, "DP Way4 [" .. tag .. "]", -89, 89, 0, true, "deg"),
        def_pitch_way5 = ui.new_slider(menu_tab, menu_container, "DP Way5 [" .. tag .. "]", -89, 89, 0, true, "deg"),
        def_pitch_way6 = ui.new_slider(menu_tab, menu_container, "DP Way6 [" .. tag .. "]", -89, 89, 0, true, "deg"),
        def_pitch_way7 = ui.new_slider(menu_tab, menu_container, "DP Way7 [" .. tag .. "]", -89, 89, 0, true, "deg"),
        def_pitch_way8 = ui.new_slider(menu_tab, menu_container, "DP Way8 [" .. tag .. "]", -89, 89, 0, true, "deg"),
        -- Defensive Yaw (Paradise: Jitter/Spin/Sway/Multiway/Generation/Random/Bodyyaw | Eternal: Forward/Random Static cache)
        def_yaw = ui.new_combobox(menu_tab, menu_container, "Def Yaw [" .. tag .. "]", { "None", "Jitter", "Spin", "Sway", "Multiway", "Generation", "Random", "Bodyyaw", "Sideways", "Sideways 45", "Progressive", "Yaw Side", "Spin Jitter", "Flick", "Clock", "Adaptive", "Random Static", "LC End", "Wave", "Custom", "Forward" }),
        def_yaw_val = ui.new_slider(menu_tab, menu_container, "Def Yaw Value [" .. tag .. "]", -180, 180, 0, true, "deg"),
        def_yaw_speed = ui.new_slider(menu_tab, menu_container, "Def Yaw Speed [" .. tag .. "]", 1, 50, 10, true),
        def_yaw_min = ui.new_slider(menu_tab, menu_container, "Def Yaw Min [" .. tag .. "]", -180, 180, -180, true, "deg"),
        def_yaw_max = ui.new_slider(menu_tab, menu_container, "Def Yaw Max [" .. tag .. "]", -180, 180, 180, true, "deg"),
        -- Eternal additions
        def_delay_ticks = ui.new_slider(menu_tab, menu_container, "Def Delay Ticks [" .. tag .. "]", 1, 10, 1, true, "t"),
        def_spin_start = ui.new_slider(menu_tab, menu_container, "Def Spin Start Offset [" .. tag .. "]", -180, 180, 0, true, "deg"),
        def_spin_reverse = ui.new_checkbox(menu_tab, menu_container, "Reverse Def Spin [" .. tag .. "]"),
        def_yaw_que = ui.new_slider(menu_tab, menu_container, "Def Yaw Ways [" .. tag .. "]", 1, 8, 3, true),
        def_yaw_way1 = ui.new_slider(menu_tab, menu_container, "DY Way1 [" .. tag .. "]", -180, 180, -90, true, "deg"),
        def_yaw_way2 = ui.new_slider(menu_tab, menu_container, "DY Way2 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        def_yaw_way3 = ui.new_slider(menu_tab, menu_container, "DY Way3 [" .. tag .. "]", -180, 180, 90, true, "deg"),
        def_yaw_way4 = ui.new_slider(menu_tab, menu_container, "DY Way4 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        def_yaw_way5 = ui.new_slider(menu_tab, menu_container, "DY Way5 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        def_yaw_way6 = ui.new_slider(menu_tab, menu_container, "DY Way6 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        def_yaw_way7 = ui.new_slider(menu_tab, menu_container, "DY Way7 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        def_yaw_way8 = ui.new_slider(menu_tab, menu_container, "DY Way8 [" .. tag .. "]", -180, 180, 0, true, "deg"),
        -- Wave params (Cathode NL)
        def_wave_type = ui.new_combobox(menu_tab, menu_container, "Wave Shape [" .. tag .. "]", { "Sine", "Triangle", "Saw" }),
        def_wave_period = ui.new_slider(menu_tab, menu_container, "Wave Period [" .. tag .. "]", 10, 200, 50, true, "%"),
        def_wave_invert = ui.new_checkbox(menu_tab, menu_container, "Wave Invert [" .. tag .. "]"),
        -- Clock params (Cathode NL)
        def_clock_step = ui.new_slider(menu_tab, menu_container, "Clock Step [" .. tag .. "]", 0, 90, 0, true, "deg"),
        def_clock_dir = ui.new_combobox(menu_tab, menu_container, "Clock Dir [" .. tag .. "]", { "Clockwise", "Counter" }),
        def_clock_jitter = ui.new_slider(menu_tab, menu_container, "Clock Jitter [" .. tag .. "]", 0, 60, 0, true),
        -- ===== CATHODE: Defensive Tick Mode =====
        -- def_mode: how the defensive tick range is decided
        -- "Neverlose"  = use cybernetics's own exploit tracking (breaking_lc/max_tickbase)
        -- "Custom"     = min/max user range (def_range1/2 already exist above)
        -- "Flick"      = cyclic trigger by internal tick driver (no cmd dependency)
        -- "Duration"   = only keep defensive for N ticks after entering defensive window
        -- "LC End"     = only active at the tail of defensive tick window
        -- "Always"     = always active when builder enabled
        def_mode = ui.new_combobox(menu_tab, menu_container, "Def Mode [" .. tag .. "]", { "Neverlose", "Custom", "Flick", "Duration", "LC End", "Always", "Limit", "Peek", "Charge", "Near Start", "Center", "Edges", "Profile" }),
        def_profile = ui.new_combobox(menu_tab, menu_container, "Def Profile [" .. tag .. "]", {
            "Legacy",
            "Abyss Core",
            "Abyss Tight",
            "Abyss Float",
            "Cathode Flick",
            "Cathode Jitter",
            "Cathode Pulse",
            "Paradise EVO",
            "Paradise Autumn",
            "Paradise Safe",
            "Hybrid Adaptive",
            "Hybrid Aggressive",
            "Hybrid Stealth",
            "Hybrid Rush",
            "Burst Unstable",
            "Limit Keeper",
            "LC End Force",
            "Peek Trigger",
            "Charge Assist",
            "Tournament Safe",
            "HVH Unsafe",
            "HVH Dynamic",
            "Mirror Chaos",
            "Flux Pulse",
            "Tension Balance",
            "Counter Step",
            "Late Tick",
            "Early Tick",
            "Center Pivot",
            "Edges Guard",
        }),
        def_runtime = ui.new_combobox(menu_tab, menu_container, "Def Runtime [" .. tag .. "]", { "Balanced", "Aggressive", "Stealth", "Adaptive", "Unstable" }),
        def_harden = ui.new_checkbox(menu_tab, menu_container, "Def Harden Driver [" .. tag .. "]"),
        def_harden_scale = ui.new_slider(menu_tab, menu_container, "Def Harden Scale [" .. tag .. "]", 0, 100, 45, true, "%"),
        def_tick_bias = ui.new_slider(menu_tab, menu_container, "Def Tick Bias [" .. tag .. "]", -8, 8, 0, true, "t"),
        def_tick_guard = ui.new_combobox(menu_tab, menu_container, "Def Tick Guard [" .. tag .. "]", { "Off", "Near End", "Near Start", "Center", "Edges" }),
        def_tick_guard_window = ui.new_slider(menu_tab, menu_container, "Def Guard Window [" .. tag .. "]", 1, 8, 2, true, "t"),
        def_check_mode = ui.new_combobox(menu_tab, menu_container, "Def Check Mode [" .. tag .. "]", { "Tickbase", "Command Num" }),
        def_flick_trigger = ui.new_combobox(menu_tab, menu_container, "Def Flick Trigger [" .. tag .. "]", { "Simple", "Advance" }),
        def_flick_tick_mode = ui.new_combobox(menu_tab, menu_container, "Def Flick Tick Mode [" .. tag .. "]", { "Static", "Random", "Random Static", "Random Trigger", "Random Jitter", "Jitter", "Cycle", "Prime", "Burst Cycle", "Entropy", "Beta" }),
        def_flick_tick_min = ui.new_slider(menu_tab, menu_container, "Def Flick Min [" .. tag .. "]", 1, 22, 7, true, "t"),
        def_flick_tick_max = ui.new_slider(menu_tab, menu_container, "Def Flick Max [" .. tag .. "]", 1, 22, 10, true, "t"),
        def_flick_cycle_speed = ui.new_slider(menu_tab, menu_container, "Def Flick Cycle [" .. tag .. "]", 1, 40, 6, true, "t"),
        def_flick_jitter_repeat = ui.new_slider(menu_tab, menu_container, "Def Flick Repeat [" .. tag .. "]", 1, 32, 4, true, "t"),
        def_flick_time = ui.new_slider(menu_tab, menu_container, "Def Flick Time [" .. tag .. "]", 1, 22, 2, true, "t"),
        def_back_time = ui.new_slider(menu_tab, menu_container, "Def Back Time [" .. tag .. "]", 1, 22, 8, true, "t"),
        def_flick_packets = ui.new_slider(menu_tab, menu_container, "Def Flick Packets [" .. tag .. "]", 0, 22, 11, true, "t"),
        def_pred_enable = ui.new_checkbox(menu_tab, menu_container, "Def Prediction Max [" .. tag .. "]"),
        def_pred_mode = ui.new_combobox(menu_tab, menu_container, "Def Prediction Mode [" .. tag .. "]", { "Maximum", "Adaptive", "Pulse" }),
        def_pred_flick = ui.new_slider(menu_tab, menu_container, "Def Prediction Flick [" .. tag .. "]", 1, 20, 2, true, "t"),
        def_pred_back = ui.new_slider(menu_tab, menu_container, "Def Prediction Back [" .. tag .. "]", 1, 24, 8, true, "t"),
        def_pred_choke = ui.new_slider(menu_tab, menu_container, "Def Prediction Choke [" .. tag .. "]", 1, 16, 12, true, "t"),
        def_flick_hidden = ui.new_checkbox(menu_tab, menu_container, "Def Flick Hidden [" .. tag .. "]"),
        def_flick_limit = ui.new_checkbox(menu_tab, menu_container, "Def Flick Limit [" .. tag .. "]"),
        def_flick_desync_release = ui.new_checkbox(menu_tab, menu_container, "Def Desync Release [" .. tag .. "]"),
        def_flick_desync_mode = ui.new_combobox(menu_tab, menu_container, "Def Release Mode [" .. tag .. "]", { "Follow", "Opposite" }),
        def_mode_tick = ui.new_slider(menu_tab, menu_container, "Def Flick Tick [" .. tag .. "]", 1, 30, 8, true, "t"),
        def_duration_mode = ui.new_combobox(menu_tab, menu_container, "Def Duration Mode [" .. tag .. "]", { "Static", "Stages", "Random", "Adaptive" }),
        def_duration_bias = ui.new_slider(menu_tab, menu_container, "Def Duration Bias [" .. tag .. "]", -5, 5, 0, true, "t"),
        def_duration_stages = ui.new_slider(menu_tab, menu_container, "Def Duration Stages [" .. tag .. "]", 1, 8, 3, true),
        def_duration_stage1 = ui.new_slider(menu_tab, menu_container, "Duration Stage 1 [" .. tag .. "]", 1, 30, 4, true, "t"),
        def_duration_stage2 = ui.new_slider(menu_tab, menu_container, "Duration Stage 2 [" .. tag .. "]", 1, 30, 8, true, "t"),
        def_duration_stage3 = ui.new_slider(menu_tab, menu_container, "Duration Stage 3 [" .. tag .. "]", 1, 30, 12, true, "t"),
        def_duration_stage4 = ui.new_slider(menu_tab, menu_container, "Duration Stage 4 [" .. tag .. "]", 1, 30, 16, true, "t"),
        def_duration_stage5 = ui.new_slider(menu_tab, menu_container, "Duration Stage 5 [" .. tag .. "]", 1, 30, 20, true, "t"),
        def_duration_stage6 = ui.new_slider(menu_tab, menu_container, "Duration Stage 6 [" .. tag .. "]", 1, 30, 24, true, "t"),
        def_duration_stage7 = ui.new_slider(menu_tab, menu_container, "Duration Stage 7 [" .. tag .. "]", 1, 30, 28, true, "t"),
        def_duration_stage8 = ui.new_slider(menu_tab, menu_container, "Duration Stage 8 [" .. tag .. "]", 1, 30, 30, true, "t"),
        def_duration_min = ui.new_slider(menu_tab, menu_container, "Def Duration Min [" .. tag .. "]", 1, 30, 3, true, "t"),
        def_duration_max = ui.new_slider(menu_tab, menu_container, "Def Duration Max [" .. tag .. "]", 1, 30, 12, true, "t"),
        -- ===== CATHODE: Delay Mode (fakelag delay between LC breaks) =====
        delay_base = ui.new_checkbox(menu_tab, menu_container, "Delay Base [" .. tag .. "]"),
        delay_mode = ui.new_combobox(menu_tab, menu_container, "Delay Mode [" .. tag .. "]", { "Static", "Random", "Jitter", "Random Jitter", "JitterTick", "Cycle", "CycleSpin", "Burst", "Stair", "Random Trigger", "Fluctuate" }),
        delay_static_tick = ui.new_slider(menu_tab, menu_container, "Delay Static [" .. tag .. "]", 1, 64, 1, true, "t"),
        delay_min_tick = ui.new_slider(menu_tab, menu_container, "Delay Min [" .. tag .. "]", 1, 32, 1, true, "t"),
        delay_max_tick = ui.new_slider(menu_tab, menu_container, "Delay Max [" .. tag .. "]", 1, 64, 6, true, "t"),
        delay_jitter_speed = ui.new_slider(menu_tab, menu_container, "Delay Jitter Speed [" .. tag .. "]", 1, 15, 1, true, "t"),
        delay_jitter_var = ui.new_slider(menu_tab, menu_container, "Delay Jitter Variance [" .. tag .. "]", 0, 10, 0, true, "t"),
        delay_cycle_speed = ui.new_slider(menu_tab, menu_container, "Delay Cycle [" .. tag .. "]", 1, 20, 1, true, "t"),
    }
end
end
-- Global always enabled
ui_set(builder[1].enabled, true); ui.set_visible(builder[1].enabled, false)

-- ===================== MISC TAB ITEMS =====================
local menu2 = "Fake lag"  -- Use separate container to avoid GS element limit in "Anti-aimbot angles"
local misc_features = ui.new_multiselect(menu_tab, menu2, "Features", { "Freestanding", "Legit AA", "Edge Yaw", "Manual AA", "Leg Breaker", "Hide Shot Fix", "Warmup Disabler", "Avoid Backstab" })
local freestanding_key = ui.new_hotkey(menu_tab, menu2, "Freestanding Key", false)
local legit_aa_key = ui.new_hotkey(menu_tab, menu2, "Legit AA Key", false, 0x45)
local edge_yaw_key = ui.new_hotkey(menu_tab, menu2, "Edge Yaw Key", false)
local manual_left_key = ui.new_hotkey(menu_tab, menu2, "Manual Left", false)
local manual_right_key = ui.new_hotkey(menu_tab, menu2, "Manual Right", false)
local manual_forward_key = ui.new_hotkey(menu_tab, menu2, "Manual Forward", false)
local force_def_key = ui.new_hotkey(menu_tab, menu2, "Force Defensive", false)
local fs_disablers = ui.new_multiselect(menu_tab, menu2, "FS Disablers", { "Slowwalk", "In Air", "Crouching", "Moving", "Body Yaw", "Yaw Jitter" })
local force_def_conds = ui.new_multiselect(menu_tab, menu2, "Force Def Conditions", conditions)
local anim_breaker = ui.new_combobox(menu_tab, menu2, "Animation Breaker", { "Off", "Static", "No Step Back", "Jitter" })

-- Safe Head conditions
local safe_head_conds = ui.new_multiselect(menu_tab, menu2, "Safe Head Triggers", { "Knife", "Zeus", "Height Advantage" })

-- Killsay
local killsay_enable = ui.new_checkbox(menu_tab, menu2, "Killsay")
local killsay_mode = ui.new_combobox(menu_tab, menu2, "Killsay Mode", { "Normal", "R18" })

local killsay_normal = {
    "你已被 Cynicism.lua 击毙 ♡",
    "Cynicism sends regards.",
    "又一个被 Cynicism 支配的可怜虫",
    "Cynicism.lua — 无情的击杀机器",
    "别挣扎了，Cynicism 已经锁定你",
    "你的防御在 Cynicism 面前不堪一击",
    "Cynicism 判你死刑，立即执行",
    "技不如人，甘拜下风 —— Cynicism",
    "你已被 Cynicism 永久除名",
    "GG | Powered by Cynicism.lua",
    "Cynicism says: 下次注意走位",
    "你刚才做了什么？哦，你死了 —— Cynicism",
    "Cynicism.lua 精准制裁",
    "这就是和 Cynicism 对线的下场",
    "Cynicism 的子弹从不说谎",
    "你的准星对不上 Cynicism 的节奏",
    "Cynicism Anti-Aim: 你瞄得到算我输",
    "被我的 Cynicism 一枪带走，不冤吧？",
    "Cynicism.lua — 幻神级 AA 体验",
    "对面的，你的 resolver 解不了我",
    "Cynicism 已将你标记为免费击杀",
    "你只是 Cynicism 今日击杀统计的一部分",
    "想赢我？先过 Cynicism 这一关吧",
    "Cynicism: 你已经死了，只是还不知道而已",
}

local killsay_r18 = {
    "杂鱼这就不行啦❤~技术真菜❤~~wwww~~",
    "♡啊啦~那孩子~去了呢♡好舒服的样子呢~♡",
    "杂鱼♡别~别碰我♡呜~慢~慢一点啊",
    "呜♡有杂鱼恶心的东西进来了",
    "杂鱼~这么容易击败啊♡~真的好蠢哦♡",
    "变成~♡人家的~♡形状吧~♡",
    "呀❤被打倒了呢~杂鱼好弱啊♡",
    "杂鱼♡怎么这么快就倒了♡~不够尽兴呢❤",
    "讨厌~♡杂鱼的子弹好痒♡一点感觉都没有❤",
    "呜嗯♡杂鱼又死了♡~再来一次嘛~♡",
    "♡好热♡杂鱼的灵魂正在被吞噬呢❤",
    "啊♡杂鱼好可爱♡倒下的样子最棒了❤~~",
    "杂鱼~♡挡不住了吧♡~人家还没认真呢❤",
    "杂鱼的身体好老实啊♡~躺得真乖❤",
    "呜♡杂鱼你抖什么♡~害怕了吗❤~~",
    "杂鱼♡不要逃啊♡~人家追上来了哦❤",
    "♡好棒♡杂鱼又给了一个人头呢❤~~",
    "嘻嘻♡杂鱼真是最好的经验包❤",
    "杂鱼~♡你的准星在发抖哦♡~紧张了吗❤",
    "呜啊♡好舒服♡杂鱼的击杀奖励好多❤",
    "♡别、别看♡人家只是在虐杂鱼而已❤",
    "杂鱼♡要乖乖倒下哦♡~这是命令❤",
    "呜嗯~♡人家对杂鱼做了好过分的事❤~~",
    "杂鱼的身体诚实得很嘛♡~直接倒了呢❤",
}
-- ===================== CHEAT SPOOFER =====================
local spoof_sep = ui.new_label(menu_tab, menu2, "\\a8C78FFFF--- Cheat Spoofer ---")
local spoof_enable = ui.new_checkbox(menu_tab, menu2, "Enable Spoofer")
local spoof_mode = ui.new_combobox(menu_tab, menu2, "Spoof Mode", { "Hide Signatures", "Spoof As..." })
local spoof_target = ui.new_combobox(menu_tab, menu2, "Target Cheat", { "Neverlose", "Nixware", "Pandora", "Onetap", "Fatality", "Plaguecheat", "Ev0lve", "Rifk7", "Airflow", "Gamesense" })
local spoof_randomize = ui.new_checkbox(menu_tab, menu2, "Randomize Patterns")
local spoof_status = ui.new_label(menu_tab, menu2, "Status: Idle")

-- ===================== SCOPE FOV / FAST LADDER / ASPECT RATIO / CLANTAG =====================
vars.misc_sep2 = ui.new_label(menu_tab, menu2, "\\a8C78FFFF--- Misc Enhancements ---")
vars.scope_fov_slider = ui.new_slider(menu_tab, menu2, "Second Zoom FOV", 0, 100, 0, true, "%", 1, {[0] = "Off"})
vars.fast_ladder_cb = ui.new_checkbox(menu_tab, menu2, "Fast Ladder")
vars.jump_shot_cb = ui.new_checkbox(menu_tab, menu2, "Jump Shot Air Stop")
local aspect_ratio_slider = ui.new_slider(menu_tab, menu2, "Aspect Ratio", 0, 300, 0, true, "%", 1, {[0] = "Off"})
local clantag_cb = ui.new_checkbox(menu_tab, menu2, "Clantag Animation")
local console_filter_cb = ui.new_checkbox(menu_tab, menu2, "Console Filter")
vars.flctl_enable = ui.new_checkbox(menu_tab, menu2, "FL Controller")
vars.flctl_mode_ref = ui.new_combobox(menu_tab, menu2, "FL Mode", { "Off", "Neverlose", "Fluctuate", "Cycle", "Random", "Dynamic" })
vars.flctl_min = ui.new_slider(menu_tab, menu2, "FL Min", 1, 62, 2, true, "t")
vars.flctl_max = ui.new_slider(menu_tab, menu2, "FL Max", 1, 62, 14, true, "t")
vars.flctl_step = ui.new_slider(menu_tab, menu2, "FL Step", 1, 10, 1, true, "t")
vars.flctl_force = ui.new_checkbox(menu_tab, menu2, "FL Force Packet")
vars.flctl_disable_exploit = ui.new_checkbox(menu_tab, menu2, "FL Disable On Exploit")
vars.flctl_nade_opt = ui.new_checkbox(menu_tab, menu2, "FL Nade Optimize")
vars.flctl_onshot = ui.new_combobox(menu_tab, menu2, "FL On Shot", { "Off", "Reset FL", "Send Packet", "Choke" })
vars.flctl_shot_window = ui.new_slider(menu_tab, menu2, "FL Shot Window", 1, 16, 5, true, "t")
vars.abf_enable = ui.new_checkbox(menu_tab, menu2, "Anti Bruteforce")
vars.abf_trigger = ui.new_combobox(menu_tab, menu2, "ABF Trigger", { "Resolver miss", "Any miss" })
vars.abf_ticks = ui.new_slider(menu_tab, menu2, "ABF Pulse Ticks", 1, 32, 10, true, "t")
vars.abf_yaw_add = ui.new_slider(menu_tab, menu2, "ABF Yaw Add", 1, 180, 50, true, "deg")
vars.abf_force_invert = ui.new_checkbox(menu_tab, menu2, "ABF Force Invert")

-- ===================== VISUALS TAB ITEMS =====================
local vis_indicators = ui.new_multiselect(menu_tab, menu2, "Indicators", { "Manual Arrows", "State Display", "Desync Bar", "Branding", "Defensive Ticks", "Exploit Info", "FL Status", "ABF Status", "Keybind List", "Spectator List" })
local vis_welcome = ui.new_checkbox(menu_tab, menu2, "Welcome Screen")
local vis_indicator_color = ui.new_color_picker(menu_tab, menu2, "Indicator Color", SCRIPT_COLOR.r, SCRIPT_COLOR.g, SCRIPT_COLOR.b, 255)
local vis_hud_style = ui.new_combobox(menu_tab, menu2, "HUD Style", { "Classic", "Mini" })

-- Custom Scope
local vis_scope_sep = ui.new_label(menu_tab, menu2, "\\a8C78FFFF--- Custom Scope ---")
local vis_scope_enable = ui.new_checkbox(menu_tab, menu2, "Custom Scope Lines")
local vis_scope_color = ui.new_color_picker(menu_tab, menu2, "Scope Color", 140, 120, 255, 255)
local vis_scope_pos = ui.new_slider(menu_tab, menu2, "Scope Position", 0, 500, 190)
local vis_scope_offset = ui.new_slider(menu_tab, menu2, "Scope Offset", 0, 500, 15)
local vis_scope_speed = ui.new_slider(menu_tab, menu2, "Scope Fade Speed", 3, 20, 12, true, "fr", 1, {[3] = "Off"})

-- Shot Logger + Hitmarker
local vis_shot_log = ui.new_checkbox(menu_tab, menu2, "Shot Logger")
local vis_hitmarker = ui.new_checkbox(menu_tab, menu2, "Hitmarker")
local vis_combat_alerts = ui.new_multiselect(menu_tab, menu2, "Combat Alerts", { "Incoming Shot", "Threat Badge", "Toast Logs", "Kill Alerts" })
local vis_esp_preview = ui.new_checkbox(menu_tab, menu2, "ESP Preview (Horus)")

local esp_preview_refs = {
    name = { ui.reference("VISUALS", "Player ESP", "Name") },
    box = { ui.reference("VISUALS", "Player ESP", "Bounding box") },
    skeleton = { ui.reference("VISUALS", "Player ESP", "Skeleton") },
    health = { ui.reference("VISUALS", "Player ESP", "Health bar") },
    flags = { ui.reference("VISUALS", "Player ESP", "Flags") },
    glow = { ui.reference("VISUALS", "Player ESP", "Glow") },
    weapon_text = { ui.reference("VISUALS", "Player ESP", "Weapon text") },
    weapon_icon = { ui.reference("VISUALS", "Player ESP", "Weapon icon") },
    ammo = { ui.reference("VISUALS", "Player ESP", "Ammo") },
    distance = { ui.reference("VISUALS", "Player ESP", "Distance") },
    money = { ui.reference("VISUALS", "Player ESP", "Money") },
}

local combat_notifications = {}

local function push_combat_notification(label, text, color, duration)
    if text == nil or text == "" then
        return
    end

    table.insert(combat_notifications, 1, {
        label = tostring(label or "alert"),
        text = tostring(text),
        color = color or { SCRIPT_COLOR.r, SCRIPT_COLOR.g, SCRIPT_COLOR.b },
        time = globals_realtime(),
        duration = duration or 2.8,
        alpha = 0,
        slide = 0
    })

    while #combat_notifications > 5 do
        table.remove(combat_notifications)
    end
end

local function get_camera_pos(ent)
    local ox, oy, oz = entity_get_prop(ent, "m_vecOrigin")
    if ox == nil then
        return nil
    end

    local _, _, view_ofs = entity_get_prop(ent, "m_vecViewOffset")
    local duck = entity_get_prop(ent, "m_flDuckAmount") or 0
    return ox, oy, oz + (view_ofs or 64) - duck * 16
end

local function fired_at_target(target, shooter, shot)
    local sx, sy, sz = get_camera_pos(shooter)
    local hx, hy, hz = entity_hitbox_position(target, 0)
    if sx == nil or hx == nil or shot == nil then
        return false
    end

    local shot_dx, shot_dy, shot_dz = shot[1] - sx, shot[2] - sy, shot[3] - sz
    local shot_len_sq = shot_dx * shot_dx + shot_dy * shot_dy + shot_dz * shot_dz
    if shot_len_sq <= 0.0001 then
        return false
    end

    local head_dx, head_dy, head_dz = hx - sx, hy - sy, hz - sz
    local proj = (head_dx * shot_dx + head_dy * shot_dy + head_dz * shot_dz) / shot_len_sq
    local closest_x = sx + shot_dx * proj
    local closest_y = sy + shot_dy * proj
    local closest_z = sz + shot_dz * proj
    local dist = math_sqrt((hx - closest_x) * (hx - closest_x) + (hy - closest_y) * (hy - closest_y) + (hz - closest_z) * (hz - closest_z))
    local frac_shot = client_trace_line(shooter, shot[1], shot[2], shot[3], hx, hy, hz)
    local frac_head = client_trace_line(target, closest_x, closest_y, closest_z, hx, hy, hz)
    return dist < 69 and (frac_shot > 0.99 or frac_head > 0.99)
end

local function will_enemy_shoot_soon(enemy, local_player)
    if enemy == nil or local_player == nil then
        return false
    end
    if not entity_is_alive(enemy) or not entity_is_alive(local_player) then
        return false
    end

    local ex, ey, ez = get_camera_pos(enemy)
    local hx, hy, hz = entity_hitbox_position(local_player, 0)
    if ex == nil or hx == nil then
        return false
    end

    local dir_x, dir_y, dir_z = hx - ex, hy - ey, hz - ez
    local dir_len = math_sqrt(dir_x * dir_x + dir_y * dir_y + dir_z * dir_z)
    if dir_len <= 0.001 then
        return false
    end
    dir_x, dir_y, dir_z = dir_x / dir_len, dir_y / dir_len, dir_z / dir_len

    local pitch, yaw = entity_get_prop(enemy, "m_angEyeAngles")
    yaw = yaw or select(2, entity_get_prop(enemy, "m_angEyeAngles"))
    if yaw == nil then
        return false
    end

    local fx, fy, fz = angle_to_forward(pitch or 0, yaw)
    if fx * dir_x + fy * dir_y + fz * dir_z <= 0.975 then
        return false
    end

    if client_trace_line(enemy, ex, ey, ez, hx, hy, hz) <= 0.82 then
        return false
    end

    local weapon = entity_get_player_weapon(enemy)
    if weapon == nil then
        return false
    end

    local weapon_data = csgo_weapons[entity_get_prop(weapon, "m_iItemDefinitionIndex")]
    if weapon_data and (weapon_data.type == "knife" or weapon_data.type == "grenade") then
        return false
    end

    local clip1 = entity_get_prop(weapon, "m_iClip1")
    if clip1 ~= nil and clip1 <= 0 then
        return false
    end

    local soon_time = globals_curtime() + globals_tickinterval() * 2
    local next_primary = entity_get_prop(weapon, "m_flNextPrimaryAttack")
    local next_player_attack = entity_get_prop(enemy, "m_flNextAttack")
    local can_shoot_weapon = next_primary == nil or soon_time >= next_primary
    local can_shoot_player = next_player_attack == nil or soon_time >= next_player_attack
    return can_shoot_weapon and can_shoot_player
end

local function update_combat_threat()
    local lp = entity_get_local_player()
    local rt = globals_realtime()
    if not lp or not entity_is_alive(lp) then
        vars.combat_threat = "idle"
        vars.combat_threat_name = ""
        vars.combat_threat_until = 0
        vars.combat_pred_until = 0
        return
    end

    if vars.combat_threat == "impact" and (vars.combat_threat_until or 0) > rt then
        return
    end

    if not has_multiselect(vis_combat_alerts, "Threat Badge") then
        vars.combat_threat = "idle"
        vars.combat_threat_name = ""
        vars.combat_threat_until = 0
        vars.combat_pred_until = 0
        return
    end

    local best_enemy, best_dist
    local threat = client_current_threat()
    local enemies = entity_get_players(true) or {}
    local hx, hy, hz = entity_hitbox_position(lp, 0)

    local function consider_enemy(enemy)
        if enemy == nil or enemy == lp or not entity_is_enemy(enemy) or not entity_is_alive(enemy) then
            return
        end
        if not will_enemy_shoot_soon(enemy, lp) then
            return
        end

        local ex, ey, ez = get_camera_pos(enemy)
        if ex == nil or hx == nil then
            best_enemy = best_enemy or enemy
            return
        end

        local dx, dy, dz = hx - ex, hy - ey, hz - ez
        local dist = dx * dx + dy * dy + dz * dz
        if best_dist == nil or dist < best_dist then
            best_dist = dist
            best_enemy = enemy
        end
    end

    consider_enemy(threat)
    for i = 1, #enemies do
        if enemies[i] ~= threat then
            consider_enemy(enemies[i])
        end
    end

    if best_enemy ~= nil then
        vars.combat_threat = "aimed"
        vars.combat_threat_name = entity.get_player_name(best_enemy) or ("enemy-" .. best_enemy)
        vars.combat_threat_until = 0
        vars.combat_pred_until = rt + 0.22
    elseif (vars.combat_pred_until or 0) <= rt then
        vars.combat_threat = "idle"
        vars.combat_threat_name = ""
        vars.combat_threat_until = 0
        vars.combat_pred_until = 0
    end
end

local function get_combat_badge_text()
    local rt = globals_realtime()
    if vars.combat_threat == "impact" and (vars.combat_threat_until or 0) > rt then
        return "impact"
    end
    if (vars.combat_pred_until or 0) > rt then
        return "aimed"
    end
    return nil
end

local function draw_combat_notifications(sw, sh, ir, ig, ib)
    if #combat_notifications == 0 then
        return
    end

    local compact = ui_get(vis_hud_style) == "Mini"
    local pal = get_hud_palette(ir, ig, ib, 1)
    local rt = globals_realtime()
    local ft = globals_frametime()
    local h = compact and 34 or 38
    local gap = 6
    local base_y = sh - (compact and 128 or 144)

    for i = #combat_notifications, 1, -1 do
        local entry = combat_notifications[i]
        local ttl = entry.duration or 2.8
        local alive = (rt - (entry.time or 0)) <= ttl
        entry.alpha = lerp(entry.alpha or 0, alive and 255 or 0, ft * (alive and 12 or 8))
        entry.slide = lerp(entry.slide or 0, alive and 1 or 0, ft * (alive and 11 or 7))

        local alpha = clamp(entry.alpha or 0, 0, 255)
        if alpha <= 1 and not alive then
            table.remove(combat_notifications, i)
        else
            local label = tostring(entry.label or "alert")
            local text = tostring(entry.text or "")
            local color = entry.color or { ir, ig, ib }
            local w = math_max(compact and 194 or 220, math_max(renderer_measure_text("", label), renderer_measure_text("", text)) + 38)
            local x = math_floor(sw * 0.5 - w * 0.5)
            local slide = clamp(entry.slide or 0, 0, 1)
            local y = math_floor(base_y - (1 - slide) * 18)
            local mul = alpha / 255

            draw_glass_panel(x, y, w, h, color[1], color[2], color[3], 0.95 * mul, compact)
            draw_round_rect(x + 8, y + 7, 3, h - 14, color[1], color[2], color[3], math_floor(alpha * 0.92), 2)
            draw_text_shadow(x + 18, y + (compact and 4 or 5), color[1], color[2], color[3], math_floor(alpha * 0.96), "", 0, label)
            draw_text_shadow(x + 18, y + (compact and 17 or 19), pal.text[1], pal.text[2], pal.text[3], math_floor(alpha * 0.94), "", 0, text)
            base_y = y - h - gap
        end
    end
end

-- ===================== CONFIG TAB ITEMS =====================
vars.cfg_sep = ui.new_label(menu_tab, menu2, "\\a8C78FFFF•  \\aFFFFFFFFConfig Management")
do

-- Ordered key list for deterministic serialization
local builder_keys = {
    "enabled", "pitch", "custom_pitch", "yaw_base", "yaw_mode", "global_yaw", "yaw_left", "yaw_right",
    "spin_speed", "rotation_steps", "jitter_type", "jitter_mode", "jitter_val1", "jitter_val2",
    "jitter_way1", "jitter_way2", "jitter_way3", "jitter_way4", "jitter_way5", "jitter_rand", "jitter_freq_speed",
    "body_yaw", "body_side", "body_delay_mode", "body_delay_ticks", "body_delay_left", "body_delay_right", "body_delay_switch",
    "fake_limit_left", "fake_limit_right", "roll_amount", "backstab", "height_safe", "fs_body_yaw",
    "def_enable", "def_force", "def_fake_flick", "def_range1", "def_range2", "def_addons", "def_ensinv",
    "desync_mode", "desync_inver", "by_l", "by_r", "by_jitter_type", "by_jitter_que",
    "by_way1", "by_way2", "by_way3", "by_way4", "by_way5", "by_way6", "by_way7", "by_way8",
    "def_disablers", "def_global_offset",
    "def_pitch", "def_pitch_val", "def_pitch_speed", "def_pitch_min", "def_pitch_max", "def_pitch_que",
    "def_pitch_way1", "def_pitch_way2", "def_pitch_way3", "def_pitch_way4", "def_pitch_way5", "def_pitch_way6", "def_pitch_way7", "def_pitch_way8",
    "def_yaw", "def_yaw_val", "def_yaw_speed", "def_yaw_min", "def_yaw_max", "def_yaw_que",
    "def_yaw_way1", "def_yaw_way2", "def_yaw_way3", "def_yaw_way4", "def_yaw_way5", "def_yaw_way6", "def_yaw_way7", "def_yaw_way8",
    "def_wave_type", "def_wave_period", "def_wave_invert",
    "def_clock_step", "def_clock_dir", "def_clock_jitter",
    "def_mode", "def_profile", "def_runtime", "def_harden", "def_harden_scale", "def_tick_bias", "def_tick_guard", "def_tick_guard_window",
    "def_check_mode", "def_flick_trigger", "def_flick_tick_mode", "def_flick_tick_min", "def_flick_tick_max",
    "def_flick_cycle_speed", "def_flick_jitter_repeat", "def_flick_time", "def_back_time", "def_flick_packets",
    "def_pred_enable", "def_pred_mode", "def_pred_flick", "def_pred_back", "def_pred_choke",
    "def_flick_hidden", "def_flick_limit",
    "def_flick_desync_release", "def_flick_desync_mode", "def_mode_tick", "def_duration_mode", "def_duration_bias", "def_duration_stages",
    "def_duration_stage1", "def_duration_stage2", "def_duration_stage3", "def_duration_stage4",
    "def_duration_stage5", "def_duration_stage6", "def_duration_stage7", "def_duration_stage8",
    "def_duration_min", "def_duration_max",
    "delay_base", "delay_mode", "delay_static_tick", "delay_min_tick", "delay_max_tick", "delay_cycle_speed",
}

-- Serialize a UI value to string
local function cfg_serialize_val(val)
    if type(val) == "boolean" then return val and "T" or "F"
    elseif type(val) == "table" then return table.concat(val, ",")
    else return tostring(val) end
end

-- Deserialize a string value back to the correct type for ui_set
local function cfg_deserialize_val(s, ref)
    if s == "T" then return true
    elseif s == "F" then return false
    elseif tonumber(s) then return tonumber(s)
    elseif s:find(",") then
        local t = {}; for v in s:gmatch("[^,]+") do t[#t+1] = v end; return t
    else return s end
end

-- Export all builder settings to a string
local function cfg_export()
    local lines = {}
    for i, b in ipairs(builder) do
        for _, key in ipairs(builder_keys) do
            if b[key] then
                local ok, val = pcall(ui_get, b[key])
                if ok then
                    lines[#lines+1] = i .. ":" .. key .. "=" .. cfg_serialize_val(val)
                end
            end
        end
    end
    return table.concat(lines, "\n")
end

-- Import builder settings from a string
local function cfg_import(data)
    for line in data:gmatch("[^\n]+") do
        local idx_s, key, val_s = line:match("^(%d+):([%w_]+)=(.+)$")
        if idx_s and key and val_s then
            local idx = tonumber(idx_s)
            if idx and builder[idx] and builder[idx][key] then
                local val = cfg_deserialize_val(val_s, builder[idx][key])
                pcall(ui_set, builder[idx][key], val)
            end
        end
    end
    pcall(update_visibility)
end

-- Apply a preset table: preset[condition_index] = { key = value, ... }
local function cfg_apply_preset(preset)
    -- Reset all conditions first
    for i, b in ipairs(builder) do
        if i > 1 then pcall(ui_set, b.enabled, false) end
    end
    -- Apply preset values
    for idx, vals in pairs(preset) do
        if builder[idx] then
            for key, val in pairs(vals) do
                if builder[idx][key] then
                    pcall(ui_set, builder[idx][key], val)
                end
            end
        end
    end
    pcall(update_visibility)
    client.color_log(SCRIPT_COLOR.r, SCRIPT_COLOR.g, SCRIPT_COLOR.b, "[Cynicism] Preset applied")
end

-- ==================== PRESET DEFINITIONS ====================
-- conditions: 1=Global, 2=Standing, 3=Moving, 4=Crouch, 5=Crouch Move, 6=Slowwalk, 7=Air, 8=Air Duck, 9=Legit AA, 10=Manual, 11=Safe Head, 12=No Enemy

-- Base AA settings shared across presets (strong jitter/desync, no defensive)
local function base_aa(opts)
    local o = opts or {}
    return {
        enabled = o.enabled ~= false and true or false,
        pitch = o.pitch or "Down",
        yaw_base = o.yaw_base or "At targets",
        yaw_mode = o.yaw_mode or "180",
        global_yaw = o.global_yaw or 0,
        yaw_left = o.yaw_left or 0,
        yaw_right = o.yaw_right or 0,
        jitter_type = o.jitter_type or "Offset",
        jitter_mode = o.jitter_mode or "Switch",
        jitter_val1 = o.jitter_val1 or 10,
        jitter_val2 = o.jitter_val2 or -10,
        jitter_rand = o.jitter_rand or 5,
        body_yaw = o.body_yaw or "Jitter",
        body_delay_mode = o.body_delay_mode or "Switch",
        body_delay_left = o.body_delay_left or 3,
        body_delay_right = o.body_delay_right or 2,
        body_delay_switch = o.body_delay_switch or 4,
        fake_limit_left = o.fake_limit_left or 60,
        fake_limit_right = o.fake_limit_right or 60,
        roll_amount = o.roll_amount or 0,
        backstab = o.backstab or "Forward",
        height_safe = o.height_safe or 50,
        fs_body_yaw = o.fs_body_yaw ~= nil and o.fs_body_yaw or true,
        -- defensive off by default
        def_enable = o.def_enable ~= nil and o.def_enable or false,
    }
end

-- Add defensive settings
local function with_def(tbl, opts)
    local o = opts or {}
    tbl.def_enable = true
    tbl.def_force = o.def_force or false
    tbl.def_fake_flick = o.def_fake_flick ~= nil and o.def_fake_flick or false
    tbl.def_range1 = o.def_range1 or 2
    tbl.def_range2 = o.def_range2 or 14
    tbl.def_addons = o.def_addons or {"Sideflick on LC End", "Disable while Knife"}
    tbl.def_ensinv = o.def_ensinv or "Jitter"
    tbl.desync_mode = o.desync_mode or "Independ"
    tbl.by_l = o.by_l or 60
    tbl.by_r = o.by_r or 60
    tbl.def_disablers = o.def_disablers or {}
    tbl.def_pitch = o.def_pitch or "Jitter"
    tbl.def_pitch_min = o.def_pitch_min or -89
    tbl.def_pitch_max = o.def_pitch_max or 89
    tbl.def_yaw = o.def_yaw or "Spin Jitter"
    tbl.def_yaw_speed = o.def_yaw_speed or 15
    tbl.def_yaw_min = o.def_yaw_min or -120
    tbl.def_yaw_max = o.def_yaw_max or 120
    tbl.def_mode = o.def_mode or "Custom"
    tbl.def_profile = o.def_profile or "Legacy"
    tbl.def_runtime = o.def_runtime or "Balanced"
    tbl.def_harden = o.def_harden ~= nil and o.def_harden or true
    tbl.def_harden_scale = o.def_harden_scale or 45
    tbl.def_tick_bias = o.def_tick_bias or 0
    tbl.def_tick_guard = o.def_tick_guard or "Off"
    tbl.def_tick_guard_window = o.def_tick_guard_window or 2
    tbl.def_check_mode = o.def_check_mode or "Tickbase"
    tbl.def_flick_trigger = o.def_flick_trigger or "Simple"
    tbl.def_flick_tick_mode = o.def_flick_tick_mode or "Static"
    tbl.def_flick_tick_min = o.def_flick_tick_min or 7
    tbl.def_flick_tick_max = o.def_flick_tick_max or 10
    tbl.def_flick_cycle_speed = o.def_flick_cycle_speed or 6
    tbl.def_flick_jitter_repeat = o.def_flick_jitter_repeat or 4
    tbl.def_flick_time = o.def_flick_time or 2
    tbl.def_back_time = o.def_back_time or 8
    tbl.def_flick_packets = o.def_flick_packets or 11
    tbl.def_pred_enable = o.def_pred_enable ~= nil and o.def_pred_enable or false
    tbl.def_pred_mode = o.def_pred_mode or "Maximum"
    tbl.def_pred_flick = o.def_pred_flick or 2
    tbl.def_pred_back = o.def_pred_back or 8
    tbl.def_pred_choke = o.def_pred_choke or 12
    tbl.def_flick_hidden = o.def_flick_hidden ~= nil and o.def_flick_hidden or false
    tbl.def_flick_limit = o.def_flick_limit ~= nil and o.def_flick_limit or false
    tbl.def_flick_desync_release = o.def_flick_desync_release ~= nil and o.def_flick_desync_release or false
    tbl.def_flick_desync_mode = o.def_flick_desync_mode or "Follow"
    tbl.def_duration_mode = o.def_duration_mode or "Static"
    tbl.def_duration_bias = o.def_duration_bias or 0
    tbl.def_duration_stages = o.def_duration_stages or 3
    tbl.def_duration_stage1 = o.def_duration_stage1 or 4
    tbl.def_duration_stage2 = o.def_duration_stage2 or 8
    tbl.def_duration_stage3 = o.def_duration_stage3 or 12
    tbl.def_duration_stage4 = o.def_duration_stage4 or 16
    tbl.def_duration_stage5 = o.def_duration_stage5 or 20
    tbl.def_duration_stage6 = o.def_duration_stage6 or 24
    tbl.def_duration_stage7 = o.def_duration_stage7 or 28
    tbl.def_duration_stage8 = o.def_duration_stage8 or 30
    tbl.def_duration_min = o.def_duration_min or 3
    tbl.def_duration_max = o.def_duration_max or 12
    tbl.delay_base = o.delay_base ~= nil and o.delay_base or true
    tbl.delay_mode = o.delay_mode or "Jitter"
    tbl.delay_min_tick = o.delay_min_tick or 1
    tbl.delay_max_tick = o.delay_max_tick or 6
    return tbl
end

-- ===== PRESET 1: No Defensive — pure jitter/desync, each condition tuned =====
local preset_no_def = {
    -- [1] Global: not used, leave disabled except enabled=true (forced)
    -- [2] Standing: strong static desync
    [2] = base_aa({ jitter_type = "Offset", jitter_mode = "Switch", jitter_val1 = 12, jitter_val2 = -8, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 3, body_delay_right = 2, fake_limit_left = 60, fake_limit_right = 60 }),
    -- [3] Moving: wider jitter, spin jitter for unpredictability
    [3] = base_aa({ jitter_type = "Skitter", jitter_val1 = 20, jitter_rand = 8, body_yaw = "Opposite", fake_limit_left = 55, fake_limit_right = 55 }),
    -- [4] Crouch: tight center jitter, max desync
    [4] = base_aa({ jitter_type = "Center", jitter_mode = "Static", jitter_val1 = 6, body_yaw = "Jitter", body_delay_mode = "Static", body_delay_ticks = 2, fake_limit_left = 60, fake_limit_right = 60, roll_amount = 15 }),
    -- [5] Crouch Move: offset jitter + roll
    [5] = base_aa({ jitter_type = "Offset", jitter_mode = "Switch", jitter_val1 = 14, jitter_val2 = -14, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 2, body_delay_right = 3, fake_limit_left = 58, fake_limit_right = 58, roll_amount = 10 }),
    -- [6] Slowwalk: randomize jitter + strong desync
    [6] = base_aa({ jitter_type = "Randomize", jitter_val1 = 15, jitter_freq_speed = 3, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 4, body_delay_right = 3, fake_limit_left = 60, fake_limit_right = 60 }),
    -- [7] Air: 3-way for head dodge
    [7] = base_aa({ jitter_type = "3-Way", jitter_way1 = -30, jitter_way2 = 0, jitter_way3 = 30, body_yaw = "Opposite", fake_limit_left = 50, fake_limit_right = 50 }),
    -- [8] Air Duck: skitter + roll for max confusion
    [8] = base_aa({ jitter_type = "Skitter", jitter_val1 = 25, jitter_rand = 12, body_yaw = "Jitter", body_delay_mode = "Static", body_delay_ticks = 1, fake_limit_left = 55, fake_limit_right = 55, roll_amount = -20 }),
    -- [9] Legit AA: minimal, looks legit
    [9] = base_aa({ pitch = "Off", jitter_type = "Off", body_yaw = "Off", fake_limit_left = 0, fake_limit_right = 0, backstab = "Off", fs_body_yaw = false }),
    -- [10] Manual: clean 180 + desync
    [10] = base_aa({ jitter_type = "Offset", jitter_mode = "Static", jitter_val1 = 5, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 3, body_delay_right = 3, fake_limit_left = 60, fake_limit_right = 60 }),
    -- [11] Safe Head: strong anti-aim for head protection
    [11] = base_aa({ jitter_type = "Random", jitter_val1 = 25, jitter_rand = 15, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 2, body_delay_right = 2, fake_limit_left = 60, fake_limit_right = 60 }),
    -- [12] No Enemy: spinning
    [12] = base_aa({ yaw_mode = "Spin", spin_speed = 20, jitter_type = "Off", body_yaw = "Opposite", fake_limit_left = 60, fake_limit_right = 60 }),
}

-- ===== PRESET 2: Partial Defensive (Slowwalk/Air/Crouch = DEF, rest = no def) =====
local preset_partial_def = {}
-- Copy non-def states from preset 1
for i = 2, 12 do preset_partial_def[i] = base_aa(preset_no_def[i] or {}) end
-- Override specific conditions with defensive
-- [2] Standing: strong jitter, no def
preset_partial_def[2] = base_aa({ jitter_type = "Offset", jitter_mode = "Switch", jitter_val1 = 14, jitter_val2 = -10, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 3, body_delay_right = 2, fake_limit_left = 60, fake_limit_right = 60 })
-- [3] Moving: skitter, no def
preset_partial_def[3] = base_aa({ jitter_type = "Skitter", jitter_val1 = 18, jitter_rand = 10, body_yaw = "Opposite", fake_limit_left = 55, fake_limit_right = 55 })
-- [4] Crouch: DEF enabled, spin jitter yaw + jitter pitch
preset_partial_def[4] = with_def(base_aa({ jitter_type = "Center", jitter_val1 = 8, body_yaw = "Jitter", body_delay_mode = "Static", body_delay_ticks = 2, fake_limit_left = 60, fake_limit_right = 60, roll_amount = 15 }), { def_yaw = "Spin Jitter", def_yaw_speed = 18, def_pitch = "Jitter", def_mode = "Custom", def_range1 = 3, def_range2 = 13 })
-- [5] Crouch Move: DEF enabled
preset_partial_def[5] = with_def(base_aa({ jitter_type = "Offset", jitter_val1 = 12, jitter_val2 = -12, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 2, body_delay_right = 3, fake_limit_left = 58, fake_limit_right = 58, roll_amount = 12 }), { def_yaw = "Flick", def_yaw_min = -90, def_yaw_max = 90, def_pitch = "Random", def_mode = "Flick", def_mode_tick = 10 })
-- [6] Slowwalk: DEF enabled, wave yaw
preset_partial_def[6] = with_def(base_aa({ jitter_type = "Randomize", jitter_val1 = 15, jitter_freq_speed = 4, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 3, body_delay_right = 4, fake_limit_left = 60, fake_limit_right = 60 }), { def_yaw = "Wave", def_yaw_min = -150, def_yaw_max = 150, def_wave_type = "Sine", def_wave_period = 60, def_pitch = "Sway", def_pitch_min = -89, def_pitch_max = 89, def_pitch_speed = 12, def_mode = "Custom", def_range1 = 2, def_range2 = 14 })
-- [7] Air: DEF enabled, generation yaw
preset_partial_def[7] = with_def(base_aa({ jitter_type = "3-Way", jitter_way1 = -35, jitter_way2 = 0, jitter_way3 = 35, body_yaw = "Opposite", fake_limit_left = 55, fake_limit_right = 55 }), { def_yaw = "Generation", def_yaw_min = -120, def_yaw_max = 120, def_pitch = "Generation", def_pitch_min = -89, def_pitch_max = 89, def_mode = "Custom", def_range1 = 1, def_range2 = 12 })
-- [8] Air Duck: DEF enabled, always mode
preset_partial_def[8] = with_def(base_aa({ jitter_type = "Skitter", jitter_val1 = 22, jitter_rand = 10, body_yaw = "Jitter", body_delay_mode = "Static", body_delay_ticks = 1, fake_limit_left = 55, fake_limit_right = 55, roll_amount = -18 }), { def_yaw = "Spin", def_yaw_speed = 25, def_pitch = "Spin", def_pitch_speed = 20, def_mode = "Always", def_mode_tick = 7 })
-- Non-def states stay the same
preset_partial_def[9] = base_aa({ pitch = "Off", jitter_type = "Off", body_yaw = "Off", fake_limit_left = 0, fake_limit_right = 0, backstab = "Off", fs_body_yaw = false })
preset_partial_def[10] = base_aa({ jitter_type = "Offset", jitter_mode = "Static", jitter_val1 = 6, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 3, body_delay_right = 3, fake_limit_left = 60, fake_limit_right = 60 })
preset_partial_def[11] = base_aa({ jitter_type = "Random", jitter_val1 = 30, jitter_rand = 15, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 2, body_delay_right = 2, fake_limit_left = 60, fake_limit_right = 60 })
preset_partial_def[12] = base_aa({ yaw_mode = "Spin", spin_speed = 22, jitter_type = "Off", body_yaw = "Opposite", fake_limit_left = 60, fake_limit_right = 60 })

-- ===== PRESET 3: Full Defensive — ALL conditions have DEF enabled =====
local preset_full_def = {
    [2] = with_def(base_aa({ jitter_type = "Offset", jitter_mode = "Switch", jitter_val1 = 12, jitter_val2 = -8, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 3, body_delay_right = 2, fake_limit_left = 60, fake_limit_right = 60 }), { def_yaw = "Spin Jitter", def_yaw_speed = 15, def_yaw_min = -120, def_yaw_max = 120, def_pitch = "Jitter", def_mode = "Custom", def_range1 = 3, def_range2 = 14 }),
    [3] = with_def(base_aa({ jitter_type = "Skitter", jitter_val1 = 20, jitter_rand = 8, body_yaw = "Opposite", fake_limit_left = 55, fake_limit_right = 55 }), { def_yaw = "Generation", def_yaw_min = -150, def_yaw_max = 150, def_pitch = "Random", def_mode = "Flick", def_mode_tick = 8 }),
    [4] = with_def(base_aa({ jitter_type = "Center", jitter_val1 = 6, body_yaw = "Jitter", body_delay_mode = "Static", body_delay_ticks = 2, fake_limit_left = 60, fake_limit_right = 60, roll_amount = 15 }), { def_yaw = "Wave", def_yaw_min = -160, def_yaw_max = 160, def_wave_type = "Triangle", def_wave_period = 50, def_pitch = "Sway", def_pitch_speed = 15, def_pitch_min = -89, def_pitch_max = 89, def_mode = "Custom", def_range1 = 2, def_range2 = 14 }),
    [5] = with_def(base_aa({ jitter_type = "Offset", jitter_val1 = 14, jitter_val2 = -14, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 2, body_delay_right = 3, fake_limit_left = 58, fake_limit_right = 58, roll_amount = 10 }), { def_yaw = "Flick", def_yaw_min = -90, def_yaw_max = 90, def_pitch = "Generation", def_pitch_min = -89, def_pitch_max = 89, def_mode = "Flick", def_mode_tick = 12 }),
    [6] = with_def(base_aa({ jitter_type = "Randomize", jitter_val1 = 15, jitter_freq_speed = 3, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 4, body_delay_right = 3, fake_limit_left = 60, fake_limit_right = 60 }), { def_yaw = "Spin", def_yaw_speed = 20, def_pitch = "Spin", def_pitch_speed = 18, def_mode = "Custom", def_range1 = 2, def_range2 = 13, delay_mode = "CycleSpin", delay_static_tick = 2, delay_min_tick = 1, delay_max_tick = 5, delay_cycle_speed = 3 }),
    [7] = with_def(base_aa({ jitter_type = "3-Way", jitter_way1 = -30, jitter_way2 = 0, jitter_way3 = 30, body_yaw = "Opposite", fake_limit_left = 50, fake_limit_right = 50 }), { def_yaw = "Random", def_yaw_min = -180, def_yaw_max = 180, def_pitch = "Random", def_pitch_min = -89, def_pitch_max = 89, def_mode = "Custom", def_range1 = 1, def_range2 = 12 }),
    [8] = with_def(base_aa({ jitter_type = "Skitter", jitter_val1 = 25, jitter_rand = 12, body_yaw = "Jitter", body_delay_mode = "Static", body_delay_ticks = 1, fake_limit_left = 55, fake_limit_right = 55, roll_amount = -20 }), { def_yaw = "Sway", def_yaw_speed = 22, def_yaw_min = -140, def_yaw_max = 140, def_pitch = "Sway", def_pitch_speed = 20, def_pitch_min = -89, def_pitch_max = 89, def_mode = "Always", def_mode_tick = 7 }),
    [9] = base_aa({ pitch = "Off", jitter_type = "Off", body_yaw = "Off", fake_limit_left = 0, fake_limit_right = 0, backstab = "Off", fs_body_yaw = false }),
    [10] = with_def(base_aa({ jitter_type = "Offset", jitter_mode = "Static", jitter_val1 = 5, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 3, body_delay_right = 3, fake_limit_left = 60, fake_limit_right = 60 }), { def_yaw = "Adaptive", def_pitch = "Bodyyaw", def_mode = "Custom", def_range1 = 3, def_range2 = 14 }),
    [11] = with_def(base_aa({ jitter_type = "Random", jitter_val1 = 25, jitter_rand = 15, body_yaw = "Jitter", body_delay_mode = "Switch", body_delay_left = 2, body_delay_right = 2, fake_limit_left = 60, fake_limit_right = 60 }), { def_yaw = "LC End", def_yaw_min = -180, def_yaw_max = 180, def_pitch = "LC End", def_pitch_min = -89, def_pitch_max = 89, def_mode = "Neverlose" }),
    [12] = with_def(base_aa({ yaw_mode = "Spin", spin_speed = 20, jitter_type = "Off", body_yaw = "Opposite", fake_limit_left = 60, fake_limit_right = 60 }), { def_yaw = "Spin", def_yaw_speed = 30, def_pitch = "Spin", def_pitch_speed = 25, def_mode = "Always", def_mode_tick = 5 }),
}

local presets = {
    ["No Defensive"] = preset_no_def,
    ["Partial Defensive"] = preset_partial_def,
    ["Full Defensive"] = preset_full_def,
}

-- Config UI
vars.export_btn = ui.new_button(menu_tab, menu2, "Export to Clipboard", function()
    local data = cfg_export()
    clipboard.set(base64.encode(data, "base64"))
    client.color_log(SCRIPT_COLOR.r, SCRIPT_COLOR.g, SCRIPT_COLOR.b, "[Cynicism] Config exported to clipboard (" .. #data .. " bytes)")
end)
vars.import_btn = ui.new_button(menu_tab, menu2, "Import from Clipboard", function()
    local raw = clipboard.get()
    if raw and #raw > 0 then
        local ok, decoded = pcall(base64.decode, raw, "base64")
        if ok and decoded and #decoded > 0 then
            cfg_import(decoded)
            client.color_log(SCRIPT_COLOR.r, SCRIPT_COLOR.g, SCRIPT_COLOR.b, "[Cynicism] Config imported from clipboard")
        else
            client.color_log(255, 80, 80, "[Cynicism] Failed to decode config data")
        end
    else
        client.color_log(255, 80, 80, "[Cynicism] Clipboard is empty")
    end
end)

vars.preset_sep = ui.new_label(menu_tab, menu2, "\\a8C78FFFF--- Presets ---")
vars.preset_selector = ui.new_combobox(menu_tab, menu2, "Preset", { "No Defensive", "Partial Defensive", "Full Defensive" })
vars.preset_load_btn = ui.new_button(menu_tab, menu2, "Load Preset", function()
    local name = ui_get(vars.preset_selector)
    if presets[name] then
        cfg_apply_preset(presets[name])
        client.color_log(SCRIPT_COLOR.r, SCRIPT_COLOR.g, SCRIPT_COLOR.b, "[Cynicism] Loaded preset: " .. name)
    end
end)
end

-- ===================== SESSION TIMER =====================
ui.new_label("AA", "Fake lag", "\\a8C78FFFF•  \\aFFFFFFFFCynicism")
ui.new_label("AA", "Fake lag", "\\a333333FF━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
ui.new_label("AA", "Fake lag", "\\a8C78FFFF•  \\aFFFFFFFFVersion: \\a8C78FFFF" .. SCRIPT_VERSION)
local info_session = ui.new_label("AA", "Fake lag", "\\a8C78FFFF•  \\aFFFFFFFFSession: \\a8C78FFFF00:00:00")

local function get_session_time()
    local elapsed = client.unix_time() - vars.session_start
    local h = math_floor(elapsed / 3600)
    local m = math_floor((elapsed % 3600) / 60)
    local s = elapsed % 60
    return string.format("%02d:%02d:%02d", h, m, s)
end

-- ===================== VISIBILITY =====================
local function update_visibility()
    local tab = ui_get(active_tab)
    local is_aa = tab == "Anti-Aim"
    local is_vis = tab == "Visuals"
    local is_misc = tab == "Misc"
    local is_cfg = tab == "Config"

    ui.set_visible(condition_selector, is_aa)
    local sel_idx = 1
    if is_aa then
        local sel = ui_get(condition_selector)
        for i, c in ipairs(conditions) do if c == sel then sel_idx = i; break end end
    end

    for i, b in ipairs(builder) do
        local ok, err = pcall(function()
        local show = is_aa and i == sel_idx
        local enabled = show and (i == 1 or ui_get(b.enabled))
        ui.set_visible(b.enabled, show and i ~= 1)
        -- Pitch
        ui.set_visible(b.pitch, enabled)
        ui.set_visible(b.custom_pitch, enabled and ui_get(b.pitch) == "Custom")
        -- Yaw
        ui.set_visible(b.yaw_base, enabled)
        ui.set_visible(b.yaw_mode, enabled)
        ui.set_visible(b.global_yaw, enabled)
        ui.set_visible(b.yaw_left, enabled)
        ui.set_visible(b.yaw_right, enabled)
        ui.set_visible(b.spin_speed, enabled and ui_get(b.yaw_mode) == "Spin")
        ui.set_visible(b.rotation_steps, enabled and ui_get(b.yaw_mode) == "Rotation")
        -- Jitter
        local jt = enabled and ui_get(b.jitter_type) or "Off"
        local is_nway = jt == "3-Way" or jt == "5-Way"
        local is_custom_offset = jt == "Frequence" or jt == "Randomize" or jt == "Skitter" or is_nway
        ui.set_visible(b.jitter_type, enabled)
        ui.set_visible(b.jitter_mode, enabled and jt ~= "Off" and not is_custom_offset)
        ui.set_visible(b.jitter_val1, enabled and jt ~= "Off")
        ui.set_visible(b.jitter_val2, enabled and jt ~= "Off" and not is_custom_offset and ui_get(b.jitter_mode) ~= "Static")
        for w = 1, 5 do
            local key = "jitter_way" .. w
            ui.set_visible(b[key], enabled and ((jt == "3-Way" and w <= 3) or (jt == "5-Way")))
        end
        ui.set_visible(b.jitter_rand, enabled and jt ~= "Off")
        ui.set_visible(b.jitter_freq_speed, enabled and (jt == "Frequence" or jt == "Randomize"))
        -- Body
        local bym = enabled and ui_get(b.body_yaw) or "Off"
        ui.set_visible(b.body_yaw, enabled)
        ui.set_visible(b.body_side, enabled and bym == "Static")
        ui.set_visible(b.body_delay_mode, enabled and bym == "Jitter")
        local bdm = ui_get(b.body_delay_mode)
        ui.set_visible(b.body_delay_ticks, enabled and bym == "Jitter" and bdm == "Static")
        ui.set_visible(b.body_delay_left, enabled and bym == "Jitter" and bdm == "Switch")
        ui.set_visible(b.body_delay_right, enabled and bym == "Jitter" and bdm == "Switch")
        ui.set_visible(b.body_delay_switch, enabled and bym == "Jitter" and bdm == "Switch")
        -- ===== Defensive Builder (Paradise EVO) =====
        local de = enabled and ui_get(b.def_enable)
        ui.set_visible(b.def_enable, enabled)
        ui.set_visible(b.def_force, de)
        ui.set_visible(b.def_fake_flick, de)
        -- Tick range
        ui.set_visible(b.def_range1, de)
        ui.set_visible(b.def_range2, de)
        -- Addons + ensinv
        ui.set_visible(b.def_addons, de)
        local has_oby = de and has_multiselect(b.def_addons, "Override Bodyyaw")
        ui.set_visible(b.def_ensinv, has_oby)
        -- Desync mode
        local dsync_vis = de
        ui.set_visible(b.desync_mode, dsync_vis)
        local dsync_val = ui_get(b.desync_mode) or "Independ"
        ui.set_visible(b.desync_inver, dsync_vis and dsync_val == "Force Static")
        -- Body fake limits (choke-phase assist for ordinary body yaw)
        local fake_limit_show = enabled and bym ~= "Off" and dsync_val ~= "NoChoke"
        ui.set_visible(b.fake_limit_left, fake_limit_show)
        ui.set_visible(b.fake_limit_right, fake_limit_show)
        -- Roll / Backstab / Extra
        ui.set_visible(b.roll_amount, enabled)
        ui.set_visible(b.backstab, enabled)
        ui.set_visible(b.height_safe, enabled)
        ui.set_visible(b.fs_body_yaw, enabled)
        -- BYaw limits + multiway
        local by_show = dsync_vis and dsync_val ~= "NoChoke"
        ui.set_visible(b.by_l, by_show)
        ui.set_visible(b.by_r, by_show)
        local bym_is_jitter = enabled and ui_get(b.body_yaw) == "Jitter"
        local by_multiway_show = by_show and bym_is_jitter and dsync_val == "Independ"
        ui.set_visible(b.by_jitter_type, by_multiway_show)
        local by_ways = by_multiway_show and ui_get(b.by_jitter_que) or 0
        ui.set_visible(b.by_jitter_que, by_multiway_show)
        for w = 1, 8 do
            ui.set_visible(b["by_way" .. w], by_multiway_show and w <= by_ways)
        end
        -- Disablers
        ui.set_visible(b.def_disablers, de)
        -- Global offset
        ui.set_visible(b.def_global_offset, de)
        -- Defensive Pitch
        local dpm = de and ui_get(b.def_pitch) or "None"
        ui.set_visible(b.def_pitch, de)
        ui.set_visible(b.def_pitch_val, de and dpm == "Custom")
        local pitch_needs_speed = de and (dpm == "Progressive" or dpm == "Spin" or dpm == "Sway" or dpm == "Multiway")
        ui.set_visible(b.def_pitch_speed, pitch_needs_speed)
        local pitch_needs_minmax = de and (dpm == "Progressive" or dpm == "Jitter" or dpm == "Spin" or dpm == "Sway"
            or dpm == "Wave" or dpm == "Random Static" or dpm == "LC End" or dpm == "Generation" or dpm == "Random" or dpm == "Randomize Jitter")
        ui.set_visible(b.def_pitch_min, pitch_needs_minmax)
        ui.set_visible(b.def_pitch_max, pitch_needs_minmax)
        -- Pitch Multiway
        local pitch_is_multiway = de and dpm == "Multiway"
        local pitch_nways = pitch_is_multiway and ui_get(b.def_pitch_que) or 0
        ui.set_visible(b.def_pitch_que, pitch_is_multiway)
        for w = 1, 8 do
            ui.set_visible(b["def_pitch_way" .. w], pitch_is_multiway and w <= pitch_nways)
        end
        -- Defensive Yaw
        local dym = de and ui_get(b.def_yaw) or "None"
        ui.set_visible(b.def_yaw, de)
        ui.set_visible(b.def_yaw_val, de and (dym == "Custom" or dym == "Clock"))
        local yaw_needs_speed = de and (dym == "Progressive" or dym == "Spin" or dym == "Spin Jitter"
            or dym == "Clock" or dym == "Sway" or dym == "Multiway")
        ui.set_visible(b.def_yaw_speed, yaw_needs_speed)
        local yaw_needs_minmax = de and (dym == "Progressive" or dym == "Jitter" or dym == "Spin Jitter"
            or dym == "Flick" or dym == "Random Static" or dym == "LC End" or dym == "Wave"
            or dym == "Sway" or dym == "Generation" or dym == "Random")
        ui.set_visible(b.def_yaw_min, yaw_needs_minmax)
        ui.set_visible(b.def_yaw_max, yaw_needs_minmax)
        -- Eternal extensions
        local needs_delay = de and (dym == "Jitter" or dpm == "Jitter" or dym == "Spin" or dpm == "Spin" or dym == "Sway" or dpm == "Sway")
        ui.set_visible(b.def_delay_ticks, needs_delay)
        local needs_spin_start = de and (dym == "Spin" or dym == "Sway")
        ui.set_visible(b.def_spin_start, needs_spin_start)
        local needs_reverse = de and (dym == "Spin" or dpm == "Spin")
        ui.set_visible(b.def_spin_reverse, needs_reverse)
        -- Yaw Multiway
        local yaw_is_multiway = de and dym == "Multiway"
        local yaw_nways = yaw_is_multiway and ui_get(b.def_yaw_que) or 0
        ui.set_visible(b.def_yaw_que, yaw_is_multiway)
        for w = 1, 8 do
            ui.set_visible(b["def_yaw_way" .. w], yaw_is_multiway and w <= yaw_nways)
        end
        -- Wave params
        local is_wave_pitch = dpm == "Wave"
        local is_wave_yaw = dym == "Wave"
        ui.set_visible(b.def_wave_type, de and (is_wave_pitch or is_wave_yaw))
        ui.set_visible(b.def_wave_period, de and (is_wave_pitch or is_wave_yaw))
        ui.set_visible(b.def_wave_invert, de and (is_wave_pitch or is_wave_yaw))
        -- Clock params
        ui.set_visible(b.def_clock_step, de and dym == "Clock")
        ui.set_visible(b.def_clock_dir, de and dym == "Clock")
        ui.set_visible(b.def_clock_jitter, de and dym == "Clock")
        -- Cathode/Paradise: Def Mode + Flick model + Delay model visibility
        ui.set_visible(b.def_mode, de)
        ui.set_visible(b.def_profile, de and ui_get(b.def_mode) == "Profile")
        ui.set_visible(b.def_runtime, de)
        ui.set_visible(b.def_harden, de)
        ui.set_visible(b.def_harden_scale, de and ui_get(b.def_harden))
        ui.set_visible(b.def_tick_bias, de)
        ui.set_visible(b.def_tick_guard, de)
        ui.set_visible(b.def_tick_guard_window, de and ui_get(b.def_tick_guard) ~= "Off")
        local dmode = de and ui_get(b.def_mode) or "Neverlose"
        local is_flick_mode = de and dmode == "Flick"
        local is_profile_mode = de and dmode == "Profile"
        local is_duration_mode = de and dmode == "Duration"
        local duration_mode = is_duration_mode and ui_get(b.def_duration_mode) or "Static"
        local flick_tick_mode = (is_flick_mode or is_profile_mode) and ui_get(b.def_flick_tick_mode) or "Static"

        ui.set_visible(b.def_check_mode, de and (dmode == "Custom" or dmode == "Limit" or dmode == "Flick" or dmode == "Profile"))
        ui.set_visible(b.def_flick_trigger, is_flick_mode or is_profile_mode)
        ui.set_visible(b.def_flick_tick_mode, is_flick_mode or is_profile_mode)

        local show_flick_static_tick = (is_flick_mode or is_profile_mode) and flick_tick_mode == "Static"
        local show_flick_minmax = (is_flick_mode or is_profile_mode) and (flick_tick_mode == "Random" or flick_tick_mode == "Random Static"
            or flick_tick_mode == "Random Trigger" or flick_tick_mode == "Random Jitter"
            or flick_tick_mode == "Jitter" or flick_tick_mode == "Cycle" or flick_tick_mode == "Prime"
            or flick_tick_mode == "Burst Cycle" or flick_tick_mode == "Entropy")
        local show_flick_cycle_speed = (is_flick_mode or is_profile_mode) and (flick_tick_mode == "Cycle" or flick_tick_mode == "Burst Cycle")
        local show_flick_jitter_repeat = (is_flick_mode or is_profile_mode) and (flick_tick_mode == "Jitter" or flick_tick_mode == "Random Jitter")

        ui.set_visible(b.def_mode_tick, de and (show_flick_static_tick or dmode == "Always" or dmode == "Limit" or dmode == "Profile" or (dmode == "Duration" and duration_mode == "Static")))
        ui.set_visible(b.def_flick_tick_min, show_flick_minmax)
        ui.set_visible(b.def_flick_tick_max, show_flick_minmax)
        ui.set_visible(b.def_flick_cycle_speed, show_flick_cycle_speed)
        ui.set_visible(b.def_flick_jitter_repeat, show_flick_jitter_repeat)
        ui.set_visible(b.def_flick_time, is_flick_mode or is_profile_mode)
        ui.set_visible(b.def_back_time, is_flick_mode or is_profile_mode)
        ui.set_visible(b.def_flick_packets, is_flick_mode or is_profile_mode)
        ui.set_visible(b.def_pred_enable, de)
        local pred_show = de and ui_get(b.def_pred_enable)
        ui.set_visible(b.def_pred_mode, pred_show)
        ui.set_visible(b.def_pred_flick, pred_show)
        ui.set_visible(b.def_pred_back, pred_show)
        ui.set_visible(b.def_pred_choke, pred_show)
        ui.set_visible(b.def_flick_hidden, is_flick_mode or is_profile_mode)
        ui.set_visible(b.def_flick_limit, is_flick_mode or is_profile_mode)
        ui.set_visible(b.def_flick_desync_release, is_flick_mode or is_profile_mode)
        ui.set_visible(b.def_flick_desync_mode, (is_flick_mode or is_profile_mode) and ui_get(b.def_flick_desync_release))

        ui.set_visible(b.def_duration_mode, is_duration_mode)
        ui.set_visible(b.def_duration_bias, is_duration_mode and duration_mode == "Adaptive")
        ui.set_visible(b.def_duration_stages, is_duration_mode and duration_mode == "Stages")
        local duration_stages = is_duration_mode and duration_mode == "Stages" and clamp(ui_get(b.def_duration_stages), 1, 8) or 0
        for w = 1, 8 do
            ui.set_visible(b["def_duration_stage" .. w], is_duration_mode and duration_mode == "Stages" and w <= duration_stages)
        end
        ui.set_visible(b.def_duration_min, is_duration_mode and (duration_mode == "Random" or duration_mode == "Adaptive"))
        ui.set_visible(b.def_duration_max, is_duration_mode and (duration_mode == "Random" or duration_mode == "Adaptive"))
        ui.set_visible(b.delay_base, de)
        local dbase = de and ui_get(b.delay_base)
        ui.set_visible(b.delay_mode, dbase)
        local dlm = dbase and ui_get(b.delay_mode) or "Static"
        ui.set_visible(b.delay_static_tick, dbase and (dlm == "Static"))
        ui.set_visible(b.delay_min_tick, dbase and (dlm == "Random" or dlm == "Jitter" or dlm == "Random Jitter" or dlm == "JitterTick" or dlm == "Cycle" or dlm == "CycleSpin" or dlm == "Burst" or dlm == "Stair" or dlm == "Random Trigger" or dlm == "Fluctuate"))
        ui.set_visible(b.delay_max_tick, dbase and (dlm == "Random" or dlm == "Jitter" or dlm == "Random Jitter" or dlm == "JitterTick" or dlm == "Cycle" or dlm == "CycleSpin" or dlm == "Burst" or dlm == "Stair" or dlm == "Random Trigger" or dlm == "Fluctuate"))
        ui.set_visible(b.delay_jitter_speed, dbase and (dlm == "Jitter" or dlm == "Random Jitter" or dlm == "JitterTick" or dlm == "Burst" or dlm == "Random Trigger"))
        ui.set_visible(b.delay_jitter_var, dbase and (dlm == "Jitter" or dlm == "Random Jitter" or dlm == "JitterTick"))
        ui.set_visible(b.delay_cycle_speed, dbase and (dlm == "Cycle" or dlm == "CycleSpin" or dlm == "Stair"))
        end) -- end pcall
        if not ok then client.color_log(255,80,80,"[Cynicism] visibility err c"..i..": "..(err or "?")) end
    end

    -- Misc items
    ui.set_visible(misc_features, is_misc)
    ui.set_visible(freestanding_key, is_misc and has_multiselect(misc_features, "Freestanding"))
    ui.set_visible(legit_aa_key, is_misc and has_multiselect(misc_features, "Legit AA"))
    ui.set_visible(edge_yaw_key, is_misc and has_multiselect(misc_features, "Edge Yaw"))
    ui.set_visible(manual_left_key, is_misc and has_multiselect(misc_features, "Manual AA"))
    ui.set_visible(manual_right_key, is_misc and has_multiselect(misc_features, "Manual AA"))
    ui.set_visible(manual_forward_key, is_misc and has_multiselect(misc_features, "Manual AA"))
    ui.set_visible(force_def_key, is_misc)
    ui.set_visible(fs_disablers, is_misc and has_multiselect(misc_features, "Freestanding"))
    ui.set_visible(force_def_conds, is_misc)
    ui.set_visible(anim_breaker, is_misc)
    ui.set_visible(safe_head_conds, is_misc)

    -- Killsay
    ui.set_visible(killsay_enable, is_misc)
    ui.set_visible(killsay_mode, is_misc and ui_get(killsay_enable))

    -- Cheat Spoofer
    ui.set_visible(spoof_sep, is_misc)
    ui.set_visible(spoof_enable, is_misc)
    local se = is_misc and ui_get(spoof_enable)
    ui.set_visible(spoof_mode, se)
    ui.set_visible(spoof_target, se and ui_get(spoof_mode) == "Spoof As...")
    ui.set_visible(spoof_randomize, se and ui_get(spoof_mode) == "Spoof As...")
    ui.set_visible(spoof_status, se)

    -- Misc Enhancements
    ui.set_visible(vars.misc_sep2, is_misc)
    ui.set_visible(vars.scope_fov_slider, is_misc)
    ui.set_visible(vars.fast_ladder_cb, is_misc)
    ui.set_visible(vars.jump_shot_cb, is_misc)
    ui.set_visible(aspect_ratio_slider, is_misc)
    ui.set_visible(clantag_cb, is_misc)
    ui.set_visible(console_filter_cb, is_misc)
    ui.set_visible(vars.flctl_enable, is_misc)
    local fl_on = is_misc and ui_get(vars.flctl_enable)
    ui.set_visible(vars.flctl_mode_ref, fl_on)
    local fl_mode = fl_on and ui_get(vars.flctl_mode_ref) or "Off"
    ui.set_visible(vars.flctl_min, fl_on and fl_mode ~= "Off")
    ui.set_visible(vars.flctl_max, fl_on and fl_mode ~= "Off")
    ui.set_visible(vars.flctl_step, fl_on and (fl_mode == "Cycle" or fl_mode == "Dynamic"))
    ui.set_visible(vars.flctl_force, fl_on and fl_mode ~= "Off")
    ui.set_visible(vars.flctl_disable_exploit, fl_on and fl_mode ~= "Off")
    ui.set_visible(vars.flctl_nade_opt, fl_on and fl_mode ~= "Off")
    ui.set_visible(vars.flctl_onshot, fl_on and fl_mode ~= "Off")
    ui.set_visible(vars.flctl_shot_window, fl_on and fl_mode ~= "Off" and ui_get(vars.flctl_onshot) ~= "Off")
    ui.set_visible(vars.abf_enable, is_misc)
    local abf_on = is_misc and ui_get(vars.abf_enable)
    ui.set_visible(vars.abf_trigger, abf_on)
    ui.set_visible(vars.abf_ticks, abf_on)
    ui.set_visible(vars.abf_yaw_add, abf_on)
    ui.set_visible(vars.abf_force_invert, abf_on)

    -- Visuals items
    ui.set_visible(vis_indicators, is_vis)
    ui.set_visible(vis_welcome, is_vis)
    ui.set_visible(vis_indicator_color, is_vis)
    ui.set_visible(vis_hud_style, is_vis)
    ui.set_visible(vis_scope_sep, is_vis)
    ui.set_visible(vis_scope_enable, is_vis)
    local sc_en = is_vis and ui_get(vis_scope_enable)
    ui.set_visible(vis_scope_color, sc_en)
    ui.set_visible(vis_scope_pos, sc_en)
    ui.set_visible(vis_scope_offset, sc_en)
    ui.set_visible(vis_scope_speed, sc_en)
    ui.set_visible(vis_shot_log, is_vis)
    ui.set_visible(vis_hitmarker, is_vis)
    ui.set_visible(vis_combat_alerts, is_vis)
    ui.set_visible(vis_esp_preview, is_vis)

    -- Config items
    ui.set_visible(vars.cfg_sep, is_cfg)
    ui.set_visible(vars.export_btn, is_cfg)
    ui.set_visible(vars.import_btn, is_cfg)
    ui.set_visible(vars.preset_sep, is_cfg)
    ui.set_visible(vars.preset_selector, is_cfg)
    ui.set_visible(vars.preset_load_btn, is_cfg)

    -- Hide native AA elements
    local aa_refs = { refs.pitch[1], refs.pitch[2], refs.yaw_base, refs.yaw[1], refs.yaw[2],
        refs.yaw_jitter[1], refs.yaw_jitter[2], refs.body_yaw[1], refs.body_yaw[2],
        refs.freestanding_body_yaw, refs.freestanding[1], refs.freestanding[2], refs.edge_yaw, refs.roll }
    for _, r in ipairs(aa_refs) do ui.set_visible(r, false) end
end

-- ===================== FREESTAND DIRECTION =====================
local function get_freestand_side(player)
    if not player or not entity_is_alive(player) then return 0 end
    local ex, ey, ez = client_eye_position()
    if not ex then return 0 end
    local _, ang_y = client_camera_angles()
    local tl, tr = 0, 0
    for i = ang_y - 120, ang_y + 120, 30 do
        if i ~= ang_y then
            local rad = math_rad(i)
            local px = ex + 256 * math_cos(rad)
            local py = ey + 256 * math_sin(rad)
            local frac = client_trace_line(player, ex, ey, ez, px, py, ez)
            if i < ang_y then tl = tl + frac else tr = tr + frac end
        end
    end
    return tl < tr and -1 or 1
end

-- ===================== ANTI-BACKSTAB =====================
local function check_anti_backstab()
    local threat = client_current_threat()
    local lp = entity_get_local_player()
    if not threat or not lp then return false end
    local wpn = entity_get_player_weapon(threat)
    if not wpn then return false end
    if entity_get_classname(wpn) == "CKnife" and is_visible(threat) then
        local lx, ly, lz = entity_get_prop(lp, "m_vecOrigin")
        local ex, ey, ez = entity_get_prop(threat, "m_vecOrigin")
        if lx and ex then
            return math_sqrt((lx-ex)^2 + (ly-ey)^2 + (lz-ez)^2) < 450
        end
    end
    return false
end

-- ===================== SINE YAW UTIL =====================
local function sine_yaw(tick, min_v, max_v)
    local amplitude = (max_v - min_v) / 2
    local center = (max_v + min_v) / 2
    return center + amplitude * math.sin(tick * 0.05)
end

-- ===================== DEFENSIVE CORE (Paradise + Cathode style rewrite) =====================
local function def_wave_value(min_v, max_v, period_pct, wave_type, invert)
    local period = math_max(0.05, (period_pct or 50) / 100)
    local phase = (globals_realtime() % period) / period
    if wave_type == "Triangle" then
        phase = math_abs(phase * 2 - 1)
    elseif wave_type == "Sine" then
        phase = (1 - math_cos(phase * math.pi * 2)) * 0.5
    elseif wave_type == "Saw" then
        phase = (1 - math_cos(phase * math.pi * 2)) * 0.788
    end
    if invert then phase = 1 - phase end
    return min_v + (max_v - min_v) * phase
end

def_profile_presets = {
    ["Legacy"] = {
        mode = "Custom", check_mode = "Tickbase", harden = 45, driver_bias = 0,
        guard = "Off", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Static",
        flick_min = 7, flick_max = 10, flick_cycle = 6, flick_repeat = 4, packet_mod = 11,
        duration_mode = "Static", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 0,
        pressure_scale = 100, window_boost = 0, limit_soft = 0, lc_end_extend = 0
    },
    ["Abyss Core"] = {
        mode = "Custom", check_mode = "Tickbase", harden = 60, driver_bias = -1,
        guard = "Near End", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Jitter",
        flick_min = 6, flick_max = 9, flick_cycle = 5, flick_repeat = 3, packet_mod = 9,
        duration_mode = "Adaptive", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 1,
        pressure_scale = 120, window_boost = 1, limit_soft = 0, lc_end_extend = 1
    },
    ["Abyss Tight"] = {
        mode = "Limit", check_mode = "Tickbase", harden = 65, driver_bias = -2,
        guard = "Near End", guard_window = 1, flick_trigger = "Advance", flick_tick_mode = "Static",
        flick_min = 5, flick_max = 7, flick_cycle = 4, flick_repeat = 2, packet_mod = 8,
        duration_mode = "Static", duration_static = 6, duration_min = 2, duration_max = 8, duration_bias = 0,
        pressure_scale = 125, window_boost = 1, limit_soft = 4, lc_end_extend = 0
    },
    ["Abyss Float"] = {
        mode = "Duration", check_mode = "Tickbase", harden = 35, driver_bias = 1,
        guard = "Center", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Cycle",
        flick_min = 8, flick_max = 12, flick_cycle = 4, flick_repeat = 4, packet_mod = 12,
        duration_mode = "Random", duration_static = 9, duration_min = 4, duration_max = 15, duration_bias = -1,
        pressure_scale = 90, window_boost = 0, limit_soft = 0, lc_end_extend = 0
    },
    ["Cathode Flick"] = {
        mode = "Flick", check_mode = "Command Num", harden = 55, driver_bias = -1,
        guard = "Off", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Random Static",
        flick_min = 6, flick_max = 10, flick_cycle = 6, flick_repeat = 3, packet_mod = 11,
        duration_mode = "Static", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 0,
        pressure_scale = 115, window_boost = 2, limit_soft = 0, lc_end_extend = 0
    },
    ["Cathode Jitter"] = {
        mode = "Flick", check_mode = "Command Num", harden = 50, driver_bias = 0,
        guard = "Edges", guard_window = 2, flick_trigger = "Advance", flick_tick_mode = "Jitter",
        flick_min = 5, flick_max = 9, flick_cycle = 5, flick_repeat = 2, packet_mod = 10,
        duration_mode = "Static", duration_static = 7, duration_min = 3, duration_max = 11, duration_bias = 0,
        pressure_scale = 110, window_boost = 1, limit_soft = 0, lc_end_extend = 0
    },
    ["Cathode Pulse"] = {
        mode = "Flick", check_mode = "Command Num", harden = 60, driver_bias = -1,
        guard = "Near End", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Random Trigger",
        flick_min = 6, flick_max = 12, flick_cycle = 7, flick_repeat = 4, packet_mod = 13,
        duration_mode = "Adaptive", duration_static = 8, duration_min = 4, duration_max = 14, duration_bias = 1,
        pressure_scale = 125, window_boost = 2, limit_soft = 0, lc_end_extend = 0
    },
    ["Paradise EVO"] = {
        mode = "Custom", check_mode = "Tickbase", harden = 45, driver_bias = 0,
        guard = "Off", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Random",
        flick_min = 7, flick_max = 11, flick_cycle = 6, flick_repeat = 3, packet_mod = 11,
        duration_mode = "Stages", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 0,
        pressure_scale = 100, window_boost = 1, limit_soft = 0, lc_end_extend = 1
    },
    ["Paradise Autumn"] = {
        mode = "Duration", check_mode = "Tickbase", harden = 50, driver_bias = 0,
        guard = "Near End", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Cycle",
        flick_min = 7, flick_max = 12, flick_cycle = 5, flick_repeat = 4, packet_mod = 12,
        duration_mode = "Stages", duration_static = 9, duration_min = 4, duration_max = 14, duration_bias = 0,
        pressure_scale = 105, window_boost = 1, limit_soft = 0, lc_end_extend = 1
    },
    ["Paradise Safe"] = {
        mode = "Limit", check_mode = "Tickbase", harden = 30, driver_bias = 1,
        guard = "Center", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Static",
        flick_min = 8, flick_max = 10, flick_cycle = 6, flick_repeat = 4, packet_mod = 12,
        duration_mode = "Static", duration_static = 6, duration_min = 3, duration_max = 10, duration_bias = 0,
        pressure_scale = 85, window_boost = 0, limit_soft = 5, lc_end_extend = 0
    },
    ["Hybrid Adaptive"] = {
        mode = "Duration", check_mode = "Command Num", harden = 55, driver_bias = 0,
        guard = "Edges", guard_window = 2, flick_trigger = "Advance", flick_tick_mode = "Random Jitter",
        flick_min = 6, flick_max = 10, flick_cycle = 6, flick_repeat = 3, packet_mod = 11,
        duration_mode = "Adaptive", duration_static = 8, duration_min = 3, duration_max = 13, duration_bias = 1,
        pressure_scale = 120, window_boost = 1, limit_soft = 0, lc_end_extend = 0
    },
    ["Hybrid Aggressive"] = {
        mode = "Flick", check_mode = "Command Num", harden = 70, driver_bias = -2,
        guard = "Near End", guard_window = 1, flick_trigger = "Advance", flick_tick_mode = "Random Trigger",
        flick_min = 4, flick_max = 8, flick_cycle = 4, flick_repeat = 2, packet_mod = 8,
        duration_mode = "Adaptive", duration_static = 7, duration_min = 2, duration_max = 10, duration_bias = 1,
        pressure_scale = 140, window_boost = 2, limit_soft = 4, lc_end_extend = 0
    },
    ["Hybrid Stealth"] = {
        mode = "Custom", check_mode = "Tickbase", harden = 25, driver_bias = 2,
        guard = "Center", guard_window = 3, flick_trigger = "Simple", flick_tick_mode = "Static",
        flick_min = 9, flick_max = 12, flick_cycle = 7, flick_repeat = 4, packet_mod = 13,
        duration_mode = "Random", duration_static = 9, duration_min = 5, duration_max = 14, duration_bias = -1,
        pressure_scale = 75, window_boost = 0, limit_soft = 0, lc_end_extend = 0
    },
    ["Hybrid Rush"] = {
        mode = "Peek", check_mode = "Command Num", harden = 65, driver_bias = -1,
        guard = "Edges", guard_window = 1, flick_trigger = "Simple", flick_tick_mode = "Jitter",
        flick_min = 5, flick_max = 8, flick_cycle = 4, flick_repeat = 2, packet_mod = 8,
        duration_mode = "Adaptive", duration_static = 7, duration_min = 3, duration_max = 10, duration_bias = 1,
        pressure_scale = 130, window_boost = 2, limit_soft = 0, lc_end_extend = 0
    },
    ["Burst Unstable"] = {
        mode = "Flick", check_mode = "Command Num", harden = 75, driver_bias = -2,
        guard = "Off", guard_window = 1, flick_trigger = "Advance", flick_tick_mode = "Beta",
        flick_min = 4, flick_max = 10, flick_cycle = 3, flick_repeat = 2, packet_mod = 6,
        duration_mode = "Adaptive", duration_static = 6, duration_min = 2, duration_max = 10, duration_bias = 2,
        pressure_scale = 145, window_boost = 3, limit_soft = 3, lc_end_extend = 0
    },
    ["Limit Keeper"] = {
        mode = "Limit", check_mode = "Tickbase", harden = 50, driver_bias = 0,
        guard = "Near End", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Static",
        flick_min = 7, flick_max = 9, flick_cycle = 6, flick_repeat = 3, packet_mod = 10,
        duration_mode = "Static", duration_static = 6, duration_min = 3, duration_max = 9, duration_bias = 0,
        pressure_scale = 100, window_boost = 0, limit_soft = 5, lc_end_extend = 0
    },
    ["LC End Force"] = {
        mode = "LC End", check_mode = "Tickbase", harden = 50, driver_bias = 0,
        guard = "Near End", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Static",
        flick_min = 6, flick_max = 10, flick_cycle = 6, flick_repeat = 3, packet_mod = 11,
        duration_mode = "Static", duration_static = 7, duration_min = 3, duration_max = 10, duration_bias = 0,
        pressure_scale = 105, window_boost = 1, limit_soft = 0, lc_end_extend = 2
    },
    ["Peek Trigger"] = {
        mode = "Peek", check_mode = "Command Num", harden = 60, driver_bias = -1,
        guard = "Edges", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Random",
        flick_min = 5, flick_max = 9, flick_cycle = 5, flick_repeat = 2, packet_mod = 8,
        duration_mode = "Adaptive", duration_static = 7, duration_min = 2, duration_max = 10, duration_bias = 1,
        pressure_scale = 125, window_boost = 2, limit_soft = 0, lc_end_extend = 0
    },
    ["Charge Assist"] = {
        mode = "Charge", check_mode = "Tickbase", harden = 45, driver_bias = 0,
        guard = "Off", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Random Static",
        flick_min = 6, flick_max = 10, flick_cycle = 6, flick_repeat = 3, packet_mod = 11,
        duration_mode = "Static", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 0,
        pressure_scale = 100, window_boost = 1, limit_soft = 0, lc_end_extend = 0
    },
    ["Tournament Safe"] = {
        mode = "Duration", check_mode = "Tickbase", harden = 20, driver_bias = 2,
        guard = "Center", guard_window = 3, flick_trigger = "Simple", flick_tick_mode = "Static",
        flick_min = 9, flick_max = 12, flick_cycle = 7, flick_repeat = 4, packet_mod = 14,
        duration_mode = "Static", duration_static = 6, duration_min = 4, duration_max = 8, duration_bias = -1,
        pressure_scale = 70, window_boost = 0, limit_soft = 0, lc_end_extend = 0
    },
    ["HVH Unsafe"] = {
        mode = "Flick", check_mode = "Command Num", harden = 80, driver_bias = -3,
        guard = "Near End", guard_window = 1, flick_trigger = "Advance", flick_tick_mode = "Random Trigger",
        flick_min = 3, flick_max = 7, flick_cycle = 3, flick_repeat = 2, packet_mod = 5,
        duration_mode = "Adaptive", duration_static = 5, duration_min = 2, duration_max = 9, duration_bias = 2,
        pressure_scale = 160, window_boost = 3, limit_soft = 3, lc_end_extend = 0
    },
    ["HVH Dynamic"] = {
        mode = "Flick", check_mode = "Command Num", harden = 70, driver_bias = -1,
        guard = "Edges", guard_window = 1, flick_trigger = "Advance", flick_tick_mode = "Cycle",
        flick_min = 4, flick_max = 10, flick_cycle = 4, flick_repeat = 2, packet_mod = 7,
        duration_mode = "Adaptive", duration_static = 6, duration_min = 2, duration_max = 11, duration_bias = 1,
        pressure_scale = 145, window_boost = 2, limit_soft = 4, lc_end_extend = 0
    },
    ["Mirror Chaos"] = {
        mode = "Flick", check_mode = "Tickbase", harden = 55, driver_bias = 0,
        guard = "Edges", guard_window = 2, flick_trigger = "Advance", flick_tick_mode = "Random Jitter",
        flick_min = 5, flick_max = 11, flick_cycle = 6, flick_repeat = 2, packet_mod = 9,
        duration_mode = "Random", duration_static = 8, duration_min = 3, duration_max = 13, duration_bias = 0,
        pressure_scale = 120, window_boost = 2, limit_soft = 0, lc_end_extend = 0
    },
    ["Flux Pulse"] = {
        mode = "Duration", check_mode = "Command Num", harden = 60, driver_bias = -1,
        guard = "Center", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Cycle",
        flick_min = 6, flick_max = 11, flick_cycle = 5, flick_repeat = 3, packet_mod = 10,
        duration_mode = "Adaptive", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 1,
        pressure_scale = 125, window_boost = 1, limit_soft = 0, lc_end_extend = 1
    },
    ["Tension Balance"] = {
        mode = "Custom", check_mode = "Tickbase", harden = 50, driver_bias = 0,
        guard = "Center", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Random Static",
        flick_min = 7, flick_max = 11, flick_cycle = 6, flick_repeat = 3, packet_mod = 11,
        duration_mode = "Stages", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 0,
        pressure_scale = 100, window_boost = 1, limit_soft = 0, lc_end_extend = 0
    },
    ["Counter Step"] = {
        mode = "Limit", check_mode = "Command Num", harden = 55, driver_bias = -1,
        guard = "Near Start", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Jitter",
        flick_min = 6, flick_max = 9, flick_cycle = 4, flick_repeat = 3, packet_mod = 9,
        duration_mode = "Static", duration_static = 7, duration_min = 3, duration_max = 10, duration_bias = 0,
        pressure_scale = 110, window_boost = 1, limit_soft = 6, lc_end_extend = 0
    },
    ["Late Tick"] = {
        mode = "LC End", check_mode = "Tickbase", harden = 45, driver_bias = 1,
        guard = "Near End", guard_window = 1, flick_trigger = "Simple", flick_tick_mode = "Static",
        flick_min = 7, flick_max = 10, flick_cycle = 6, flick_repeat = 3, packet_mod = 11,
        duration_mode = "Static", duration_static = 8, duration_min = 3, duration_max = 11, duration_bias = 0,
        pressure_scale = 95, window_boost = 1, limit_soft = 0, lc_end_extend = 3
    },
    ["Early Tick"] = {
        mode = "Custom", check_mode = "Tickbase", harden = 40, driver_bias = 1,
        guard = "Near Start", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Random",
        flick_min = 8, flick_max = 12, flick_cycle = 7, flick_repeat = 4, packet_mod = 12,
        duration_mode = "Random", duration_static = 9, duration_min = 4, duration_max = 14, duration_bias = -1,
        pressure_scale = 90, window_boost = 0, limit_soft = 0, lc_end_extend = 0
    },
    ["Center Pivot"] = {
        mode = "Duration", check_mode = "Tickbase", harden = 35, driver_bias = 0,
        guard = "Center", guard_window = 2, flick_trigger = "Simple", flick_tick_mode = "Cycle",
        flick_min = 7, flick_max = 10, flick_cycle = 5, flick_repeat = 3, packet_mod = 10,
        duration_mode = "Adaptive", duration_static = 7, duration_min = 3, duration_max = 11, duration_bias = 0,
        pressure_scale = 95, window_boost = 1, limit_soft = 0, lc_end_extend = 0
    },
    ["Edges Guard"] = {
        mode = "Custom", check_mode = "Tickbase", harden = 55, driver_bias = -1,
        guard = "Edges", guard_window = 2, flick_trigger = "Advance", flick_tick_mode = "Jitter",
        flick_min = 6, flick_max = 10, flick_cycle = 5, flick_repeat = 2, packet_mod = 9,
        duration_mode = "Stages", duration_static = 8, duration_min = 3, duration_max = 12, duration_bias = 0,
        pressure_scale = 110, window_boost = 1, limit_soft = 0, lc_end_extend = 0
    },
}

def_runtime_modifiers = {
    ["Balanced"] = { pressure_scale = 100, tick_bias = 0, window_scale = 100, duration_scale = 100, random_amp = 100 },
    ["Aggressive"] = { pressure_scale = 125, tick_bias = -1, window_scale = 135, duration_scale = 120, random_amp = 125 },
    ["Stealth"] = { pressure_scale = 82, tick_bias = 1, window_scale = 88, duration_scale = 90, random_amp = 75 },
    ["Adaptive"] = { pressure_scale = 112, tick_bias = 0, window_scale = 110, duration_scale = 100, random_amp = 100 },
    ["Unstable"] = { pressure_scale = 135, tick_bias = 0, window_scale = 145, duration_scale = 115, random_amp = 160 },
}

function def_get_profile_cfg(aa)
    local profile_name = (aa.def_profile and ui_get(aa.def_profile)) or "Legacy"
    local runtime_name = (aa.def_runtime and ui_get(aa.def_runtime)) or "Balanced"
    local profile = def_profile_presets[profile_name] or def_profile_presets["Legacy"]
    local runtime = def_runtime_modifiers[runtime_name] or def_runtime_modifiers["Balanced"]
    vars.def_profile_name = profile_name
    vars.def_runtime_name = runtime_name
    return profile, runtime
end

function def_get_resolved_mode(raw_mode, profile)
    local resolved = raw_mode
    if raw_mode == "Profile" then
        resolved = profile.mode or "Custom"
    end
    if resolved == "Profile" then resolved = "Custom" end
    vars.def_mode_resolved = resolved
    return resolved
end

function def_tick_guard_pass(aa, profile, source_ticks, range1, range2)
    local guard_name = (aa.def_tick_guard and ui_get(aa.def_tick_guard)) or "Off"
    local guard_window = (aa.def_tick_guard_window and ui_get(aa.def_tick_guard_window)) or 2
    if ui_get(aa.def_mode) == "Profile" then
        guard_name = profile.guard or guard_name
        guard_window = profile.guard_window or guard_window
    end

    vars.def_guard_name = guard_name
    vars.def_guard_window = guard_window
    if guard_name == "Off" then
        vars.def_guard_pass = true
        return true
    end

    local pass = true
    if guard_name == "Near End" then
        pass = source_ticks > 0 and source_ticks <= math_max(1, guard_window)
    elseif guard_name == "Near Start" then
        local min_start = math_max(1, range2 - guard_window + 1)
        pass = source_ticks >= min_start
    elseif guard_name == "Center" then
        local center = math_floor((range1 + range2) * 0.5 + 0.5)
        pass = math_abs(source_ticks - center) <= guard_window
    elseif guard_name == "Edges" then
        local min_start = math_max(1, range2 - guard_window + 1)
        pass = (source_ticks > 0 and source_ticks <= math_max(1, guard_window)) or source_ticks >= min_start
    end

    vars.def_guard_pass = pass and true or false
    return vars.def_guard_pass
end

local function def_resolve_tick_driver(aa, def_ticks)
    local profile, runtime = def_get_profile_cfg(aa)
    local fallback = math_max(1, ui_get(aa.def_mode_tick) or profile.duration_static or 8)
    local harden_toggle = aa.def_harden and ui_get(aa.def_harden)
    if harden_toggle == nil then harden_toggle = true end
    local harden_scale = ((aa.def_harden_scale and ui_get(aa.def_harden_scale)) or (profile.harden or 45)) / 100
    local total_bias = ((aa.def_tick_bias and ui_get(aa.def_tick_bias)) or 0) + (profile.driver_bias or 0) + (runtime.tick_bias or 0)

    local function get_threat_pressure()
        local lp = entity_get_local_player()
        local threat = client_current_threat()
        if not lp or not threat or not entity_is_alive(lp) or not entity_is_alive(threat) then
            return 0
        end

        local pressure = 0
        if is_visible(threat) then pressure = pressure + 2 end

        local lx, ly, lz = entity_get_prop(lp, "m_vecOrigin")
        local tx, ty, tz = entity_get_prop(threat, "m_vecOrigin")
        if lx and tx then
            local dist = math_sqrt((lx - tx)^2 + (ly - ty)^2 + (lz - tz)^2)
            if dist < 280 then pressure = pressure + 3
            elseif dist < 600 then pressure = pressure + 2
            elseif dist < 1000 then pressure = pressure + 1 end
        end

        local tw = entity_get_player_weapon(threat)
        local tw_data = tw and csgo_weapons[entity_get_prop(tw, "m_iItemDefinitionIndex")]
        if tw_data then
            if tw_data.is_taser then pressure = pressure + 2 end
            if tw_data.type == "sniper" or tw_data.type == "shotgun" then pressure = pressure + 1 end
        end

        if exploit_data.breaking_lc then pressure = pressure + 1 end
        if exploit_data.defensive.left > 0 and exploit_data.defensive.left <= 2 then pressure = pressure + 2 end
        if (vars.def_tick_streak or 0) > 0 then
            pressure = pressure + math_min(3, math_floor((vars.def_tick_streak + 1) * 0.5))
        end
        if (vars.def_tick_peak or 0) >= 6 then
            pressure = pressure + 1
        end
        if vars.def_pred_active then
            pressure = pressure + 1
        end
        pressure = pressure * ((profile.pressure_scale or 100) / 100) * ((runtime.pressure_scale or 100) / 100)
        return clamp(math_floor(pressure + 0.5), 0, 12)
    end

    local function harden_driver_tick(base_tick, min_tick, max_tick)
        local pressure = harden_toggle and math_floor(get_threat_pressure() * harden_scale + 0.5) or 0
        vars.def_driver_pressure = pressure

        local lo = math_max(1, min_tick or 1)
        local hi = math_max(lo, max_tick or base_tick or 1)
        local out = clamp(base_tick or 1, lo, hi)

        if pressure > 0 then
            out = out - math_floor((pressure + 1) * 0.5)
            local rand_scale = (runtime.random_amp or 100) / 100
            local rand_span = math_max(1, math_floor((pressure * 0.75) * rand_scale))
            out = out + math.random(-rand_span, rand_span)
            if def_ticks and def_ticks > 0 and def_ticks <= 2 then
                out = math_min(out, lo + (pressure >= 4 and 0 or 1))
            end
            out = clamp(out, lo, hi)
        end

        out = clamp(out + total_bias, lo, hi)

        if out == vars.def_driver_last then
            vars.def_driver_repeat = vars.def_driver_repeat + 1
        else
            vars.def_driver_repeat = 0
        end
        if vars.def_driver_repeat >= 2 then
            local nudge = (globals_tickcount() % 2 == 0) and 1 or -1
            out = clamp(out + nudge * math_max(1, math_floor(pressure * 0.5) + 1), lo, hi)
            vars.def_driver_repeat = 0
        end

        vars.def_driver_last = out
        return out
    end

    if not ui_get(aa.delay_base) then
        if globals_chokedcommands() ~= 0 then
            return math_max(1, vars.def_driver_cached or fallback)
        end
        local hardened = harden_driver_tick(fallback, math_max(1, fallback - 2), math_max(1, fallback + 2))
        vars.delay_current = hardened
        vars.def_driver_cached = hardened
        return hardened
    end

    local mode = ui_get(aa.delay_mode)
    local mn = math_max(1, math_min(ui_get(aa.delay_min_tick), ui_get(aa.delay_max_tick)))
    local mx = math_max(1, math_max(ui_get(aa.delay_min_tick), ui_get(aa.delay_max_tick)))
    local jitter_speed = math_max(1, ui_get(aa.delay_jitter_speed) or 1)
    local cycle_speed = math_max(1, ui_get(aa.delay_cycle_speed) or 1)
    local resolved = fallback

    if mode == "Static" then
        resolved = math_max(1, ui_get(aa.delay_static_tick) or fallback)
    elseif mode == "Random" then
        if globals_chokedcommands() == 0 then vars.delay_current = math.random(mn, mx) end
        resolved = vars.delay_current
    elseif mode == "Jitter" then
        if globals_chokedcommands() == 0 then
            vars.delay_tick = vars.delay_tick + 1
            if vars.delay_tick >= jitter_speed then
                vars.delay_tick = 0
                vars.delay_jitter_switch = not vars.delay_jitter_switch
            end
        end
        resolved = vars.delay_jitter_switch and mx or mn
    elseif mode == "Random Jitter" then
        if globals_chokedcommands() == 0 then
            vars.delay_tick = vars.delay_tick + 1
            if vars.delay_tick >= jitter_speed then
                vars.delay_tick = 0
                vars.delay_jitter_switch = math.random(0, 1) == 1
            end
        end
        resolved = vars.delay_jitter_switch and mx or mn
    elseif mode == "JitterTick" then
        local phase = math_floor(globals_tickcount() / jitter_speed) % 2 == 0
        resolved = phase and mx or mn
    elseif mode == "Cycle" then
        if globals_chokedcommands() == 0 and globals_tickcount() % cycle_speed == 0 then
            vars.delay_cycle_idx = vars.delay_cycle_idx + 1
        end
        local span = math_max(1, mx - mn + 1)
        resolved = mn + ((vars.delay_cycle_idx - 1) % span)
    elseif mode == "CycleSpin" then
        if globals_chokedcommands() == 0 and globals_tickcount() % cycle_speed == 0 then
            vars.delay_cycle_idx = vars.delay_cycle_idx + 1
        end
        local span = math_max(1, mx - mn + 1)
        resolved = mn + ((vars.delay_cycle_idx - 1) % span)
    elseif mode == "Burst" then
        local phase = math_floor(globals_tickcount() / jitter_speed) % 2 == 0
        resolved = phase and mx or mn
    elseif mode == "Stair" then
        if globals_chokedcommands() == 0 and globals_tickcount() % cycle_speed == 0 then
            vars.delay_cycle_idx = vars.delay_cycle_idx + 1
        end
        local span = math_max(1, mx - mn + 1)
        resolved = mn + ((vars.delay_cycle_idx - 1) % span)
    elseif mode == "Random Trigger" then
        resolved = globals_tickcount() % math.random(15, 20) > 1 and mx or mn
    elseif mode == "Fluctuate" then
        resolved = globals_tickcount() % 17 == 0 and mn or mx
    end

    if globals_chokedcommands() ~= 0 then
        return math_max(1, vars.def_driver_cached or vars.delay_current or fallback)
    end

    local hard_min = (mode == "Static") and math_max(1, resolved - 2) or mn
    local hard_max = (mode == "Static") and math_max(hard_min, resolved + 2) or mx
    local hardened = harden_driver_tick(math_max(1, resolved or fallback), hard_min, hard_max)
    vars.delay_current = hardened
    vars.def_driver_cached = hardened
    return hardened
end

local function def_resolve_source_ticks(raw_mode, profile, aa, def_ticks)
    local check_mode = (aa.def_check_mode and ui_get(aa.def_check_mode)) or "Tickbase"
    if raw_mode == "Profile" and profile.check_mode then
        check_mode = profile.check_mode
    end

    local tick_src = math_max(0, def_ticks or 0)
    local cmd_src = math_max(0, exploit_data.defensive.cmd_left or 0)
    local source_ticks = check_mode == "Command Num" and cmd_src or tick_src

    if source_ticks <= 0 then
        if check_mode == "Command Num" and tick_src > 0 then
            source_ticks = tick_src
            check_mode = "Command Num+Tickbase"
        elseif check_mode ~= "Command Num" and cmd_src > 0 then
            source_ticks = cmd_src
            check_mode = "Tickbase+Command Num"
        end
    end

    source_ticks = math_max(source_ticks, vars.def_tick_last or 0)
    return math_max(0, source_ticks or 0), check_mode
end

local function def_reset_mode_runtime(raw_mode, mode)
    if vars.def_mode_last ~= raw_mode then
        vars.def_flick_tick = 0
        vars.def_flick_advance_idx = 0
        vars.def_flick_cycle_idx = 1
        vars.def_flick_jitter_switch = false
        vars.def_fake_flick_last_trigger = false
        vars.def_trigger_state = false
        vars.def_trigger_tick = 0
        vars.def_trigger_counter = 0
        vars.def_trigger_prev_raw = false
        vars.def_trigger_cooldown = 0
    end
    vars.def_mode_last = raw_mode

    if mode ~= "Duration" then
        vars.def_duration_active = false
        vars.def_duration_tick = 0
        vars.def_duration_target = 0
    end
    if mode ~= "Flick" then
        vars.def_flick_period_target = 0
        vars.def_flick_window_target = 0
        vars.def_trigger_state = false
        vars.def_trigger_tick = 0
        vars.def_trigger_counter = 0
        vars.def_trigger_prev_raw = false
        vars.def_trigger_cooldown = 0
    end
end

local function def_resolve_in_window(mode, ctx)
    local source_ticks = ctx.source_ticks
    local range1 = ctx.range1
    local range2 = ctx.range2
    local raw_mode = ctx.raw_mode
    local profile = ctx.profile
    local aa = ctx.aa
    local cmd = ctx.cmd
    local resolve_flick_tick = ctx.resolve_flick_tick
    local resolve_duration_target = ctx.resolve_duration_target

    local in_window = false
    local triggered = false
    if mode == "Neverlose" then
        in_window = source_ticks > 0
    elseif mode == "Custom" then
        in_window = source_ticks >= range1 and source_ticks <= range2
    elseif mode == "Flick" then
        local base_back = math_max(1, resolve_flick_tick())
        local flick_time = math_max(1, (aa.def_flick_time and ui_get(aa.def_flick_time)) or 2)
        local back_time = math_max(1, (aa.def_back_time and ui_get(aa.def_back_time)) or base_back)
        local cycle_tick = math_max(2, flick_time + back_time)
        vars.def_trigger_tick = cycle_tick
        local trigger_mode = (aa.def_flick_trigger and ui_get(aa.def_flick_trigger)) or "Simple"
        if raw_mode == "Profile" and profile.flick_trigger then
            trigger_mode = profile.flick_trigger
        end
        local streak_ticks = vars.def_tick_streak or 0
        if globals_chokedcommands() == 0 then
            vars.def_trigger_cooldown = math_max(0, (vars.def_trigger_cooldown or 0) - 1)
            local raw_triggered = false
            if trigger_mode == "Simple" then
                local cmdn = cmd and cmd.command_number or globals_tickcount()
                local phase = cmdn % cycle_tick
                raw_triggered = phase < flick_time
            else
                vars.def_flick_advance_idx = (vars.def_flick_advance_idx % cycle_tick) + 1
                raw_triggered = vars.def_flick_advance_idx <= flick_time
            end

            local allow_seed = source_ticks > 0 or streak_ticks > 0 or exploit_data.breaking_lc
            local rising = raw_triggered and not (vars.def_trigger_prev_raw or false)
            if rising then
                local panic_window = (vars.def_driver_pressure or 0) >= 6 or (source_ticks > 0 and source_ticks <= 2)
                if not panic_window and (vars.def_trigger_cooldown or 0) > 0 then
                    raw_triggered = false
                else
                    local next_cd = math_max(1, math_floor(back_time * 0.5 + 0.5))
                    if (vars.def_driver_pressure or 0) >= 5 then
                        next_cd = math_max(1, next_cd - 1)
                    end
                    vars.def_trigger_cooldown = next_cd
                end
            end

            vars.def_trigger_prev_raw = (raw_triggered and allow_seed) and true or false
            triggered = raw_triggered and allow_seed
            vars.def_trigger_state = triggered
            if triggered then
                vars.def_trigger_counter = math_max(vars.def_trigger_counter or 0, flick_time)
            else
                vars.def_trigger_counter = math_max(0, (vars.def_trigger_counter or 0) - 1)
            end
        else
            triggered = vars.def_trigger_state
        end
        in_window = source_ticks > 0 and (triggered or (vars.def_trigger_counter or 0) > 0)
        local force_limit = (aa.def_flick_limit and ui_get(aa.def_flick_limit)) or ((profile.limit_soft or 0) > 0)
        if force_limit then
            local lim = math_max(1, profile.limit_soft or cycle_tick)
            in_window = in_window and source_ticks <= lim
        end
        if (vars.def_driver_pressure or 0) >= 6 and source_ticks > 0 and source_ticks <= 2 then
            in_window = true
        end
    elseif mode == "Duration" then
        if source_ticks > 0 then
            if not vars.def_duration_active then
                vars.def_duration_active = true
                vars.def_duration_tick = 0
                vars.def_duration_target = resolve_duration_target()
            end
            if globals_chokedcommands() == 0 then
                vars.def_duration_tick = vars.def_duration_tick + 1
            end
        else
            vars.def_duration_active = false
            vars.def_duration_tick = 0
            vars.def_duration_target = 0
        end
        local duration_limit = math_max(1, vars.def_duration_target > 0 and vars.def_duration_target or (profile.duration_static or ui_get(aa.def_mode_tick) or 8))
        local pressure = vars.def_driver_pressure or 0
        if pressure >= 4 then
            duration_limit = math_min(30, duration_limit + 1 + math_floor((pressure - 3) * 0.5))
        end
        if source_ticks > 0 and source_ticks <= 2 then
            duration_limit = math_max(duration_limit, vars.def_duration_tick + 1)
        end
        duration_limit = math_floor(duration_limit * ((ctx.runtime.duration_scale or 100) / 100) + 0.5)
        local sustained_ticks = math_max(vars.def_duration_tick or 0, vars.def_tick_streak or 0)
        in_window = source_ticks > 0 and sustained_ticks <= duration_limit
    elseif mode == "LC End" then
        in_window = source_ticks > 0 and source_ticks <= math_max(1, range1 + (profile.lc_end_extend or 0))
    elseif mode == "Always" then
        in_window = true
    elseif mode == "Limit" then
        local lim = ui_get(aa.def_mode_tick) or profile.limit_soft or 1
        in_window = source_ticks > 0 and source_ticks <= math_max(1, lim)
    elseif mode == "Peek" then
        in_window = client_current_threat() ~= nil and (source_ticks > 0 or exploit_data.breaking_lc)
    elseif mode == "Charge" then
        in_window = exploit_data.shift or globals_chokedcommands() > 0
    elseif mode == "Near Start" then
        local start_min = math_max(1, range2 - math_max(1, range1) + 1)
        in_window = source_ticks >= start_min and source_ticks <= range2
    elseif mode == "Center" then
        local center = math_floor((range1 + range2) * 0.5 + 0.5)
        local span = math_max(1, math_floor(math_max(1, range2 - range1) * 0.5))
        in_window = source_ticks > 0 and math_abs(source_ticks - center) <= span
    elseif mode == "Edges" then
        local start_min = math_max(1, range2 - math_max(1, range1) + 1)
        in_window = (source_ticks > 0 and source_ticks <= math_max(1, range1)) or (source_ticks >= start_min and source_ticks <= range2)
    else
        in_window = source_ticks > 0
    end

    return in_window, triggered
end

local function def_adjust_pred_params_for_mode(mode, pred_flick, pred_back, pred_choke, aa, profile, range1, range2)
    if mode == "Flick" then
        pred_flick = math_max(1, (aa.def_flick_time and ui_get(aa.def_flick_time)) or pred_flick)
        pred_back = math_max(1, (aa.def_back_time and ui_get(aa.def_back_time)) or pred_back)
    elseif mode == "Neverlose" then
        pred_flick = math_max(pred_flick, math_max(1, range1 > 0 and range1 or math_floor(math_max(2, range2) * 0.25 + 0.5)))
        pred_back = math_max(pred_back, math_max(3, range2))
    elseif mode == "Custom" then
        local custom_span = math_max(1, range2 - range1 + 1)
        pred_flick = math_max(1, math_min(pred_flick, custom_span))
        pred_back = math_max(pred_back, math_max(3, range2))
    elseif mode == "LC End" then
        pred_flick = math_max(1, math_min(pred_flick, math_max(1, range1)))
        pred_back = math_max(pred_back, math_max(4, range2))
        pred_choke = clamp(pred_choke + 2, 1, 16)
    elseif mode == "Always" then
        pred_flick = math_max(pred_flick, math_max(2, math_floor(math_max(2, range2) * 0.35 + 0.5)))
        pred_back = math_max(pred_back, pred_flick + math_max(2, range1))
        pred_choke = clamp(pred_choke + 1, 1, 16)
    elseif mode == "Limit" then
        local limit_tick = math_max(1, (aa.def_mode_tick and ui_get(aa.def_mode_tick)) or profile.limit_soft or pred_flick)
        pred_flick = math_max(1, math_min(math_max(pred_flick, math_max(1, range1)), limit_tick))
        pred_back = math_max(pred_back, limit_tick + math_max(1, range1))
        pred_choke = clamp(pred_choke + 1, 1, 16)
    elseif mode == "Duration" then
        local duration_target = math_max(1, vars.def_duration_target > 0 and vars.def_duration_target or ((aa.def_mode_tick and ui_get(aa.def_mode_tick)) or pred_back))
        pred_flick = math_max(1, math_min(pred_flick, math_max(1, math_floor(duration_target * 0.35 + 0.5))))
        pred_back = math_max(pred_back, duration_target)
    elseif mode == "Peek" then
        pred_flick = math_max(pred_flick, math_max(2, math_floor(math_max(2, range2) * 0.3 + 0.5)))
        pred_back = math_max(pred_back, math_max(3, range2))
        pred_choke = clamp(pred_choke + 1, 1, 16)
    elseif mode == "Charge" then
        pred_flick = math_max(pred_flick, math_max(2, math_floor(math_max(2, range2) * 0.28 + 0.5)))
        pred_back = math_max(pred_back, math_max(4, range2))
        pred_choke = clamp(pred_choke + 2, 1, 16)
    elseif mode == "Center" then
        pred_flick = math_max(2, math_floor((pred_flick + math_max(2, range1)) * 0.5 + 0.5))
        pred_back = math_max(pred_back, math_max(3, range2))
    elseif mode == "Near Start" or mode == "Edges" then
        pred_back = math_max(pred_back, math_max(3, range2))
        pred_choke = clamp(pred_choke + 1, 1, 16)
    end
    return pred_flick, pred_back, pred_choke
end

local function def_compute_active(aa, def_ticks, driver_tick, cmd)
    local raw_mode = ui_get(aa.def_mode)
    local profile, runtime = def_get_profile_cfg(aa)
    local mode = def_get_resolved_mode(raw_mode, profile)
    local range1 = clamp(ui_get(aa.def_range1), 0, 15)
    local range2 = clamp(ui_get(aa.def_range2), 0, 15)
    if range1 > range2 then range1, range2 = range2, range1 end

    local source_ticks, check_mode = def_resolve_source_ticks(raw_mode, profile, aa, def_ticks)
    vars.def_source_ticks = source_ticks
    vars.def_check_source = check_mode

    def_reset_mode_runtime(raw_mode, mode)

    local function resolve_duration_target()
        local dmode = aa.def_duration_mode and ui_get(aa.def_duration_mode) or "Static"
        if raw_mode == "Profile" and profile.duration_mode then
            dmode = profile.duration_mode
        end
        if dmode == "Stages" then
            local stages = aa.def_duration_stages and clamp(ui_get(aa.def_duration_stages), 1, 8) or 1
            if vars.def_duration_stage_idx < 1 or vars.def_duration_stage_idx > stages then
                vars.def_duration_stage_idx = 1
            end
            local key = "def_duration_stage" .. vars.def_duration_stage_idx
            local raw = (aa[key] and ui_get(aa[key])) or (profile.duration_static or ui_get(aa.def_mode_tick) or 8)
            vars.def_duration_stage_idx = (vars.def_duration_stage_idx % stages) + 1
            return math_max(1, raw)
        elseif dmode == "Random" then
            local raw_min = aa.def_duration_min and ui_get(aa.def_duration_min) or profile.duration_min or 1
            local raw_max = aa.def_duration_max and ui_get(aa.def_duration_max) or profile.duration_max or 8
            local mn = math_max(1, math_min(raw_min, raw_max))
            local mx = math_max(1, math_max(raw_min, raw_max))
            return math.random(mn, mx)
        elseif dmode == "Adaptive" then
            local raw_min = aa.def_duration_min and ui_get(aa.def_duration_min) or profile.duration_min or 1
            local raw_max = aa.def_duration_max and ui_get(aa.def_duration_max) or profile.duration_max or 14
            local mn = math_max(1, math_min(raw_min, raw_max))
            local mx = math_max(1, math_max(raw_min, raw_max))
            local user_bias = aa.def_duration_bias and ui_get(aa.def_duration_bias) or 0
            local p_bias = profile.duration_bias or 0
            local pressure = vars.def_driver_pressure or 0
            local scaled = math_floor(driver_tick * ((runtime.duration_scale or 100) / 100) + 0.5)
            return clamp(scaled + user_bias + p_bias + math_floor(pressure * 0.4), mn, mx)
        end
        return math_max(1, profile.duration_static or ui_get(aa.def_mode_tick) or 8)
    end

    local function resolve_flick_tick()
        local mode_tick = (aa.def_flick_tick_mode and ui_get(aa.def_flick_tick_mode)) or "Static"
        if raw_mode == "Profile" and profile.flick_tick_mode then
            mode_tick = profile.flick_tick_mode
        end
        local min_tick = math_max(1, (aa.def_flick_tick_min and ui_get(aa.def_flick_tick_min)) or profile.flick_min or math_max(1, driver_tick or 1))
        local max_tick = math_max(min_tick, (aa.def_flick_tick_max and ui_get(aa.def_flick_tick_max)) or profile.flick_max or min_tick)
        local repeat_ticks = math_max(1, (aa.def_flick_jitter_repeat and ui_get(aa.def_flick_jitter_repeat)) or profile.flick_repeat or 4)
        local cycle_speed = math_max(1, (aa.def_flick_cycle_speed and ui_get(aa.def_flick_cycle_speed)) or profile.flick_cycle or 6)

        if mode_tick == "Static" then
            return math_max(1, profile.flick_min or ui_get(aa.def_mode_tick) or 8)
        elseif mode_tick == "Random" then
            return math.random(min_tick, max_tick)
        elseif mode_tick == "Random Static" then
            if globals_chokedcommands() == 0 and source_ticks == 0 then
                vars.def_flick_random_static = math.random(min_tick, max_tick)
            end
            vars.def_flick_random_static = clamp(vars.def_flick_random_static or min_tick, min_tick, max_tick)
            return vars.def_flick_random_static
        elseif mode_tick == "Random Trigger" then
            return globals_tickcount() % math.random(15, 20) > 1 and max_tick or min_tick
        elseif mode_tick == "Random Jitter" then
            if globals_chokedcommands() == 0 then
                vars.def_flick_tick = vars.def_flick_tick + 1
                if vars.def_flick_tick >= repeat_ticks then
                    vars.def_flick_tick = 0
                    vars.def_flick_jitter_switch = math.random(0, 1) == 1
                end
            end
            return vars.def_flick_jitter_switch and max_tick or min_tick
        elseif mode_tick == "Jitter" then
            if globals_chokedcommands() == 0 then
                vars.def_flick_tick = vars.def_flick_tick + 1
                if vars.def_flick_tick >= repeat_ticks then
                    vars.def_flick_tick = 0
                    vars.def_flick_jitter_switch = not vars.def_flick_jitter_switch
                end
            end
            return vars.def_flick_jitter_switch and max_tick or min_tick
        elseif mode_tick == "Cycle" then
            if globals_chokedcommands() == 0 and globals_tickcount() % cycle_speed == 0 then
                vars.def_flick_cycle_idx = vars.def_flick_cycle_idx + 1
                if vars.def_flick_cycle_idx > max_tick then
                    vars.def_flick_cycle_idx = min_tick
                end
            end
            if vars.def_flick_cycle_idx < min_tick or vars.def_flick_cycle_idx > max_tick then
                vars.def_flick_cycle_idx = min_tick
            end
            return vars.def_flick_cycle_idx
        elseif mode_tick == "Prime" then
            local primes = {}
            for n = min_tick, max_tick do
                local is_prime = n >= 2
                if is_prime then
                    local lim = math_floor(math_sqrt(n))
                    for d = 2, lim do
                        if n % d == 0 then
                            is_prime = false
                            break
                        end
                    end
                end
                if is_prime then
                    primes[#primes + 1] = n
                end
            end
            if #primes == 0 then
                return min_tick
            end
            if globals_chokedcommands() == 0 then
                vars.def_flick_cycle_idx = (vars.def_flick_cycle_idx % #primes) + 1
            end
            local pidx = vars.def_flick_cycle_idx
            if pidx < 1 or pidx > #primes then
                pidx = 1
                vars.def_flick_cycle_idx = 1
            end
            return primes[pidx]
        elseif mode_tick == "Burst Cycle" then
            local span = math_max(1, max_tick - min_tick + 1)
            if globals_chokedcommands() == 0 and globals_tickcount() % cycle_speed == 0 then
                vars.def_flick_cycle_idx = vars.def_flick_cycle_idx + 1
                if vars.def_flick_cycle_idx > span then
                    vars.def_flick_cycle_idx = 1
                end
            end
            if math_floor(globals_tickcount() / cycle_speed) % 2 == 0 then
                return max_tick
            end
            local cidx = vars.def_flick_cycle_idx
            if cidx < 1 or cidx > span then
                cidx = 1
                vars.def_flick_cycle_idx = 1
            end
            return min_tick + (cidx - 1)
        elseif mode_tick == "Entropy" then
            local seed = (globals_tickcount() * 131)
                + ((cmd and cmd.command_number or 0) * 17)
                + ((vars.def_driver_pressure or 0) * 29)
                + ((source_ticks or 0) * 7)
            local span = math_max(1, max_tick - min_tick + 1)
            return min_tick + (math_abs(seed) % span)
        end

        local beta = { 6, 8, 10, 12, 9, 7, 11, 5 }
        if globals_chokedcommands() == 0 then
            vars.def_flick_beta_idx = (vars.def_flick_beta_idx % #beta) + 1
        end
        return beta[vars.def_flick_beta_idx > 0 and vars.def_flick_beta_idx or 1]
    end

    local in_window = def_resolve_in_window(mode, {
        source_ticks = source_ticks,
        range1 = range1,
        range2 = range2,
        raw_mode = raw_mode,
        profile = profile,
        runtime = runtime,
        aa = aa,
        cmd = cmd,
        resolve_flick_tick = resolve_flick_tick,
        resolve_duration_target = resolve_duration_target,
    })

    local guard_ok = def_tick_guard_pass(aa, profile, source_ticks, range1, range2)
    local active_base = ui_get(aa.def_enable) and in_window and guard_ok and not vars.def_knife_near
    local active = active_base

    vars.def_send_packet_state = nil
    vars.def_release_body = false
    vars.def_release_follow = true
    vars.def_pred_active = false
    vars.def_pred_mode = "Off"
    vars.def_pred_phase = "idle"
    vars.def_pred_target = 0
    if active_base and mode == "Flick" then
        local packet_mod = (aa.def_flick_packets and ui_get(aa.def_flick_packets)) or profile.packet_mod or 0
        if packet_mod > 0 and cmd then
            vars.def_send_packet_state = (cmd.command_number % packet_mod == 0)
        end
        vars.def_release_body = aa.def_flick_desync_release and ui_get(aa.def_flick_desync_release) or false
        vars.def_release_follow = ((aa.def_flick_desync_mode and ui_get(aa.def_flick_desync_mode)) or "Follow") == "Follow"
    end

    if aa.def_pred_enable and ui_get(aa.def_pred_enable) and ui_get(aa.def_enable) and not vars.def_knife_near then
        local pred_mode = (aa.def_pred_mode and ui_get(aa.def_pred_mode)) or "Maximum"
        local pred_flick = math_max(1, (aa.def_pred_flick and ui_get(aa.def_pred_flick)) or 2)
        local pred_back = math_max(1, (aa.def_pred_back and ui_get(aa.def_pred_back)) or 8)
        local pred_choke = clamp((aa.def_pred_choke and ui_get(aa.def_pred_choke)) or 12, 1, 16)
        if raw_mode == "Profile" then
            pred_mode = profile.pred_mode or pred_mode
            pred_flick = math_max(1, profile.pred_flick or pred_flick)
            pred_back = math_max(1, profile.pred_back or pred_back)
            pred_choke = clamp(profile.pred_choke or pred_choke, 1, 16)
        end
        pred_flick, pred_back, pred_choke = def_adjust_pred_params_for_mode(
            mode, pred_flick, pred_back, pred_choke, aa, profile, range1, range2
        )

        local cycle_tick = math_max(2, pred_flick + pred_back)
        local cmdn = cmd and cmd.command_number or globals_tickcount()
        local phase = cmdn % cycle_tick
        local synthetic_source = clamp(math_floor(range2 - (phase / math_max(1, cycle_tick - 1)) * math_max(0, range2 - 1) + 0.5), 1, math_max(1, range2))
        local in_flick_phase = phase < pred_flick
        local pred_phase_name = in_flick_phase and "flick" or "back"
        local choked = globals_chokedcommands()
        local target_choke = pred_choke

        if mode == "Neverlose" then
            local nl_edge = math_max(1, range1 > 0 and range1 or math_floor(math_max(2, range2) * 0.25 + 0.5))
            in_flick_phase = synthetic_source <= nl_edge or phase < pred_flick
            pred_phase_name = in_flick_phase and "nl-flick" or "nl-back"
        elseif mode == "Custom" then
            local custom_min = math_max(1, range1)
            local custom_max = math_max(custom_min, range2)
            in_flick_phase = synthetic_source >= custom_min and synthetic_source <= custom_max
            pred_phase_name = in_flick_phase and "window" or "return"
        elseif mode == "LC End" then
            in_flick_phase = synthetic_source <= math_max(1, range1)
            pred_phase_name = in_flick_phase and "lc-end" or "travel"
        elseif mode == "Always" then
            in_flick_phase = phase < pred_flick or synthetic_source <= math_max(1, math_floor(math_max(2, range2) * 0.35 + 0.5))
            pred_phase_name = in_flick_phase and "always-flick" or "always-back"
        elseif mode == "Limit" then
            local limit_tick = math_max(1, (aa.def_mode_tick and ui_get(aa.def_mode_tick)) or profile.limit_soft or pred_flick)
            in_flick_phase = synthetic_source <= limit_tick
            pred_phase_name = in_flick_phase and "limit" or "recover"
        elseif mode == "Duration" then
            in_flick_phase = vars.def_duration_active or phase < pred_flick
            pred_phase_name = in_flick_phase and "duration" or "recover"
        elseif mode == "Peek" then
            local threat = client_current_threat()
            in_flick_phase = threat ~= nil and (phase < pred_flick or source_ticks > 0)
            pred_phase_name = in_flick_phase and "peek" or "hold"
        elseif mode == "Charge" then
            in_flick_phase = exploit_data.shift or globals_chokedcommands() > 0 or phase < pred_flick
            pred_phase_name = in_flick_phase and "charge" or "buffer"
        elseif mode == "Center" then
            local center = math_floor((range1 + range2) * 0.5 + 0.5)
            local center_window = math_max(1, math_floor(math_max(1, range2 - range1) * 0.3 + 0.5))
            in_flick_phase = math_abs(synthetic_source - center) <= center_window
            pred_phase_name = in_flick_phase and "center" or "outer"
        elseif mode == "Near Start" then
            local start_min = math_max(1, range2 - math_max(1, range1) + 1)
            in_flick_phase = synthetic_source >= start_min
            pred_phase_name = in_flick_phase and "start" or "travel"
        elseif mode == "Edges" then
            local start_min = math_max(1, range2 - math_max(1, range1) + 1)
            in_flick_phase = synthetic_source <= math_max(1, range1) or synthetic_source >= start_min
            pred_phase_name = in_flick_phase and "edge" or "center"
        end

        if pred_mode == "Adaptive" then
            local pressure = clamp(vars.def_driver_pressure or 0, 0, 12)
            target_choke = clamp(target_choke - math_floor(pressure * 0.5), 1, 16)
        elseif pred_mode == "Pulse" then
            target_choke = in_flick_phase and target_choke or clamp(math_floor(target_choke * 0.6 + 0.5), 1, 16)
        end

        local send_state
        if in_flick_phase then
            send_state = choked >= target_choke
        else
            send_state = choked >= math_max(1, target_choke - 1)
        end

        if active_base then
            vars.def_pred_extend = math_max(vars.def_pred_extend or 0, cycle_tick)
        elseif (vars.def_pred_extend or 0) > 0 and globals_chokedcommands() == 0 then
            vars.def_pred_extend = math_max(0, (vars.def_pred_extend or 0) - 1)
        end

        local pred_support_active = active_base or (vars.def_pred_extend or 0) > 0
        if pred_support_active then
            vars.def_send_packet_state = send_state and true or false
        end
        vars.def_pred_active = pred_support_active
        vars.def_pred_mode = pred_mode
        vars.def_pred_phase = pred_phase_name
        vars.def_pred_target = target_choke
        if pred_support_active then
            active = true
            if source_ticks <= 0 then
                source_ticks = synthetic_source
                vars.def_source_ticks = synthetic_source
                vars.def_check_source = check_mode .. "+Pred"
            end
        end
    else
        vars.def_pred_extend = 0
    end

    local state_name = (active and "Active-" or "Idle-") .. mode
    return active, state_name, range1, range2, source_ticks, vars.def_trigger_state
end

local function def_update_fake_flick(aa, active, trigger_state, source_ticks, range1, range2)
    local enabled = active and ui_get(aa.def_fake_flick)
    if not enabled then
        vars.def_fake_flick_tick = 0
        vars.def_fake_flick_side = 1
        vars.def_fake_flick_last_trigger = false
        vars.def_fake_flick_cooldown = 0
        return 1, false
    end

    local profile, _ = def_get_profile_cfg(aa)
    local raw_mode = ui_get(aa.def_mode)
    local mode = vars.def_mode_resolved
    if mode == nil or mode == "" then
        mode = def_get_resolved_mode(raw_mode, profile)
    end

    local src = math_max(0, source_ticks or vars.def_source_ticks or 0)
    local r1 = clamp(range1 or (aa.def_range1 and ui_get(aa.def_range1)) or 0, 0, 15)
    local r2 = clamp(range2 or (aa.def_range2 and ui_get(aa.def_range2)) or 0, 0, 15)
    if r1 > r2 then
        r1, r2 = r2, r1
    end

    local pulse = false
    if mode == "Flick" then
        pulse = trigger_state and true or false
    elseif mode == "LC End" then
        local lim = math_max(1, r1 + (profile.lc_end_extend or 0))
        pulse = src > 0 and src <= lim
    elseif mode == "Custom" then
        pulse = src >= r1 and src <= r2
    elseif mode == "Limit" then
        local lim = math_max(1, (aa.def_mode_tick and ui_get(aa.def_mode_tick)) or profile.limit_soft or 1)
        pulse = src > 0 and src <= lim
    elseif mode == "Duration" then
        local dlim = math_max(1, vars.def_duration_target > 0 and vars.def_duration_target
            or (profile.duration_static or (aa.def_mode_tick and ui_get(aa.def_mode_tick)) or 8))
        pulse = src > 0 and vars.def_duration_tick > 0 and vars.def_duration_tick <= dlim
    elseif mode == "Peek" then
        pulse = src > 0 and client_current_threat() ~= nil
    elseif mode == "Charge" then
        pulse = exploit_data.shift or globals_chokedcommands() > 0
    elseif mode == "Near Start" then
        local start_min = math_max(1, r2 - math_max(1, r1) + 1)
        pulse = src >= start_min and src <= r2
    elseif mode == "Center" then
        local center = math_floor((r1 + r2) * 0.5 + 0.5)
        local span = math_max(1, math_floor(math_max(1, r2 - r1) * 0.5))
        pulse = src > 0 and math_abs(src - center) <= span
    elseif mode == "Edges" then
        local start_min = math_max(1, r2 - math_max(1, r1) + 1)
        pulse = (src > 0 and src <= math_max(1, r1)) or (src >= start_min and src <= r2)
    elseif mode == "Always" then
        pulse = src > 0 and src <= math_max(1, r1)
    else
        pulse = src > 0
    end

    local trigger_mode = (aa.def_flick_trigger and ui_get(aa.def_flick_trigger)) or "Simple"
    if raw_mode == "Profile" and profile.flick_trigger then
        trigger_mode = profile.flick_trigger
    end
    if globals_chokedcommands() == 0 then
        vars.def_fake_flick_cooldown = math_max(0, (vars.def_fake_flick_cooldown or 0) - 1)
        local rising = pulse and not vars.def_fake_flick_last_trigger
        local pressure = vars.def_driver_pressure or 0
        local panic = pressure >= 6 or (src > 0 and src <= 1)
        local can_flip = panic or (vars.def_fake_flick_cooldown or 0) <= 0

        if rising and can_flip then
            if trigger_mode == "Advance" then
                vars.def_fake_flick_tick = vars.def_fake_flick_tick + 1
                if vars.def_fake_flick_tick % 2 == 0 then
                    vars.def_fake_flick_side = -vars.def_fake_flick_side
                end
            else
                vars.def_fake_flick_side = -vars.def_fake_flick_side
            end

            local base_cd = math_max(1, math_floor((((aa.def_back_time and ui_get(aa.def_back_time)) or profile.flick_min or 4) * 0.4) + 0.5))
            if pressure >= 5 then
                base_cd = math_max(1, base_cd - 1)
            end
            vars.def_fake_flick_cooldown = base_cd
        end

        if vars.def_runtime_name == "Unstable" and rising and can_flip and math.random(0, 6) == 0 then
            vars.def_fake_flick_side = -vars.def_fake_flick_side
        end
        if not pulse and src == 0 and (vars.def_fake_flick_cooldown or 0) > 0 and pressure <= 2 then
            vars.def_fake_flick_side = vars.body_inverted and 1 or -1
        end
        vars.def_fake_flick_last_trigger = pulse and true or false
    end

    return vars.def_fake_flick_side, true
end

local function def_get_pitch_way(aa, idx)
    local key = "def_pitch_way" .. idx
    return aa[key] and ui_get(aa[key]) or 0
end

local function def_get_yaw_way(aa, idx)
    local key = "def_yaw_way" .. idx
    return aa[key] and ui_get(aa[key]) or 0
end

local function def_calc_pitch(aa, source_ticks, range1, range2)
    local mode = ui_get(aa.def_pitch)
    if mode == "None" then return nil end

    local pmin, pmax = ui_get(aa.def_pitch_min), ui_get(aa.def_pitch_max)
    local speed = ui_get(aa.def_pitch_speed)
    local delay_ticks = math_max(1, ui_get(aa.def_delay_ticks) or 1)

    if mode == "Zero" then
        return 0
    elseif mode == "Up" then
        return -89
    elseif mode == "Custom" then
        return clamp(ui_get(aa.def_pitch_val), -89, 89)
    elseif mode == "Random" then
        return math.random(pmin, pmax)
    elseif mode == "Progressive" then
        return clamp(sine_yaw(globals_tickcount() * speed * 0.1, pmin, pmax), -89, 89)
    elseif mode == "Jitter" then
        if globals_tickcount() % delay_ticks == 0 then
            vars.def_pitch_jitter_twisted = not vars.def_pitch_jitter_twisted
        end
        return vars.def_pitch_jitter_twisted and pmax or pmin
    elseif mode == "Randomize Jitter" then
        if globals_tickcount() % delay_ticks == 0 then
            vars.def_pitch_jitter_twisted = not vars.def_pitch_jitter_twisted
        end
        return math.random(0, 1) == 1 and pmax or pmin
    elseif mode == "Spin" then
        vars.def_pitch_spin_val = vars.def_pitch_spin_val + (speed * 0.5)
        if vars.def_pitch_spin_val > pmax then vars.def_pitch_spin_val = pmin end
        return vars.def_pitch_spin_val
    elseif mode == "Sway" then
        vars.def_pitch_sway = vars.def_pitch_sway + speed * 0.05
        return pmin + (pmax - pmin) * (0.5 + 0.5 * math_sin(vars.def_pitch_sway))
    elseif mode == "Multiway" then
        if globals_chokedcommands() == 0 then
            vars.def_pitch_way_ticks = vars.def_pitch_way_ticks + 1
            local ways = clamp(ui_get(aa.def_pitch_que), 1, 8)
            if vars.def_pitch_way_ticks >= speed then
                vars.def_pitch_way_ticks = 0
                vars.def_pitch_way_idx = (vars.def_pitch_way_idx % ways) + 1
            end
        end
        return def_get_pitch_way(aa, vars.def_pitch_way_idx)
    elseif mode == "Generation" then
        if vars.def_gen_phase ~= exploit_data.breaking_lc then
            vars.def_gen_pitch = math.random(pmin, pmax)
        end
        return vars.def_gen_pitch
    elseif mode == "Random Static" then
        if vars.def_gen_phase ~= exploit_data.breaking_lc then
            vars.def_rand_static_pitch = math.random(pmin, pmax)
        end
        return vars.def_rand_static_pitch
    elseif mode == "LC End" then
        local mid = (range1 + range2) * 0.5
        return source_ticks >= mid and pmax or pmin
    elseif mode == "Wave" then
        return clamp(def_wave_value(pmin, pmax, ui_get(aa.def_wave_period), ui_get(aa.def_wave_type), ui_get(aa.def_wave_invert)), -89, 89)
    elseif mode == "Bodyyaw" then
        return vars.body_inverted and pmax or pmin
    end
    return nil
end

local function def_calc_yaw(aa, source_ticks, yaw_offset, range1, range2)
    local mode = ui_get(aa.def_yaw)
    if mode == "None" then return nil end

    local ymin, ymax = ui_get(aa.def_yaw_min), ui_get(aa.def_yaw_max)
    local speed = ui_get(aa.def_yaw_speed)
    local delay_ticks = math_max(1, ui_get(aa.def_delay_ticks) or 1)
    local out = 0

    if mode == "Jitter" then
        if globals_tickcount() % delay_ticks == 0 then
            vars.def_yaw_jitter_twisted = not vars.def_yaw_jitter_twisted
        end
        out = vars.def_yaw_jitter_twisted and ymax or ymin
    elseif mode == "Spin" then
        local dir = ui_get(aa.def_spin_reverse) and -1 or 1
        local start_off = ui_get(aa.def_spin_start) or 0
        out = normalize_yaw(start_off + globals_tickcount() * speed * dir)
    elseif mode == "Sway" then
        local dir = ui_get(aa.def_spin_reverse) and -1 or 1
        local start_off = ui_get(aa.def_spin_start) or 0
        vars.def_yaw_sway = vars.def_yaw_sway + (speed * 0.05 * dir)
        out = normalize_yaw(start_off + (ymin + (ymax - ymin) * (0.5 + 0.5 * math_sin(vars.def_yaw_sway))))
    elseif mode == "Multiway" then
        if globals_chokedcommands() == 0 then
            vars.def_yaw_way_ticks = vars.def_yaw_way_ticks + 1
            local ways = clamp(ui_get(aa.def_yaw_que), 1, 8)
            if vars.def_yaw_way_ticks >= speed then
                vars.def_yaw_way_ticks = 0
                vars.def_yaw_way_idx = (vars.def_yaw_way_idx % ways) + 1
            end
        end
        out = def_get_yaw_way(aa, vars.def_yaw_way_idx)
    elseif mode == "Generation" then
        if vars.def_gen_phase ~= exploit_data.breaking_lc then
            vars.def_gen_yaw = math.random(ymin, ymax)
        end
        out = vars.def_gen_yaw
    elseif mode == "Random" then
        out = math.random(ymin, ymax)
    elseif mode == "Bodyyaw" then
        out = vars.body_inverted and ui_get(aa.yaw_right) or ui_get(aa.yaw_left)
    elseif mode == "Sideways" then
        out = globals_tickcount() % 6 <= 2 and 90 or -90
    elseif mode == "Sideways 45" then
        out = globals_tickcount() % 6 <= 2 and 45 or -45
    elseif mode == "Progressive" then
        out = sine_yaw(globals_tickcount() * speed * 0.1, ymin, ymax)
    elseif mode == "Yaw Side" then
        out = vars.body_inverted and ui_get(aa.yaw_left) or ui_get(aa.yaw_right)
    elseif mode == "Spin Jitter" then
        local spin = sine_yaw(globals_tickcount() * speed * 0.1, ymin, ymax)
        out = (globals_tickcount() % 6 <= 2 and 90 or -90) + spin
    elseif mode == "Flick" then
        if globals_chokedcommands() == 0 and globals_tickcount() % delay_ticks == 0 then
            vars.def_yaw_jitter_twisted = not vars.def_yaw_jitter_twisted
        end
        local fv = globals_tickcount() % math.random(16, 20) > 1 and ymax or ymin
        out = vars.def_yaw_jitter_twisted and fv or -fv
    elseif mode == "Clock" then
        local step = ui_get(aa.def_clock_step)
        local dir = ui_get(aa.def_clock_dir) == "Clockwise" and 1 or -1
        local w = globals_realtime() * (speed * 80) * dir % 360
        if step >= 1 then w = math_floor(w / step + 0.5) * step end
        local jit = ui_get(aa.def_clock_jitter)
        if jit > 0 then w = w + math.random(-jit, jit) end
        out = normalize_yaw(ui_get(aa.def_yaw_val) + w)
    elseif mode == "Adaptive" then
        local cx = globals_tickcount() % math.random(14, 20) > 1 and -100 or 100
        if vars.manual_dir then cx = yaw_offset end
        out = normalize_yaw(cx)
    elseif mode == "Forward" then
        out = 180
    elseif mode == "Random Static" then
        if vars.def_gen_phase ~= exploit_data.breaking_lc then
            vars.def_rand_static_yaw = math.random(ymin, ymax)
        end
        out = vars.def_rand_static_yaw
    elseif mode == "LC End" then
        local mid = (range1 + range2) * 0.5
        out = source_ticks >= mid and ymax or ymin
    elseif mode == "Wave" then
        out = normalize_yaw(def_wave_value(ymin, ymax, ui_get(aa.def_wave_period), ui_get(aa.def_wave_type), ui_get(aa.def_wave_invert)))
    elseif mode == "Custom" then
        out = ui_get(aa.def_yaw_val)
    end

    return normalize_yaw(out + ui_get(aa.def_global_offset))
end

function cyn_resolve_manual_dir()
    if not has_multiselect(misc_features, "Manual AA") then
        pcall(ui_set, manual_left_key, false)
        pcall(ui_set, manual_right_key, false)
        pcall(ui_set, manual_forward_key, false)
        return nil
    end

    local left = ui_get(manual_left_key)
    local right = ui_get(manual_right_key)
    local forward = ui_get(manual_forward_key)
    if left then return "Left" end
    if right then return "Right" end
    if forward then return "Forward" end
    return nil
end

function cyn_detect_safe_head(lp)
    local threat = client_current_threat()
    if not threat then return false end

    local twpn = entity_get_player_weapon(threat)
    local twpn_data = twpn and csgo_weapons[entity_get_prop(twpn, "m_iItemDefinitionIndex")]
    local is_knife = twpn and entity_get_classname(twpn) == "CKnife" and has_multiselect(safe_head_conds, "Knife")
    local is_zeus = twpn_data and twpn_data.is_taser and has_multiselect(safe_head_conds, "Zeus")
    local height_adv = false
    if has_multiselect(safe_head_conds, "Height Advantage") then
        local lx, ly, lz = entity_get_prop(lp, "m_vecOrigin")
        local tx, ty, tz = entity_get_prop(threat, "m_vecOrigin")
        if lz and tz and (lz - tz) > 50 then height_adv = true end
    end
    return is_knife or is_zeus or height_adv
end

function cyn_detect_standard_state(cmd, lp)
    local flags = entity_get_prop(lp, "m_fFlags") or 0
    local on_ground = bit_band(flags, 1) ~= 0
    local prev_idx = vars.state_detect_idx or 2
    local prev_crouch = prev_idx == 4 or prev_idx == 5 or prev_idx == 8
    local prev_move = prev_idx == 3 or prev_idx == 5 or prev_idx == 6
    local duck_amt = entity_get_prop(lp, "m_flDuckAmount") or 0
    local crouching = duck_amt > (prev_crouch and 0.50 or 0.58)
    local vel_x, vel_y, vel_z = entity_get_prop(lp, "m_vecVelocity")
    local speed_2d = vel_x and math_sqrt(vel_x * vel_x + vel_y * vel_y) or 0
    local moving = speed_2d > (prev_move and 3 or 8)

    local target_idx = 2

    if not on_ground then
        target_idx = crouching and 8 or 7
    else
        if crouching then
            target_idx = moving and 5 or 4
        elseif moving then
            target_idx = ((cmd and cmd.in_speed or 0) == 1) and 6 or 3
        else
            target_idx = 2
        end
    end

    if target_idx ~= prev_idx then
        if vars.state_detect_candidate ~= target_idx then
            vars.state_detect_candidate = target_idx
            vars.state_detect_ticks = 1
        else
            vars.state_detect_ticks = (vars.state_detect_ticks or 0) + 1
        end

        local need_ticks = (target_idx == 7 or target_idx == 8 or prev_idx == 7 or prev_idx == 8) and 1 or 2
        if vars.state_detect_ticks >= need_ticks then
            prev_idx = target_idx
            vars.state_detect_ticks = 0
        end
    else
        vars.state_detect_candidate = target_idx
        vars.state_detect_ticks = 0
    end

    vars.state_detect_idx = prev_idx
    return conditions[prev_idx] or "Standing", prev_idx
end

function cyn_resolve_jitter(aa, rt)
    rt = rt or get_aa_runtime(vars.state_idx or 1)
    local jt = ui_get(aa.jitter_type)
    local jitter_val = 0
    local jitter_offset = 0
    local jitter_mode = "Off"

    if jt == "3-Way" or jt == "5-Way" then
        local ways = jt == "3-Way" and 3 or 5
        local way_idx = (globals_tickcount() % ways) + 1
        jitter_offset = ui_get(aa["jitter_way" .. way_idx])
    elseif jt == "Frequence" then
        local spd = ui_get(aa.jitter_freq_speed)
        local side = math_floor(globals_tickcount() / (spd > 0 and spd or 1)) % 2 == 0
        jitter_offset = side and ui_get(aa.jitter_val1) or ui_get(aa.jitter_val2)
    elseif jt == "Randomize" then
        if globals_chokedcommands() == 0 then
            rt.flu_idx = rt.flu_idx + 1
            local spd = ui_get(aa.jitter_freq_speed)
            if rt.flu_idx % (spd > 0 and spd or 1) == 0 then
                rt.flu_random_val = math.random(0, 1) == 0 and ui_get(aa.jitter_val1) or ui_get(aa.jitter_val2)
            end
        end
        jitter_offset = rt.flu_random_val
    elseif jt == "Skitter" then
        jitter_offset = globals_tickcount() % 2 == 0 and ui_get(aa.jitter_val1) or -ui_get(aa.jitter_val1)
    elseif jt ~= "Off" then
        local jm = ui_get(aa.jitter_mode)
        if jm == "Spin" then
            jitter_val = sine_yaw(globals_tickcount(), ui_get(aa.jitter_val2), ui_get(aa.jitter_val1))
        elseif jm == "Random" then
            if globals_chokedcommands() == 0 then
                rt.jitter_random_pick = math.random(0, 1) == 1 and ui_get(aa.jitter_val2) or ui_get(aa.jitter_val1)
            end
            jitter_val = rt.jitter_random_pick or ui_get(aa.jitter_val1)
        elseif jm == "Switch" then
            if globals_chokedcommands() == 0 then
                rt.jitter_switch_tick = rt.jitter_switch_tick + 1
                if rt.jitter_switch_tick >= 3 then
                    rt.jitter_switch_tick = 0
                    rt.jitter_switch_state = not rt.jitter_switch_state
                end
            end
            jitter_val = rt.jitter_switch_state and ui_get(aa.jitter_val2) or ui_get(aa.jitter_val1)
        else
            jitter_val = ui_get(aa.jitter_val1)
        end
        jitter_mode = jt
    end

    local rand_range = ui_get(aa.jitter_rand)
    local is_offset_mode = jt == "3-Way" or jt == "5-Way" or jt == "Frequence" or jt == "Randomize" or jt == "Skitter"
    if rand_range > 0 then
        if globals_chokedcommands() == 0 then
            rt.jitter_rand_noise = math.random(-rand_range, rand_range)
        end
        local rand_noise = clamp(rt.jitter_rand_noise or 0, -rand_range, rand_range)
        if is_offset_mode then
            jitter_offset = jitter_offset + rand_noise
        elseif jt ~= "Off" then
            jitter_val = jitter_val + rand_noise
        end
    end

    return normalize_yaw(jitter_offset), jitter_mode, normalize_yaw(jitter_val)
end

function cyn_update_body_delay_state(aa, rt)
    rt = rt or get_aa_runtime(vars.state_idx or 1)
    if globals_chokedcommands() ~= 0 then
        return
    end

    if ui_get(aa.body_delay_mode) == "Static" then
        local d = ui_get(aa.body_delay_ticks)
        rt.body_packets = rt.body_packets > d * 2 - 2 and 0 or rt.body_packets + 1
        return
    end

    local body_delay = rt.body_delay
    local sw_ticks = ui_get(aa.body_delay_switch)
    body_delay.switch_ticks = (sw_ticks == 0 and -1) or (body_delay.switch_ticks > sw_ticks - 2 and 0 or body_delay.switch_ticks + 1)
    if body_delay.switch_ticks == 0 then
        body_delay.switch = not body_delay.switch
    else
        body_delay.switch = sw_ticks ~= 0 and body_delay.switch or false
    end

    local ws = body_delay.work_side
    local other_side = ws == "left" and "right" or "left"
    local target_side = body_delay.switch and other_side or ws
    local target_lim = ui_get(aa["body_delay_" .. target_side]) - 2
    if body_delay[ws] > target_lim then
        body_delay.work_side = other_side
    end

    local active_side = body_delay.work_side
    local mirror_side = active_side == "left" and "right" or "left"
    local use_side = body_delay.switch and mirror_side or active_side
    local lim = ui_get(aa["body_delay_" .. use_side]) - 2
    body_delay[active_side] = body_delay[active_side] > lim and 0 or body_delay[active_side] + 1
end

local function cyn_side_sign(side)
    if side == true then
        return 1
    elseif side == false then
        return -1
    end
    return (tonumber(side) or 0) >= 0 and 1 or -1
end

local function cyn_body_value_for_side(aa, side)
    local sign = cyn_side_sign(side)
    local left = clamp(ui_get(aa.by_l) or 0, 0, 60)
    local right = clamp(ui_get(aa.by_r) or 0, 0, 60)
    return sign > 0 and right or -left
end

local function cyn_set_body_runtime(aa, side, value)
    local sign = cyn_side_sign(side)
    local out = value
    if out == nil then
        if aa ~= nil then
            out = cyn_body_value_for_side(aa, sign)
        else
            local mag = math_abs(vars.body_yaw_value or 0)
            if mag <= 0 then mag = 58 end
            out = sign > 0 and mag or -mag
        end
    end
    vars.body_inverted = sign > 0
    vars.body_yaw_side = sign
    vars.body_yaw_value = out
    return out
end

local function cyn_get_live_body_metrics()
    local side = vars.body_yaw_side or (vars.body_inverted and 1 or -1)
    local amount = 0
    local overlap = 0
    local lp = entity_get_local_player()
    if lp then
        local pose = entity_get_prop(lp, "m_flPoseParameter", 11)
        if pose ~= nil then
            local desync_delta = clamp(pose * 120 - 60, -60, 60)
            amount = math_abs(desync_delta)
            if desync_delta > 1 then
                side = 1
            elseif desync_delta < -1 then
                side = -1
            end
        end
    end
    local ok, raw_overlap = pcall(anti_aim_f.get_overlap)
    if ok then
        overlap = clamp(tonumber(raw_overlap) or 0, 0, 1)
    end
    vars.body_live_amount = amount
    vars.body_overlap = overlap
    return side, amount, overlap
end

local function cyn_apply_body_dynamic_scale(aa, rt, side, value)
    rt = rt or get_aa_runtime(vars.state_idx or 1)
    local sign = cyn_side_sign(side)
    local out = clamp(value or cyn_body_value_for_side(aa, sign), -60, 60)

    if aa == nil or ui_get(aa.body_yaw) == "Off" then
        rt.body_dynamic_value = math_abs(out)
        vars.body_dynamic_value = out
        return out
    end

    local _, live_amount, overlap = cyn_get_live_body_metrics()
    local lp = entity_get_local_player()
    local speed_2d = 0
    if lp then
        local vx, vy = entity_get_prop(lp, "m_vecVelocity")
        speed_2d = (vx and vy) and math_sqrt(vx * vx + vy * vy) or 0
    end

    local base_mag = clamp(math_abs(out), 0, 60)
    local speed_bias = clamp(speed_2d / 250, 0, 1)
    local state_bias = 0
    if vars.state == "Air" or vars.state == "Air Duck" then
        state_bias = 4
    elseif vars.state == "Moving" or vars.state == "Slowwalk" then
        state_bias = 2
    elseif vars.state == "Crouch" or vars.state == "Crouch Move" then
        state_bias = 1
    end

    local overlap_boost = overlap * 10
    local live_boost = live_amount * 0.22
    local speed_boost = speed_bias * 8
    local threat = client_current_threat()
    local threat_boost = (threat and entity_is_enemy(threat) and entity_is_alive(threat)) and 2 or 0
    local target = clamp(base_mag * (0.72 + overlap * 0.18) + overlap_boost + live_boost + speed_boost + state_bias + threat_boost, 0, 60)

    local current = rt.body_dynamic_value or base_mag
    if current <= 0 then
        current = base_mag
    end
    local smooth = clamp(globals_frametime() * (globals_chokedcommands() == 0 and 10 or 16), 0.18, 0.62)
    local final_mag = clamp(lerp(current, target, smooth), 0, 60)
    rt.body_dynamic_value = final_mag
    out = sign > 0 and final_mag or -final_mag
    vars.body_dynamic_value = out
    return out
end

local function cyn_set_def_body_runtime(aa, side)
    local sign = cyn_side_sign(side)
    if aa ~= nil and ui_get(aa.body_yaw) ~= "Off" then
        local current_mag = math_abs(vars.body_yaw_value or 0)
        if current_mag > 0 then
            return cyn_set_body_runtime(aa, sign, sign > 0 and current_mag or -current_mag)
        end
        return cyn_set_body_runtime(aa, sign)
    end
    return cyn_set_body_runtime(nil, sign, sign)
end

local function cyn_fake_limit_for_side(aa, side)
    local sign = cyn_side_sign(side)
    local ref = sign > 0 and aa.fake_limit_right or aa.fake_limit_left
    return clamp(ui_get(ref) or 0, 0, 60)
end

local function cyn_apply_body_fake_limit(aa, side, value)
    local sign = cyn_side_sign(side)
    local out = clamp(value or cyn_body_value_for_side(aa, sign), -60, 60)
    vars.body_fake_value = 0

    if aa == nil or ui_get(aa.body_yaw) == "Off" or ui_get(aa.desync_mode) == "NoChoke" then
        return out
    end

    local fake_mag = cyn_fake_limit_for_side(aa, sign)
    if fake_mag <= 0 or globals_chokedcommands() == 0 then
        return out
    end

    local lp = entity_get_local_player()
    local speed_2d = 0
    if lp then
        local vx, vy = entity_get_prop(lp, "m_vecVelocity")
        speed_2d = (vx and vy) and math_sqrt(vx * vx + vy * vy) or 0
    end

    local speed_bias = clamp(speed_2d / 220, 0, 1)
    local threat = client_current_threat()
    local threat_bias = (threat and entity_is_enemy(threat) and entity_is_alive(threat)) and 0.18 or 0
    local jitter_bias = ui_get(aa.body_yaw) == "Jitter" and 0.12 or 0
    local blend = clamp(0.34 + speed_bias * 0.26 + threat_bias + jitter_bias, 0.34, 0.82)
    local mag = clamp(math_floor(lerp(math_abs(out), fake_mag, blend) + 0.5), 0, 60)

    out = sign > 0 and mag or -mag
    vars.body_fake_value = out
    return out
end

local function cyn_finalize_body_value(aa, rt, side, value)
    local out = cyn_set_body_runtime(aa, side, value)
    out = cyn_apply_body_dynamic_scale(aa, rt, side, out)
    out = cyn_apply_body_fake_limit(aa, side, out)
    return cyn_set_body_runtime(aa, side, out)
end

function cyn_resolve_body_yaw(aa, rt)
    rt = rt or get_aa_runtime(vars.state_idx or 1)
    cyn_update_body_delay_state(aa, rt)
    local bym = ui_get(aa.body_yaw)

    if bym == "Off" then
        local idle_side = ui_get(aa.body_side) == 1 and 1 or -1
        vars.body_dynamic_value = 0
        vars.body_fake_value = 0
        vars.body_live_amount = 0
        vars.body_overlap = 0
        rt.body_dynamic_value = 0
        cyn_set_body_runtime(aa, idle_side, 0)
        return "Off", 0, idle_side
    end

    local side = vars.body_yaw_side or (vars.body_inverted and 1 or -1)
    if bym == "Static" or bym == "Opposite" then
        side = ui_get(aa.body_side) == 1 and 1 or -1
    elseif bym == "Jitter" then
        if ui_get(aa.body_delay_mode) == "Switch" then
            side = rt.body_delay.work_side == "right" and 1 or -1
        else
            local d = math_max(1, ui_get(aa.body_delay_ticks) or 1)
            side = rt.body_packets % (d * 2) >= d and 1 or -1
        end
    end

    local body_value = cyn_finalize_body_value(aa, rt, side)
    return bym == "Jitter" and "Static" or bym, body_value, side
end

function cyn_guard_call(tag, fallback1, fallback2, fallback3, fn, ...)
    local ok, a, b, c = pcall(fn, ...)
    if ok then
        return a, b, c
    end

    local now = globals_realtime()
    local last = vars.err_clock[tag] or 0
    if now - last > 1.5 then
        vars.err_clock[tag] = now
        client.color_log(255, 80, 80, "[Cynicism] " .. tag .. " err: " .. tostring(a))
    end
    return fallback1, fallback2, fallback3
end

-- ===================== STATE DETECTION =====================
local function detect_state(cmd)
    local lp = entity_get_local_player()
    if not lp or not entity_is_alive(lp) then return end
    exploit_on_setup(cmd)
    vars.legitaa_on = false

    vars.manual_dir = cyn_resolve_manual_dir()

    if vars.manual_dir then
        vars.state = "Manual"; vars.state_idx = 10
        vars.aa_dir = vars.manual_dir == "Left" and -90 or (vars.manual_dir == "Right" and 90 or 180)
        return
    end
    vars.aa_dir = 0

    local enemies = entity.get_players(true)
    local no_enemy = #enemies == 0
    local no_enemy_override = no_enemy and builder[12] and ui_get(builder[12].enabled)

    -- Legit AA
    vars.legitaa_on = has_multiselect(misc_features, "Legit AA") and ui_get(legit_aa_key)
    if vars.legitaa_on then vars.state = "Legit AA"; vars.state_idx = 9; return end

    if cyn_detect_safe_head(lp) then
        vars.state = "Safe Head"; vars.state_idx = 11; return
    end
    if no_enemy_override then
        vars.state = "No Enemy"; vars.state_idx = 12; return
    end

    local st_name, st_idx = cyn_guard_call("state", "Standing", 2, nil, cyn_detect_standard_state, cmd, lp)
    if st_name and st_idx then
        vars.state = st_name
        vars.state_idx = st_idx
        return
    end

    vars.state = "Standing"
    vars.state_idx = 2
end

function cyn_abf_should_trigger(reason_text)
    if not vars.abf_enable or not ui_get(vars.abf_enable) then
        return false
    end
    local mode = ui_get(vars.abf_trigger) or "Resolver miss"
    if mode == "Any miss" then
        return true
    end
    local rs = string.lower(tostring(reason_text or ""))
    if rs == "" then
        return false
    end
    if string.find(rs, "resolver", 1, true) then
        return true
    end
    if string.find(rs, "prediction error", 1, true) then
        return true
    end
    return false
end

function cyn_trigger_abf(reason_text)
    if not cyn_abf_should_trigger(reason_text) then
        return
    end
    vars.abf_side = -(vars.abf_side or 1)
    vars.abf_ticks_left = math_max(1, ui_get(vars.abf_ticks) or 10)
    vars.abf_last_reason = tostring(reason_text or "unknown")
    vars.abf_state = "trigger"
end

function cyn_apply_abf_overlay()
    if not vars.abf_enable or not ui_get(vars.abf_enable) then
        vars.abf_ticks_left = 0
        vars.abf_state = "idle"
        return
    end
    local ticks_left = vars.abf_ticks_left or 0
    if ticks_left <= 0 then
        vars.abf_state = "idle"
        return
    end
    local add = clamp(ui_get(vars.abf_yaw_add) or 0, 0, 180)
    local side = (vars.abf_side or 1) >= 0 and 1 or -1
    local cur_yaw = ui_get(refs.yaw[2]) or 0
    ui_set(refs.yaw[2], normalize_yaw(cur_yaw + add * side))
    if ui_get(vars.abf_force_invert) then
        local aa = builder[clamp(vars.state_idx or 1, 1, #builder)]
        ui_set(refs.body_yaw[1], "Static")
        ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, side))
    end
    vars.abf_state = "pulse[" .. tostring(ticks_left) .. "]"
    if globals_chokedcommands() == 0 then
        vars.abf_ticks_left = math_max(0, ticks_left - 1)
    end
end

function cyn_apply_fakelag_runtime(cmd, aa, def_active, def_source_ticks, no_choke_active, pred_active)
    local function restore_def_pred_fakelag()
        if vars.def_pred_owned then
            if vars.def_pred_restore ~= nil then
                ui_set(refs.fakelag_enabled[1], vars.def_pred_restore)
            end
            vars.def_pred_owned = false
            vars.def_pred_restore = nil
        end
    end

    if no_choke_active then
        restore_def_pred_fakelag()
        if ui_get(refs.fakelag_enabled[1]) then
            ui_set(refs.fakelag_enabled[1], false)
        end
        vars.flctl_mode = "NoChoke"
        vars.flctl_limit = 0
        vars.flctl_state = "off"
        return
    end

    if pred_active then
        if not vars.def_pred_owned then
            vars.def_pred_owned = true
            vars.def_pred_restore = ui_get(refs.fakelag_enabled[1]) and true or false
        end
        if ui_get(refs.fakelag_enabled[1]) then
            ui_set(refs.fakelag_enabled[1], false)
        end
        vars.flctl_mode = "DefPred-" .. (vars.def_pred_mode or "Maximum")
        vars.flctl_limit = 0
        vars.flctl_state = "off"
        return
    end

    restore_def_pred_fakelag()

    local ctrl_on = vars.flctl_enable and ui_get(vars.flctl_enable)
    local mode = ctrl_on and ui_get(vars.flctl_mode_ref) or "Off"
    if not ctrl_on or mode == "Off" then
        vars.flctl_mode = "Off"
        vars.flctl_limit = ui_get(refs.fakelag_enabled[1]) and (ui_get(refs.fakelag_limit) or 0) or 0
        vars.flctl_state = ui_get(refs.fakelag_enabled[1]) and "on" or "off"
        return
    end
    local fl_enabled = ui_get(refs.fakelag_enabled[1]) and true or false
    local fl_limit = clamp((ui_get(refs.fakelag_limit) or 1), 1, 62)
    local state_mode = mode

    local raw_min = ui_get(vars.flctl_min) or 1
    local raw_max = ui_get(vars.flctl_max) or 14
    local min_tick = clamp(math_min(raw_min, raw_max), 1, 62)
    local max_tick = clamp(math_max(raw_min, raw_max), min_tick, 62)
    local step = math_max(1, ui_get(vars.flctl_step) or 1)
    local packet_owned_by_def = def_active and vars.def_send_packet_state ~= nil
    local disable_on_exploit = ui_get(vars.flctl_disable_exploit)
    local block_exploit = disable_on_exploit and (exploit_data.shift or exploit_data.breaking_lc or def_active)

    if block_exploit then
        fl_enabled = false
        fl_limit = 0
        state_mode = mode .. "+ExploitStop"
    else
        if mode == "Neverlose" then
            fl_limit = max_tick
        elseif mode == "Fluctuate" then
            fl_limit = globals_tickcount() % 2 == 0 and max_tick or min_tick
        elseif mode == "Cycle" then
            if globals_chokedcommands() == 0 then
                vars.flctl_cycle = vars.flctl_cycle + step
            end
            if vars.flctl_cycle < min_tick or vars.flctl_cycle > max_tick then
                vars.flctl_cycle = min_tick
            end
            fl_limit = vars.flctl_cycle
        elseif mode == "Random" then
            if globals_chokedcommands() == 0 then
                vars.flctl_cycle = math.random(min_tick, max_tick)
            end
            if vars.flctl_cycle < min_tick or vars.flctl_cycle > max_tick then
                vars.flctl_cycle = min_tick
            end
            fl_limit = vars.flctl_cycle
        elseif mode == "Dynamic" then
            if globals_chokedcommands() == 0 then
                vars.flctl_cycle = vars.flctl_cycle + step
                if vars.flctl_cycle > max_tick then
                    vars.flctl_cycle = min_tick
                end
            end
            if vars.flctl_cycle < min_tick or vars.flctl_cycle > max_tick then
                vars.flctl_cycle = min_tick
            end
            local pressure = vars.def_driver_pressure or 0
            local pressure_target = clamp(min_tick + pressure * step + (def_source_ticks > 0 and step or 0), min_tick, max_tick)
            fl_limit = clamp(math_floor((pressure_target + vars.flctl_cycle) * 0.5 + 0.5), min_tick, max_tick)
        else
            fl_limit = max_tick
        end
        fl_enabled = fl_limit > 0
    end

    if ui_get(vars.flctl_nade_opt) then
        local lp = entity_get_local_player()
        local wpn = lp and entity_get_player_weapon(lp) or nil
        local wpn_data = wpn and csgo_weapons[entity_get_prop(wpn, "m_iItemDefinitionIndex")]
        if wpn_data and wpn_data.type == "grenade" then
            fl_limit = math_min(fl_limit, 2)
            fl_enabled = fl_limit > 0
            state_mode = state_mode .. "+Nade"
        end
    end

    local on_shot = ui_get(vars.flctl_onshot) or "Off"
    if on_shot ~= "Off" then
        local shot_window = math_max(1, ui_get(vars.flctl_shot_window) or 5)
        local shot_delta = globals_tickcount() - (vars.flctl_last_shot_time or 0)
        if (vars.flctl_last_shot_time or 0) > 0 and shot_delta >= 0 and shot_delta <= shot_window then
            if on_shot == "Reset FL" then
                fl_enabled = true
                fl_limit = 1
                state_mode = state_mode .. "+ShotReset"
            elseif on_shot == "Send Packet" then
                if not packet_owned_by_def then
                    cmd.send_packet = true
                    state_mode = state_mode .. "+ShotSend"
                else
                    state_mode = state_mode .. "+ShotHold"
                end
            elseif on_shot == "Choke" then
                if not packet_owned_by_def then
                    cmd.send_packet = false
                    state_mode = state_mode .. "+ShotChoke"
                else
                    state_mode = state_mode .. "+ShotHold"
                end
            end
        end
    end

    if ui_get(vars.flctl_force) and fl_enabled and fl_limit > 1 and not packet_owned_by_def then
        if globals_chokedcommands() < (fl_limit - 1) then
            cmd.send_packet = false
        else
            cmd.send_packet = true
        end
        state_mode = state_mode .. "+Force"
    elseif ui_get(vars.flctl_force) and fl_enabled and fl_limit > 1 and packet_owned_by_def then
        state_mode = state_mode .. "+DefLock"
    end

    if fl_enabled and fl_limit > 0 then
        ui_set(refs.fakelag_enabled[1], true)
        pcall(ui_set, refs.fakelag_limit, clamp(fl_limit, 1, 62))
    else
        ui_set(refs.fakelag_enabled[1], false)
    end
    pcall(ui_set, refs.fakelag_amount, "Maximum")
    pcall(ui_set, refs.fakelag_variance, 0)
    vars.flctl_mode = state_mode ~= "" and state_mode or "Off"
    vars.flctl_limit = fl_enabled and clamp(fl_limit, 1, 62) or 0
    vars.flctl_state = fl_enabled and "on" or "off"
end

-- ===================== APPLY ANTI-AIM (SUPER FUSED) =====================
local function apply_antiaim(cmd)
    local function restore_def_nchoke_fakelag(full_restore)
        if full_restore and vars.def_pred_owned then
            if vars.def_pred_restore ~= nil then
                ui_set(refs.fakelag_enabled[1], vars.def_pred_restore)
            end
            vars.def_pred_owned = false
            vars.def_pred_restore = nil
        end
        if full_restore then
            vars.def_pred_active = false
            vars.def_pred_mode = "Off"
            vars.def_pred_phase = "idle"
            vars.def_pred_target = 0
            vars.def_pred_extend = 0
        end
        if vars.def_nchoke_owned then
            if vars.def_nchoke_restore ~= nil then
                ui_set(refs.fakelag_enabled[1], vars.def_nchoke_restore)
            end
            vars.def_nchoke_owned = false
            vars.def_nchoke_restore = nil
        end
    end

    local lp = entity_get_local_player()
    if not lp or not entity_is_alive(lp) then
        restore_def_nchoke_fakelag(true)
        return
    end
    if not ui_get(refs.enabled) then
        restore_def_nchoke_fakelag(true)
        return
    end

    -- Pick active builder (fallback to Global)
    local idx = vars.state_idx
    local aa = (idx ~= 1 and builder[idx] and ui_get(builder[idx].enabled)) and builder[idx] or builder[1]
    local aa_runtime = get_aa_runtime(idx)

    -- ========== LEGIT AA ==========
    if vars.legitaa_on then
        ui_set(refs.pitch[1], "Off")
        ui_set(refs.yaw[1], "180"); ui_set(refs.yaw[2], 0)
        ui_set(refs.yaw_jitter[1], "Off")
        ui_set(refs.body_yaw[1], "Static"); ui_set(refs.body_yaw[2], 0)
        ui_set(refs.roll, 0)
        restore_def_nchoke_fakelag(true)
        return
    end

    -- ========== FREESTANDING ==========
    local fs_active = has_multiselect(misc_features, "Freestanding") and ui_get(freestanding_key)
    local fs_disabled = false
    if fs_active then
        local fsn = ui_get(fs_disablers)
        if type(fsn) == "table" then
            for _, v in ipairs(fsn) do
                if v == "Slowwalk" and (cmd.in_speed or 0) == 1 then fs_disabled = true end
                if v == "In Air" and bit_band(entity_get_prop(lp, "m_fFlags") or 0, 1) == 0 then fs_disabled = true end
                if v == "Crouching" and (entity_get_prop(lp, "m_flDuckAmount") or 0) > 0.5 then fs_disabled = true end
                if v == "Moving" then
                    local vx, vy = entity_get_prop(lp, "m_vecVelocity")
                    if vx and math_sqrt(vx*vx + vy*vy) > 50 then fs_disabled = true end
                end
            end
        end
    end

    if fs_active and not fs_disabled and not vars.manual_dir then
        ui_set(refs.freestanding[1], true)
        if has_multiselect(fs_disablers, "Body Yaw") then ui_set(refs.body_yaw[1], "Off") end
        if has_multiselect(fs_disablers, "Yaw Jitter") then ui_set(refs.yaw_jitter[1], "Off") end
    else
        ui_set(refs.freestanding[1], false)
    end

    -- ========== HIDE SHOT FIX ==========
    if has_multiselect(misc_features, "Hide Shot Fix") then
        if ui_get(refs.on_shot_aa[1]) then ui_set(refs.on_shot_aa[2], 180) end
    end

    -- ========== PITCH ==========
    local pitch_mode = ui_get(aa.pitch)
    if pitch_mode == "Custom" then
        ui_set(refs.pitch[1], "Custom"); ui_set(refs.pitch[2], ui_get(aa.custom_pitch))
    elseif pitch_mode == "Random" then
        ui_set(refs.pitch[1], "Custom"); ui_set(refs.pitch[2], math.random(-89, 89))
    elseif pitch_mode == "Off" then
        ui_set(refs.pitch[1], "Off")
    else
        ui_set(refs.pitch[1], pitch_mode)
    end

    -- ========== YAW ==========
    ui_set(refs.yaw_base, ui_get(aa.yaw_base))

    -- Body yaw inversion for L/R yaw
    local inverted = vars.body_inverted
    local yaw_offset = ui_get(aa.global_yaw) + (inverted and ui_get(aa.yaw_right) or ui_get(aa.yaw_left))

    -- Manual override
    if vars.manual_dir then
        local manual_map = { Forward = 180, Left = -90, Right = 90 }
        yaw_offset = manual_map[vars.manual_dir] or 0
    end

    local ym = ui_get(aa.yaw_mode)
    if ym == "Spin" then
        yaw_offset = yaw_offset + normalize_yaw(globals_tickcount() * ui_get(aa.spin_speed))
    elseif ym == "Rotation" then
        local steps = ui_get(aa.rotation_steps)
        local step_angle = 360 / steps
        local cur_step = globals_tickcount() % (steps * 8)
        yaw_offset = yaw_offset + normalize_yaw(math_floor(cur_step / 8) * step_angle)
    end

    -- ========== JITTER ==========
    local jitter_offset, jitter_mode, jitter_val = cyn_guard_call("jitter", 0, "Off", 0, cyn_resolve_jitter, aa, aa_runtime)
    if jitter_mode ~= "Off" then
        ui_set(refs.yaw_jitter[1], jitter_mode)
        ui_set(refs.yaw_jitter[2], jitter_val)
    else
        ui_set(refs.yaw_jitter[1], "Off")
    end
    yaw_offset = yaw_offset + jitter_offset

    ui_set(refs.yaw[1], "180")
    ui_set(refs.yaw[2], normalize_yaw(yaw_offset))

    -- ========== BODY YAW (abyss-style delay system) ==========
    local by_mode, by_value = cyn_guard_call("bodyyaw", "Off", vars.body_yaw_value or 0, vars.body_yaw_side or -1, cyn_resolve_body_yaw, aa, aa_runtime)
    ui_set(refs.body_yaw[1], by_mode)
    ui_set(refs.body_yaw[2], by_value)
    ui_set(refs.freestanding_body_yaw, ui_get(aa.fs_body_yaw))

    -- ========== ROLL ==========
    local roll_val = ui_get(aa.roll_amount)
    ui_set(refs.roll, (roll_val ~= 0 and not vars.legitaa_on) and roll_val or 0)

    local threat = client_current_threat()
    if threat and entity_is_enemy(threat) and entity_is_alive(threat) and not vars.manual_dir and not vars.legitaa_on then
        local lx, ly, lz = entity_get_prop(lp, "m_vecOrigin")
        local tx, ty, tz = entity_get_prop(threat, "m_vecOrigin")
        if lx and tx then
            local dist = math_sqrt((lx - tx) * (lx - tx) + (ly - ty) * (ly - ty))
            local visible = is_visible(threat)
            if visible then
                local threat_bias = clamp(math_floor((440 - dist) * 0.045 + 0.5), 0, 18)
                if vars.state == "Air" or vars.state == "Air Duck" then
                    threat_bias = threat_bias + 6
                elseif vars.state == "Moving" or vars.state == "Slowwalk" then
                    threat_bias = threat_bias + 3
                end
                if exploit_data.breaking_lc then
                    threat_bias = threat_bias + 4
                end
                if threat_bias > 0 then
                    local threat_side = globals_tickcount() % 6 < 3 and 1 or -1
                    ui_set(refs.yaw[2], normalize_yaw((ui_get(refs.yaw[2]) or 0) + threat_bias * threat_side))
                    if ui_get(aa.body_yaw) ~= "Off" and ui_get(aa.desync_mode) == "Independ" and dist < 320 then
                        ui_set(refs.body_yaw[1], "Static")
                        ui_set(refs.body_yaw[2], cyn_finalize_body_value(aa, aa_runtime, threat_side))
                    end
                end
            end
        end
    end

    if not ui_get(aa.def_enable) and not vars.manual_dir and not vars.legitaa_on then
        local vx, vy = entity_get_prop(lp, "m_vecVelocity")
        local speed_2d = (vx and vy) and math_sqrt(vx * vx + vy * vy) or 0
        local amp = clamp((ui_get(aa.jitter_rand) or 0) * 0.2 + speed_2d * 0.02, 0, 12)
        if amp > 0 then
            vars.nondef_drift_phase = vars.nondef_drift_phase + globals_frametime() * (2.2 + clamp(speed_2d * 0.01, 0, 2.8))
            local drift = math_sin(vars.nondef_drift_phase) * amp
            vars.nondef_drift = drift
            ui_set(refs.yaw[2], normalize_yaw((ui_get(refs.yaw[2]) or yaw_offset) + drift))
        else
            vars.nondef_drift = 0
        end
    else
        vars.nondef_drift = 0
    end

    -- ========== EDGE YAW ==========
    if has_multiselect(misc_features, "Edge Yaw") then
        ui_set(refs.edge_yaw, ui_get(edge_yaw_key) and not vars.manual_dir)
    end

    -- ========== HEIGHT SAFE ==========
    if threat then
        local lx, ly, lz = entity_get_prop(lp, "m_vecOrigin")
        local tx, ty, tz = entity_get_prop(threat, "m_vecOrigin")
        if lz and tz and (lz - tz) > ui_get(aa.height_safe) then
            ui_set(refs.pitch[1], "Down")
            ui_set(refs.yaw[2], 0); ui_set(refs.yaw_jitter[1], "Off")
            ui_set(refs.body_yaw[1], "Static"); ui_set(refs.body_yaw[2], 0)
        end
    end

    -- ========== AVOID BACKSTAB (abyss-style) ==========
    if has_multiselect(misc_features, "Avoid Backstab") then
        local origin_x, origin_y, origin_z = entity_get_prop(lp, "m_vecOrigin")
        if origin_x then
            for _, v in ipairs(entity.get_players(true)) do
                local tw = entity_get_player_weapon(v)
                if tw and entity_get_classname(tw) == "CKnife" then
                    local ex, ey, ez = entity_get_prop(v, "m_vecOrigin")
                    if ex and math_sqrt((origin_x-ex)^2 + (origin_y-ey)^2 + (origin_z-ez)^2) <= 200 then
                        ui_set(refs.pitch[1], "Off")
                        ui_set(refs.yaw[1], "180"); ui_set(refs.yaw[2], 180)
                        ui_set(refs.body_yaw[1], "Opposite")
                    end
                end
            end
        end
    end

    -- ========== PER-CONDITION BACKSTAB ==========
    local bs = ui_get(aa.backstab)
    if bs ~= "Off" and check_anti_backstab() then
        if bs == "Forward" then
            ui_set(refs.yaw_base, "Local view")
            ui_set(refs.yaw[1], "180"); ui_set(refs.yaw[2], 0)
            ui_set(refs.yaw_jitter[1], "Off")
            ui_set(refs.body_yaw[1], "Static"); ui_set(refs.body_yaw[2], 0)
        elseif bs == "Random" then
            ui_set(refs.yaw[2], math.random(-180, 180))
            ui_set(refs.yaw_jitter[1], "Center"); ui_set(refs.yaw_jitter[2], 60)
        end
    end

    -- ========== DEFENSIVE AA (Paradise + Cathode rewritten core) ==========
    local def_ticks = exploit_data.defensive.left

    -- Knife disabler (Paradise-style)
    vars.def_knife_near = false
    if has_multiselect(aa.def_addons, "Disable while Knife") then
        local lox, loy, loz = entity_get_prop(lp, "m_vecOrigin")
        if lox then
            for _, ev in ipairs(entity.get_players(true)) do
                local tw = entity_get_player_weapon(ev)
                if tw and entity_get_classname(tw) == "CKnife" then
                    local ex, ey, ez = entity_get_prop(ev, "m_vecOrigin")
                    if ex and math_sqrt((lox - ex)^2 + (loy - ey)^2 + (loz - ez)^2) < 300 then
                        vars.def_knife_near = true
                        break
                    end
                end
            end
        end
    end

    local def_driver_tick = def_resolve_tick_driver(aa, def_ticks)
    local def_active, def_state_name, def_range1, def_range2, def_source_ticks, def_triggered = def_compute_active(aa, def_ticks, def_driver_tick, cmd)
    vars.def_state = string.format(
        "%s|mode:%s|pf:%s/%s|src:%s:%dt|drv:%dt|trg:%s|guard:%s|p:%d|tk:%d/%d|nd:%d|bd:%d|bf:%d|ov:%d%s",
        def_state_name,
        vars.def_mode_resolved or "?",
        vars.def_profile_name or "Legacy",
        vars.def_runtime_name or "Balanced",
        vars.def_check_source,
        def_source_ticks,
        def_driver_tick,
        def_triggered and "on" or "off",
        vars.def_guard_pass and "ok" or "block",
        vars.def_driver_pressure or 0,
        vars.def_tick_streak or 0,
        vars.def_tick_peak or 0,
        math_floor(math_abs(vars.nondef_drift or 0) + 0.5),
        math_floor(math_abs(vars.body_dynamic_value or 0) + 0.5),
        math_floor(math_abs(vars.body_fake_value or 0) + 0.5),
        math_floor(clamp((vars.body_overlap or 0) * 100 + 0.5, 0, 100)),
        vars.def_knife_near and "|knife" or ""
    )
    if vars.def_pred_active then
        vars.def_state = vars.def_state .. string.format("|pred:%s:%s:%dt", vars.def_pred_mode or "Maximum", vars.def_pred_phase or "idle", vars.def_pred_target or 0)
    end

    local dsync = ui_get(aa.desync_mode)
    local no_choke_active = def_active and dsync == "NoChoke"
    if no_choke_active then
        if not vars.def_nchoke_owned then
            vars.def_nchoke_owned = true
            vars.def_nchoke_restore = ui_get(refs.fakelag_enabled[1]) and true or false
        end
        if ui_get(refs.fakelag_enabled[1]) then
            ui_set(refs.fakelag_enabled[1], false)
        end
    else
        restore_def_nchoke_fakelag()
    end

    cyn_apply_fakelag_runtime(cmd, aa, def_active, def_source_ticks, no_choke_active, vars.def_pred_active)

    if def_active then
        exploit_data.def_aa = true
        cmd.force_defensive = 1
        if vars.def_send_packet_state ~= nil then
            cmd.send_packet = vars.def_send_packet_state
        end

        -- Defensive disablers
        if has_multiselect(aa.def_disablers, "Body Yaw") then ui_set(refs.body_yaw[1], "Off") end
        if has_multiselect(aa.def_disablers, "Yaw Jitter") then ui_set(refs.yaw_jitter[1], "Off") end

        -- Desync mode fusion
        if dsync == "Force Static" then
            ui_set(refs.body_yaw[1], "Static")
            ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, ui_get(aa.desync_inver)))
        elseif dsync == "Def Adaptive" then
            local flip_side = exploit_data.breaking_lc and (not vars.body_inverted) or vars.body_inverted
            ui_set(refs.body_yaw[1], "Static")
            ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, flip_side))
        elseif dsync == "NoChoke" then
            -- handled by no-choke ownership block above
        end

        -- Paradise body-yaw sequencer
        if ui_get(aa.body_yaw) == "Jitter" and dsync == "Independ" then
            local byjtype = ui_get(aa.by_jitter_type)
            local by_ways = ui_get(aa.by_jitter_que)
            if by_ways > 1 and globals_chokedcommands() == 0 then
                vars.by_multiway.ticks = vars.by_multiway.ticks + 1
                if vars.by_multiway.way_idx < 1 or vars.by_multiway.way_idx > by_ways then
                    vars.by_multiway.way_idx = 1
                end
                local way_key = "by_way" .. vars.by_multiway.way_idx
                local way_dur = (aa[way_key] and ui_get(aa[way_key])) or 1
                if way_dur < 1 then way_dur = 1 end
                if vars.by_multiway.ticks >= way_dur then
                    vars.by_multiway.ticks = 0
                    if byjtype == "Frequence" then
                        vars.by_multiway.way_idx = (vars.by_multiway.way_idx % by_ways) + 1
                    else
                        vars.by_multiway.way_idx = math.random(1, by_ways)
                    end
                end
                local side = vars.by_multiway.way_idx % 2 == 0 and 1 or -1
                ui_set(refs.body_yaw[1], "Static")
                ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, side))
            end
        end

        -- Bodyyaw override addon
        if has_multiselect(aa.def_addons, "Override Bodyyaw") then
            local by = ui_get(aa.def_ensinv)
            if by == "Left" then
                ui_set(refs.body_yaw[1], "Static"); ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, -1))
            elseif by == "Right" then
                ui_set(refs.body_yaw[1], "Static"); ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, 1))
            elseif by == "Jitter" then
                ui_set(refs.body_yaw[1], "Static")
                ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, globals_tickcount() % 4 < 2 and 1 or -1))
            elseif by == "Overlap" then
                ui_set(refs.body_yaw[1], "Static")
                ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, vars.body_inverted))
            elseif by == "De-Overlap" then
                ui_set(refs.body_yaw[1], "Static")
                ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, not vars.body_inverted))
            end
        end

        if vars.def_release_body then
            local side = vars.def_release_follow and def_triggered or (not def_triggered)
            ui_set(refs.body_yaw[1], "Static")
            ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, side))
        end

        local lc_end_sideflick = has_multiselect(aa.def_addons, "Sideflick on LC End") and def_source_ticks <= math_max(1, def_range1)

        -- Defensive pitch
        local pitch_out = def_calc_pitch(aa, def_source_ticks, def_range1, def_range2)
        if pitch_out ~= nil then
            ui_set(refs.pitch[1], "Custom")
            ui_set(refs.pitch[2], clamp(pitch_out, -89, 89))
        end

        -- Defensive yaw + fake flick
        local yaw_out = def_calc_yaw(aa, def_source_ticks, yaw_offset, def_range1, def_range2)
        if yaw_out ~= nil then
            ui_set(refs.yaw[1], "180")
            if lc_end_sideflick then
                yaw_out = normalize_yaw(yaw_out + 180)
            end
            local flick_side, flick_enabled = def_update_fake_flick(aa, true, def_triggered, def_source_ticks, def_range1, def_range2)
            if flick_enabled then
                local cur_body_side = ui_get(refs.body_yaw[2]) or 1
                cur_body_side = cur_body_side >= 0 and 1 or -1
                local flick_sign = flick_side >= 0 and 1 or -1
                local out_body = cur_body_side * flick_sign
                ui_set(refs.body_yaw[1], "Static")
                ui_set(refs.body_yaw[2], cyn_set_def_body_runtime(aa, out_body))
            end
            ui_set(refs.yaw[2], yaw_out)
        else
            def_update_fake_flick(aa, false, false, 0, 0, 0)
        end

        vars.def_gen_phase = exploit_data.breaking_lc
    else
        exploit_data.def_aa = false
        vars.def_pitch_way_ticks = 0
        vars.def_yaw_way_ticks = 0
        vars.by_multiway.ticks = 0
        vars.def_flick_tick = 0
        vars.def_always_ticks = 0
        vars.def_flick_period_target = 0
        vars.def_flick_window_target = 0
        vars.def_trigger_counter = 0
        vars.def_duration_tick = 0
        vars.def_duration_target = 0
        vars.def_duration_active = false
        vars.def_trigger_state = false
        vars.def_trigger_tick = 0
        vars.def_trigger_prev_raw = false
        vars.def_trigger_cooldown = 0
        vars.def_fake_flick_cooldown = 0
        vars.def_driver_pressure = 0
        vars.def_send_packet_state = nil
        vars.def_release_body = false
        vars.def_release_follow = true
        vars.def_pred_active = false
        vars.def_pred_mode = "Off"
        vars.def_pred_phase = "idle"
        vars.def_pred_target = 0
        vars.def_pred_extend = 0
        def_update_fake_flick(aa, false, false, 0, 0, 0)
    end

    cyn_apply_abf_overlay()
    vars.def_state = vars.def_state .. string.format("|fl:%s:%dt|abf:%s", vars.flctl_mode or "Off", vars.flctl_limit or 0, vars.abf_state or "idle")

    -- ========== FORCE DEFENSIVE ==========
    if ui_get(aa.def_force) or ui_get(force_def_key) then cmd.force_defensive = 1 end
    local fw = entity_get_player_weapon(lp)
    local fwd = fw and csgo_weapons[entity_get_prop(fw, "m_iItemDefinitionIndex")]
    if not fwd or fwd.type == "grenade" then cmd.force_defensive = 0 end

    -- ========== LEG BREAKER ==========
    if has_multiselect(misc_features, "Leg Breaker") then
        ui_set(refs.leg_movement, cmd.command_number % 3 == 0 and "Always slide" or "Never slide")
    end

    -- ========== ANIMATION BREAKER ==========
    local ab = ui_get(anim_breaker)
    if ab == "Static" then ui_set(refs.leg_movement, "Always slide")
    elseif ab == "No Step Back" then ui_set(refs.leg_movement, "Never slide")
    elseif ab == "Jitter" then ui_set(refs.leg_movement, globals_tickcount() % 11 <= 2 and "Always slide" or "Never slide") end

    -- ========== WARMUP DISABLER ==========
    if has_multiselect(misc_features, "Warmup Disabler") then
        local gr = entity.get_game_rules()
        if gr and entity_get_prop(gr, "m_bWarmupPeriod") == 1 then
            ui_set(refs.pitch[1], "Off"); ui_set(refs.yaw[1], "180"); ui_set(refs.yaw[2], 0)
            ui_set(refs.yaw_jitter[1], "Off"); ui_set(refs.body_yaw[1], "Off")
        end
    end

    -- Suppress native UI flickering caused by defensive AA ui_set changes
    if ui.is_menu_open() then
        local aa_refs = { refs.pitch[1], refs.pitch[2], refs.yaw_base, refs.yaw[1], refs.yaw[2],
            refs.yaw_jitter[1], refs.yaw_jitter[2], refs.body_yaw[1], refs.body_yaw[2],
            refs.freestanding_body_yaw, refs.freestanding[1], refs.freestanding[2], refs.edge_yaw, refs.roll }
        for _, r in ipairs(aa_refs) do ui.set_visible(r, false) end
    end
end


-- ===================== CHEAT SPOOFER SYSTEM =====================
local spoof_state = { packet_count = 0, random_base = math.random(0x1000, 0xFFFF), xuid_pattern = {} }

local spoof_generators = {
    neverlose = function(p, c) local base = spoof_state.random_base + math.floor(c / 4) end,
    nixware = function(p, c) end,
    pandora = function(p, c) end,
    onetap = function(p, c) end,
    fatality = function(p, c) end,
    plaguecheat = function(p, c) end,
    ev0lve = function(p, c) end,
    rifk7 = function(p, c) end,
    airflow = function(p, c) end,
    gamesense = function(p, c) end,
}

local function try_spoof_voice(e)
    if not ui_get(spoof_enable) then return end
    local mode = ui_get(spoof_mode)
    spoof_state.packet_count = spoof_state.packet_count + 1
    if mode == "Spoof As..." then
        local target = ui_get(spoof_target):lower():gsub("%s+", "")
        local gen = spoof_generators[target]
        if gen then
            if ui_get(spoof_randomize) then
                if spoof_state.packet_count % 10 < 7 then gen(e, spoof_state.packet_count) end
            else
                gen(e, spoof_state.packet_count)
            end
        end
        ui_set(spoof_status, string.format("Status: Spoofing as %s (%d)", ui_get(spoof_target), spoof_state.packet_count))
    else
        ui_set(spoof_status, string.format("Status: Hiding (%d)", spoof_state.packet_count))
    end
end

-- ===================== CUSTOM SCOPE RENDERER =====================
vars.scope_overlay_ref = ui.reference("VISUALS", "Effects", "Remove scope overlay")
vars.scope_alpha = 0

local function draw_custom_scope()
    if not ui_get(vis_scope_enable) then return end
    ui_set(vars.scope_overlay_ref, false)
    local sw, sh = client_screen_size()
    local lp = entity_get_local_player()
    if not lp or not entity_is_alive(lp) then return end
    local wpn = entity_get_player_weapon(lp)
    if not wpn then return end
    local scope_level = entity_get_prop(wpn, "m_zoomLevel")
    local scoped = entity_get_prop(lp, "m_bIsScoped") == 1
    local is_valid = scope_level and scope_level > 0 and scoped
    local speed = ui_get(vis_scope_speed)
    local compact = ui_get(vis_hud_style) == "Mini"
    local anim_speed = globals_frametime() * math_max(6, speed * 2)
    vars.scope_alpha = clamp(vars.scope_alpha + (is_valid and anim_speed or -anim_speed), 0, 1)
    if vars.scope_alpha <= 0 then return end

    local cx, cy = math_floor(sw * 0.5), math_floor(sh * 0.5)
    local offset = math_floor(ui_get(vis_scope_offset) * sh / 1080 + 0.5)
    local pos = math_floor(ui_get(vis_scope_pos) * sh / 1080 + 0.5)
    local cr, cg, cb, ca = ui_get(vis_scope_color)
    local pal = get_hud_palette(cr, cg, cb, vars.scope_alpha)
    local a = math_floor(vars.scope_alpha * ca + 0.5)
    local arm = math_max(1, pos - offset)
    local inner_len = compact and 12 or 16
    local inner_gap = math_max(3, offset - (compact and 3 or 4))
    local core = compact and 2 or 3

    vars.hud_scope_breathe = vars.hud_scope_breathe + globals_frametime() * 5
    local pulse = 0.55 + 0.45 * math_abs(math_sin(vars.hud_scope_breathe))
    local main_alpha = math_floor(a * (0.72 + pulse * 0.22))
    local sub_alpha = math_floor(a * (0.32 + pulse * 0.18))

    draw_blur(cx - 18, cy - 18, 36, 36, math_floor(a * 0.42), compact and 4 or 5)
    renderer_gradient(cx - arm - offset, cy, arm, 1, cr, cg, cb, 0, cr, cg, cb, main_alpha, true)
    renderer_gradient(cx + offset, cy, arm, 1, cr, cg, cb, main_alpha, cr, cg, cb, 0, true)
    renderer_gradient(cx, cy - arm - offset, 1, arm, cr, cg, cb, 0, cr, cg, cb, main_alpha, false)
    renderer_gradient(cx, cy + offset, 1, arm, cr, cg, cb, main_alpha, cr, cg, cb, 0, false)

    renderer_gradient(cx - inner_gap - inner_len, cy - 2, inner_len, 1, cr, cg, cb, 0, pal.accent_soft[1], pal.accent_soft[2], pal.accent_soft[3], sub_alpha, true)
    renderer_gradient(cx + inner_gap, cy - 2, inner_len, 1, pal.accent_soft[1], pal.accent_soft[2], pal.accent_soft[3], sub_alpha, cr, cg, cb, 0, true)
    renderer_gradient(cx - 2, cy - inner_gap - inner_len, 1, inner_len, cr, cg, cb, 0, pal.accent_soft[1], pal.accent_soft[2], pal.accent_soft[3], sub_alpha, false)
    renderer_gradient(cx - 2, cy + inner_gap, 1, inner_len, pal.accent_soft[1], pal.accent_soft[2], pal.accent_soft[3], sub_alpha, cr, cg, cb, 0, false)

    draw_round_rect(cx - 5, cy - 5, 11, 11, 10, 13, 21, math_floor(a * 0.14), 4)
    draw_round_rect(cx - core, cy - core, core * 2 + 1, core * 2 + 1, cr, cg, cb, math_floor(a * 0.36), core)
    draw_round_rect(cx - 1, cy - 1, 3, 3, pal.text[1], pal.text[2], pal.text[3], math_floor(a * (0.42 + pulse * 0.22)), 1)
end

-- ===================== SCOPE FOV OVERRIDE =====================
vars.override_zoom_fov = ui.reference("Misc", "Miscellaneous", "Override zoom FOV")

local function apply_scope_fov()
    local val = ui_get(vars.scope_fov_slider)
    if val > 0 then
        ui_set(vars.override_zoom_fov, val)
    end
end

-- ===================== JUMP SHOT AIR STOP =====================
vars.jump_shot_cfg = {
    min_damage = 38,
    hitchance = 58,
    scoped_speed = 34,
    unscoped_speed = 58,
    sample_radius = 1.2,
    weapons = {
        CWeaponSSG08 = true,
        CWeaponAWP = true
    },
    hitboxes = { 0, 3, 5 },
    samples = {
        { 0.0, 0.0, 0.0 },
        { 1.0, 0.0, 0.0 },
        { -1.0, 0.0, 0.0 },
        { 0.0, 1.0, 0.0 },
        { 0.0, -1.0, 0.0 }
    }
}

local function apply_jump_shot_air_stop(cmd)
    if not ui_get(vars.jump_shot_cb) then
        return
    end

    local cfg = vars.jump_shot_cfg

    local local_player = entity_get_local_player()
    if not local_player or not entity_is_alive(local_player) or not is_in_air(local_player) then
        return
    end

    local weapon = entity_get_player_weapon(local_player)
    local weapon_name = weapon and entity_get_classname(weapon)
    if weapon_name == nil or cfg.weapons[weapon_name] ~= true then
        return
    end

    if (entity_get_prop(weapon, "m_iClip1") or 0) <= 0 then
        return
    end

    local soon_time = globals_curtime() + globals_tickinterval() * 2
    local next_primary_attack = entity_get_prop(weapon, "m_flNextPrimaryAttack") or 0
    local next_player_attack = entity_get_prop(local_player, "m_flNextAttack") or 0
    if next_primary_attack > soon_time or next_player_attack > soon_time then
        return
    end

    local threat = client_current_threat()
    if not threat or not entity_is_enemy(threat) or not entity_is_alive(threat) then
        return
    end

    local eye_x, eye_y, eye_z = client_eye_position()
    if not eye_x then
        return
    end

    local best_score = -1
    for i = 1, #cfg.hitboxes do
        local hitbox = cfg.hitboxes[i]
        local hit_x, hit_y, hit_z = entity_hitbox_position(threat, hitbox)
        if hit_x ~= nil then
            local _, dmg = client.trace_bullet(local_player, eye_x, eye_y, eye_z, hit_x, hit_y, hit_z, false)
            dmg = dmg or 0

            if dmg >= cfg.min_damage then
                local hits = 0
                for j = 1, #cfg.samples do
                    local sample = cfg.samples[j]
                    local _, sample_dmg = client.trace_bullet(
                        local_player,
                        eye_x, eye_y, eye_z,
                        hit_x + sample[1] * cfg.sample_radius,
                        hit_y + sample[2] * cfg.sample_radius,
                        hit_z + sample[3] * cfg.sample_radius,
                        false
                    )

                    if (sample_dmg or 0) > 0 then
                        hits = hits + 1
                    end
                end

                local hitchance = (hits / #cfg.samples) * 100
                if hitchance >= cfg.hitchance then
                    best_score = math_max(best_score, dmg * 100 + hitchance)
                end
            end
        end
    end

    if best_score < 0 then
        return
    end

    local scoped = entity_get_prop(local_player, "m_bIsScoped") == 1
    if not scoped then
        cmd.in_attack2 = 1
        if cmd.buttons ~= nil then
            cmd.buttons = bit.bor(cmd.buttons, 2048)
        end
    end

    local vel_x, vel_y = entity_get_prop(local_player, "m_vecVelocity")
    if vel_x == nil then
        return
    end

    local speed_2d = math_sqrt(vel_x * vel_x + vel_y * vel_y)
    local speed_limit = scoped and cfg.scoped_speed or cfg.unscoped_speed
    if speed_2d <= speed_limit then
        return
    end

    local _, camera_yaw = client_camera_angles()
    local velocity_yaw = math_deg(math_atan2(vel_y, vel_x))
    local yaw_delta = math_rad((camera_yaw or 0) - velocity_yaw)

    cmd.forwardmove = math_cos(yaw_delta) * -450
    cmd.sidemove = math_sin(yaw_delta) * 450
end

-- ===================== FAST LADDER =====================
local function apply_fast_ladder(cmd)
    if not ui_get(vars.fast_ladder_cb) then return end
    local lp = entity_get_local_player()
    if not lp or not entity_is_alive(lp) then return end
    local mt = entity_get_prop(lp, "m_MoveType")
    if mt == 9 then -- MOVETYPE_LADDER
        cmd.forwardmove = 450
        cmd.sidemove = (cmd.in_moveleft or 0) == 1 and -450 or ((cmd.in_moveright or 0) == 1 and 450 or 0)
    end
end

-- ===================== ASPECT RATIO =====================
vars.aspect_cvar = cvar and cvar.r_aspectratio

local function apply_aspect_ratio()
    if not vars.aspect_cvar then return end
    local val = ui_get(aspect_ratio_slider)
    if val > 0 then
        vars.aspect_cvar:set_float(val / 100)
    else
        vars.aspect_cvar:set_float(0)
    end
end

-- ===================== CLANTAG ANIMATION =====================
vars.clantag_frames = {}
vars.clantag_text = "Cynicism "
for i = 0, #vars.clantag_text do vars.clantag_frames[i+1] = vars.clantag_text:sub(1, i) end
vars.clantag_idx = 1
vars.clantag_timer = 0

local function apply_clantag()
    if not ui_get(clantag_cb) then return end
    local rt = globals_realtime()
    if rt - vars.clantag_timer < 0.4 then return end
    vars.clantag_timer = rt
    vars.clantag_idx = vars.clantag_idx % #vars.clantag_frames + 1
    local ok, fn = pcall(function() return client.set_clan_tag end)
    if ok and fn then fn(vars.clantag_frames[vars.clantag_idx]) end
end

-- ===================== CONSOLE FILTER =====================
local function apply_console_filter()
    if not ui_get(console_filter_cb) then return end
    local ok, fn = pcall(function() return cvar.con_filter_enable end)
    if ok and fn then fn:set_int(1) end
end

-- ===================== SHOT LOGGER =====================
vars.shot_log_entries = {}

local function on_aim_fire(e)
    vars.flctl_last_shot_time = globals_tickcount()
    if not ui_get(vis_shot_log) then return end
    local target = entity.get_player_name(e.target) or "?"
    local hc = e.hit_chance or 0
    table.insert(vars.shot_log_entries, 1, {
        text = string.format("Fired at %s (hc: %d%%)", target, math.floor(hc)),
        time = globals_realtime(), alpha = 255, kind = "fire", slide = 0
    })
    if #vars.shot_log_entries > 6 then table.remove(vars.shot_log_entries) end
end

local function on_aim_hit(e)
    local target = entity.get_player_name(e.target) or "?"
    local dmg = e.damage or 0
    if has_multiselect(vis_combat_alerts, "Toast Logs") then
        push_combat_notification("命中", string.format("命中 %s - %d dmg", target, dmg), { 100, 255, 100 }, 2.6)
    end
    if not ui_get(vis_shot_log) then return end
    table.insert(vars.shot_log_entries, 1, {
        text = string.format("Hit %s for %d dmg", target, dmg),
        time = globals_realtime(), alpha = 255, color = {100, 255, 100}, kind = "hit", slide = 0
    })
    if #vars.shot_log_entries > 6 then table.remove(vars.shot_log_entries) end
end

local function on_aim_miss(e)
    cyn_trigger_abf(e.reason or "?")
    local target = entity.get_player_name(e.target) or "?"
    local reason = e.reason or "?"
    if has_multiselect(vis_combat_alerts, "Toast Logs") then
        push_combat_notification("空枪", string.format("空枪 %s - %s", target, reason), { 255, 118, 118 }, 2.8)
    end
    if not ui_get(vis_shot_log) then return end
    table.insert(vars.shot_log_entries, 1, {
        text = string.format("Missed %s (%s)", target, reason),
        time = globals_realtime(), alpha = 255, color = {255, 100, 100}, kind = "miss", slide = 0
    })
    if #vars.shot_log_entries > 6 then table.remove(vars.shot_log_entries) end
end

-- ===================== HITMARKER =====================
vars.hitmarker_data = { alpha = 0, time = 0, size = 0 }

local function on_player_hurt_hitmarker(e)
    if not ui_get(vis_hitmarker) then return end
    local attacker = client.userid_to_entindex(e.attacker)
    if attacker == entity_get_local_player() then
        vars.hitmarker_data.alpha = 255
        vars.hitmarker_data.time = globals_realtime()
        vars.hitmarker_data.size = 0
    end
end

local function draw_hud_watermark(sw, sh, ir, ig, ib)
    if not has_multiselect(vis_indicators, "Branding") then return end
    local compact = ui_get(vis_hud_style) == "Mini"
    local pal = get_hud_palette(ir, ig, ib, 1)
    local ok_time, hours, minutes, seconds = pcall(client.system_time)
    local ok_ping, latency = pcall(client.latency)
    if not ok_time then
        hours, minutes, seconds = 0, 0, 0
    end
    local ping = math_floor((((ok_ping and latency) or 0) * 1000) + 0.5)
    local h = compact and 22 or 26
    local y = 18
    local gap = compact and 4 or 5
    local shimmer = 0.72 + 0.28 * math_abs(math_sin(globals_realtime() * 2.4))
    local parts = {
        { text = compact and "CY" or "CYN", accent = true },
        { text = "v" .. tostring(SCRIPT_VERSION) },
        { text = string.format("%02d:%02d:%02d", hours or 0, minutes or 0, seconds or 0) },
        { text = string.format("%dms", ping) },
        { text = vars.state or "Global" }
    }
    local target_w = 0

    for i = 1, #parts do
        local part = parts[i]
        local tw = renderer_measure_text("", part.text)
        local pad = part.accent and (compact and 20 or 24) or (compact and 14 or 18)
        part.w = math_max(part.accent and (compact and 34 or 42) or 0, tw + pad)
        target_w = target_w + part.w
        if i < #parts then
            target_w = target_w + gap
        end
    end

    vars.hud_watermark_w = lerp(vars.hud_watermark_w, target_w, globals_frametime() * 10)
    local shell_w = math_floor(vars.hud_watermark_w + 0.5)
    local shell_x = sw - shell_w - 24
    draw_glass_panel(shell_x, y, shell_w, h, ir, ig, ib, 0.16, compact)

    local x = sw - target_w - 24
    for i = 1, #parts do
        local part = parts[i]
        local alpha = part.accent and (0.92 + shimmer * 0.08) or 0.84
        local tr, tg, tb = pal.soft[1], pal.soft[2], pal.soft[3]
        if part.accent then
            tr, tg, tb = pal.text[1], pal.text[2], pal.text[3]
        end

        draw_glass_panel(x, y, part.w, h, ir, ig, ib, alpha, compact)
        if part.accent then
            draw_round_rect(x + 6, y + 5, part.w - 12, h - 10, ir, ig, ib, math_floor(82 * shimmer), compact and 4 or 5)
        end
        draw_text_shadow(x + part.w * 0.5, y + (compact and 5 or 6), tr, tg, tb, 240, "c", 0, part.text)
        x = x + part.w + gap
    end
end

local function draw_hud_center(lp, sw, sh, ir, ig, ib)
    local compact = ui_get(vis_hud_style) == "Mini"
    local pal = get_hud_palette(ir, ig, ib, 1)
    local cx, cy = math_floor(sw * 0.5), math_floor(sh * 0.5)
    local stack_y = cy + (compact and 36 or 40)
    local gap = compact and 4 or 5
    local badges = {}

    local function push_badge(label, value, condition)
        if not condition then return end
        badges[#badges + 1] = { label = label, value = tostring(value or "") }
    end

    push_badge("STATE", vars.state or "Global", has_multiselect(vis_indicators, "State Display"))
    push_badge("DEF", tostring(exploit_data.defensive.left or 0) .. "t", has_multiselect(vis_indicators, "Defensive Ticks") and (exploit_data.defensive.left or 0) > 0)
    push_badge("MODE", vars.def_mode_resolved or vars.def_state or "Idle", has_multiselect(vis_indicators, "Exploit Info"))

    local fl_txt = "off"
    if (vars.flctl_mode or "Off") ~= "Off" and (vars.flctl_limit or 0) > 0 then
        fl_txt = tostring(vars.flctl_limit or 0) .. "t"
    end
    local threat_txt = get_combat_badge_text()
    push_badge("FL", fl_txt, has_multiselect(vis_indicators, "FL Status"))
    push_badge("ABF", vars.abf_state or "idle", has_multiselect(vis_indicators, "ABF Status"))
    push_badge("THREAT", threat_txt, has_multiselect(vis_combat_alerts, "Threat Badge") and threat_txt ~= nil)

    if has_multiselect(vis_indicators, "Manual Arrows") then
        local arrow_offset = compact and 48 or 58
        local idle_a = ui.is_menu_open() and 52 or 22
        local active_a = 245
        draw_text_shadow(cx - arrow_offset, cy - 4, ir, ig, ib, vars.aa_dir == -90 and active_a or idle_a, "c", 0, "◂")
        draw_text_shadow(cx + arrow_offset, cy - 4, ir, ig, ib, vars.aa_dir == 90 and active_a or idle_a, "c", 0, "▸")
        if vars.aa_dir == 180 or ui.is_menu_open() then
            draw_text_shadow(cx, cy - (compact and 28 or 32), ir, ig, ib, vars.aa_dir == 180 and active_a or idle_a, "c", 0, "▴")
        end
    end

    local offset_y = 0
    for i = 1, #badges do
        local badge = badges[i]
        local bw, bh = measure_hud_badge(badge.label, badge.value, compact)
        local bx = cx - math_floor(bw * 0.5)
        local by = stack_y + offset_y
        draw_hud_badge(bx, by, badge.label, badge.value, ir, ig, ib, 0.94, compact)
        offset_y = offset_y + bh + gap
    end

    if #badges > 0 and not compact then
        draw_text_shadow(cx, stack_y - 14, pal.faint[1], pal.faint[2], pal.faint[3], 128, "c", 0, "anti-aim matrix")
    end

    if has_multiselect(vis_indicators, "Desync Bar") then
        local pose = entity_get_prop(lp, "m_flPoseParameter", 11)
        local amount = pose and math_abs(pose * 120 - 60) or 0
        vars.anim_desync = lerp(vars.anim_desync, clamp(amount / 60, 0, 1), globals_frametime() * 12)

        local bar_w = compact and 88 or 104
        local bar_h = compact and 10 or 12
        local bar_x = cx - math_floor(bar_w * 0.5)
        local bar_y = stack_y + offset_y + (compact and 4 or 6)
        local fill = math_floor((bar_w - 6) * vars.anim_desync + 0.5)

        draw_glass_panel(bar_x, bar_y, bar_w, bar_h, ir, ig, ib, 0.9, compact)
        renderer_gradient(bar_x + 3, bar_y + 3, bar_w - 6, bar_h - 6, 255, 255, 255, 10, 255, 255, 255, 0, false)
        if fill > 0 then
            renderer_gradient(bar_x + 3, bar_y + 3, fill, bar_h - 6, ir, ig, ib, 185, pal.accent_soft[1], pal.accent_soft[2], pal.accent_soft[3], 42, true)
        end
        if not compact then
            draw_text_shadow(cx, bar_y + bar_h + 4, pal.dim[1], pal.dim[2], pal.dim[3], 156, "c", 0, string.format("desync %d", math_floor(vars.anim_desync * 60 + 0.5)))
        end
    end
end

local function draw_hud_keylist(sw, sh, ir, ig, ib)
    if not has_multiselect(vis_indicators, "Keybind List") then return end
    local compact = ui_get(vis_hud_style) == "Mini"
    local pal = get_hud_palette(ir, ig, ib, 1)
    local items = collect_active_binds()
    local menu_open = ui.is_menu_open()
    local header_h = compact and 22 or 24
    local row_h = compact and 18 or 20
    local row_gap = 4
    local target_w = compact and 148 or 170

    for i = 1, #items do
        local item = items[i]
        local name_w = renderer_measure_text("", item.name or "")
        local state_w = renderer_measure_text("", item.state or "")
        target_w = math_max(target_w, name_w + state_w + (compact and 40 or 48))
    end

    if #items == 0 then
        target_w = math_max(target_w, renderer_measure_text("", "No active binds") + 40)
    end

    vars.hud_keylist_w = lerp(vars.hud_keylist_w, target_w, globals_frametime() * 10)
    if #items == 0 and not menu_open and vars.hud_keylist_w < target_w * 0.98 then return end
    if #items == 0 and not menu_open then return end

    local rows = math_max(#items, menu_open and 1 or 0)
    local w = math_floor(vars.hud_keylist_w + 0.5)
    local h = header_h + 8 + rows * row_h + math_max(0, rows - 1) * row_gap + 8
    local x = 28
    local y = math_floor(sh * 0.42 - h * 0.5)

    draw_glass_panel(x, y, w, h, ir, ig, ib, 0.92, compact)
    draw_hud_header(x, y, w, "Hotkeys", ir, ig, ib, 1, compact, tostring(#items))

    local row_y = y + header_h + 8
    if #items == 0 then
        draw_text_shadow(x + w * 0.5, row_y + 2, pal.dim[1], pal.dim[2], pal.dim[3], 158, "c", 0, "No active binds")
        return
    end

    for i = 1, #items do
        local item = items[i]
        draw_hud_row(x + 6, row_y, w - 12, row_h, item.name or "unknown", item.state or "on", ir, ig, ib, 1, compact, pal.accent_soft[1], pal.accent_soft[2], pal.accent_soft[3], 216)
        row_y = row_y + row_h + row_gap
    end
end

local function draw_hud_spectators(local_player, sw, sh, ir, ig, ib)
    if not has_multiselect(vis_indicators, "Spectator List") then return end
    local compact = ui_get(vis_hud_style) == "Mini"
    local pal = get_hud_palette(ir, ig, ib, 1)
    local items = collect_spectators(local_player)
    local menu_open = ui.is_menu_open()
    local header_h = compact and 22 or 24
    local row_h = compact and 18 or 20
    local row_gap = 4
    local title = string.format("Spectators (%d)", #items)
    local target_w = math_max(compact and 156 or 178, renderer_measure_text("", title) + 38)

    for i = 1, #items do
        target_w = math_max(target_w, renderer_measure_text("", items[i]) + 40)
    end

    if #items == 0 then
        target_w = math_max(target_w, renderer_measure_text("", "Nobody watching") + 40)
    end

    vars.hud_speclist_w = lerp(vars.hud_speclist_w, target_w, globals_frametime() * 10)
    if #items == 0 and not menu_open and vars.hud_speclist_w < target_w * 0.98 then return end
    if #items == 0 and not menu_open then return end

    local rows = math_max(#items, menu_open and 1 or 0)
    local w = math_floor(vars.hud_speclist_w + 0.5)
    local h = header_h + 8 + rows * row_h + math_max(0, rows - 1) * row_gap + 8
    local x = sw - w - 28
    local y = math_floor(sh * 0.42 - h * 0.5)

    draw_glass_panel(x, y, w, h, ir, ig, ib, 0.92, compact)
    draw_hud_header(x, y, w, title, ir, ig, ib, 1, compact)

    local row_y = y + header_h + 8
    if #items == 0 then
        draw_text_shadow(x + w * 0.5, row_y + 2, pal.dim[1], pal.dim[2], pal.dim[3], 158, "c", 0, "Nobody watching")
        return
    end

    for i = 1, #items do
        local name = items[i]
        draw_hud_row(x + 6, row_y, w - 12, row_h, name, tostring(i), ir, ig, ib, 1, compact, pal.dim[1], pal.dim[2], pal.dim[3], 188)
        row_y = row_y + row_h + row_gap
    end
end

local function draw_shot_logs(sw, sh, ir, ig, ib)
    if not ui_get(vis_shot_log) then return end
    local compact = ui_get(vis_hud_style) == "Mini"
    local pal = get_hud_palette(ir, ig, ib, 1)
    local rt = globals_realtime()
    local ft = globals_frametime()
    local icon_size = compact and 22 or 24
    local card_h = icon_size
    local y = 56

    for i = 1, #vars.shot_log_entries do
        local entry = vars.shot_log_entries[i]
        local age = rt - (entry.time or 0)
        if age > 4.6 then
            entry.alpha = lerp(entry.alpha or 255, 0, ft * 8)
        else
            entry.alpha = lerp(entry.alpha or 0, 255, ft * 12)
        end

        local alpha = clamp(entry.alpha or 0, 0, 255)
        if alpha > 1 then
            local text = entry.text or ""
            local tw = renderer_measure_text("", text)
            local icon = entry.kind == "hit" and "H" or (entry.kind == "miss" and "M" or "F")
            local w = math_max(compact and 164 or 188, tw + icon_size + 26)
            local mul = alpha / 255
            local stay = age < 4.6
            entry.slide = lerp(entry.slide or 0, stay and 1 or 0, ft * (stay and 11 or 8))
            local slide = clamp(entry.slide or 0, 0, 1)
            local x = math_floor(24 - (1 - slide) * 42)
            local accent = entry.color or { ir, ig, ib }
            local chip_x = x
            local body_x = x + icon_size + 4

            draw_glass_panel(chip_x, y, icon_size, card_h, accent[1], accent[2], accent[3], 0.92 * mul, compact)
            draw_round_rect(chip_x + 4, y + 4, icon_size - 8, card_h - 8, accent[1], accent[2], accent[3], math_floor(alpha * 0.26), compact and 4 or 5)
            draw_text_shadow(chip_x + math_floor(icon_size * 0.5), y + (compact and 5 or 6), pal.text[1], pal.text[2], pal.text[3], math_floor(alpha * 0.96), "c", 0, icon)

            draw_glass_panel(body_x, y, w - icon_size - 4, card_h, ir, ig, ib, 0.92 * mul, compact)
            draw_round_rect(body_x, y, 3, card_h, accent[1], accent[2], accent[3], math_floor(alpha * 0.92), 2)
            draw_text_shadow(body_x + 10, y + (compact and 4 or 5), pal.text[1], pal.text[2], pal.text[3], math_floor(alpha * 0.96), "", 0, text)
            y = y + card_h + 6
        end
    end

    for i = #vars.shot_log_entries, 1, -1 do
        if (vars.shot_log_entries[i].alpha or 0) <= 1 then
            table.remove(vars.shot_log_entries, i)
        end
    end
end

-- ===================== VISUAL RENDERING =====================
vars.anim_desync = 0

local function draw_esp_preview(sw, sh, ir, ig, ib)
    local should_show = ui_get(vis_esp_preview) and ui.is_menu_open()
    local fade_speed = globals_frametime() * 9.5
    vars.esp_preview_alpha = clamp(vars.esp_preview_alpha + (should_show and fade_speed or -fade_speed), 0, 1)
    if vars.esp_preview_alpha <= 0 then
        return
    end

    local mul = vars.esp_preview_alpha
    local panel_w, panel_h = 242, 394
    local panel_x = math_floor(sw * 0.76 - panel_w * 0.5)
    local panel_y = math_floor(sh * 0.50 - panel_h * 0.5)

    if ui.menu_position ~= nil and ui.menu_size ~= nil then
        local ok_pos, mx, my = pcall(ui.menu_position)
        local ok_size, mw, mh = pcall(ui.menu_size)
        if ok_pos and ok_size and mx and my and mw and mh then
            panel_x = mx + mw + 20
            panel_y = my + math_floor(mh * 0.5 - panel_h * 0.5)
        end
    end

    panel_x = clamp(panel_x, 10, sw - panel_w - 10)
    panel_y = clamp(panel_y, 10, sh - panel_h - 10)

    draw_glass_panel(panel_x, panel_y, panel_w, panel_h, ir, ig, ib, 0.94 * mul, false)
    draw_round_rect(panel_x + 10, panel_y + 10, panel_w - 20, 20, 15, 19, 28, math_floor(154 * mul), 6)
    draw_round_rect(panel_x + 15, panel_y + 15, 6, 6, ir, ig, ib, math_floor(228 * mul), 3)
    draw_text_shadow(panel_x + 27, panel_y + 14, 232, 236, 243, math_floor(240 * mul), "", 0, "ESP PREVIEW")
    draw_text_shadow(panel_x + panel_w - 15, panel_y + 14, 171, 176, 187, math_floor(210 * mul), "r", 0, "HORUS")

    local x = panel_x + 30
    local y = panel_y + 42
    local box_x, box_y, box_w, box_h = x + 20, y + 42, 142, 288

    local name_r, name_g, name_b, name_a = ref_color_or(esp_preview_refs.name, 255, 255, 255, 255)
    local box_r, box_g, box_b, box_a = ref_color_or(esp_preview_refs.box, 255, 255, 255, 255)
    local skeleton_r, skeleton_g, skeleton_b, skeleton_a = ref_color_or(esp_preview_refs.skeleton, 255, 255, 255, 255)
    local ammo_r, ammo_g, ammo_b, ammo_a = ref_color_or(esp_preview_refs.ammo, ir, ig, ib, 255)
    local icon_r, icon_g, icon_b, icon_a = ref_color_or(esp_preview_refs.weapon_icon, 255, 255, 255, 255)
    local glow_r, glow_g, glow_b, glow_a = ref_color_or(esp_preview_refs.glow, ir, ig, ib, 180)

    if ref_active(esp_preview_refs.glow) then
        draw_blur(box_x - 14, box_y - 10, box_w + 28, box_h + 20, math_floor(glow_a * mul * 0.62), 4)
        draw_round_rect(box_x + 34, box_y + 8, 74, box_h - 24, glow_r, glow_g, glow_b, math_floor(glow_a * mul * 0.22), 8)
    end

    draw_round_rect(box_x + 42, box_y + 8, 58, box_h - 20, 44, 49, 58, math_floor(110 * mul), 8)
    draw_round_rect(box_x + 56, box_y - 4, 30, 30, 54, 59, 70, math_floor(132 * mul), 15)

    if ref_active(esp_preview_refs.name) then
        draw_text_shadow(x + 90, y + 35, name_r, name_g, name_b, math_floor(name_a * mul), "c", 0, "KnF7")
    end

    if ref_active(esp_preview_refs.health) then
        local hp_h = 245
        local hp_fill = math_floor(hp_h * 0.76 + 0.5)
        renderer_rectangle(x + 14, y + 43, 2, hp_h, 0, 0, 0, math_floor(235 * mul))
        renderer_gradient(x + 14, y + 43 + (hp_h - hp_fill), 2, hp_fill, 188, 184, 234, math_floor(255 * mul), 146, 116, 105, math_floor(255 * mul), false)
        draw_text_shadow(x + 9, y + 80, 255, 255, 255, math_floor(245 * mul), "-", 0, "76")
    end

    if ref_active(esp_preview_refs.box) then
        renderer_line(box_x, box_y, box_x + box_w, box_y, box_r, box_g, box_b, math_floor(box_a * mul))
        renderer_line(box_x, box_y, box_x, box_y + box_h, box_r, box_g, box_b, math_floor(box_a * mul))
        renderer_line(box_x, box_y + box_h, box_x + box_w, box_y + box_h, box_r, box_g, box_b, math_floor(box_a * mul))
        renderer_line(box_x + box_w, box_y, box_x + box_w, box_y + box_h, box_r, box_g, box_b, math_floor(box_a * mul))
    end

    local flag_offset = 41
    if ref_active(esp_preview_refs.money) then
        draw_text_shadow(x + 164, y + 41, 115, 180, 25, math_floor(240 * mul), "-", 0, "$1337")
        flag_offset = flag_offset + 9
    end

    if ref_active(esp_preview_refs.flags) then
        draw_text_shadow(x + 164, y + flag_offset, 255, 255, 255, math_floor(240 * mul), "-", 0, "HK")
        draw_text_shadow(x + 164, y + flag_offset + 9, 53, 166, 208, math_floor(240 * mul), "-", 0, "ZOOM")
        draw_text_shadow(x + 164, y + flag_offset + 18, 255, 255, 255, math_floor(240 * mul), "-", 0, "FAKE")
        draw_text_shadow(x + 164, y + flag_offset + 27, 255, 0, 0, math_floor(240 * mul), "-", 0, "PIN")
    end

    local other_offset = 0
    if ref_active(esp_preview_refs.ammo) then
        renderer_rectangle(x + 20, y + 335 + other_offset, 141, 2, 0, 0, 0, math_floor(245 * mul))
        renderer_rectangle(x + 20, y + 335 + other_offset, 99, 2, ammo_r, ammo_g, ammo_b, math_floor(ammo_a * mul))
        draw_text_shadow(x + 117, y + 336 + other_offset, 255, 255, 255, math_floor(245 * mul), "c-", 0, "7")
        other_offset = other_offset + 10
    end

    if ref_active(esp_preview_refs.distance) then
        draw_text_shadow(x + 90, y + 339 + other_offset, 255, 255, 255, math_floor(245 * mul), "c-", 0, "70 FT")
        other_offset = other_offset + 10
    end

    if ref_active(esp_preview_refs.weapon_text) then
        draw_text_shadow(x + 90, y + 338 + other_offset, 255, 255, 255, math_floor(245 * mul), "c-", 0, "SSG08")
        other_offset = other_offset + 10
    end

    if ref_active(esp_preview_refs.weapon_icon) then
        draw_text_shadow(x + 90, y + 338 + other_offset, icon_r, icon_g, icon_b, math_floor(icon_a * mul), "c-", 0, "[ICON]")
        other_offset = other_offset + 10
    end

    if ref_active(esp_preview_refs.skeleton) then
        local sy = y + 40
        renderer_line(x + 90, sy + 40, x + 86, sy + 132, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 86, sy + 132, x + 72, sy + 152, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 72, sy + 152, x + 73, sy + 194, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 73, sy + 194, x + 90, sy + 250, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 86, sy + 132, x + 102, sy + 154, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 102, sy + 154, x + 105, sy + 193, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 105, sy + 193, x + 120, sy + 250, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 88, sy + 68, x + 66, sy + 75, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 66, sy + 75, x + 52, sy + 100, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 52, sy + 100, x + 43, sy + 70, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 88, sy + 68, x + 115, sy + 76, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 115, sy + 76, x + 130, sy + 105, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
        renderer_line(x + 130, sy + 105, x + 124, sy + 130, skeleton_r, skeleton_g, skeleton_b, math_floor(skeleton_a * mul))
    end
end

local function draw_indicators()
    local sw, sh = client_screen_size()
    local cx, cy = math_floor(sw * 0.5), math_floor(sh * 0.5)
    local ir, ig, ib = ui_get(vis_indicator_color)
    local lp = entity_get_local_player()
    local compact = ui_get(vis_hud_style) == "Mini"
    local pulse = 0.65 + 0.35 * math_abs(math_sin(globals_realtime() * 9))

    draw_hud_watermark(sw, sh, ir, ig, ib)
    draw_shot_logs(sw, sh, ir, ig, ib)
    draw_combat_notifications(sw, sh, ir, ig, ib)
    draw_hud_keylist(sw, sh, ir, ig, ib)
    draw_hud_spectators(lp, sw, sh, ir, ig, ib)
    draw_esp_preview(sw, sh, ir, ig, ib)

    if lp and entity_is_alive(lp) then
        draw_hud_center(lp, sw, sh, ir, ig, ib)
        draw_custom_scope()
    end

    if ui_get(vis_hitmarker) and vars.hitmarker_data.alpha > 1 then
        vars.hitmarker_data.alpha = lerp(vars.hitmarker_data.alpha, 0, globals_frametime() * 7.5)
        vars.hitmarker_data.size = lerp(vars.hitmarker_data.size, compact and 8 or 10, globals_frametime() * 18)

        local ha = clamp(vars.hitmarker_data.alpha, 0, 255)
        local hs = vars.hitmarker_data.size
        local outer = hs + (compact and 5 or 6)
        local inner = hs * 0.42
        local ring_scale = outer + pulse * 2

        draw_blur(cx - outer - 8, cy - outer - 8, (outer + 8) * 2, (outer + 8) * 2, math_floor(ha * 0.32), compact and 4 or 5)
        draw_ring(cx, cy, 255, 255, 255, math_floor(ha * 0.12), ring_scale + 2, 0, 1, 1)
        draw_ring(cx, cy, ir, ig, ib, math_floor(ha * 0.24), outer, 0, 1, 1)
        renderer_line(cx - hs, cy - hs, cx - hs * 0.45, cy - hs * 0.45, 255, 255, 255, ha)
        renderer_line(cx + hs, cy - hs, cx + hs * 0.45, cy - hs * 0.45, 255, 255, 255, ha)
        renderer_line(cx - hs, cy + hs, cx - hs * 0.45, cy + hs * 0.45, 255, 255, 255, ha)
        renderer_line(cx + hs, cy + hs, cx + hs * 0.45, cy + hs * 0.45, 255, 255, 255, ha)
        renderer_line(cx - inner, cy, cx + inner, cy, ir, ig, ib, math_floor(ha * 0.26))
        renderer_line(cx, cy - inner, cx, cy + inner, ir, ig, ib, math_floor(ha * 0.26))
        draw_round_rect(cx - 2, cy - 2, 4, 4, 11, 14, 22, math_floor(ha * 0.38), 2)
        draw_round_rect(cx - 1, cy - 1, 2, 2, ir, ig, ib, ha, 1)
    end
end

local function draw_welcome()
    if vars.welcome_done or not ui_get(vis_welcome) then return end
    local sw, sh = client_screen_size()
    if not vars.welcome_fading then
        vars.welcome_alpha = lerp(vars.welcome_alpha, 255, globals_frametime() * 24)
        if vars.welcome_alpha > 210 then vars.welcome_progress = lerp(vars.welcome_progress, 150, globals_frametime() * 24) end
        if vars.welcome_progress > 149 then vars.welcome_fading = true end
    else
        vars.welcome_alpha = lerp(vars.welcome_alpha, 0, globals_frametime() * 24)
        if vars.welcome_alpha < 1 then vars.welcome_done = true end
    end
    if vars.welcome_alpha > 0 then
        local compact = ui_get(vis_hud_style) == "Mini"
        local ir, ig, ib = ui_get(vis_indicator_color)
        local pal = get_hud_palette(ir, ig, ib, vars.welcome_alpha / 255)
        local panel_w = math_floor((compact and 300 or 340) + vars.welcome_progress + 0.5)
        local panel_h = compact and 86 or 96
        local x = math_floor(sw * 0.5 - panel_w * 0.5)
        local y = math_floor(sh * 0.5 - panel_h * 0.5)
        local logo_w = compact and 52 or 60
        local shimmer = 0.72 + 0.28 * math_abs(math_sin(globals_realtime() * 2.1))
        local alpha_mul = vars.welcome_alpha / 255

        draw_blur(0, 0, sw, sh, math_floor(vars.welcome_alpha * 0.5), 6)
        draw_glass_panel(x, y, panel_w, panel_h, ir, ig, ib, 0.98 * alpha_mul, compact)
        draw_round_rect(x + 10, y + 10, logo_w, panel_h - 20, ir, ig, ib, math_floor(vars.welcome_alpha * 0.84), compact and 6 or 8)
        draw_round_rect(x + 16, y + 16, logo_w - 12, panel_h - 32, ir, ig, ib, math_floor(vars.welcome_alpha * 0.22 * shimmer), compact and 5 or 6)
        draw_text_shadow(x + 10 + logo_w * 0.5, y + panel_h * 0.5 - 8, 255, 255, 255, vars.welcome_alpha, "c", 0, compact and "CY" or "CYN")

        local title = animate_text(globals_realtime() * 2, "CYNICISM", 255, 255, 255, vars.welcome_alpha, ir, ig, ib, vars.welcome_alpha)
        renderer_text(x + logo_w + 30 + 1, y + 20 + 1, 0, 0, 0, math_floor(vars.welcome_alpha * 0.35), "", 0, "CYNICISM")
        renderer_text(x + logo_w + 30, y + 20, 255, 255, 255, vars.welcome_alpha, "", 0, title)
        draw_text_shadow(x + logo_w + 30, y + 46, pal.soft[1], pal.soft[2], pal.soft[3], math_floor(vars.welcome_alpha * 0.82), "", 0, "hysteria-inspired visual rebuild")
        draw_text_shadow(x + logo_w + 30, y + 64, pal.dim[1], pal.dim[2], pal.dim[3], math_floor(vars.welcome_alpha * 0.7), "", 0, "version " .. SCRIPT_VERSION .. "  |  glass HUD enabled")
        renderer_gradient(x + logo_w + 30, y + panel_h - 16, panel_w - logo_w - 44, 1, ir, ig, ib, math_floor(vars.welcome_alpha * 0.76), ir, ig, ib, 0, true)
    end
end

-- ===================== EVENT CALLBACKS =====================
local callbacks = {
    paint_ui = function()
        apply_scope_fov(); apply_aspect_ratio(); apply_clantag(); apply_console_filter()
        if ui.is_menu_open() then
            ui_set(info_session, "\\a8C78FFFF•  \\aFFFFFFFFSession: \\a8C78FFFF" .. get_session_time())
        end
        if ui_get(vis_scope_enable) then ui_set(vars.scope_overlay_ref, true) end
    end,
    paint = function() draw_indicators(); draw_welcome() end,
    setup_command = function(cmd)
        detect_state(cmd); update_combat_threat(); apply_antiaim(cmd); apply_fast_ladder(cmd); apply_jump_shot_air_stop(cmd)
    end,
    shutdown = function()
        local aa_refs = { refs.pitch[1], refs.pitch[2], refs.yaw_base, refs.yaw[1], refs.yaw[2],
            refs.yaw_jitter[1], refs.yaw_jitter[2], refs.body_yaw[1], refs.body_yaw[2],
            refs.freestanding_body_yaw, refs.freestanding[1], refs.freestanding[2], refs.edge_yaw, refs.roll }
        for _, r in ipairs(aa_refs) do ui.set_visible(r, true) end
        if vars.def_pred_owned then
            if vars.def_pred_restore ~= nil then
                ui_set(refs.fakelag_enabled[1], vars.def_pred_restore)
            end
            vars.def_pred_owned = false
            vars.def_pred_restore = nil
        end
        if vars.def_nchoke_owned then
            if vars.def_nchoke_restore ~= nil then
                ui_set(refs.fakelag_enabled[1], vars.def_nchoke_restore)
            end
            vars.def_nchoke_owned = false
            vars.def_nchoke_restore = nil
        end
        if vars.aspect_cvar then vars.aspect_cvar:set_float(0) end
    end,
    round_start = function() exploit_reset(); vars.yaw_tick = 0; vars.aa_dir = 0 end,
    player_death = function(e)
        local lp = entity_get_local_player()
        local attacker = client.userid_to_entindex(e.attacker)
        local victim = client.userid_to_entindex(e.userid)
        if victim == lp then
            exploit_reset(); vars.yaw_tick = 0
        end
        if has_multiselect(vis_combat_alerts, "Kill Alerts") then
            if attacker == lp and victim ~= lp then
                push_combat_notification("击杀", "击杀 " .. ((victim and entity.get_player_name(victim)) or "?"), { 120, 220, 255 }, 2.6)
            elseif victim == lp and attacker ~= lp then
                push_combat_notification("阵亡", "被 " .. ((attacker and entity.get_player_name(attacker)) or "?") .. " 击杀", { 255, 118, 118 }, 2.8)
            end
        end
        -- Killsay
        if attacker == lp and victim ~= lp and ui_get(killsay_enable) then
            local mode = ui_get(killsay_mode)
            local pool = mode == "R18" and killsay_r18 or killsay_normal
            local msg = pool[client.random_int(1, #pool)]
            client.exec("say " .. msg)
        end
    end,
    bullet_impact = function(e)
        local lp = entity_get_local_player()
        if not lp or not entity_is_alive(lp) then
            return
        end

        local enemy = client.userid_to_entindex(e.userid)
        if not enemy or enemy == lp or not entity_is_enemy(enemy) or not entity_is_alive(enemy) then
            return
        end

        if not fired_at_target(lp, enemy, { e.x, e.y, e.z }) then
            return
        end

        if vars.combat_last_impact_tick == globals_tickcount() then
            return
        end

        vars.combat_last_impact_tick = globals_tickcount()
        vars.combat_threat = "impact"
        vars.combat_threat_name = entity.get_player_name(enemy) or ("enemy-" .. enemy)
        vars.combat_threat_until = globals_realtime() + 0.65
        vars.combat_pred_until = globals_realtime() + 0.65

        if has_multiselect(vis_combat_alerts, "Incoming Shot") then
            push_combat_notification("危险", vars.combat_threat_name .. " 的子弹正在指向你", { 255, 128, 128 }, 2.4)
        end
    end,
    player_hurt = function(e) on_player_hurt_hitmarker(e) end,
    aim_fire = function(e) on_aim_fire(e) end,
    aim_hit = function(e) on_aim_hit(e) end,
    aim_miss = function(e) on_aim_miss(e) end,
    cs_game_disconnected = function() exploit_reset(); vars.yaw_tick = 0 end,
}

for event, cb in pairs(callbacks) do client_set_event_callback(event, cb) end

-- Register callbacks for elements that control visibility
local vis_elements = {
    active_tab, condition_selector, misc_features, spoof_enable, spoof_mode, vis_scope_enable, vis_indicators, vis_hud_style, vis_combat_alerts, vis_esp_preview, killsay_enable, vars.jump_shot_cb,
    vars.flctl_enable, vars.flctl_mode_ref, vars.flctl_onshot, vars.abf_enable
}
for i = 1, #builder do
    local b = builder[i]
    local b_elems = {
        b.enabled, b.pitch, b.yaw_mode, b.jitter_type, b.jitter_mode, b.body_yaw, b.body_delay_mode,
        b.def_enable, b.def_fake_flick, b.def_addons, b.desync_mode, b.def_pitch, b.def_yaw,
        b.def_wave_type, b.def_clock_dir, b.def_mode, b.def_profile, b.def_runtime, b.def_harden,
        b.def_harden_scale, b.def_tick_bias, b.def_tick_guard, b.def_tick_guard_window, b.def_check_mode,
        b.def_flick_trigger, b.def_flick_tick_mode, b.def_flick_tick_min, b.def_flick_tick_max,
        b.def_flick_cycle_speed, b.def_flick_jitter_repeat, b.def_flick_time, b.def_back_time, b.def_flick_packets,
        b.def_pred_enable, b.def_pred_mode, b.def_pred_flick, b.def_pred_back, b.def_pred_choke, b.def_flick_hidden,
        b.def_flick_limit, b.def_flick_desync_release, b.def_flick_desync_mode,
        b.def_duration_mode, b.def_duration_bias, b.def_duration_stages,
        b.delay_base, b.delay_mode, b.delay_jitter_speed, b.delay_jitter_var, b.backstab,
        b.def_delay_ticks, b.def_spin_start, b.def_spin_reverse
    }
    for _, e in ipairs(b_elems) do table.insert(vis_elements, e) end
end
for _, e in ipairs(vis_elements) do
    if e then ui.set_callback(e, update_visibility) end
end

update_visibility()
client.color_log(SCRIPT_COLOR.r, SCRIPT_COLOR.g, SCRIPT_COLOR.b, "[Cynicism] ", "Loaded v" .. SCRIPT_VERSION .. " | Super Lua")