local function NeutralizeAntiCheat()
    local ReplicatedStorage = game:GetService("ReplicatedStorage")
    local RunService = game:GetService("RunService")
    local LogService = game:GetService("LogService")
    local ScriptContext = game:GetService("ScriptContext")

    local targetNames = {
        report = true, checkEnvironment = true, checkLoadstring = true,
        checkIdentity = true, checkIntegrity = true, checkGui = true,
        fromLoadstring = true, scriptless = true,
    }

    local neutralized = {}
    for _, obj in ipairs(getgc(true)) do
        if type(obj) == "function" then
            local ok, name = pcall(debug.info, obj, "n")
            if ok and targetNames[name] then
                pcall(function() hookfunction(obj, newcclosure(function() end)) end)
                neutralized[name] = true
            end
        end
    end

    local function disconnectACConns(signal)
        pcall(function()
            for _, conn in ipairs(getconnections(signal)) do
                local ok, fn = pcall(function() return conn.Function end)
                if ok and fn then
                    local ups = {}
                    pcall(function() ups = getupvalues(fn) end)
                    for _, uv in pairs(ups) do
                        if type(uv) == "function" then
                            local uvOk, uvName = pcall(debug.info, uv, "n")
                            if uvOk and (uvName == "fromLoadstring" or uvName == "scriptless" or uvName == "report") then
                                pcall(function() conn:Disable() end)
                                break
                            end
                        end
                    end
                end
            end
        end)
    end

    disconnectACConns(LogService.MessageOut)
    disconnectACConns(ScriptContext.Error)
    disconnectACConns(RunService.Heartbeat)

    pcall(function()
        local Events = ReplicatedStorage:WaitForChild("Events", 10)
        if not Events then return end
        local ClientStats = Events:FindFirstChild("ClientStats")
        if not ClientStats then return end
        local oldFire = nil
        oldFire = hookfunction(ClientStats.FireServer, newcclosure(function(self, arg1, ...)
            if self == ClientStats and type(arg1) == "string" and arg1 == "R" then return end
            return oldFire(self, arg1, ...)
        end))
    end)

    pcall(function()
        local pg = game:GetService("Players").LocalPlayer:FindFirstChild("PlayerGui")
        if pg then
            for _, conn in ipairs(getconnections(pg.ChildAdded)) do
                local ok, fn = pcall(function() return conn.Function end)
                if ok and fn then
                    local fOk, fName = pcall(debug.info, fn, "n")
                    if fOk and fName == "checkGui" then pcall(function() conn:Disable() end) end
                end
            end
        end
    end)

    pcall(function()
        local Events = ReplicatedStorage:WaitForChild("Events", 10)
        local SafeRemote = Events and Events:FindFirstChild("Safe")
        if SafeRemote then SafeRemote:FireServer(true) end
    end)

    return neutralized
end

local _acResult = NeutralizeAntiCheat()

---------------------------------------------------------------------------
-- Patch DataModel metatable (Rivals obfuscates service names)
---------------------------------------------------------------------------
do
    local SERVICE_ALIASES = {
        Players=true, Workspace=true, Lighting=true,
        ReplicatedStorage=true, ReplicatedFirst=true,
        StarterGui=true, StarterPack=true, StarterPlayer=true,
        SoundService=true, TweenService=true, UserInputService=true,
        RunService=true, HttpService=true, MarketplaceService=true,
        TeleportService=true, TextService=true, CoreGui=true,
        Chat=true, Teams=true, CollectionService=true,
        VirtualInputManager=true, LogService=true,
        ScriptContext=true, ContentProvider=true,
        GuiService=true, ContextActionService=true,
    }
    local mt = getrawmetatable(game)
    local oldIndex = mt.__index
    setreadonly(mt, false)
    mt.__index = newcclosure(function(self, key)
        if self == game and type(key) == "string" and SERVICE_ALIASES[key] then
            local ok, svc = pcall(game.GetService, game, key)
            if ok and svc then return svc end
        end
        return oldIndex(self, key)
    end)
    setreadonly(mt, true)
end

---------------------------------------------------------------------------
-- Services
---------------------------------------------------------------------------
local Players           = game:GetService("Players")
local RunService        = game:GetService("RunService")
local UserInputService  = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Workspace         = game:GetService("Workspace")
local SoundService      = game:GetService("SoundService")

local LocalPlayer = Players.LocalPlayer
local Camera      = Workspace.CurrentCamera

---------------------------------------------------------------------------
-- Load Neverlose UI
---------------------------------------------------------------------------
local Library = loadstring(game:HttpGet(
    "https://raw.githubusercontent.com/ImInsane-1337/neverlose-ui/refs/heads/main/source/library.lua"
))()
Library.MenuKeybind = tostring(Enum.KeyCode.K)

---------------------------------------------------------------------------
-- State & Config
---------------------------------------------------------------------------
local STATE = {
    Running = true,
    Connections = {},
    ESPObjects = {},
    FOVCircle = nil,
    Whitelist = {},
    BlacklistMode = false,
    CurrentTarget = nil,
    Shooting = false,
    RainbowTraces = {},
    HitSoundObj = nil,
}

local HIT_SOUNDS = {
    {Name = "None", Id = 0},
    {Name = "F2 Critical Hit", Id = 1395087300},
    {Name = "F2 Critical Hit 2", Id = 142813515},
    {Name = "Metal Pipe", Id = 8406005582},
    {Name = "Bonk!", Id = 877221802},
    {Name = "Minecraft Hit", Id = 8766809464},
    {Name = "Windows XP Error", Id = 9066167010},
    {Name = "Vine Boom", Id = 4547965628},
    {Name = "Orchestra Hit", Id = 6380285152},
    {Name = "Sonic.EXE Laugh", Id = 7337298420},
    {Name = "Hitmarker", Id = 5630037419},
}

local function getHitSoundNames()
    local names = {}
    for _, s in ipairs(HIT_SOUNDS) do table.insert(names, s.Name) end
    return names
end

local function getHitSoundId(name)
    for _, s in ipairs(HIT_SOUNDS) do if s.Name == name then return s.Id end end
    return 0
end

local CFG = {
    -- Aimbot
    RageBot = false, AutoShoot = true,
    AimPart = "HeadHB", FOV = 500, VisibleCheck = true,
    TeamCheck = true, PredictMovement = true, PredictionScale = 0.08,
    AimSpeed = 1.0,

    -- Weapon
    NoSpread = true, NoRecoil = true, Wallbang = true,
    RapidFire = false, RapidFireMult = 0.4,
    TapFireDelay = 0.18,

    -- Rainbow Traces
    RainbowTraces = true, TraceFadeTime = 0.8, TraceThickness = 2,

    -- Hit Sound
    HitSound = "Hitmarker", HitSoundVolume = 1.0,

    -- ESP
    ESP_Enabled = false, ESP_Box = true,
    ESP_BoxColor = Color3.fromRGB(255, 30, 30),
    ESP_Name = true, ESP_NameColor = Color3.fromRGB(255, 255, 255),
    ESP_Health = true, ESP_Distance = true,
    ESP_Tracers = false, ESP_TracerColor = Color3.fromRGB(255, 30, 30),
    ESP_TracerOrigin = "Bottom",
    ESP_Highlight = true,
    ESP_HighlightFillColor = Color3.fromRGB(255, 0, 80),
    ESP_HighlightOutlineColor = Color3.fromRGB(255, 255, 255),
    ESP_HighlightFillTransparency = 0.5,
    ESP_Skeleton = false, ESP_SkeletonColor = Color3.fromRGB(255, 255, 255),
    ESP_ShowTeam = false, ESP_TeamColor = Color3.fromRGB(0, 200, 255),
    ESP_FOVCircle = true, ESP_FOVCircleColor = Color3.fromRGB(255, 255, 255),
}

---------------------------------------------------------------------------
-- Utilities
---------------------------------------------------------------------------
local function isAlive(player)
    local s = player:FindFirstChild("Status")
    if not s then return false end
    local a = s:FindFirstChild("Alive")
    return a and a.Value == true
end

local function getTeamValue(player)
    local s = player:FindFirstChild("Status")
    if not s then return nil end
    local tv = s:FindFirstChild("TeamValue")
    return tv and tv.Value or nil
end

local function isEnemy(player)
    if not CFG.TeamCheck then return player ~= LocalPlayer end
    if player == LocalPlayer then return false end
    local myTeam = getTeamValue(LocalPlayer)
    local theirTeam = getTeamValue(player)
    if not myTeam or not theirTeam then return true end
    return myTeam ~= theirTeam
end

local function shouldTarget(player)
    if player == LocalPlayer then return false end
    if CFG.TeamCheck and not isEnemy(player) then return false end
    if not isAlive(player) then return false end
    if not player.Character then return false end
    if STATE.BlacklistMode then
        if STATE.Whitelist[player.Name] then return false end
    else
        if next(STATE.Whitelist) ~= nil and not STATE.Whitelist[player.Name] then return false end
    end
    return true
end

local function getAimPart(character)
    return character:FindFirstChild(CFG.AimPart)
        or character:FindFirstChild("HeadHB")
        or character:FindFirstChild("Head")
        or character:FindFirstChild("UpperTorso")
        or character:FindFirstChild("HumanoidRootPart")
end

local function worldToScreen(pos)
    local v, onScreen = Camera:WorldToViewportPoint(pos)
    return Vector2.new(v.X, v.Y), onScreen, v.Z
end

local function screenCenter()
    return Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
end

local function isVisible(origin, target)
    if not CFG.VisibleCheck then return true end
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    local filter = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p.Character then table.insert(filter, p.Character) end
    end
    params.FilterDescendantsInstances = filter
    params.RespectCanCollide = true
    local ray = Workspace:Raycast(origin, (target - origin).Unit * (target - origin).Magnitude, params)
    return ray == nil
end

local function predictPosition(part)
    if not CFG.PredictMovement then return part.Position end
    local ok, vel = pcall(function() return part.AssemblyLinearVelocity end)
    if not ok then pcall(function() vel = part.Velocity end) end
    if vel and vel.Magnitude > 0.5 then return part.Position + vel * CFG.PredictionScale end
    return part.Position
end

---------------------------------------------------------------------------
-- Target Acquisition
---------------------------------------------------------------------------
local function getBestTarget()
    local best, bestDist = nil, CFG.FOV
    local center = screenCenter()

    for _, player in ipairs(Players:GetPlayers()) do
        if not shouldTarget(player) then continue end
        local char = player.Character
        if not char then continue end
        local aimPart = getAimPart(char)
        if not aimPart then continue end

        local pos = predictPosition(aimPart)
        local sp, onScreen, depth = worldToScreen(pos)
        if not onScreen or depth < 0 then continue end

        local d2d = (sp - center).Magnitude
        if d2d > CFG.FOV then continue end
        if CFG.VisibleCheck and not isVisible(Camera.CFrame.Position, pos) then continue end

        if d2d < bestDist then
            bestDist = d2d
            best = { Player = player, Character = char, AimPart = aimPart, Position = pos, ScreenPos = sp, Distance = d2d }
        end
    end

    STATE.CurrentTarget = best
    return best
end

---------------------------------------------------------------------------
-- AIMLOCK — Snaps camera to enemy head
---------------------------------------------------------------------------
local function installAimlock()
    local conn = RunService.RenderStepped:Connect(function()
        if not STATE.Running or not CFG.RageBot then return end
        if not isAlive(LocalPlayer) then return end

        local target = getBestTarget()
        if not target or not target.AimPart then return end

        local tPos = predictPosition(target.AimPart)
        local camPos = Camera.CFrame.Position
        local dir = (tPos - camPos).Unit

        if CFG.AimSpeed >= 1.0 then
            Camera.CFrame = CFrame.lookAt(camPos, tPos)
        else
            local currentLook = Camera.CFrame.LookVector
            local lerpedDir = currentLook:Lerp(dir, CFG.AimSpeed)
            Camera.CFrame = CFrame.lookAt(camPos, camPos + lerpedDir)
        end
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- AUTO-SHOOT — Tap-fire when aimlock has a target (no spray)
---------------------------------------------------------------------------
local function installAutoShoot()
    local lastTap = 0
    local tapDown = false
    local tapDownTime = 0

    local conn = RunService.Heartbeat:Connect(function()
        if not STATE.Running or not CFG.RageBot or not CFG.AutoShoot then
            if tapDown then mouse1release(); tapDown = false; STATE.Shooting = false end
            return
        end
        if not isAlive(LocalPlayer) then
            if tapDown then mouse1release(); tapDown = false; STATE.Shooting = false end
            return
        end

        local now = os.clock()

        if tapDown then
            if now - tapDownTime >= 0.06 then
                mouse1release()
                tapDown = false
                STATE.Shooting = false
            end
            return
        end

        if now - lastTap < CFG.TapFireDelay then return end

        local target = getBestTarget()

        if target then
            mouse1press()
            tapDown = true
            tapDownTime = now
            lastTap = now
            STATE.Shooting = true
        end
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- NO SPREAD — Zero spread values on weapon objects + module table
-- SAFE approach: zeros the inputs to spread calc, never touches ConeDirection
---------------------------------------------------------------------------
local function installNoSpread()
    local modTable = nil
    pcall(function()
        modTable = require(ReplicatedStorage.Modules.WeaponModule)
    end)

    local conn = RunService.RenderStepped:Connect(function()
        if not STATE.Running or not CFG.NoSpread then return end

        pcall(function()
            if modTable then
                modTable.SpreadModifier = 0
                if modTable.csaccuracy then modTable.csaccuracy = 0 end
                if modTable.shotsfired then modTable.shotsfired = 0 end
            end
        end)

        pcall(function()
            local char = LocalPlayer.Character
            if not char then return end
            local tool = char:FindFirstChildOfClass("Tool")
            if not tool then return end

            local spreadFolder = tool:FindFirstChild("Spread")
            if spreadFolder then
                if spreadFolder:FindFirstChild("Value") or spreadFolder:IsA("NumberValue") then
                    spreadFolder.Value = 0
                end
                local jump = spreadFolder:FindFirstChild("Jump")
                if jump then jump.Value = 0 end
                local move = spreadFolder:FindFirstChild("Move")
                if move then move.Value = 0 end
                local crouch = spreadFolder:FindFirstChild("Crouch")
                if crouch then crouch.Value = 0 end
            end

            local we = ReplicatedStorage:FindFirstChild("WeaponEngine")
            if we then
                local weapons = we:FindFirstChild("Weapons")
                if weapons then
                    for _, wep in ipairs(weapons:GetChildren()) do
                        local sp = wep:FindFirstChild("Spread")
                        if sp then
                            if sp:IsA("NumberValue") then sp.Value = 0 end
                            local j = sp:FindFirstChild("Jump"); if j then j.Value = 0 end
                            local m = sp:FindFirstChild("Move"); if m then m.Value = 0 end
                            local c = sp:FindFirstChild("Crouch"); if c then c.Value = 0 end
                        end
                    end
                end
            end
        end)
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- NO RECOIL — Zero recoil values on WeaponModule table every frame
---------------------------------------------------------------------------
local function installNoRecoil()
    local modTable = nil
    pcall(function()
        modTable = require(ReplicatedStorage.Modules.WeaponModule)
    end)
    if not modTable then return end

    local conn = RunService.RenderStepped:Connect(function()
        if not STATE.Running or not CFG.NoRecoil then return end
        pcall(function()
            modTable.KickBack = 0
            modTable.KickVel = 0
            modTable.KickPitch = 0
            modTable.RecoilX = 0
            modTable.RecoilY = 0
            modTable.CamRoll = 0
            modTable.JitterYaw = 0
            modTable.JitterPitch = 0
            modTable.px = 0
            modTable.py = 0
            modTable.pz = 0
            modTable.rec = 0
            modTable.rec2 = 0
            modTable.recs1 = 0
            modTable.recs2 = 0
        end)
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- WALLBANG — Max penetration on all weapons via GunConfig override
---------------------------------------------------------------------------
local function installWallbang()
    pcall(function()
        local GunConfig = require(ReplicatedStorage.Modules.GunConfig)
        if GunConfig and GunConfig.Penetration then
            GunConfig.Penetration.None = 999
            GunConfig.Penetration.Low = 999
            GunConfig.Penetration.Medium = 999
            GunConfig.Penetration.High = 999
        end
        if GunConfig and GunConfig.MinWallMul then
            GunConfig.MinWallMul = 1.0
        end
    end)

    local conn = RunService.Heartbeat:Connect(function()
        if not STATE.Running or not CFG.Wallbang then return end
        pcall(function()
            local we = ReplicatedStorage:FindFirstChild("WeaponEngine")
            if not we then return end
            local weapons = we:FindFirstChild("Weapons")
            if not weapons then return end
            for _, wep in ipairs(weapons:GetChildren()) do
                local pen = wep:FindFirstChild("Penetration")
                if pen and pen:IsA("IntValue") then
                    if pen.Value < 9999 then pen.Value = 9999 end
                end
            end
        end)
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- RAINBOW BULLET TRACES — Hook GunFX.Tracer to draw rainbow lines
---------------------------------------------------------------------------
local rainbowHue = 0

local function installRainbowTraces()
    pcall(function()
        local GunFX = require(ReplicatedStorage.Modules.GunFX)
        if not GunFX or not GunFX.Tracer then return end

        local origTracer = GunFX.Tracer
        GunFX.Tracer = function(fromPos, toPos, ...)
            origTracer(fromPos, toPos, ...)

            if not CFG.RainbowTraces or not Drawing then return end

            local startSP, startOn = worldToScreen(fromPos)
            local endSP, endOn = worldToScreen(toPos)
            if not startOn and not endOn then return end

            local segCount = 8
            local dir = toPos - fromPos

            for i = 0, segCount - 1 do
                local t0 = i / segCount
                local t1 = (i + 1) / segCount
                local p0 = fromPos + dir * t0
                local p1 = fromPos + dir * t1

                local s0, o0 = worldToScreen(p0)
                local s1, o1 = worldToScreen(p1)
                if not o0 and not o1 then continue end

                local hue = (rainbowHue + t0 * 0.5) % 1
                local color = Color3.fromHSV(hue, 1, 1)

                local line = Drawing.new("Line")
                line.From = s0
                line.To = s1
                line.Color = color
                line.Thickness = CFG.TraceThickness
                line.Transparency = 1
                line.Visible = true

                table.insert(STATE.RainbowTraces, {
                    Line = line,
                    SpawnTime = os.clock(),
                    Hue = hue,
                    From3D = p0,
                    To3D = p1,
                })
            end

            rainbowHue = (rainbowHue + 0.08) % 1
        end
    end)

    local conn = RunService.RenderStepped:Connect(function()
        if not STATE.Running then return end
        local now = os.clock()

        for i = #STATE.RainbowTraces, 1, -1 do
            local trace = STATE.RainbowTraces[i]
            local age = now - trace.SpawnTime
            local fadeTime = CFG.TraceFadeTime

            if age >= fadeTime then
                pcall(function() trace.Line:Remove() end)
                table.remove(STATE.RainbowTraces, i)
            else
                local alpha = 1 - (age / fadeTime)
                pcall(function()
                    trace.Line.Transparency = alpha

                    local cycleHue = (trace.Hue + now * 0.5) % 1
                    trace.Line.Color = Color3.fromHSV(cycleHue, 1, 1)

                    local s0, o0 = worldToScreen(trace.From3D)
                    local s1, o1 = worldToScreen(trace.To3D)
                    if o0 or o1 then
                        trace.Line.From = s0
                        trace.Line.To = s1
                        trace.Line.Visible = true
                    else
                        trace.Line.Visible = false
                    end
                end)
            end
        end
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- HIT SOUND SYSTEM — Custom sound on enemy hit
---------------------------------------------------------------------------
local function installHitSound()
    pcall(function()
        local soundObj = Instance.new("Sound")
        soundObj.Name = "RageHitSound"
        soundObj.Parent = SoundService
        soundObj.Volume = CFG.HitSoundVolume
        STATE.HitSoundObj = soundObj
    end)

    pcall(function()
        local Sounds = ReplicatedStorage:FindFirstChild("Sounds")
        if not Sounds then return end
        local bullet1 = Sounds:FindFirstChild("Bullet1")
        if not bullet1 then return end

        local origPlay = bullet1.Play
        hookfunction(bullet1.Play, newcclosure(function(self, ...)
            origPlay(self, ...)

            if not STATE.Running then return end
            local soundId = getHitSoundId(CFG.HitSound)
            if soundId == 0 then return end

            pcall(function()
                if STATE.HitSoundObj then
                    STATE.HitSoundObj.SoundId = "rbxassetid://" .. tostring(soundId)
                    STATE.HitSoundObj.Volume = CFG.HitSoundVolume
                    STATE.HitSoundObj:Play()
                end
            end)
        end))
    end)
end

local function previewHitSound(soundId)
    if soundId == 0 then return end
    pcall(function()
        if STATE.HitSoundObj then
            STATE.HitSoundObj.SoundId = "rbxassetid://" .. tostring(soundId)
            STATE.HitSoundObj.Volume = CFG.HitSoundVolume
            STATE.HitSoundObj:Play()
        end
    end)
end

---------------------------------------------------------------------------
-- RAPID FIRE
---------------------------------------------------------------------------
local function installRapidFire()
    local conn = RunService.Heartbeat:Connect(function()
        if not STATE.Running or not CFG.RapidFire then return end
        pcall(function()
            local WE = ReplicatedStorage:FindFirstChild("WeaponEngine")
            if not WE then return end
            local Weapons = WE:FindFirstChild("Weapons")
            if not Weapons then return end
            for _, weapon in ipairs(Weapons:GetChildren()) do
                local fr = weapon:FindFirstChild("FireRate")
                if fr and fr:IsA("NumberValue") and fr.Value > 0.05 then
                    fr.Value = fr.Value * CFG.RapidFireMult
                end
            end
        end)
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- ESP System
---------------------------------------------------------------------------
local SKELETON_JOINTS = {
    {"Head","UpperTorso"},{"UpperTorso","LowerTorso"},
    {"UpperTorso","LeftUpperArm"},{"LeftUpperArm","LeftLowerArm"},{"LeftLowerArm","LeftHand"},
    {"UpperTorso","RightUpperArm"},{"RightUpperArm","RightLowerArm"},{"RightLowerArm","RightHand"},
    {"LowerTorso","LeftUpperLeg"},{"LeftUpperLeg","LeftLowerLeg"},{"LeftLowerLeg","LeftFoot"},
    {"LowerTorso","RightUpperLeg"},{"RightUpperLeg","RightLowerLeg"},{"RightLowerLeg","RightFoot"},
}

local function createESP(player)
    if player == LocalPlayer or STATE.ESPObjects[player] then return end
    local esp = {SkeletonLines = {}}

    local hl = Instance.new("Highlight")
    hl.Name = string.rep(string.char(math.random(97,122)), 8)
    hl.FillTransparency = CFG.ESP_HighlightFillTransparency
    hl.OutlineTransparency = 0
    hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
    esp.Highlight = hl

    if Drawing then
        esp.Box = Drawing.new("Square"); esp.Box.Thickness = 1.5; esp.Box.Filled = false; esp.Box.Transparency = 1; esp.Box.Visible = false
        esp.BoxOutline = Drawing.new("Square"); esp.BoxOutline.Thickness = 3; esp.BoxOutline.Filled = false; esp.BoxOutline.Transparency = 0.5; esp.BoxOutline.Color = Color3.new(0,0,0); esp.BoxOutline.Visible = false
        esp.Name = Drawing.new("Text"); esp.Name.Size = 13; esp.Name.Center = true; esp.Name.Outline = true; esp.Name.OutlineColor = Color3.new(0,0,0); esp.Name.Visible = false; esp.Name.Text = player.DisplayName
        esp.Dist = Drawing.new("Text"); esp.Dist.Size = 12; esp.Dist.Center = true; esp.Dist.Outline = true; esp.Dist.OutlineColor = Color3.new(0,0,0); esp.Dist.Color = Color3.fromRGB(200,200,200); esp.Dist.Visible = false
        esp.HealthBg = Drawing.new("Square"); esp.HealthBg.Filled = true; esp.HealthBg.Transparency = 0.5; esp.HealthBg.Color = Color3.new(0,0,0); esp.HealthBg.Visible = false
        esp.HealthBar = Drawing.new("Square"); esp.HealthBar.Filled = true; esp.HealthBar.Transparency = 1; esp.HealthBar.Visible = false
        esp.HealthText = Drawing.new("Text"); esp.HealthText.Size = 11; esp.HealthText.Center = false; esp.HealthText.Outline = true; esp.HealthText.OutlineColor = Color3.new(0,0,0); esp.HealthText.Visible = false
        esp.Tracer = Drawing.new("Line"); esp.Tracer.Thickness = 1.2; esp.Tracer.Transparency = 0.8; esp.Tracer.Visible = false
        for i = 1, #SKELETON_JOINTS do local l = Drawing.new("Line"); l.Thickness = 1.5; l.Transparency = 1; l.Visible = false; esp.SkeletonLines[i] = l end
    end
    STATE.ESPObjects[player] = esp
end

local function removeESP(player)
    local esp = STATE.ESPObjects[player]
    if not esp then return end
    pcall(function() if esp.Highlight then esp.Highlight:Destroy() end end)
    for _, k in ipairs({"Box","BoxOutline","Name","Dist","HealthBg","HealthBar","HealthText","Tracer"}) do pcall(function() if esp[k] then esp[k]:Remove() end end) end
    for _, l in ipairs(esp.SkeletonLines) do pcall(function() l:Remove() end) end
    STATE.ESPObjects[player] = nil
end

local function hideESP(esp)
    for _, k in ipairs({"Box","BoxOutline","Name","Dist","HealthBg","HealthBar","HealthText","Tracer"}) do if esp[k] then esp[k].Visible = false end end
    for _, l in ipairs(esp.SkeletonLines) do l.Visible = false end
    if esp.Highlight then esp.Highlight.Adornee = nil; esp.Highlight.Parent = nil end
end

local function updateESP()
    for _, player in ipairs(Players:GetPlayers()) do
        if player == LocalPlayer then continue end
        local isEn = isEnemy(player)
        local show = CFG.ESP_Enabled and (isEn or CFG.ESP_ShowTeam)
        if not show then if STATE.ESPObjects[player] then hideESP(STATE.ESPObjects[player]) end continue end
        if not STATE.ESPObjects[player] then createESP(player) end
        local esp = STATE.ESPObjects[player]
        if not esp then continue end

        local char = player.Character
        if not char or not isAlive(player) then hideESP(esp); continue end
        local hrp = char:FindFirstChild("HumanoidRootPart")
        local head = char:FindFirstChild("HeadHB") or char:FindFirstChild("Head")
        local hum = char:FindFirstChildOfClass("Humanoid")
        if not hrp then hideESP(esp); continue end

        local color = isEn and CFG.ESP_BoxColor or CFG.ESP_TeamColor

        if esp.Highlight then
            if CFG.ESP_Highlight then
                esp.Highlight.FillColor = isEn and CFG.ESP_HighlightFillColor or CFG.ESP_TeamColor
                esp.Highlight.OutlineColor = CFG.ESP_HighlightOutlineColor
                esp.Highlight.FillTransparency = CFG.ESP_HighlightFillTransparency
                esp.Highlight.Adornee = char; esp.Highlight.Parent = char
            else esp.Highlight.Adornee = nil; esp.Highlight.Parent = nil end
        end

        if not Drawing then continue end
        local rootSP, rootOn, rootDepth = worldToScreen(hrp.Position)
        if not rootOn or rootDepth < 0 then hideESP(esp); continue end

        local headTop = head and worldToScreen(head.Position + Vector3.new(0,1.8,0)) or (rootSP - Vector2.new(0,45))
        local feetSP = worldToScreen(hrp.Position - Vector3.new(0,3,0))
        local boxH = math.abs(headTop.Y - feetSP.Y)
        local boxW = boxH * 0.55
        local boxX, boxY = rootSP.X - boxW/2, headTop.Y

        if esp.Box then esp.Box.Visible = CFG.ESP_Box; esp.Box.Size = Vector2.new(boxW, boxH); esp.Box.Position = Vector2.new(boxX, boxY); esp.Box.Color = color end
        if esp.BoxOutline then esp.BoxOutline.Visible = CFG.ESP_Box; esp.BoxOutline.Size = Vector2.new(boxW, boxH); esp.BoxOutline.Position = Vector2.new(boxX, boxY) end
        if esp.Name then esp.Name.Visible = CFG.ESP_Name; esp.Name.Position = Vector2.new(rootSP.X, boxY - 15); esp.Name.Color = CFG.ESP_NameColor; esp.Name.Text = player.DisplayName end
        if esp.Dist then
            local dist = (hrp.Position - Camera.CFrame.Position).Magnitude
            esp.Dist.Visible = CFG.ESP_Distance; esp.Dist.Position = Vector2.new(rootSP.X, feetSP.Y + 2); esp.Dist.Text = string.format("[%d studs]", math.floor(dist))
        end
        if esp.HealthBg and esp.HealthBar and hum then
            local frac = math.clamp(hum.Health / hum.MaxHealth, 0, 1)
            local barX = boxX - 6
            esp.HealthBg.Visible = CFG.ESP_Health; esp.HealthBg.Position = Vector2.new(barX-1, boxY); esp.HealthBg.Size = Vector2.new(5, boxH)
            esp.HealthBar.Visible = CFG.ESP_Health; esp.HealthBar.Position = Vector2.new(barX, boxY + boxH*(1-frac)); esp.HealthBar.Size = Vector2.new(3, boxH*frac)
            esp.HealthBar.Color = Color3.fromRGB(255*(1-frac), 255*frac, 0)
            if esp.HealthText then esp.HealthText.Visible = CFG.ESP_Health; esp.HealthText.Position = Vector2.new(barX-2, boxY + boxH*(1-frac) - 7); esp.HealthText.Text = tostring(math.floor(hum.Health)); esp.HealthText.Color = esp.HealthBar.Color end
        end
        if esp.Tracer then
            esp.Tracer.Visible = CFG.ESP_Tracers; esp.Tracer.Color = CFG.ESP_TracerColor
            local fromY = Camera.ViewportSize.Y
            if CFG.ESP_TracerOrigin == "Center" then fromY = Camera.ViewportSize.Y/2 elseif CFG.ESP_TracerOrigin == "Top" then fromY = 0 end
            esp.Tracer.From = Vector2.new(Camera.ViewportSize.X/2, fromY); esp.Tracer.To = Vector2.new(rootSP.X, feetSP.Y)
        end
        for i, joint in ipairs(SKELETON_JOINTS) do
            local line = esp.SkeletonLines[i]
            if line then
                if CFG.ESP_Skeleton then
                    local p1, p2 = char:FindFirstChild(joint[1]), char:FindFirstChild(joint[2])
                    if p1 and p2 and p1:IsA("BasePart") and p2:IsA("BasePart") then
                        local s1, o1 = worldToScreen(p1.Position); local s2, o2 = worldToScreen(p2.Position)
                        if o1 and o2 then line.From = s1; line.To = s2; line.Color = CFG.ESP_SkeletonColor; line.Visible = true
                        else line.Visible = false end
                    else line.Visible = false end
                else line.Visible = false end
            end
        end
    end
end

---------------------------------------------------------------------------
-- FOV Circle
---------------------------------------------------------------------------
local function setupFOVCircle()
    if not Drawing then return end
    STATE.FOVCircle = Drawing.new("Circle")
    STATE.FOVCircle.NumSides = 64; STATE.FOVCircle.Thickness = 1; STATE.FOVCircle.Filled = false; STATE.FOVCircle.Visible = false
    local conn = RunService.RenderStepped:Connect(function()
        if not STATE.Running or not STATE.FOVCircle then return end
        STATE.FOVCircle.Visible = CFG.ESP_FOVCircle and CFG.RageBot
        STATE.FOVCircle.Radius = CFG.FOV; STATE.FOVCircle.Color = CFG.ESP_FOVCircleColor; STATE.FOVCircle.Position = screenCenter()
    end)
    table.insert(STATE.Connections, conn)
end

---------------------------------------------------------------------------
-- Cleanup
---------------------------------------------------------------------------
local function cleanup()
    STATE.Running = false
    for _, c in ipairs(STATE.Connections) do pcall(function() c:Disconnect() end) end
    STATE.Connections = {}
    for p in pairs(STATE.ESPObjects) do removeESP(p) end
    if STATE.FOVCircle then pcall(function() STATE.FOVCircle:Remove() end); STATE.FOVCircle = nil end
    for _, trace in ipairs(STATE.RainbowTraces) do pcall(function() trace.Line:Remove() end) end
    STATE.RainbowTraces = {}
    if STATE.HitSoundObj then pcall(function() STATE.HitSoundObj:Destroy() end); STATE.HitSoundObj = nil end
    pcall(function() mouse1release() end)
end

local function getPlayerNames()
    local n = {}
    for _, p in ipairs(Players:GetPlayers()) do if p ~= LocalPlayer then table.insert(n, p.Name) end end
    return n
end

---------------------------------------------------------------------------
-- ═══════════════════ NEVERLOSE UI ═══════════════════
---------------------------------------------------------------------------
local Window = Library:Window({
    Name = "Rivals Rage Suite",
    SubName = "v6.0 Full Send",
    Logo = "95741420510574"
})

-- ═══ RAGE BOT ═══
local RagePage = Window:Page({Name = "Rage Bot", Icon = "100050851789190", Columns = 2})

local AimbotSection = RagePage:Section({Name = "Aimlock", Side = 1})
AimbotSection:Toggle({Name = "Enable Rage Bot", Default = false, Flag = "rage_enabled", Callback = function(v) CFG.RageBot = v end})
AimbotSection:Toggle({Name = "Auto Shoot", Default = true, Flag = "auto_shoot", Callback = function(v) CFG.AutoShoot = v end})
AimbotSection:Toggle({Name = "Visible Check", Default = true, Flag = "vis_check", Callback = function(v) CFG.VisibleCheck = v end})
AimbotSection:Toggle({Name = "Team Check", Default = true, Flag = "team_check", Callback = function(v) CFG.TeamCheck = v end})
AimbotSection:Toggle({Name = "Predict Movement", Default = true, Flag = "predict", Callback = function(v) CFG.PredictMovement = v end})
AimbotSection:Slider({Name = "FOV Radius", Min = 50, Max = 800, Default = 500, Flag = "fov", Callback = function(v) CFG.FOV = v end})
AimbotSection:Slider({Name = "Prediction Scale", Min = 1, Max = 30, Default = 8, Flag = "pred_scale", Callback = function(v) CFG.PredictionScale = v/100 end})
AimbotSection:Slider({Name = "Aim Speed", Min = 10, Max = 100, Default = 100, Suffix = "%", Flag = "aim_speed", Callback = function(v) CFG.AimSpeed = v/100 end})
AimbotSection:Dropdown({Name = "Aim Part", Items = {"HeadHB","Head","UpperTorso","LowerTorso","HumanoidRootPart"}, Default = "HeadHB", Flag = "aim_part", Callback = function(v) CFG.AimPart = v end})

local WeaponSection = RagePage:Section({Name = "Weapon Mods", Side = 2})
WeaponSection:Toggle({Name = "No Spread", Default = true, Flag = "no_spread", Callback = function(v) CFG.NoSpread = v end})
WeaponSection:Toggle({Name = "No Recoil", Default = true, Flag = "no_recoil", Callback = function(v) CFG.NoRecoil = v end})
WeaponSection:Toggle({Name = "Wallbang", Default = true, Flag = "wallbang", Callback = function(v) CFG.Wallbang = v end})
WeaponSection:Slider({Name = "Tap Fire Delay", Min = 8, Max = 50, Default = 18, Suffix = "x10ms", Flag = "tap_delay", Callback = function(v) CFG.TapFireDelay = v/100 end})
WeaponSection:Toggle({Name = "Rapid Fire", Default = false, Flag = "rapid_fire", Callback = function(v) CFG.RapidFire = v end})
WeaponSection:Slider({Name = "Fire Rate Mult %", Min = 10, Max = 100, Default = 40, Flag = "fire_rate_mult", Callback = function(v) CFG.RapidFireMult = v/100 end})

-- ═══ EFFECTS ═══
local FXPage = Window:Page({Name = "Effects", Icon = "123944728972740", Columns = 2})

local TraceSection = FXPage:Section({Name = "Rainbow Traces", Side = 1})
TraceSection:Toggle({Name = "Rainbow Bullet Traces", Default = true, Flag = "rainbow_traces", Callback = function(v) CFG.RainbowTraces = v end})
TraceSection:Slider({Name = "Trace Fade Time", Min = 2, Max = 30, Default = 8, Suffix = "x0.1s", Flag = "trace_fade", Callback = function(v) CFG.TraceFadeTime = v/10 end})
TraceSection:Slider({Name = "Trace Thickness", Min = 1, Max = 5, Default = 2, Flag = "trace_thick", Callback = function(v) CFG.TraceThickness = v end})

local SoundSection = FXPage:Section({Name = "Hit Sounds", Side = 2})
SoundSection:Dropdown({
    Name = "Hit Sound", Items = getHitSoundNames(), Default = "Hitmarker", Flag = "hit_sound",
    Callback = function(v) CFG.HitSound = v end
})
SoundSection:Slider({Name = "Volume", Min = 0, Max = 100, Default = 100, Suffix = "%", Flag = "hit_vol", Callback = function(v) CFG.HitSoundVolume = v/100 end})

SoundSection:Button({Name = "Preview: F2 Critical Hit", Callback = function() previewHitSound(1395087300) end})
SoundSection:Button({Name = "Preview: F2 Critical Hit 2", Callback = function() previewHitSound(142813515) end})
SoundSection:Button({Name = "Preview: Metal Pipe", Callback = function() previewHitSound(8406005582) end})
SoundSection:Button({Name = "Preview: Bonk!", Callback = function() previewHitSound(877221802) end})
SoundSection:Button({Name = "Preview: Minecraft Hit", Callback = function() previewHitSound(8766809464) end})
SoundSection:Button({Name = "Preview: Windows XP Error", Callback = function() previewHitSound(9066167010) end})
SoundSection:Button({Name = "Preview: Vine Boom", Callback = function() previewHitSound(4547965628) end})
SoundSection:Button({Name = "Preview: Orchestra Hit", Callback = function() previewHitSound(6380285152) end})
SoundSection:Button({Name = "Preview: Sonic.EXE Laugh", Callback = function() previewHitSound(7337298420) end})
SoundSection:Button({Name = "Preview: Hitmarker", Callback = function() previewHitSound(5630037419) end})

-- ═══ WHITELIST ═══
local WLPage = Window:Page({Name = "Whitelist", Icon = "100050851789190", Columns = 2})
local WLModeSection = WLPage:Section({Name = "Mode", Side = 1})
WLModeSection:Toggle({Name = "Blacklist Mode", Default = false, Flag = "blacklist_mode", Callback = function(v) STATE.BlacklistMode = v end})
WLModeSection:Toggle({Name = "Rage On Everyone", Default = true, Flag = "rage_all", Callback = function(v) if v then STATE.Whitelist = {} end end})

local WLPlayerSection = WLPage:Section({Name = "Players", Side = 2})
local wlDropdown = WLPlayerSection:Dropdown({
    Name = "Select Players", Items = getPlayerNames(), Multi = true, Flag = "wl_players",
    Callback = function(v)
        STATE.Whitelist = {}
        if type(v) == "table" then for name, sel in pairs(v) do if sel then STATE.Whitelist[name] = true end end end
    end
})
task.spawn(function() while STATE.Running do task.wait(5); pcall(function() wlDropdown:Refresh(getPlayerNames()) end) end end)

-- ═══ VISUALS ═══
local ESPPage = Window:Page({Name = "Visuals", Icon = "123944728972740", Columns = 2})

local ESPToggleSection = ESPPage:Section({Name = "ESP Toggles", Side = 1})
ESPToggleSection:Toggle({Name = "Enable ESP", Default = false, Flag = "esp_enabled", Callback = function(v) CFG.ESP_Enabled = v end})
ESPToggleSection:Toggle({Name = "Box ESP", Default = true, Flag = "esp_box", Callback = function(v) CFG.ESP_Box = v end})
ESPToggleSection:Toggle({Name = "Name ESP", Default = true, Flag = "esp_name", Callback = function(v) CFG.ESP_Name = v end})
ESPToggleSection:Toggle({Name = "Health Bar", Default = true, Flag = "esp_health", Callback = function(v) CFG.ESP_Health = v end})
ESPToggleSection:Toggle({Name = "Distance", Default = true, Flag = "esp_dist", Callback = function(v) CFG.ESP_Distance = v end})
ESPToggleSection:Toggle({Name = "Tracers", Default = false, Flag = "esp_tracers", Callback = function(v) CFG.ESP_Tracers = v end})
ESPToggleSection:Dropdown({Name = "Tracer Origin", Items = {"Bottom","Center","Top"}, Default = "Bottom", Flag = "tracer_origin", Callback = function(v) CFG.ESP_TracerOrigin = v end})
ESPToggleSection:Toggle({Name = "Highlight (Chams)", Default = true, Flag = "esp_highlight", Callback = function(v) CFG.ESP_Highlight = v end})
ESPToggleSection:Toggle({Name = "Skeleton ESP", Default = false, Flag = "esp_skeleton", Callback = function(v) CFG.ESP_Skeleton = v end})
ESPToggleSection:Toggle({Name = "Show Teammates", Default = false, Flag = "esp_team", Callback = function(v) CFG.ESP_ShowTeam = v end})
ESPToggleSection:Toggle({Name = "FOV Circle", Default = true, Flag = "esp_fov", Callback = function(v) CFG.ESP_FOVCircle = v end})

local ESPColorSection = ESPPage:Section({Name = "Colors", Side = 2})
ESPColorSection:Label("Box Color"):Colorpicker({Flag = "box_color", Default = Color3.fromRGB(255,30,30), Callback = function(c) CFG.ESP_BoxColor = c end})
ESPColorSection:Label("Name Color"):Colorpicker({Flag = "name_color", Default = Color3.fromRGB(255,255,255), Callback = function(c) CFG.ESP_NameColor = c end})
ESPColorSection:Label("Tracer Color"):Colorpicker({Flag = "tracer_color", Default = Color3.fromRGB(255,30,30), Callback = function(c) CFG.ESP_TracerColor = c end})
ESPColorSection:Label("Chams Fill"):Colorpicker({Flag = "chams_fill", Default = Color3.fromRGB(255,0,80), Callback = function(c) CFG.ESP_HighlightFillColor = c end})
ESPColorSection:Label("Chams Outline"):Colorpicker({Flag = "chams_outline", Default = Color3.fromRGB(255,255,255), Callback = function(c) CFG.ESP_HighlightOutlineColor = c end})
ESPColorSection:Label("Skeleton Color"):Colorpicker({Flag = "skel_color", Default = Color3.fromRGB(255,255,255), Callback = function(c) CFG.ESP_SkeletonColor = c end})
ESPColorSection:Label("Team Color"):Colorpicker({Flag = "team_color", Default = Color3.fromRGB(0,200,255), Callback = function(c) CFG.ESP_TeamColor = c end})
ESPColorSection:Slider({Name = "Chams Transparency", Min = 0, Max = 100, Default = 50, Flag = "chams_trans", Callback = function(v) CFG.ESP_HighlightFillTransparency = v/100 end})
ESPColorSection:Label("FOV Circle Color"):Colorpicker({Flag = "fov_color", Default = Color3.fromRGB(255,255,255), Callback = function(c) CFG.ESP_FOVCircleColor = c end})

-- ═══ MISC ═══
local MiscPage = Window:Page({Name = "Settings", Icon = "123944728972740", Columns = 2})
local ACSection = MiscPage:Section({Name = "Anti-Cheat", Side = 1})
local acCount = 0; for _ in pairs(_acResult or {}) do acCount = acCount + 1 end
ACSection:Button({Name = "AC Status: " .. acCount .. " neutralized", Callback = function()
    Library:Notification({Title = "AC Bypass", Description = acCount .. " AttachGuard functions gutted. ClientStats hooked.", Duration = 4})
end})

local ActionsSection = MiscPage:Section({Name = "Actions", Side = 2})
ActionsSection:Button({Name = "Kill Switch", Callback = function() cleanup(); Library:Unload() end})

---------------------------------------------------------------------------
-- ═══════════════════ INIT ═══════════════════
---------------------------------------------------------------------------
installAimlock()
installAutoShoot()
installNoSpread()
installNoRecoil()
installWallbang()
installRainbowTraces()
installHitSound()
installRapidFire()
setupFOVCircle()

for _, p in ipairs(Players:GetPlayers()) do createESP(p) end
Players.PlayerAdded:Connect(function(p) createESP(p) end)
Players.PlayerRemoving:Connect(function(p) removeESP(p) end)
local espConn = RunService.RenderStepped:Connect(function() if STATE.Running then updateESP() end end)
table.insert(STATE.Connections, espConn)

Library:Notification({Title = "Rivals Rage Suite v6.0", Description = "Full Send loaded. K to toggle UI.", Icon = "95741420510574", Duration = 5})