local game_id = 6035872082

if getgenv().HI_I_HAVE_BALL_CANCER == true or game.GameId ~= game_id then
	return
end

pcall(function() getgenv().HI_I_HAVE_BALL_CANCER = true end)
if not game:IsLoaded() then game.Loaded:Wait() end

if not LPH_OBFUSCATED then
	local DevApiKey = "ba17cd54606f49e16cee758e5930652b46128d6f09caf3dfa798e2b9bb8eaa44"
	local ScriptId = "43853841615976269471" -- Your script ID
	local Key = isfile("Aetherea/key.txt") and readfile("Aetherea/key.txt") or ""

	LPH_ENCNUM = function(toEncrypt, ...)
		assert(type(toEncrypt) == "number" and #{...} == 0, "LPH_ENCNUM only accepts a single double or integer as an argument.")
		return toEncrypt
	end
	LPH_NUMENC = LPH_ENCNUM

	LPH_ENCSTR = function(toEncrypt, ...)
		assert(type(toEncrypt) == "string" and #{...} == 0, "LPH_ENCSTR only accepts a single string as an argument.")
		return toEncrypt
	end
	LPH_STRENC = LPH_ENCSTR

	LPH_ENCFUNC = function(toEncrypt, encKey, decKey, ...)
		assert(type(toEncrypt) == "function" and type(encKey) == "string" and #{...} == 0, "LPH_ENCFUNC accepts a function, constant string, and string variable as arguments.")
		return toEncrypt
	end
	LPH_FUNCENC = LPH_ENCFUNC

	LPH_JIT = function(f, ...)
		assert(type(f) == "function" and #{...} == 0, "LPH_JIT only accepts a single function as an argument.")
		return f
	end
	LPH_JIT_MAX = LPH_JIT

	LPH_NO_VIRTUALIZE = function(f, ...)
		assert(type(f) == "function" and #{...} == 0, "LPH_NO_VIRTUALIZE only accepts a single function as an argument.")
		return f
	end

	LPH_NO_UPVALUES = function(f, ...)
		assert(type(setfenv) == "function", "LPH_NO_UPVALUES can only be used on Lua versions with getfenv & setfenv")
		assert(type(f) == "function" and #{...} == 0, "LPH_NO_UPVALUES only accepts a single function as an argument.")
		return f
	end

	LPH_CRASH = function(...)
		assert(#{...} == 0, "LPH_CRASH does not accept any arguments.")
		error("LPH_CRASH called")
	end

	LP_BLACKLIST = function(s, ...)
		assert(#{...} == 0, "LP_BLACKLIST only accepts 1 argument.")
		assert(type(s) == "string", "LP_BLACKLIST requires 1 string argument.")
		error("LP_BLACKLIST called: " .. s)
	end

	LP_VMIFY = function(f, ...)
		assert(type(f) == "function" and #{...} == 0, "LP_VMIFY only accepts a single function as an argument.")
		return f
	end

	LP_INIT = function(f, ...)
		assert(type(f) == "function" and #{...} == 0, "LP_INIT only accepts a single function as an argument.")
		task.spawn(f)
	end

	LP_DISCORD = "unknown"
	LP_DISCORD_ID = 0
	LP_KEYNOTE = ""
	LP_EXECUTIONS = 1
	LP_SCRIPT_EXECUTIONS = 1
	LP_FINGERPRINT = gethwid and gethwid() or "unknown"
	LP_TIMELEFT = 0
	LP_PREMIUM = true
	LP_SCRIPT_NAME = "RIVALS"
	LP_SCRIPT_VERSION = 1
	LP_SESSION_ID = "unknown"
	LP_SESSION_COUNT = 1

	LP_SECURE_REQUEST = (http and http.request) or request

	LP_SAVE_VALUE = function(key, value, overwrite)
		assert(type(key) == "string", "LP_SAVE_VALUE requires a string as first argument.")
		assert(type(value) ~= "string" and type(value) ~= "number" and type(value) ~= "boolean", "LP_SAVE_VALUE requires a string, number or boolean as second argument.")
	end

	LP_GET_VALUE = function(key)
		assert(type(key) == "string", "LP_GET_VALUE requires a string key.")
	end

	LP_DELETE_VALUE = function(key)
		assert(type(key) == "string", "LP_DELETE_VALUE requires a string key.")
	end
end

local function GetService(name)
    local service = game:GetService(name)
    return cloneref and cloneref(service) or service
end

local services = {
    CoreGui = GetService("CoreGui"),
    MarketplaceService = GetService("MarketplaceService"),
    ReplicatedFirst = GetService("ReplicatedFirst"),
    ReplicatedStorage = GetService("ReplicatedStorage"),
    Players = GetService("Players"),
    SoundService = GetService("SoundService"),
    RunService = GetService("RunService"),
    GuiService = GetService("GuiService"),
    Lighting = GetService("Lighting"),
    CollectionService = GetService("CollectionService"),
    TweenService = GetService("TweenService"),
    UserInputService = GetService("UserInputService"),
    ScriptContext = GetService("ScriptContext"),
    HttpService = GetService("HttpService")
}

local LocalPlayer = services.Players.LocalPlayer
local LocalChar;

local function GetCharacter()
	local character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()

	character:WaitForChild("Humanoid", 5)
	character:WaitForChild("HumanoidRootPart", 5)

	return character
end

LocalChar = GetCharacter()
LocalPlayer.CharacterAdded:Connect(function(char)
	LocalChar = char
	char:WaitForChild("Humanoid", 5)
	char:WaitForChild("HumanoidRootPart", 5)
end)

local TeleportCheck = false
LocalPlayer.OnTeleport:Connect(function()
	if (not TeleportCheck) and queueteleport then
		TeleportCheck = true

        local script = request({
            Url = "https://aetherea.lol/loader.luau",
            Method = "GET",
            Headers = {
                ["Content-Type"] = "application/json"
            }
        }).Body
        queueteleport(script)
	end
end)

--[[
    Bypass :shush:
]]

pcall(LPH_NO_VIRTUALIZE(function()
    local bypassed = false

    local kKickNames = {
        "Kick",
        "kick"
    }

    local kProtectedProperties = {
        Enabled = true,
        Disabled = false
    }

    local kSlotMap = {
        [69]  = 2,
        [138] = 3,
        [207] = 4,
        [276] = 5,
        [345] = 6,
        [414] = 7,
    }

    local kFilledSub = {
        1,
        2,
        3,
        4,
        5
    }

    local Players = cloneref(game:GetService("Players"))
    local ReplicatedFirst = cloneref(game:GetService("ReplicatedFirst"))
    local ReplicatedStorage = cloneref(game:GetService("ReplicatedStorage"))
    local ScriptContext = cloneref(game:GetService("ScriptContext"))

    local LocalPlayer = Players.LocalPlayer

    local ac_script = ReplicatedFirst:WaitForChild("LocalScript3")
    local ac_event = ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("RemoteEvent")

    local last = nil
    local first_seen = false
    local hijack_ready = false
    local client_id
    local expected_interval = 0.6
    local min_interval = 0.25
    local ema_alpha = 0.5
    local samples = 0
    local hidden_fn = {}
    local max_stack_depth = 128
    if not setstackhidden then
        local function ValidTraceback(s)
            local dotPos = string.find(s, "%.")
            local colonPos = string.find(s, ":")

            if not dotPos then
                return false
            end

            if not colonPos then
                return true
            end

            return dotPos < colonPos
        end

        local function TracebackLines(str, lvl)
            local pos = lvl
            return function()
                if not pos then
                    return nil
                end
                local p1, p2 = string.find(str, "\r?\n", pos)
                local line
                if p1 then
                    line = str:sub(pos, p1 - 1)
                    pos = p2 + 1
                else
                    line = str:sub(pos)
                    pos = nil
                end
                return line
            end
        end

        local old_dbg_traceback;
        old_dbg_traceback = hookfunction(getrenv().debug.traceback, function(...)
            if checkcaller() or not (pcall(old_dbg_traceback, ...)) then
                return old_dbg_traceback(...)
            end

            local StartingString, StackLevel = ...
            local Traceback = old_dbg_traceback(...)
            local NewTraceback = {}

            if typeof(StartingString) == "string" or typeof(StartingString) == "number" then
                table.insert(NewTraceback, tostring(StartingString))
            end

            if typeof(StackLevel) ~= "number" or not tonumber(StackLevel) then
                StackLevel = 1
            else
                StackLevel = math.floor(tonumber(StackLevel))
            end

            for Line in TracebackLines(Traceback, StackLevel) do
                if not ValidTraceback(Line) then
                    continue
                end

                table.insert(NewTraceback, Line)
            end

            return table.concat(NewTraceback, "\n") .. "\n"
        end)

        local old_dbg_info;
        old_dbg_info = hookfunction(getrenv().debug.info, function(...)
            local ToInspect, LevelOrInfo, _ThreadInfo = ...

            if
                checkcaller()
                or typeof(ToInspect) == "function"
                or typeof(ToInspect) == "thread"
                or not pcall(function(LevelOrInfo)
                    old_dbg_info(function() end, LevelOrInfo)
                end, LevelOrInfo)
            then
                return old_dbg_info(...)
            end

            ToInspect = math.floor(ToInspect)

            local ReconstructedConstructedStack = {}
            for Level = 2, max_stack_depth do
                local Function, Source, Line, Name, NumberOfArgs, Varargs = old_dbg_info(Level, "fslna")

                if not Function or not Source or not Line or not Name then
                    break
                end

                if isexecutorclosure(Function) and not hidden_fn[Function] then
                    continue
                end

                table.insert(ReconstructedConstructedStack, {
                    f = Function,
                    s = Source,
                    l = Line,
                    n = Name,
                    a = { NumberOfArgs, Varargs },
                })
            end

            local InfoLevel = ReconstructedConstructedStack[ToInspect + 1]

            if not InfoLevel then
                return old_dbg_info(3e4, LevelOrInfo)
            end

            local ReturnResult = {}
            for idx, info in string.split(LevelOrInfo, "") do
                local Value = InfoLevel[info]

                if typeof(Value) == "table" then
                    for _, v in Value do
                        table.insert(ReturnResult, v)
                    end

                    continue
                end

                table.insert(ReturnResult, Value)
            end

            return table.unpack(ReturnResult, 1, #ReturnResult)
        end)

        local old_getfenv;
        old_getfenv = hookfunction(getrenv().getfenv, function(...)
            if checkcaller() then
                return old_getfenv(...)
            end

            local ToInspect: (...any) -> (...any) | number = ...

            local Success, ResultingEnv = pcall(function()
                if typeof(ToInspect) == "number" and ToInspect >= 0 then
                    return old_getfenv(ToInspect + 3)
                end

                return old_getfenv(ToInspect)
            end)

            if not Success then
                if typeof(ToInspect) == "number" and ToInspect >= 0 then
                    return old_getfenv(ToInspect + 3)
                end

                return old_getfenv(ToInspect)
            end

            if ToInspect == nil or typeof(ToInspect) == "function" then
                return ResultingEnv
            end

            ToInspect = math.floor(ToInspect)

            local ReconstructedConstructedStack = {}
            for Level = 1, max_stack_depth do
                local StackInfoSuccess, Data = pcall(function()
                    return {
                        Environement = old_getfenv(Level + 3),
                        Function = old_dbg_info(Level + 3, "f"),
                    }
                end)

                if not StackInfoSuccess or not Data then
                    break
                end

                local Environement = Data.Environement
                local Function = Data.Function

                if typeof(Environement["getgenv"]) == "function" and isexecutorclosure(Environement["getgenv"]) then
                    if shared.Hooking.IncludeInStackFunctions[Function] then
                        Environement = setmetatable(ResultingEnv, {
                            __index = getrenv()
                        })
                    else
                        continue
                    end
                end

                table.insert(ReconstructedConstructedStack, Environement)
            end

            local InfoLevel = ReconstructedConstructedStack[ToInspect + 1]

            if not InfoLevel then
                return old_getfenv(3e4)
            end

            return InfoLevel
        end)
    end

    setstackhidden = setstackhidden or function(fn_or_level, hidden)
        assert(typeof(hidden) == "boolean", "hidden must be boolean")

        local ok, fn = pcall(function()
            if typeof(fn_or_level) == "number" then
                return debug.info(fn_or_level + 2, "f")
            end
            return fn_or_level
        end)

        assert(ok and fn, "invalid argument #1 to 'setstackhidden'")
        hidden_fn[fn] = not hidden
    end

    local TrustedFunctions = setmetatable({}, {
        __mode = "k"
    })

    local function TrustFunction(fn)
        if type(fn) == "function" then
            TrustedFunctions[fn] = true
        end

        return fn
    end

    local function IsTrustedFunction(fn)
        return TrustedFunctions[fn] == true
    end

    local SafeHook = function(hookfn, ...)
        local args = {...}
        local func, inst, metamethod, detour

        if hookfn == hookmetamethod then
            inst = args[1]
            metamethod = args[2]
            detour = args[3]
        else
            func = args[1]
            detour = args[2]
        end

        local original_func

        if hookfn == hookfunction and iscclosure(func) then
            detour = newcclosure(detour)
        end

        if not iscclosure(detour) then
            detour = newcclosure(detour)
        end

        setstackhidden(detour, true)

        local ok, _ = pcall(function()
            TrustFunction(detour)
                    
            if hookfn == hookmetamethod then
                original_func = hookfn(inst, metamethod, detour)
            else
                original_func = hookfn(func, detour)
            end
        end)

        if not ok then
            LocalPlayer:Kick("[AethSec]: Bypass failed! n1")
        end

        return original_func
    end

    local SafeCall = function(func, ...)
        if checkcaller() then
            return func(...)
        end

        local old = getthreadidentity()
        if old ~= 2 then
            setthreadidentity(2)
        end

        local result = {func(...)}

        if old ~= 2 then
            setthreadidentity(old)
        end

        return table.unpack(result)
    end

    local monitor_conn = ScriptContext.Error:Connect(TrustFunction(function(message, stack, _)
        message = tostring(message)
        stack = tostring(stack)
        if stack:find("PlayerScripts.Controllers.MiscellaneousController") and message:find("attempt to index number with number") then
            LocalPlayer:Kick("[AethSec]: Bypass failed! n2")
        end
    end))

    local oldindex; oldindex = SafeHook(hookmetamethod, ac_script, "__index", function(t, k)
        local is_caller = not bypassed and checkcaller()
        if t == ac_script and not is_caller and kProtectedProperties[k] ~= nil then
            return kProtectedProperties[k]
        end
        if checkcaller() then
            return oldindex(t, k)
        end
        return SafeCall(oldindex, t, k)
    end)

    local oldnewindex; oldnewindex = SafeHook(hookmetamethod, ac_script, "__newindex", function(t, k, v)
        local is_caller = not bypassed and checkcaller()
        if t == ac_script and not is_caller and kProtectedProperties[k] ~= nil then
            kProtectedProperties[k] = v
            if k == "Enabled" then
                kProtectedProperties["Disabled"] = not v
            end

            if k == "Disabled" then
                kProtectedProperties["Enabled"] = not v
            end
            return
        end
        if checkcaller() then
            return oldnewindex(t, k, v)
        end
        return SafeCall(oldnewindex, t, k, v)
    end)

    client_id = ""
    last = tick()

    local oldfireserver; oldfireserver = SafeHook(hookfunction, ac_event.FireServer, function(self, ...)
        local now = tick()
        local args = {...}

        if not first_seen then
            first_seen = true
            local first_arg = args[1]

            if type(first_arg) == "table" and #first_arg >= 1 and (type(first_arg[1]) == "string" or type(first_arg[1]) == "number") then
                client_id = tostring(first_arg[1])
            else
                client_id = client_id or ""
            end

            last = tick()
            samples = 1
            hijack_ready = true

            local res = SafeCall(oldfireserver, self, ...)
            return res
        end

        local interval = now - (last or now)

        if interval > 0 then
            if samples == 0 then
                expected_interval = interval
            else
                expected_interval = ema_alpha * interval + (1 - ema_alpha) * expected_interval
            end

            samples = samples + 1

            if expected_interval < min_interval then
                expected_interval = min_interval
            end
        end

        local res = SafeCall(oldfireserver, self, ...)
        last = tick()

        return res
    end)

    local BuildSubTable = function()
        local num_empty = math.random(1, 5)
        local empty_map = {}
        local empty_slots = {7}
        empty_map[7] = true

        while #empty_slots < num_empty do
            local slot = math.random(1, 6)
            if not empty_map[slot] then
                empty_map[slot] = true
                table.insert(empty_slots, slot)
            end
        end

        table.sort(empty_slots)

        local result = {}
        for i = 1, 7 do
            if empty_map[i] then
                result[i] = {}
            else
                result[i] = kFilledSub
            end
        end

        return result, empty_slots
    end

    local ApplyTransforms = function(t, mask, empty_slots)
        local payload = t[1]
        local outer_index = #payload
        local inner_index = empty_slots[math.random(1, #empty_slots)]
        local derived
        local outer_val = payload[outer_index]

        if type(outer_val) == "table" and type(inner_index) == "number" then
            derived = outer_val[inner_index]
        else
            for i = outer_index, 1, -1 do
                if type(payload[i]) ~= "table" then
                    continue
                end

                local candidate = payload[i]

                if type(inner_index) == "number" and candidate[inner_index] ~= nil then
                    derived = candidate[inner_index]
                    break
                else
                    derived = candidate
                    break
                end
            end

            if derived == nil then
                derived = {}
            end
        end

        local written = {}
        local kSlotMapRef = kSlotMap

        for _, value in ipairs(mask) do
            local slot = kSlotMapRef[value]
            if slot and not written[slot] then
                t[slot] = derived
                written[slot] = true
            end
        end

        return t
    end

    local BuildPayload = function(challenge, mask)
        local sub_table, empty_slots = BuildSubTable()
        local total_idx = math.random(1, 8)
        local payload = {client_id, buffer.tostring(challenge)}
        local extra_strings = math.random(0, 2)

        for _ = 1, extra_strings do
            payload[#payload + 1] = ""
        end

        while #payload < (total_idx - 1) do
            payload[#payload + 1] = math.random(5, 100000)
        end

        payload[#payload + 1] = sub_table

        local t = {
            payload,
            {},
            nil,
            nil,
            nil,
            nil,
            nil
        }
        return ApplyTransforms(t, mask, empty_slots)
    end

    task.spawn(function()
        getfenv().script = ac_script
        while not hijack_ready do
            task.wait()
        end

        ac_script.Enabled = false

        ac_event.OnClientEvent:Connect(function(...)
            last = tick()

            local remote = Instance.new("RemoteEvent", nil)
            remote:FireServer()

            local t = {...}
            local challenge = t[1]
            local index = t[2]
            local mask = t[3]

            if typeof(challenge) ~= "buffer" or type(index) ~= "number" or type(mask) ~= "table" then
                LocalPlayer:Kick("[AethSec]: Bypass failed! n3")
            end

            local payload = BuildPayload(challenge, mask)
            task.defer(function()
                local since_last = tick() - (last or 0)
                local desired_wait = expected_interval - since_last
                
                if desired_wait > 0 then
                    task.wait(desired_wait)
                end
                ac_event:FireServer(table.unpack(payload, 1, 5))
                last = tick()
                remote:Destroy()
            end)
        end)
            
        bypassed = true
        monitor_conn:Disconnect()
    end)

    for _, name in ipairs(kKickNames) do
        local func = LocalPlayer[name]
        if type(func) ~= "function" then return end
            
        local oldfunc; oldfunc = SafeHook(hookfunction, func, function(self, ...)
            if self == LocalPlayer and not checkcaller() then
                return nil
            end
            return oldfunc(self, ...)
        end)
    end

    for _, conn in ipairs(getconnections(ScriptContext.Error)) do
        if not conn.Function then continue end
        if IsTrustedFunction(conn.Function) then continue end
        SafeHook(hookfunction, conn.Function, function(...)
            return nil
        end)
    end

    SafeHook(hookfunction, ScriptContext.Error.Connect, function(...)
        return nil
    end)

    while not bypassed do
        task.wait(0.5)
    end
    task.wait(1)
end))

local NamecallDispatcher = {
    Hooks = {},
    Original = nil,
}

function NamecallDispatcher:Register(callback)
    self.Hooks[#self.Hooks + 1] = callback
    return #self.Hooks
end

function NamecallDispatcher:Unregister(index)
    table.remove(self.Hooks, index)
end

function NamecallDispatcher:Clear()
    table.clear(self.Hooks)
    table.clear(self.OrderedHooks)
end

function NamecallDispatcher:CallOriginal(object, ...)
    if self.Original then
        return self.Original(object, ...)
    end

    return nil
end

NamecallDispatcher.Original = hookmetamethod(game, "__namecall", newcclosure(LPH_NO_VIRTUALIZE(function(object, ...)
    local hooks = NamecallDispatcher.Hooks
    local count = #hooks

    if count == 0 then
        return NamecallDispatcher.Original(object, ...)
    end

    local method = getnamecallmethod()

    for i = 1, count do
        local result = hooks[i](object, method, ...)

        if result ~= nil and result ~= false then
            if result == true then
                return nil
            end

            return result
        end
    end

    return NamecallDispatcher.Original(object, ...)
end)))

local kConstants = {
    kBaseFolderName = "Aetherea",
    kBaseURL = "https://aetherea.lol/",

    kAethereaLogo = 1000000000,
    kLucideHome = 1,
    kLucideUser = 2,
    kLucideHeart = 64,
    kLucideClipboard = 69,
    kLucideCheckCircle = 29,
    kLucideCrosshair = 77,
    kLucideEye = 36,
    kLucideView = 78,
    kLucideSparkles = 76,
    kLucideSettings = 14,
    kLucideGlobe = 79,
    kLucideUnlock = 39,
    kLucideRainbow = 80,
    kLucideSmartphone = 81,
    kLucideList = 82,
    kLucideStar = 62,
    kLucideSearch = 4,
    kLucideBox = 83,
    kLucideCircleDollarSign = 84,
    kLucideVolume2 = 61,
    kLucideX = 5,
    kLucideCloud = 50,
    kLucideCat = 85,

    kCharmEloMap = {
        ["Unranked"] = -1,
        ["Bronze 1"] = 0,
        ["Bronze 2"] = 200,
        ["Bronze 3"] = 400,
        ["Silver 1"] = 600,
        ["Silver 2"] = 800,
        ["Silver 3"] = 1000,
        ["Gold 1"] = 1200,
        ["Gold 2"] = 1400,
        ["Gold 3"] = 1600,
        ["Platinum 1"] = 1800,
        ["Platinum 2"] = 2000,
        ["Platinum 3"] = 2200,
        ["Diamond 1"] = 2400,
        ["Diamond 2"] = 2600,
        ["Diamond 3"] = 2800,
        ["Onyx 1"] = 3000,
        ["Onyx 2"] = 3200,
        ["Onyx 3"] = 3400,
        ["Nemesis"] = 3600,
        ["Archnemesis"] = 3600,
    },

    kSeasonNameMap = {
        [0] = "Zero",
	    [1] = "Warp",
	    [2] = "Polar",
	    [3] = "Fame",
        ["Zero"] = 0,
	    ["Warp"] = 1,
	    ["Polar"] = 2,
	    ["Fame"] = 3,
    },

    kSeasonToggleMap = {
        [0] = "s0_charm",
        [1] = "s1_charm",
        [2] = "s2_charm",
        [3] = "s3_charm",
    },

    kFunctionsUsed = {
        "cloneref",
        "gethui",
        "isfolder",
        "makefolder",
        "isfile",
        "readfile",
        "writefile",
        "getcustomasset",
        "hookmetamethod",
        "hookfunction",
        "getcallingscript",
        "newcclosure",
        "getconnections",
        "checkcaller",
        "queueteleport",
        "getgenv",
        "base64decode"
    },

    kCosmeticTypes = {
        "Skin",
        "Wrap",
        "Charm",
        "Finisher"
    },

    kCosmeticRarities = {
        "Common",
        "Rare",
        "Legendary",
        "Mythical",
        "Unique",
        "Unobtainable"
    },

    kSoundMods = {
        "None",
        "Use Asset Id",
        "Use URL",
        "Bameware",
        "Bell",
        "Bubble",
        "Click",
        "Pop",
        "Rust",
        "Fart",
        "Big",
        "Vine",
        "Bruh",
        "Skeet",
        "Neverlose",
        "Fatality",
        "Bonk",
        "Minecraft",
    },

    kSoundModsMap = {
        ["Bameware"] = "ShootSounds/bameware.mp3",
        ["Bell"] = "ShootSounds/bell.mp3",
        ["Bubble"] = "ShootSounds/bubble.mp3",
        ["Click"] = "ShootSounds/click.mp3",
        ["Pop"] = "ShootSounds/pop.mp3",
        ["Rust"] = "ShootSounds/rust.mp3",
        ["Fart"] = "ShootSounds/fart.mp3",
        ["Big"] = "ShootSounds/big.mp3",
        ["Vine"] = "ShootSounds/vine.mp3",
        ["Bruh"] = "ShootSounds/bruh.mp3",
        ["Skeet"] = "ShootSounds/skeet.mp3",
        ["Neverlose"] = "ShootSounds/neverlose.mp3",
        ["Fatality"] = "ShootSounds/fatality.mp3",
        ["Bonk"] = "ShootSounds/bonk.mp3",
        ["Minecraft"] = "ShootSounds/minecraft.mp3",
    },

    kCharmRanks = {
        "Use Spoofed ELO",
        "Unranked",
        "Bronze 1",
        "Bronze 2",
        "Bronze 3",
        "Silver 1",
        "Silver 2",
        "Silver 3",
        "Gold 1",
        "Gold 2",
        "Gold 3",
        "Platinum 1",
        "Platinum 2",
        "Platinum 3",
        "Diamond 1",
        "Diamond 2",
        "Diamond 3",
        "Onyx 1",
        "Onyx 2",
        "Onyx 3",
        "Nemesis",
        "Archnemesis",
    },

    kOriginalHitmarkers = {
        kill_layer1 = "rbxassetid://16537449730",
        kill_layer2 = "rbxassetid://16537337310",
        hit = "rbxassetid://13110130082",
    },

    kShootSemanticKeys = {
        "Shoot",
        "Shoot1",
        "Shoot2",
        "Shoot3",
        "Shoot4",
        "FinalShoot",
        "EmptyShoot",
        "AltShoot",
        "AltShoot1",
        "ChargeShoot",
        "ChargeShootRelease",
    },

    kReloadSemanticKeys = {
        "Reload",
        "EmptyReload",
        "EmptyReloadStart",
        "EmptyReloadEnd",
        "ReloadInsert",
        "ReloadFinish",
        "TacticalReload",
    },

    kLootboxNames = {
        "Skin Case",
        "Skin Case 2",
        "Skin Case 3",
        "Wrap Box",
        "Wrap Box 2",
        "Wrap Box 3",
        "Charm Capsule",
        "Finisher Pack",
        "Finisher Pack 2",
        "Spooky Skin Case",
        "Haunted Chest",
        "Festive Skin Case",
        "Jolly Chest",
        "Festive Wrap Box",
        "Festive Wrap Box 2",
        "Goodie Bag",
        "Prime Goodie Bag",
        "Weapon Crate",
        "Standard Weapon Crate",
        "Prime Weapon Crate",
        "Contraband Weapon Crate",
    },

    kItemTypes = {
        "Skin",
        "Wrap",
        "Charm",
        "Finisher",
        "Emote"
    },

    kDuelResults = {
        "Victory",
        "Defeat"
    },

    kDuelMaps = {
        "Village",
        "Iceberg",
        "Backrooms",
        "Arena",
        "Dimension",
        "Bridge",
        "Museum",
        "Graveyard",
        "Studio",
        "Playground",
        "Splash",
        "Chess",
        "Construction",
        "Station",
        "Onyx",
        "Crossroads",
        "Docks",
        "Westown",
        "Big Arena",
        "Big Onyx",
        "Big Splash",
        "Big Backrooms",
        "Big Crossroads",
        "Big Graveyard",
        "Big Station",
        "Shooting Range",
        "Battleground",
        "Legacy Backrooms",
        "Legacy Big Splash",
        "Legacy Splash",
        "Legacy Docks",
        "Legacy Onyx",
        "Legacy Crossroads",
        "Legacy Battleground",
        "Baseplate",
        "Boss Arena",
        "Obby",
        "Zombie Tower",
        "Spleef",
        "Sandbox",
        "Factory",
    },

    kMaterialList = {
        "Asphalt",
        "Basalt",
        "Brick",
        "Cardboard",
        "Carpet",
        "CeramicTiles",
        "ClayRoofTiles",
        "Cobblestone",
        "Concrete",
        "CorrodedMetal",
        "CrackedLava",
        "DiamondPlate",
        "Fabric",
        "Foil",
        "ForceField",
        "Glacier",
        "Glass",
        "Ground",
        "Ice",
        "LeafyGrass",
        "Leather",
        "Limestone",
        "Marble",
        "Metal",
        "Mud",
        "Neon",
        "Pavement",
        "Pebble",
        "Plaster",
        "Plastic",
        "Rock",
        "RoofShingles",
        "Rubber",
        "Salt",
        "Sand",
        "Sandstone",
        "Slate",
        "SmoothPlastic",
        "Snow",
        "Wood",
        "WoodPlanks",
    },

    kMaterialMap = {
        ["Asphalt"] = Enum.Material.Asphalt,
        ["Basalt"] = Enum.Material.Basalt,
        ["Brick"] = Enum.Material.Brick,
        ["Cardboard"] = Enum.Material.Cardboard,
        ["Carpet"] = Enum.Material.Carpet,
        ["CeramicTiles"] = Enum.Material.CeramicTiles,
        ["ClayRoofTiles"] = Enum.Material.ClayRoofTiles,
        ["Cobblestone"] = Enum.Material.Cobblestone,
        ["Concrete"] = Enum.Material.Concrete,
        ["CorrodedMetal"] = Enum.Material.CorrodedMetal,
        ["CrackedLava"] = Enum.Material.CrackedLava,
        ["DiamondPlate"] = Enum.Material.DiamondPlate,
        ["Fabric"] = Enum.Material.Fabric,
        ["Foil"] = Enum.Material.Foil,
        ["ForceField"] = Enum.Material.ForceField,
        ["Glacier"] = Enum.Material.Glacier,
        ["Glass"] = Enum.Material.Glass,
        ["Ground"] = Enum.Material.Ground,
        ["Ice"] = Enum.Material.Ice,
        ["LeafyGrass"] = Enum.Material.LeafyGrass,
        ["Leather"] = Enum.Material.Leather,
        ["Limestone"] = Enum.Material.Limestone,
        ["Marble"] = Enum.Material.Marble,
        ["Metal"] = Enum.Material.Metal,
        ["Mud"] = Enum.Material.Mud,
        ["Neon"] = Enum.Material.Neon,
        ["Pavement"] = Enum.Material.Pavement,
        ["Pebble"] = Enum.Material.Pebble,
        ["Plaster"] = Enum.Material.Plaster,
        ["Plastic"] = Enum.Material.Plastic,
        ["Rock"] = Enum.Material.Rock,
        ["RoofShingles"] = Enum.Material.RoofShingles,
        ["Rubber"] = Enum.Material.Rubber,
        ["Salt"] = Enum.Material.Salt,
        ["Sand"] = Enum.Material.Sand,
        ["Sandstone"] = Enum.Material.Sandstone,
        ["Slate"] = Enum.Material.Slate,
        ["SmoothPlastic"] = Enum.Material.SmoothPlastic,
        ["Snow"] = Enum.Material.Snow,
        ["Wood"] = Enum.Material.Wood,
        ["WoodPlanks"] = Enum.Material.WoodPlanks,
    },

    kWordList = {
        "late",
        "couple",
        "economic",
        "obscure",
        "landscape",
        "spot",
        "college",
        "rainbow",
        "leg",
        "mixture",
        "frank",
        "commitment",
        "draft",
        "motivation",
        "fuss",
        "settle",
        "jelly",
        "confine",
        "pin",
        "modernize",
        "velvet",
        "quarter",
        "physical",
        "differ",
        "dish",
        "aisle",
        "happen",
        "council",
        "appeal",
        "depart",
        "urgency",
        "vessel",
    },

    kCameraStates = {
        "FirstPerson",
        "ThirdPerson",
        "ThirdPersonMirrored",
        "ThirdPersonUnlockedMouse",
        "CustomFreecam"
    },

    kSkyboxList = {
        "None",
        "Use Custom",
        "Aurora",
        "Battlerock",
        "Beach Bowl",
        "Buoy Base",
        "Clockwork",
        "Dark Matter",
        "Flash Black",
        "Ghostly",
        "Good Egg",
        "Melty Molten",
        "Shiverburn",
        "Spin Dig",
        "Sweet Mystery"
    },

    kSkyboxMap = {
        ["None"] = {
            skybox_back = "rbxassetid://14147881792",
            skybox_down = "rbxassetid://14147882149",
            skybox_front = "rbxassetid://14147882761",
            skybox_left = "rbxassetid://14147883091",
            skybox_right = "rbxassetid://14147882405",
            skybox_up = "rbxassetid://14147881297",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Aurora"] = {
            skybox_back = "rbxassetid://116533337330584",
            skybox_down = "rbxassetid://80054106187171",
            skybox_front = "rbxassetid://94459139270943",
            skybox_left = "rbxassetid://116368999680791",
            skybox_right = "rbxassetid://125758104196312",
            skybox_up = "rbxassetid://107060226443967",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Battlerock"] = {
            skybox_back = "rbxassetid://131136284306917",
            skybox_down = "rbxassetid://89505977207531",
            skybox_front = "rbxassetid://140099243548102",
            skybox_left = "rbxassetid://121676169821100",
            skybox_right = "rbxassetid://97183886241447",
            skybox_up = "rbxassetid://107128620201556",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Beach Bowl"] = {
            skybox_back = "rbxassetid://81804134601271",
            skybox_down = "rbxassetid://92395364196932",
            skybox_front = "rbxassetid://81804134601271",
            skybox_left = "rbxassetid://81804134601271",
            skybox_right = "rbxassetid://81804134601271",
            skybox_up = "rbxassetid://119089964803065",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Buoy Base"] = {
            skybox_back = "rbxassetid://135017685421888",
            skybox_down = "rbxassetid://76610044495625",
            skybox_front = "rbxassetid://89675413438577",
            skybox_left = "rbxassetid://138307087837279",
            skybox_right = "rbxassetid://136723547010707",
            skybox_up = "rbxassetid://83404878914838",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Clockwork"] = {
            skybox_back = "rbxassetid://86284761193226",
            skybox_down = "rbxassetid://111425663631622",
            skybox_front = "rbxassetid://115606366886873",
            skybox_left = "rbxassetid://127287488325060",
            skybox_right = "rbxassetid://126844150113423",
            skybox_up = "rbxassetid://74510789204352",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Dark Matter"] = {
            skybox_back = "rbxassetid://97629693450922",
            skybox_down = "rbxassetid://97898396690232",
            skybox_front = "rbxassetid://134755033418084",
            skybox_left = "rbxassetid://118219143707956",
            skybox_right = "rbxassetid://114940065588775",
            skybox_up = "rbxassetid://95430908943263",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Flash Black"] = {
            skybox_back = "rbxassetid://78426835654353",
            skybox_down = "rbxassetid://6213218651",
            skybox_front = "rbxassetid://71970982976722",
            skybox_left = "rbxassetid://78426835654353",
            skybox_right = "rbxassetid://78426835654353",
            skybox_up = "rbxassetid://138004866371717",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Ghostly"] = {
            skybox_back = "rbxassetid://111506743048183",
            skybox_down = "rbxassetid://86198196348228",
            skybox_front = "rbxassetid://86265514167302",
            skybox_left = "rbxassetid://100257959405445",
            skybox_right = "rbxassetid://71935101953120",
            skybox_up = "rbxassetid://132011089223498",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Good Egg"] = {
            skybox_back = "rbxassetid://94681381933012",
            skybox_down = "rbxassetid://75843838469806",
            skybox_front = "rbxassetid://97891957473259",
            skybox_left = "rbxassetid://102971518965494",
            skybox_right = "rbxassetid://94588890960775",
            skybox_up = "rbxassetid://127368871569815",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Melty Molten"] = {
            skybox_back = "rbxassetid://131463907527649",
            skybox_down = "rbxassetid://116154164311420",
            skybox_front = "rbxassetid://113077689016278",
            skybox_left = "rbxassetid://79984367513909",
            skybox_right = "rbxassetid://82395195737484",
            skybox_up = "rbxassetid://117530106700350",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Shiverburn"] = {
            skybox_back = "rbxassetid://113636030839991",
            skybox_down = "rbxassetid://118027268179499",
            skybox_front = "rbxassetid://76405010847029",
            skybox_left = "rbxassetid://112044353352688",
            skybox_right = "rbxassetid://121078604572355",
            skybox_up = "rbxassetid://132486295432727",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Spin Dig"] = {
            skybox_back = "rbxassetid://124211111366754",
            skybox_down = "rbxassetid://120491795220431",
            skybox_front = "rbxassetid://130119279111055",
            skybox_left = "rbxassetid://70742671331562",
            skybox_right = "rbxassetid://76516826791940",
            skybox_up = "rbxassetid://100229310567751",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Sweet Mystery"] = {
            skybox_back = "rbxassetid://107264897520277",
            skybox_down = "rbxassetid://135637946277638",
            skybox_front = "rbxassetid://135705252786048",
            skybox_left = "rbxassetid://119667604517747",
            skybox_right = "rbxassetid://75904303027092",
            skybox_up = "rbxassetid://97011146822716",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
        ["Terrace Dome"] = {
            skybox_back = "rbxassetid://98684100016510",
            skybox_down = "rbxassetid://108354040356521",
            skybox_front = "rbxassetid://95723629635852",
            skybox_left = "rbxassetid://106269064939837",
            skybox_right = "rbxassetid://136234415079744",
            skybox_up = "rbxassetid://75385962780878",
            sun_texture = "rbxasset://sky/sun.jpg",
            moon_texture = "rbxasset://sky/moon.jpg",
        },
    },

    kLightingStyles = {
        "Realistic",
        "Soft"
    },

    kLightingStyleMap = {
        ["Realistic"] = Enum.LightingStyle.Realistic,
        ["Soft"] = Enum.LightingStyle.Soft
    },

    kWeatherTypes = {
        "Rain",
        "Snow",
        "Thunder"
    },

    kAmbienceTypes = {
        "Rain",
        "City",
        "Windy Day",
        "Thunder",
        "Forest Rain Night",
        "Light Rain And Thunder"
    },

    kAmbienceMap = {
        ["Rain"] = "rbxassetid://9112858162",
        ["City"] = "rbxassetid://238385471",
        ["Windy Day"] = "rbxassetid://159798309",
        ["Thunder"] = "rbxassetid://9064263922",
        ["Forest Rain Night"] = "rbxassetid://5356133579",
        ["Light Rain And Thunder"] = "rbxassetid://9120018695",
    },

    kViewmodelDisable = {
        "None",
        "sway",
        "tilt",
        "bobbing",
        "muzzle flash",
        "idle animation",
        "jump animation",
        "slide animation",
        "equip animation",
        "shoot animation",
        "aiming animation",
        "sprint animation"
    },

    kGunIgnoreList = {
        "None",
        "Katana",
        "Riot Shield"
    },

    kCharacterAnims = {
        "Default",
        "Zombie",
        "Oldschool",
        "Bubbly",
        "Elder",
        "Ninja",
        "Vampire",
        "Stylish",
        "Levitation",
        "Superhero",
        "Werewolf",
        "Knight",
        "Pirate"
    },

    kCharacterAnimsMap = {
        ["Default"] = {
            idle = "http://www.roblox.com/asset/?id=507766388",
            walk = "rbxassetid://10921541949",
            run = "rbxassetid://10899968825",
            jump = "http://www.roblox.com/asset/?id=507765000",
            fall = "http://www.roblox.com/asset/?id=507767968",
            climb = "http://www.roblox.com/asset/?id=507765644",
        },
        ["Zombie"] = {
            idle = "http://www.roblox.com/asset/?id=10921344533",
            walk = "http://www.roblox.com/asset/?id=10921355261",
            run = "http://www.roblox.com/asset/?id=616163682",
            jump = "http://www.roblox.com/asset/?id=10921351278",
            fall = "http://www.roblox.com/asset/?id=10921350320",
            climb = "http://www.roblox.com/asset/?id=10921343576",
        },
        ["Oldschool"] = {
            idle = "http://www.roblox.com/asset/?id=10921230744",
            walk = "http://www.roblox.com/asset/?id=10921244891",
            run = "http://www.roblox.com/asset/?id=10921240218",
            jump = "http://www.roblox.com/asset/?id=10921242013",
            fall = "http://www.roblox.com/asset/?id=10921241244",
            climb = "http://www.roblox.com/asset/?id=10921229866",
        },
        ["Bubbly"] = {
            idle = "http://www.roblox.com/asset/?id=10921054344",
            walk = "http://www.roblox.com/asset/?id=10980888364",
            run = "http://www.roblox.com/asset/?id=10921057244",
            jump = "http://www.roblox.com/asset/?id=10921062673",
            fall = "http://www.roblox.com/asset/?id=10921061530",
            climb = "http://www.roblox.com/asset/?id=10921053544",
        },
        ["Elder"] = {
            idle = "http://www.roblox.com/asset/?id=10921101664",
            walk = "http://www.roblox.com/asset/?id=10921111375",
            run = "http://www.roblox.com/asset/?id=10921104374",
            jump = "http://www.roblox.com/asset/?id=10921107367",
            fall = "http://www.roblox.com/asset/?id=10921105765",
            climb = "http://www.roblox.com/asset/?id=10921100400",
        },
        ["Ninja"] = {
            idle = "http://www.roblox.com/asset/?id=10921155160",
            walk = "http://www.roblox.com/asset/?id=10921162768",
            run = "http://www.roblox.com/asset/?id=10921157929",
            jump = "http://www.roblox.com/asset/?id=10921160088",
            fall = "http://www.roblox.com/asset/?id=10921159222",
            climb = "http://www.roblox.com/asset/?id=10921154678",
        },
        ["Vampire"] = {
            idle = "http://www.roblox.com/asset/?id=10921315373",
            walk = "http://www.roblox.com/asset/?id=10921326949",
            run = "http://www.roblox.com/asset/?id=10921320299",
            jump = "http://www.roblox.com/asset/?id=10921322186",
            fall = "http://www.roblox.com/asset/?id=10921321317",
            climb = "http://www.roblox.com/asset/?id=10921314188",
        },
        ["Stylish"] = {
            idle = "http://www.roblox.com/asset/?id=10921272275",
            walk = "http://www.roblox.com/asset/?id=10921283326",
            run = "http://www.roblox.com/asset/?id=10921276116",
            jump = "http://www.roblox.com/asset/?id=10921279832",
            fall = "http://www.roblox.com/asset/?id=10921278648",
            climb = "http://www.roblox.com/asset/?id=10921271391",
        },
        ["Levitation"] = {
            idle = "http://www.roblox.com/asset/?id=10921132962",
            walk = "http://www.roblox.com/asset/?id=10921140719",
            run = "http://www.roblox.com/asset/?id=10921135644",
            jump = "http://www.roblox.com/asset/?id=10921137402",
            fall = "http://www.roblox.com/asset/?id=10921136539",
            climb = "http://www.roblox.com/asset/?id=10921132092",
        },
        ["Superhero"] = {
            idle = "http://www.roblox.com/asset/?id=10921288909",
            walk = "http://www.roblox.com/asset/?id=10921298616",
            run = "http://www.roblox.com/asset/?id=10921291831",
            jump = "http://www.roblox.com/asset/?id=10921294559",
            fall = "http://www.roblox.com/asset/?id=10921293373",
            climb = "http://www.roblox.com/asset/?id=10921286911",
        },
        ["Werewolf"] = {
            idle = "http://www.roblox.com/asset/?id=10921330408",
            walk = "http://www.roblox.com/asset/?id=10921342074",
            run = "http://www.roblox.com/asset/?id=10921336997",
            jump = "http://www.roblox.com/asset/?id=1083218792",
            fall = "http://www.roblox.com/asset/?id=10921337907",
            climb = "http://www.roblox.com/asset/?id=10921329322",
        },
        ["Knight"] = {
            idle = "http://www.roblox.com/asset/?id=10921117521",
            walk = "http://www.roblox.com/asset/?id=10921127095",
            run = "http://www.roblox.com/asset/?id=10921121197",
            jump = "http://www.roblox.com/asset/?id=10921123517",
            fall = "http://www.roblox.com/asset/?id=10921122579",
            climb = "http://www.roblox.com/asset/?id=10921116196",
        },
        ["Pirate"] = {
            idle = "http://www.roblox.com/asset/?id=750781874",
            walk = "http://www.roblox.com/asset/?id=750785693",
            run = "http://www.roblox.com/asset/?id=750783738",
            jump = "http://www.roblox.com/asset/?id=750782230",
            fall = "http://www.roblox.com/asset/?id=750780242",
            climb = "http://www.roblox.com/asset/?id=750779899",
        },
    },

    kLerpPos = {
        "None",
        "Target",
        "Barrel"
    },

    kTargetList = {
        "FOV",
        "Visible",
    },

    kBodyParts = {
        "Head",
        "HumanoidRootPart",
        "UpperTorso",
        "LowerTorso",
        "LeftFoot",
        "LeftLowerLeg",
        "LeftUpperLeg",
        "RightFoot",
        "RightLowerLeg",
        "RightUpperLeg",
        "LeftHand",
        "LeftLowerArm",
        "LeftUpperArm",
        "RightHand",
        "RightLowerArm",
        "RightUpperArm",
    },
    
    kCheckScoped = {
        "None",
        "Sniper",
        "Crossbow"
    },
    
    kPitchOptions = {
        "None",
        "Offset",
        "Custom",
        "Random",
        "Look Up",
        "Look Down",
    },

    kYawOptions = {
        "None",
        "Offset",
        "Custom",
        "Random",
        "Spin",
        "Jitter",
        "Backwards",
    },
}

local modules = {
    CONSTANTS = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("CONSTANTS")),
    AnimationLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("AnimationLibrary")),
    SoundLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("SoundLibrary")),
    CosmeticLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("CosmeticLibrary")),
    ItemLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("ItemLibrary")),
    PlayerDataController = require(LocalPlayer.PlayerScripts:FindFirstChild("Controllers"):WaitForChild("PlayerDataController")),
    EnumLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("EnumLibrary")),
    LeaderboardController = require(LocalPlayer.PlayerScripts:FindFirstChild("Controllers"):WaitForChild("LeaderboardController")),
    ControlsController = require(LocalPlayer.PlayerScripts:FindFirstChild("Controllers"):WaitForChild("ControlsController")),
    SeasonLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("SeasonLibrary")),
    ShopLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("ShopLibrary")),
    GameplayUtility = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("GameplayUtility")),
    InspectBackpackReward = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("Prompts"):WaitForChild("InspectBackpackReward")),
    LootboxEffect = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("Functions"):WaitForChild("LootboxEffect")),
    MonetizationController = require(LocalPlayer.PlayerScripts:FindFirstChild("Controllers"):WaitForChild("MonetizationController")),
    MonetizationLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("MonetizationLibrary")),
    SendChat = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("Functions"):WaitForChild("SendChat")),
    CameraController = require(LocalPlayer.PlayerScripts:FindFirstChild("Controllers"):WaitForChild("CameraController")),
    DuelLibrary = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("DuelLibrary")),
    Gun = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("ItemTypes"):WaitForChild("Gun")),
    Melee = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("ItemTypes"):WaitForChild("Melee")),
    Throwable = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("ItemTypes"):WaitForChild("Throwable")),
    Flashbang = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("Items"):WaitForChild("Flashbang")),
    SmokeClouds = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("GameComponents"):WaitForChild("SmokeClouds")),
    Utility = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("Utility")),
    OutOfBoundsMachine = require(services.ReplicatedStorage:FindFirstChild("Modules"):WaitForChild("OutOfBoundsMachine")),
    MechanicsController = require(LocalPlayer.PlayerScripts:FindFirstChild("Controllers"):WaitForChild("MechanicsController")),
    Knife = require(LocalPlayer.PlayerScripts:FindFirstChild("Modules"):WaitForChild("Items"):WaitForChild("Knife")),
    ClientEntity = require(LocalPlayer.PlayerScripts.Modules.ClientReplicatedClasses:FindFirstChild("ClientEntity")),
}

task.spawn(function()
    local fc = LocalPlayer.PlayerScripts:FindFirstChild("Controllers"):WaitForChild("FighterController")
    if fc then
        pcall(function()
            modules.FighterController = require(fc)
        end)
    end
end)

while not modules.FighterController do task.wait(0.5) end

local shoot_anim_names  = {}  -- [name] = true
local reload_anim_names = {}  -- [name] = true

local states = {
    target = nil,
    target_part = nil,
    server_cf = nil,
    is_reloading = false,
    screen_gui = Instance.new("ScreenGui"),
    targeting_state = {
        target_group = "Visible",
        ignore = { "None" },
        radius = 100,
        max_distance = 150,
        weight_ratio = 0.7,
        reaction_time = 0,
        forget_time = 1,
        target = "Closest Part",
        include_parts = { "Head", "UpperTorso" },

        wallcheck = true,
        show_fov = false,

        fov_outline = false,
        fov_fill = false,
        fov_lerp = 1,

        fov_rotation = 0,
        fov_rotation_speed = 1,

        fov_start_color = Color3.fromRGB(255, 255, 255),
        fov_mid_color = Color3.fromRGB(255, 255, 255),
        fov_end_color = Color3.fromRGB(255, 255, 255),

        fov_outline_start_color = Color3.fromRGB(0, 0, 0),
        fov_outline_mid_color = Color3.fromRGB(0, 0, 0),
        fov_outline_end_color = Color3.fromRGB(0, 0, 0),

        fov_transparency = 0,
        fov_outline_transparency = 0,

        fov_position = { ["None"] = true },

        blocking = {},
    },
    legit_state = {
        silent_aim = {
            enabled = false,
            hit_chance = 100,
            manipulation = false,
            visualize = false,
        },
        triggerbot = {
            enabled = false,
            shoot_delay = 0,
            check_scoped = { "Sniper", "Crossbow" },

            triggerbot_shot_started = Instance.new("BindableEvent"),
            triggerbot_shot_finished = Instance.new("BindableEvent"),
            triggerbot_active = false,
        }
    },
    rage_state = {
        weapons = {
            no_recoil = false,
            no_spread = false,
            full_auto = false,
            firerate = 100,
        },
        pluggwalk = {
            enabled = false,
        },
        misc = {
            anti_tripmine = false,
            tp_throwables = false,
        },
        rage_bot = {
            enabled = false,
            void_spam = false,
            hide = 0.25,
            attack = 0.1,
            shoot_attempts = 1,
            attack_mode = "Gun",
            preferred = "Primary",
            hit_notifications = true,
            rage_hud = true,

            sync_void_state = Instance.new("BindableEvent"),
        },
        anti_aim = {
            enabled = false,
            pitch = "None",
            pitch_angle = 0,
            yaw = "None",
            yaw_angle = 0,
            jitter_angle = 20,
            speed = 10,
            underground = false,
        },
        movement = {
            fly = false,
            velocity = false,
            slide_boost = false,
            double_jump_height = false,
            infinite_double_jump = false,

            fly_speed = 50,
            velocity_speed = 50,
            slide_boost_value = 1,
            double_jump_height_value = 1,
        }
    },
    visuals_state = {
        visuals_enabled = false,
        teammates = false,
        team_colors = false,
        target_highlights = false,
        box_filled = false,
        tracer_origin = "Bottom",
        outlines = {
            Box = false,
            Skeletons = false,
            Chams = false,
            Health = false,
            Name = false,
            Tracers = false,
            Weapon = false,
            Distance = false
        },
        trails = {
            Bullets = false,
            Throwables = false,
        },
        max_distance = 150,
        cham_material = "ForceField",
        cham_texture = 0,
        viewmodel = {
            disable = { "None" },
            override_fps = false,
            fps_multi = 60,
            chams = false,
            cham_material = "ForceField",
            cham_texture = 0,
            cham_transparency = 0,
            offset = false,
            x_offset = 0,
            y_offset = 0,
            z_offset = 0,

            appearance = false,
            color = Color3.fromRGB(181, 126, 220),
            transparency = 0,
            material = "ForceField",
            wireframe = false,
            no_textures = false,
            no_clothes = false,

            appearance_cache = {},
            wireframe_cache = {},

            vm_cham_model = nil,
            vm_cham_model_name = nil,
            vm_cham_connections = {},
            vm_cham_parts = {},
        },
        animations = {
            char_anims = "Default"
        },
        skybox = {
            skybox_value = "None",
            skybox_back = "",
            skybox_down = "",
            skybox_front = "",
            skybox_left = "",
            skybox_right = "",
            skybox_up = "",
            sun_texture = "",
            moon_texture = "",
            star_count = 3000,
            sun_angular_size = 21,
            moon_angular_size = 11,
            clocktime = services.Lighting.ClockTime,

            auto_rotate = false,
            auto_rotate_conn = nil,
            auto_rotate_speed = 1
        },
        crosshair = {
            enabled = false,
            fill_color = Color3.fromRGB(255, 255, 255),
            outline_color = Color3.fromRGB(0, 0, 0),
            rotation = 0,
            rotation_speed = 0.5,
            bounce = 0,
            bounce_speed = 0.1,
            offset = 5,
            length = 20,
            thickness = 2,
            lerp = 1,
            position = { "None" },
        },
        colors = {
            enemy_box_fill_color = Color3.fromRGB(106, 13, 173),
            enemy_box_outline_color = Color3.fromRGB(181, 126, 220),
            enemy_tracer_color = Color3.fromRGB(131, 38, 198),
            enemy_chams_fill_color = Color3.fromRGB(106, 13, 173),

            friendly_box_outline_color = Color3.fromRGB(120, 180, 255),
            friendly_box_fill_color = Color3.fromRGB(50, 138, 220),
            friendly_chams_fill_color = Color3.fromRGB(50, 138, 220),
            friendly_tracer_color = Color3.fromRGB(50, 138, 220),

            trail_color = Color3.fromRGB(181, 126, 220),
            viewmodel_chams_color = Color3.fromRGB(181, 126, 220),
            target_highlight_color = Color3.fromRGB(255, 255, 255),

            chams_fill_transparency = 0,
            tracer_transparency = 1,
        },
        sunrays = {
            sunrays_enabled = false,
            sunrays_intensity = 0.25,
            sunrays_spread = 1,
        },
        camera = {
            state_changer = false,
            camera_state = "ThirdPerson",

            anti_flashbang = false,
            anti_smoke = false,

            camera_fov = modules.CameraController._base_fov,
            camera_resolution = 1,
        },
        lighting = {
            ambient_color = services.Lighting.Ambient,
            outdoor_ambient_color = services.Lighting.OutdoorAmbient,
            shift_top = services.Lighting.ColorShift_Top,
            shift_bottom = services.Lighting.ColorShift_Bottom,
            exposure = services.Lighting.ExposureCompensation,
            brightness = services.Lighting.Brightness,
            shadow_softness = services.Lighting.ShadowSoftness,
            diffuse_scale = services.Lighting.EnvironmentDiffuseScale,
            specular_scale = services.Lighting.EnvironmentSpecularScale,
            global_shadows = services.Lighting.GlobalShadows,
            lighting_style = "Realistic"
        },
        atmosphere = {
            density = 0.255,
            offset = 0.2,
            color = Color3.fromRGB(140, 196, 231),
            decay = Color3.fromRGB(92, 60, 13),
            glare = 0,
            haze = 1.82,
        },
        color_correction = {
            enabled = true,
            brightness = 0,
            contrast = 0,
            saturation = 0,
            tint_color = Color3.fromRGB(255, 255, 255)
        },
        weather = {
            enabled = false,
            type = "Rain",
            rate = 1,
            timescale = 1,

            thunder_active = false,
            thunder_loop = nil,
        },
        ambience = {
            enabled = false,
            type = "Rain",
            volume = 0.5
        }
    },

    skinchanger_state = {
        constructing_weapon = nil,
        viewing_profile = nil,
        last_used_weapon = nil,
        fake_owned = modules.PlayerDataController:Get("CosmeticInventory"),
        fake_weapon_owned = modules.PlayerDataController:Get("WeaponInventory"),
        equipped = {},
        placed_object_map = {},
        favorites = modules.PlayerDataController:Get("FavoritedCosmetics"),
        
        general_unlocker = {
            unlock_type = "Skin",
            unlock_rarity = "Common",
        },

        specific_unlocker = {
            unlock_type = "Skin",
            cosmetic_name = "",
            weapon_name = "",
        },

        equip_unlocker = {
            unlock_type = "Skin",
            cosmetic_name = "",
            weapon_name = "",
            inverted = false,
        },

        shoot_sound = {
            sound_value = "",
            sound_asset_id = nil,
            sound_url = "",
            sound_volume = 50,
            sound_pitch = 10,
        },

        reload_sound = {
            sound_value = "",
            sound_asset_id = nil,
            sound_url = "",
            sound_volume = 50,
            sound_pitch = 10,
        },

        hit_sound = {
            sound_value = "",
            sound_asset_id = nil,
            sound_url = "",
            sound_volume = 50,
            sound_pitch = 10,
        },

        crit_sound = {
            sound_value = "",
            sound_asset_id = nil,
            sound_url = "",
            sound_volume = 50,
            sound_pitch = 10,
        },

        death_sound = {
            sound_value = "",
            sound_asset_id = nil,
            sound_url = "",
            sound_volume = 50,
            sound_pitch = 10,
        },

        kill_sound = {
            sound_value = "",
            sound_asset_id = nil,
            sound_url = "",
            sound_volume = 50,
            sound_pitch = 10,
        },
    },

    spoofer_state = {
        device = "Desktop",
        old_device = tostring(modules.ControlsController.CurrentControls),
        spoof_device = false,
        device_spam = false,
        spam_rate = 1,

        display_name_value = LocalPlayer.DisplayName,
        username_value = LocalPlayer.Name,
        display_name = false,
        username = false,
        name_spoof_conn = {},

        avatar_userid = LocalPlayer.UserId,
        spoof_avatar = false,
        thumb_spoof_conn = {},

        anonymous_mode = false,
        fake_names = {},
        anon_connections = {},

        leaderboard = {
            elo_value = 0,
            streak_value = LocalPlayer:GetAttribute("StatisticDuelsWinStreak"),
            kills_value = 0,
            wins_value = 0,
            level_value = LocalPlayer:GetAttribute("Level"),

            old_streak_value = LocalPlayer:GetAttribute("StatisticDuelsWinStreak"),
            old_level_value = LocalPlayer:GetAttribute("Level"),

            ELO = false,
            Streak = false,
            Kills = false,
            Wins = false,
            Level = false,
        },

        badges = {
            Premium = false,
            Verified = false,
            Influencer = false,
            Admin = false
        },

        charm = {
            charm_rank = "Use Spoofed ELO",
            arch_rank = 1,
            s0_charm = false,
            s1_charm = false,
            s2_charm = false,
            s3_charm = false
        },

        currency = {
            weapon_keys = false,
            unlock_tokens = false,
            event_currency = false,
            glory = false,
            skin_tickets = false,

            weapon_keys_value = modules.PlayerDataController:Get("WeaponKeys"),
            unlock_tokens_value = modules.PlayerDataController:Get("UnlockTokens"),
            event_currency_value = modules.PlayerDataController:Get("EventCurrency"),
            glory_value = modules.PlayerDataController:Get("Glory"),
            skin_tickets_value = modules.PlayerDataController:Get("SkinTickets")
        },

        duel_history = {
            duel_history_value = modules.PlayerDataController:Get("DuelHistory"),
            logged_elo_events = modules.PlayerDataController:Get("LoggedELOEvents"),

            match_index = 1,
            mode = "Ranked",
            result = "Victory",
            map = "Factory",
            team1score = 5,
            team2score = 0,

            dueler_index = 1,
            username = "",
            display_name = "",

            kills = 15,
            deaths = 2,
            assists = 6,
            damage = 5000,
            elo = 2000,
            elo_change = 35,
        },

        marketplace = {
            fake_bundles_owned = modules.PlayerDataController:Get("GamepassBundlesClaimed"),
            fake_gift_robux_spent = modules.PlayerDataController:Get("GiftRobuxSpentProgress"),
            fake_gift_rewards_claimed = modules.PlayerDataController:Get("GiftRobuxSpentRewardsClaimed"),

            fake_robux = false,
            robux_amount = 0,
            fake_gifting = false
        }
    },

    inventory_state = {
        fake_owned = modules.PlayerDataController:Get("UnclaimedRewards"),

        specific = {
            lootbox_name = "Skin Case",
            quantity = 1,
            weapon_name = "",
            new_entry = false
        },

        bulk = {
            quantity = 1,
        },

        delete = {
            backpack_entry = "",
            quantity = 1
        },

        inject = {
            item_type = "Skin",
            weapon_name = "",
            cosmetic_name = "",
            stack_duplicates = false
        }
    }
}

local ui_objects = {

}

local caches = {
    asset_cache = {},
    sound_cache = {},
    objectid_to_weapon_cache = {},
    image_cache = {}
}

local ChangeLogs = tostring(request({
    Url = kConstants.kBaseURL .. "rivals_changelog.txt",
    Method = "GET",
    Headers = {
        ["Content-Type"] = "application/json"
    }
}).Body)

local EspInterface = loadstring(request({
    Url = kConstants.kBaseURL .. "Sense.luau",
    Method = "GET",
    Headers = {
        ["Content-Type"] = "application/json"
    }
}).Body)()

local Library = loadstring(request({
    Url = kConstants.kBaseURL .. "AethereaUI.luau",
    Method = "GET",
    Headers = {
        ["Content-Type"] = "application/json"
    }
}).Body)()

if EspInterface == nil or Library == nil then
	warn("Failed to load sources")
	getgenv().HI_I_HAVE_BALL_CANCER = nil
	return
end

EspInterface.GetWeapon = LPH_NO_VIRTUALIZE(function(player)
    local fighter = modules.FighterController:GetFighter(player)
    if not fighter then
        return "Unknown"
    end

    local equippedItem = fighter.EquippedItem
    if not equippedItem then
        return "Unknown"
    end

    return equippedItem.Name
end)

EspInterface.IsFriendly = LPH_NO_VIRTUALIZE(function(player)
    local our_team = LocalPlayer:GetAttribute("TeamID")
    local their_team = player:GetAttribute("TeamID")

    return their_team and their_team == our_team
end)

EspInterface.GetTeamColor = LPH_NO_VIRTUALIZE(function(player)
    local teams = rawget(modules.DuelLibrary, "TeamsByID")
    local team = rawget(teams, player:GetAttribute("TeamID"))

    return team and rawget(team, "Color") or rawget(modules.DuelLibrary, "EMPTY_TEAM_COLOR")
end)

EspInterface.Load()

--[[
    Extra Assets
]]

local Assets = {}

local function EnsureFolder(path)
    if isfolder and not isfolder(path) then
        makefolder(path)
    end
end

function Assets.Register(id, url)
    local ext = url:match("%.([%w]+)$")

    if not ext then
        ext = "dat"
    end

    caches.asset_cache[tostring(id)] = {
        url = url,
        uri = nil,
        extension = ext
    }
end

function Assets.Preload()
    local has_gca = type(getcustomasset) == "function"
    local has_fs = type(writefile) == "function"
        and type(readfile) == "function"
        and type(isfile) == "function"

    EnsureFolder(kConstants.kBaseFolderName)
    EnsureFolder(kConstants.kBaseFolderName .. "/assets")

    for id, entry in pairs(caches.asset_cache) do
        if entry.uri then
            continue
        end

        local file_path = string.format(
            "%s/assets/%s.%s",
            kConstants.kBaseFolderName,
            id,
            entry.extension
        )

        if has_gca and has_fs then
            if not isfile(file_path) then
                local ok, body = pcall(function()
                    return http_get(entry.url)
                end)

                if ok and body and #body > 0 then
                    writefile(file_path, body)
                end
            end

            if isfile(file_path) then
                local ok, asset = pcall(getcustomasset, file_path)

                if ok then
                    entry.uri = asset
                end
            end
        end

        entry.uri = entry.uri or ("rbxassetid://" .. id)
    end
end

function Assets.Get(id)
    local entry = caches.asset_cache[tostring(id)]

    if not entry then
        return ""
    end

    return entry.uri or ("rbxassetid://" .. tostring(id))
end

for _, path in pairs(kConstants.kSoundModsMap) do
    local name = path:match("([^/]+)%.")
    local url = kConstants.kBaseURL .. path

    Assets.Register("sound_" .. name, url)
end
Assets.Preload()

--[[
    Main Logic
]]

local Connections = {}

local function Bind(name, signal, fn)
    if Connections[name] then
        Connections[name]:Disconnect()
    end
    Connections[name] = signal:Connect(fn)
end

local function Unbind(name)
    if Connections[name] then
        Connections[name]:Disconnect()
        Connections[name] = nil
    end
end

if modules.EnumLibrary and modules.EnumLibrary.WaitForEnumBuilder then
    pcall(function()
        modules.EnumLibrary:WaitForEnumBuilder()
    end)
end

if modules.PlayerDataController and modules.PlayerDataController.WaitUntilLoaded then
    pcall(function()
        modules.PlayerDataController:WaitUntilLoaded()
    end)
end

local frozen = false
local org_cam = modules.CameraController.Update
modules.CameraController.Update = LPH_NO_VIRTUALIZE(function(self, ...)
    if frozen then
        return
    end

    return org_cam(self, ...)
end)

local function FreezeCamera()
    frozen = true
end

local function UnfreezeCamera()
    frozen = false
end

local orig_startrl = modules.Gun.StartReloading
modules.Gun.StartReloading = LPH_NO_VIRTUALIZE(function(u21, p22, p23, p24, p25)
    states.is_reloading = true
    task.delay(u21.Info.ReloadLength + 0.1, function()
        states.is_reloading = false
    end)

    return orig_startrl(u21, p22, p23, p24, p25)
end)

pcall(function()
    states.screen_gui.Name = ""
    states.screen_gui.Parent = gethui()
    states.screen_gui.IgnoreGuiInset = true
end)

--[[
    Server CF
]]

local server_cf_sync = true

pcall(LPH_JIT_MAX(function()
    local real
    local real_lin_vel
    local real_ang_vel

    services.RunService:BindToRenderStep(tostring(math.random(100000, 999999)), 0, LPH_NO_VIRTUALIZE(function()
        local root = LocalChar and LocalChar.PrimaryPart
        if not root or not root.Parent or not real then
            return
        end

        root.AssemblyLinearVelocity = real_lin_vel or Vector3.zero
        root.AssemblyAngularVelocity = real_ang_vel or Vector3.zero
        root.CFrame = real
    end))

    services.RunService.PostSimulation:Connect(LPH_NO_VIRTUALIZE(function()
        local root = LocalChar and LocalChar.PrimaryPart
        if not root or not root.Parent then
            return
        end

        real = root.CFrame
        real_lin_vel = root.AssemblyLinearVelocity
        real_ang_vel = root.AssemblyAngularVelocity

        if server_cf_sync then
            states.server_cf = real
        end

        root.CFrame = states.server_cf
    end))
end))

local function ServerCFDesync()
    server_cf_sync = false
end

local function ServerCFSync()
    server_cf_sync = true
end

--[[
    OOB Exploit
]]

local oob_remote = services.ReplicatedStorage:FindFirstChild("Remotes").Replication.Fighter.OutOfBounds
if not oob_remote then
    LocalPlayer:Kick("Couldn't initialize Aetherea.")
end

NamecallDispatcher:Register(LPH_JIT_MAX(function(self, method, ...)
    if method ~= "FireServer" or self ~= oob_remote then
        return false
    end

    return true
end))

modules.OutOfBoundsMachine.IsOutOfBounds = function()
    return false
end

modules.OutOfBoundsMachine.Update = LPH_NO_VIRTUALIZE(function()
    return
end)

modules.GameplayUtility.GetOOBWarnDelay = function()
    return 9999
end

modules.GameplayUtility.GetOOBKillDelay = function()
    return 9999
end

modules.GameplayUtility.IsWithinOOBPart = function()
    return
end

--[[
    Targeting
]]

GetMuzzlePos = LPH_JIT_MAX(function()
    local vms = workspace:FindFirstChild("ViewModels")
    if not vms then
        return nil
    end

    local first_person = vms:FindFirstChild("FirstPerson")
    if not first_person then
        return nil
    end

    local player_name = LocalPlayer.Name
    for _, model in pairs(first_person:GetChildren()) do
        if not model:IsA("Model") or not model.Name:find("^" .. player_name) then
            continue
        end

        local item_visual = model:FindFirstChild("ItemVisual")
        if not item_visual then
            continue
        end

        local body = item_visual:FindFirstChild("Body")
        if not body then
            continue
        end

        local body_primary = body:FindFirstChild("BodyPrimary")
        if not body_primary then
            continue
        end

        local muzzle = body_primary:FindFirstChild("_muzzle")
        if muzzle and muzzle:IsA("Attachment") then
            return muzzle.WorldPosition
        end
    end

    return nil
end)

WorldToScreen = LPH_NO_VIRTUALIZE(function(world_position)
    local screen_point, on_screen = workspace.CurrentCamera:WorldToViewportPoint(world_position)
    return Vector2.new(screen_point.X, screen_point.Y), on_screen, screen_point.Z
end)

SetTarget = LPH_NO_VIRTUALIZE(function(player, part)
    states.target = player
    states.target_part = part
    EspInterface.SetTarget(player)
end)

pcall(function()
    task.wait(3)
    task.spawn(function()
        local katana_path = LocalPlayer.PlayerScripts.Modules.Items:FindFirstChild("Katana", true)
        local riot_path = LocalPlayer.PlayerScripts.Modules.Items:FindFirstChild("Riot Shield", true)
        local katana = require(katana_path)
        local riot = require(riot_path)

        if katana and type(katana) == "table" and katana.StartAiming then
            local old = katana.StartAiming
            katana.StartAiming = function(self, force)
                if not table.find(states.targeting_state.ignore, "Katana") then
                    return old(self, force)
                end

                local fighter = self.ClientFighter
                local player = fighter and fighter.Player
                if player then
                    states.targeting_state.blocking[player.Name] = true
                    local dur = self.Info.DeflectDuration or 0.6
                    task.delay(dur, function()
                        states.targeting_state.blocking[player.Name] = nil
                    end)
                end
                return old(self, force)
            end
        end

        if riot and type(riot) == "table" and riot._UpdateUnequippedViewModel then
            local old = riot._UpdateUnequippedViewModel
            riot._UpdateUnequippedViewModel = function(self, ...)
                if not table.find(states.targeting_state.ignore, "Riot Shield") then
                    return old(self, ...)
                end

                local was_on_back = self._shieldOnBack
                local fighter = self.ClientFighter
                local player = fighter and fighter.Player
                local on_back = not (self.IsEquipped or fighter:IsActuallyFirstPerson()) and not fighter:Get("IsHiddenByEmotes")

                if was_on_back ~= on_back then
                    self._shieldOnBack = on_back

                    if on_back then
                        states.targeting_state.blocking[player.Name] = true
                    else
                        states.targeting_state.blocking[player.Name] = nil
                    end
                end
                return old(self, ...)
            end
        end
    end)

    local fov_frame = Instance.new("Frame")
    fov_frame.Name = ""
    fov_frame.Parent = states.screen_gui
    fov_frame.AnchorPoint = Vector2.new(0.5, 0.5)
    fov_frame.Position = UDim2.fromScale(0.5, 0.5)
    fov_frame.Size = UDim2.fromScale(1, 1)
    fov_frame.BackgroundTransparency = 1
    fov_frame.BorderSizePixel = 0
    fov_frame.ZIndex = 1

    local fov_circle_inline = Instance.new("Frame")
    fov_circle_inline.Name = ""
    fov_circle_inline.Parent = fov_frame
    fov_circle_inline.AnchorPoint = Vector2.new(0.5, 0.5)
    fov_circle_inline.BackgroundTransparency = 1
    fov_circle_inline.ZIndex = 1

    local fov_circle_inline_stroke = Instance.new("UIStroke")
    fov_circle_inline_stroke.Name = ""
    fov_circle_inline_stroke.Parent = fov_circle_inline
    fov_circle_inline_stroke.Color = Color3.new(1, 1, 1)
    fov_circle_inline_stroke.Thickness = 1

    local fov_circle_inline_grad = Instance.new("UIGradient")
    fov_circle_inline_grad.Name = ""
    fov_circle_inline_grad.Parent = fov_circle_inline_stroke

    local fov_circle = Instance.new("Frame")
    fov_circle.Name = ""
    fov_circle.Parent = fov_frame
    fov_circle.AnchorPoint = Vector2.new(0.5, 0.5)
    fov_circle.ZIndex = 2

    local fov_circle_stroke = Instance.new("UIStroke")
    fov_circle_stroke.Name = ""
    fov_circle_stroke.Parent = fov_circle
    fov_circle_stroke.Color = Color3.new(1, 1, 1)
    fov_circle_stroke.Thickness = 1

    local fov_circle_grad = Instance.new("UIGradient")
    fov_circle_grad.Name = ""
    fov_circle_grad.Parent = fov_circle_stroke

    local fov_circle_fill =  Instance.new("UIGradient")
    fov_circle_fill.Name = ""
    fov_circle_fill.Parent = fov_circle

    local fov_circle_outline =  Instance.new("Frame")
    fov_circle_outline.Name = ""
    fov_circle_outline.Parent = fov_frame
    fov_circle_outline.AnchorPoint = Vector2.new(0.5, 0.5)
    fov_circle_outline.BackgroundTransparency = 1
    fov_circle_outline.ZIndex = 3

    local fov_circle_outline_stroke = Instance.new("UIStroke")
    fov_circle_outline_stroke.Name = ""
    fov_circle_outline_stroke.Parent = fov_circle_outline
    fov_circle_outline_stroke.Color = Color3.new(1, 1, 1)
    fov_circle_outline_stroke.Thickness = 1

    local fov_circle_outline_grad = Instance.new("UIGradient")
    fov_circle_outline_grad.Name = ""
    fov_circle_outline_grad.Parent = fov_circle_outline_stroke

    local circle_mod = Instance.new("UICorner")
    circle_mod.Name = ""
    circle_mod.Parent = fov_circle_inline
    circle_mod.CornerRadius = UDim.new(1, 0)
    circle_mod:Clone().Parent = fov_circle
    circle_mod:Clone().Parent = fov_circle_outline

    local camera = workspace.CurrentCamera
    local raycast_params = RaycastParams.new()
    raycast_params.FilterType = Enum.RaycastFilterType.Exclude
    raycast_params.IgnoreWater = true
    raycast_params.FilterDescendantsInstances = {
        LocalPlayer.Character
    }
    LocalPlayer.CharacterAdded:Connect(function(char)
        raycast_params.FilterDescendantsInstances = {char}
    end)

    local wallcheck_cache = {}
    local wallcheck_cache_ttl = 0.15

    local WallCheck = LPH_NO_VIRTUALIZE(function(character, part)
        if not states.targeting_state.wallcheck then
            return true
        end

        local char_cache = wallcheck_cache[character]
        if not char_cache then
            char_cache = {}
            wallcheck_cache[character] = char_cache
        end

        local now = os.clock()
        local cached = char_cache[part]
        if cached and (now - cached.time) < wallcheck_cache_ttl then
            return cached.value
        end

        local origin = camera.CFrame.Position
        local result = workspace:Raycast(origin, part.Position - origin, raycast_params)
        local passed = not result or result.Instance:IsDescendantOf(character)

        char_cache[part] = {
            time = now,
            value = passed,
        }

        return passed
    end)

    local FindBestTarget = LPH_JIT_MAX(function()
        local origin = camera.CFrame.Position
        
        local best_part
        local best_player
        local best_distance = math.huge

        for _, player in services.Players:GetPlayers() do
            if player == LocalPlayer then
                continue
            end

            local character = player.Character
            if not character then
                continue
            end
            
            local root = character:FindFirstChild("HumanoidRootPart")
            local humanoid = character:FindFirstChildOfClass("Humanoid")
            if not root or not humanoid or humanoid.Health <= 0 then
                continue
            end

            local their_team = player:GetAttribute("TeamID")
            if their_team and their_team == LocalPlayer:GetAttribute("TeamID") then
                continue
            end

            if states.targeting_state.blocking[player.Name] then
                continue
            end

            local root_dist = (root.Position - origin).Magnitude
            if root_dist > (states.targeting_state.max_distance + 6) then
                continue
            end

            local closest_part = nil
            local closest = math.huge

            if states.targeting_state.target == "Closest Part" then
                for _, part_name in states.targeting_state.include_parts do
                    if type(part_name) ~= "string" then
                        continue
                    end

                    local part = character:FindFirstChild(part_name)
                    if not part or not part:IsA("BasePart") then
                        continue
                    end

                    local world_dist = (part.Position - origin).Magnitude
                    if world_dist > states.targeting_state.max_distance then
                        continue
                    end

                    local screen, visible = camera:WorldToViewportPoint(part.Position)
                    if not visible and screen.Z <= 0 then
                        continue
                    end

                    local dx = screen.X - fov_circle.Position.X.Offset
                    local dy = screen.Y - fov_circle.Position.Y.Offset
                    local screen_dist = dx * dx + dy * dy
                    local radius_sq = states.targeting_state.radius * states.targeting_state.radius

                    if states.targeting_state.target_group == "FOV" and screen_dist > radius_sq then
                        continue
                    end

                    local score = (screen_dist * states.targeting_state.weight_ratio) + (world_dist * (1 - states.targeting_state.weight_ratio))

                    if score < closest then
                        closest = score
                        closest_part = part
                    end
                end
            else
                local part = character:FindFirstChild(states.targeting_state.target)
                if part and part:IsA("BasePart") then
                    local world_dist = (part.Position - origin).Magnitude

                    if world_dist <= states.targeting_state.max_distance then
                        local screen, visible = camera:WorldToViewportPoint(part.Position)

                        if visible or screen.Z > 0 then
                            local dx = screen.X - fov_circle.Position.X.Offset
                            local dy = screen.Y - fov_circle.Position.Y.Offset
                            local screen_dist = dx * dx + dy * dy
                            local radius_sq = states.targeting_state.radius * states.targeting_state.radius

                            if states.targeting_state.target_group ~= "FOV" or screen_dist <= radius_sq then
                                closest = (screen_dist * states.targeting_state.weight_ratio) + (world_dist * (1 - states.targeting_state.weight_ratio))
                                closest_part = part
                            end
                        end
                    end
                end
            end

            if not closest_part or closest >= best_distance then
                continue
            end

            if not WallCheck(character, closest_part) then
                continue
            end

            best_distance = closest
            best_player = player
            best_part = closest_part
        end

        return best_player, best_part
    end)

    local pending_player
    local pending_part
    local pending_time = 0

    local current_player
    local current_part
    local current_lost_time = 0

    local next_search = 0
    local current_pos = UDim2.fromOffset((camera.ViewportSize / 2).X, (camera.ViewportSize / 2).Y)
    local target_scan_interval = 0.03

    services.RunService.RenderStepped:Connect(LPH_NO_VIRTUALIZE(function()
        local now = os.clock()
        local state = states.targeting_state

        if not (states.legit_state.silent_aim.enabled or states.rage_state.rage_bot.enabled or states.legit_state.triggerbot.enabled or state.show_fov) then
            if current_player then
                current_player = nil
                current_part = nil
                current_lost_time = 0
                SetTarget(nil, nil)
            end
            fov_frame.Visible = false
            return
        end

        fov_frame.Visible = state.show_fov

        local target_pos = UDim2.fromOffset((camera.ViewportSize / 2).X, (camera.ViewportSize / 2).Y)
        if state.fov_position["Barrel"] and not states.target_part then
            local muzzle_pos = GetMuzzlePos()
            if muzzle_pos then
                local screenPos, on_screen = WorldToScreen(muzzle_pos)
                if on_screen then
                    target_pos = UDim2.fromOffset(screenPos.X, screenPos.Y)
                else
                    target_pos = UDim2.fromOffset((camera.ViewportSize / 2).X, (camera.ViewportSize / 2).Y)
                end
            end
        end

        if state.fov_position["Target"] and states.target_part then
            local hitbox_pos = states.target_part.Position
            if hitbox_pos then
                local screenPos, on_screen = WorldToScreen(hitbox_pos)
                if on_screen then
                    target_pos = UDim2.fromOffset(screenPos.X, screenPos.Y)
                else
                    target_pos = UDim2.fromOffset((camera.ViewportSize / 2).X, (camera.ViewportSize / 2).Y)
                end
            end
        end

        if state.fov_lerp and state.fov_lerp > 0 then
            current_pos = current_pos:Lerp(target_pos, state.fov_lerp)
        else
            current_pos = target_pos
        end

        local radius = state.radius
        local transparency = state.fov_transparency
        local rotation = state.fov_rotation
        local rot_speed = state.fov_rotation_speed * 0.5
        if state.fov_rotation_speed > 0 then
            rotation = (state.fov_rotation + now * rot_speed * 360) % 360
        end

        local color_start = state.fov_start_color
        local color_mid = state.fov_mid_color
        local color_end = state.fov_end_color

        local outline_transparency = state.fov_outline_transparency
        local outline_color_start = state.fov_outline_start_color
        local outline_color_mid = state.fov_outline_mid_color
        local outline_color_end = state.fov_outline_end_color

        fov_circle_inline.Position = current_pos
        fov_circle_inline.Size = UDim2.fromOffset((radius * 2) - 2, (radius * 2) - 2)
        fov_circle_inline.Visible = state.fov_outline
        fov_circle_inline_stroke.Transparency = outline_transparency
        fov_circle_inline_grad.Color = ColorSequence.new{ColorSequenceKeypoint.new(0, outline_color_start), ColorSequenceKeypoint.new(0.5, outline_color_mid), ColorSequenceKeypoint.new(1, outline_color_end)}
        fov_circle_inline_grad.Rotation = rotation

        fov_circle.Position = current_pos
        fov_circle.Size = UDim2.fromOffset(radius * 2, radius * 2)
        fov_circle.Visible = state.show_fov
        fov_circle.BackgroundTransparency = state.fov_fill and math.clamp(0.35 + (transparency * 0.65), 0, 1) or 1
        fov_circle_stroke.Transparency = transparency
        fov_circle_grad.Color = ColorSequence.new{ColorSequenceKeypoint.new(0, color_start), ColorSequenceKeypoint.new(0.5, color_mid), ColorSequenceKeypoint.new(1, color_end)}
        fov_circle_grad.Rotation = rotation
        fov_circle_fill.Color = ColorSequence.new{ColorSequenceKeypoint.new(0, color_start), ColorSequenceKeypoint.new(0.5, color_mid), ColorSequenceKeypoint.new(1, color_end)}
        fov_circle_fill.Rotation = rotation

        fov_circle_outline.Position = current_pos
        fov_circle_outline.Size = UDim2.fromOffset((radius * 2) + 2, (radius * 2) + 2)
        fov_circle_outline.Visible = state.fov_outline
        fov_circle_outline_stroke.Transparency = outline_transparency
        fov_circle_outline_grad.Color = ColorSequence.new{ColorSequenceKeypoint.new(0, outline_color_start), ColorSequenceKeypoint.new(0.5, outline_color_mid), ColorSequenceKeypoint.new(1, outline_color_end)}
        fov_circle_outline_grad.Rotation = rotation

        if now < next_search then
            return
        end

        next_search = now + math.max(state.reaction_time / 1000, target_scan_interval)

        local best_player, best_part = FindBestTarget()

        if best_player ~= pending_player or best_part ~= pending_part then
            pending_player = best_player
            pending_part = best_part
            pending_time = now
            return
        end

        if best_player then
            current_lost_time = 0

            if current_player ~= best_player or current_part ~= best_part then
                if now - pending_time >= state.reaction_time / 1000 then
                    current_player = best_player
                    current_part = best_part
                    SetTarget(best_player, best_part)
                end
            end

            return
        end

        if not current_player then
            current_lost_time = 0
            return
        end

        if state.forget_time <= 0 then
            current_player = nil
            current_part = nil
            SetTarget(nil, nil)
            return
        end

        if current_lost_time == 0 then
            current_lost_time = now
            return
        end

        if now - current_lost_time >= state.forget_time then
            current_player = nil
            current_part = nil
            current_lost_time = 0
            SetTarget(nil, nil)
        end
    end))
end)

--[[
    Legit
]]

local candidates = {
    Vector3.new(5, 3, 5),
    Vector3.new(-5, 3, 5),
    Vector3.new(5, 3, -5),
    Vector3.new(-5, 3, -5),

    Vector3.new(0, 5, 8),
    Vector3.new(0, 5, -8),
}

local overlap_params = OverlapParams.new()
overlap_params.FilterType = Enum.RaycastFilterType.Exclude

local ray_params = RaycastParams.new()
ray_params.FilterType = Enum.RaycastFilterType.Exclude

local valid_position_cache = {}
local valid_position_cache_ttl = 0.5

FindValidPosition = LPH_NO_VIRTUALIZE(function(target)
    overlap_params.FilterDescendantsInstances = {
       LocalChar
    }

    ray_params.FilterDescendantsInstances = {
        LocalChar
    }

    local target_pos = target.Position
    local target_model = target.Parent

    for i = 1, #candidates do
        local offset = candidates[i]
        local pos = target_pos + offset

        local result = workspace:Raycast(
            pos,
            target_pos - pos,
            ray_params
        )

        if not result or result.Instance:IsDescendantOf(target_model) then
            local parts = workspace:GetPartBoundsInBox(
                CFrame.new(pos),
                Vector3.new(3, 6, 3),
                overlap_params
            )

            local blocked = false

            for j = 1, #parts do
                if parts[j].CanCollide then
                    blocked = true
                    break
                end
            end

            if not blocked then
                return offset
            end
        end
    end

    return nil
end)

GetCachedValidPosition = LPH_NO_VIRTUALIZE(function(target)
    if not target or not target.Parent then
        return nil
    end

    local now = os.clock()
    local entry = valid_position_cache[target]
    if entry and now - entry.time < valid_position_cache_ttl then
        return entry.value
    end

    local value = FindValidPosition(target)
    valid_position_cache[target] = {
        value = value,
        time = now,
    }

    return value
end)

local function SetSilentAimEnabled(state)
    if state == states.legit_state.silent_aim.enabled then
        return
    end

    states.legit_state.silent_aim.enabled = state

    ui_objects.SilentAimEnabled:Set(state)
    ui_objects.SilentAimKeybind:SetPressed(state)
end

--[[
    Triggerbot
]]

states.legit_state.triggerbot.triggerbot_shot_started.Parent = nil
states.legit_state.triggerbot.triggerbot_shot_finished.Parent = nil

pcall(function()
    local last_shot = 0
    services.RunService.Heartbeat:Connect(LPH_NO_VIRTUALIZE(function()
        setthreadidentity(2)
        local state = states.legit_state.triggerbot
        if not state.enabled then
            if state.triggerbot_active then
                state.triggerbot_shot_finished:Fire()
            end
            setthreadidentity(8)
            return
        end

        local target = states.target_part
        if not target then
            if state.triggerbot_active then
                state.triggerbot_shot_finished:Fire()
            end
            setthreadidentity(8)
            return
        end

        if states.is_reloading then
            if state.triggerbot_active then
                state.triggerbot_shot_finished:Fire()
            end
            setthreadidentity(8)
            return
        end

        local fighter = modules.FighterController:GetFighter(LocalPlayer)
        if not fighter then
            setthreadidentity(8)
            return
        end

        local equipped_item = fighter.EquippedItem
        if not equipped_item then
            setthreadidentity(8)
            return
        end

        if table.find(state.check_scoped, equipped_item.Name) then
            if not equipped_item:IsFullyAiming() then
                if state.triggerbot_active then
                    state.triggerbot_shot_finished:Fire()
                end

                setthreadidentity(8)
                return
            end
        end

        local now = os.clock()
        local shoot_delay_ms = state.shoot_delay or 100
        local shoot_delay = shoot_delay_ms / 1000

        if now - last_shot < shoot_delay then
            setthreadidentity(8)
            return
        end

        if not state.triggerbot_active then
            state.triggerbot_shot_started:Fire()
        end

        last_shot = now
        modules.MechanicsController:EquippedItemInput("StartShooting")
        setthreadidentity(8)
    end))
end)

local function SetTriggerbotEnabled(state)
    if state == states.legit_state.triggerbot.enabled then
        return
    end

    states.legit_state.triggerbot.enabled = state

    ui_objects.TriggerbotEnabled:Set(state)
    ui_objects.TriggerbotKeybind:SetPressed(state)
end

--[[
    Rage
]]

pcall(function()
    --[[
        Weapons
    ]]
    local old = {}
    local weapon_state = states.rage_state.weapons
    local misc_state = states.rage_state.misc
    local tripmine_last_scan = 0
    local tripmine_scan_interval = 0.2
    local weapon_last_update = 0
    local weapon_update_interval = 0.03

    local function RestoreWeaponInfo(info, original)
        if not info or not original then
            return
        end

        info.ShootRecoil = original.ShootRecoil
        info.ShootAccuracy = original.ShootAccuracy
        info.ShootSpread = original.ShootSpread
        info.QuickShotSpread = original.QuickShotSpread
        info.ShootSpreadConsistent = original.ShootSpreadConsistent
        info.AimSpreadMultiplier = original.AimSpreadMultiplier
        info.InputSpammingEnabled.StartShooting = original.StartShooting
        info.ShootCooldown = original.ShootCooldown
        info.MaxDoubleJumps = original.MaxDoubleJumps
    end

    services.RunService.Heartbeat:Connect(LPH_NO_VIRTUALIZE(function()
        local fighter = modules.FighterController:GetFighter(LocalPlayer)
        if not fighter then
            return
        end

        local equipped_item = fighter.EquippedItem
        if not equipped_item then
            return
        end

        local info = equipped_item.Info
        if not info then
            return
        end

        if not old[equipped_item] then
            old[equipped_item] = {
                ShootRecoil = info.ShootRecoil,
                ShootAccuracy = info.ShootAccuracy,
                ShootSpread = info.ShootSpread,
                QuickShotSpread = info.QuickShotSpread,
                ShootSpreadConsistent = info.ShootSpreadConsistent,
                AimSpreadMultiplier = info.AimSpreadMultiplier,
                StartShooting = info.InputSpammingEnabled.StartShooting,
                ShootCooldown = info.ShootCooldown,
                MaxDoubleJumps = info.MaxDoubleJumps
            }
        end

        local original = old[equipped_item]
        local should_apply = weapon_state.no_recoil
            or weapon_state.no_spread
            or weapon_state.full_auto
            or weapon_state.firerate ~= 100
            or misc_state.anti_tripmine
            or states.rage_state.movement.infinite_double_jump

        if not should_apply then
            RestoreWeaponInfo(info, original)
            return
        end

        local now = os.clock()
        if now - weapon_last_update < weapon_update_interval then
            return
        end
        weapon_last_update = now

        if weapon_state.no_recoil then
            info.ShootRecoil = 0
        else
            info.ShootRecoil = original.ShootRecoil
        end

        if weapon_state.no_spread then
            info.ShootAccuracy = 0
            info.ShootSpread = 0
            info.QuickShotSpread = 0
            info.ShootSpreadConsistent = true
            info.AimSpreadMultiplier = 0
        else
            info.ShootAccuracy = original.ShootAccuracy
            info.ShootSpread = original.ShootSpread
            info.QuickShotSpread = original.QuickShotSpread
            info.ShootSpreadConsistent = original.ShootSpreadConsistent
            info.AimSpreadMultiplier = original.AimSpreadMultiplier
        end

        if weapon_state.full_auto then
            info.InputSpammingEnabled.StartShooting = 0
        else
            info.InputSpammingEnabled.StartShooting = original.StartShooting
        end

        if weapon_state.firerate ~= 100 then
            info.ShootCooldown = original.ShootCooldown and original.ShootCooldown * (weapon_state.firerate / 100) or nil
        else
            info.ShootCooldown = original.ShootCooldown
        end

        if states.rage_state.movement.infinite_double_jump then
            info.MaxDoubleJumps = math.huge
        else
            info.MaxDoubleJumps = original.MaxDoubleJumps
        end

        if misc_state.anti_tripmine and now - tripmine_last_scan >= tripmine_scan_interval then
            tripmine_last_scan = now

            local root = LocalChar and LocalChar:FindFirstChild("HumanoidRootPart")
            if root then
                for _, s in workspace:GetChildren() do
                    if s.Name == "SubspaceTripmineHitbox" and s:FindFirstChild("Hitbox") then
                        firetouchinterest(root, s.Hitbox, 1)
                        firetouchinterest(root, s.Hitbox, 0)
                    end
                end
            end
        end
    end))

    local orig_finish = modules.Throwable.FinishShooting
    local throw_id = 0
    modules.Throwable.FinishShooting = function(p9, p10)
        if not p9.ClientFighter.IsLocalPlayer or not states.rage_state.misc.tp_throwables or not states.target_part then
            return orig_finish(p9, p10)
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root then
            return orig_finish(p9, p10)
        end

        local args = {orig_finish(p9, p10)}

        if args[1] ~= true and args[2] ~= "FinishShooting" then
            return unpack(args)
        end

        local prev = root.CFrame
        local part = states.target_part

        FreezeCamera()
        LocalChar:PivotTo(part.CFrame * CFrame.new(FindValidPosition(part) or Vector3.new(0, 5, 5)))

        local v68 = CFrame.new(root.Position, part.Position) * CFrame.new(0.75, -0.5, 0)
        args[3] = modules.Utility:EncodeCFrame(v68)

        throw_id += 1
        local id = throw_id

        task.delay(LocalPlayer:GetNetworkPing(), function()
            if id ~= throw_id then
                return
            end
            LocalChar:PivotTo(prev)
            UnfreezeCamera()
        end)

        return unpack(args)
    end
end)

--[[
    PluggWalk
]]

local flip_pluggwalk = Instance.new("BindableEvent")
local flip_conn
local hb_conn

local function EnablePluggWalk()
    local high_y = 2147483647
    local debounce = false
    local plugg_id = 0

    ServerCFDesync()

    flip_conn = flip_pluggwalk.Event:Connect(LPH_JIT_MAX(function()
        local nearby = false
        for _, plr in ipairs(services.Players:GetPlayers()) do
            if plr ~= LocalPlayer then
                local c = plr.Character
                local root = c and c.PrimaryPart

                if root and LocalChar.PrimaryPart and (root.Position - LocalChar.PrimaryPart.Position).Magnitude <= 2 then
                    nearby = true
                    break
                end
            end
        end

        if nearby then
            high_y = -2147483647
            return
        end

        if debounce then
            return
        end

        debounce = true

        if math.random() > 0.35 then
            debounce = false
            return
        end

        local root = LocalChar.PrimaryPart
        high_y = math.random(math.floor(root.Position.Y), math.floor(root.Position.Y + 50))

        plugg_id += 1
        local id = plugg_id

        task.delay(0.035, function()
            if id ~= plugg_id then
                return
            end

            high_y = 2147483647
            debounce = false
        end)
    end))

    hb_conn = services.RunService.Heartbeat:Connect(LPH_NO_VIRTUALIZE(function()
        if not states.rage_state.pluggwalk.enabled or states.rage_state.rage_bot.void_spam then
            return
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root or not root.Parent then
            return
        end

        local cf = root.CFrame
        if not cf then
            return
        end

        local pos = cf.Position
        states.server_cf = CFrame.new(pos.X, high_y, pos.Z) * (cf - pos)
    end))
end

local function DisablePluggWalk()
    if hb_conn then
        hb_conn:Disconnect()
        hb_conn = nil
    end
    if flip_conn then
        flip_conn:Disconnect()
        flip_conn = nil
    end

    ServerCFSync()
end

local function SetPluggWalkEnabled(state)
    if state == states.rage_state.pluggwalk.enabled then
        return
    end

    if state and states.rage_state.rage_bot.void_spam then
        return
    end

    if state then
        EnablePluggWalk()
        task.wait()
        states.rage_state.pluggwalk.enabled = true
    else
        states.rage_state.pluggwalk.enabled = false
        task.wait()
        DisablePluggWalk()
    end

    ui_objects.PluggWalkEnabled:Set(state)
    ui_objects.PluggWalkKeybind:SetPressed(state)
end

--[[
    StartShooting
]]

pcall(function()
    local manip_cf
    local manip_conn
    local manipulation = false
    local manip_visualizer = nil
    local manip_visualizer_conns = {}
    local last_manip_update = 0
    local manip_update_interval = 0.02

    local function DestroyManipVisualizer()
        if manip_visualizer then
            manip_visualizer:Destroy()
            manip_visualizer = nil
        end
        for _, conn in ipairs(manip_visualizer_conns) do
            conn:Disconnect()
        end
        table.clear(manip_visualizer_conns)
    end

    local function CreateManipVisualizer()
        if manip_visualizer then
            return
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root then
            return
        end

        manip_visualizer = Instance.new("Part")
        manip_visualizer.Name = ""
        manip_visualizer.Material = Enum.Material.Neon
        manip_visualizer.Size = root.Size
        manip_visualizer.Color = states.visuals_state.colors.trail_color
        manip_visualizer.CanCollide = false
        manip_visualizer.CanQuery = false
        manip_visualizer.CanTouch = false
        manip_visualizer.CFrame = manip_cf or root.CFrame
        manip_visualizer.Parent = EspInterface.GlobalChamRenderer.Viewport

        table.insert(manip_visualizer_conns, root.Destroying:Connect(function()
            if manip_visualizer then
                manip_visualizer:Destroy()
                manip_visualizer = nil
            end
        end))

        table.insert(manip_visualizer_conns, root.AncestryChanged:Connect(function(_, parent)
            if not parent and manip_visualizer then
                manip_visualizer:Destroy()
                manip_visualizer = nil
            end
        end))
    end

    local function EnsureManipVisualizer()
        if not states.legit_state.silent_aim.visualize then
            DestroyManipVisualizer()
            return
        end

        if not manip_visualizer then
            CreateManipVisualizer()
        elseif manip_cf then
            manip_visualizer.CFrame = manip_cf
        end
    end

    local ApplyManipulation = LPH_NO_VIRTUALIZE(function()
        if not manipulation or not manip_cf then
            return
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if root and root.Parent then
            root.CFrame = manip_cf
        end

        states.server_cf = manip_cf
    end)

    local StartManipulation = Instance.new("BindableEvent")
    StartManipulation.Parent = nil

    StartManipulation.Event:Connect(function(cf)
        ServerCFDesync()

        manip_cf = cf
        manipulation = true
        last_manip_update = 0

        ApplyManipulation()

        if not manip_conn then
            manip_conn = services.RunService.RenderStepped:Connect(LPH_NO_VIRTUALIZE(function()
                if not manipulation or not manip_cf then
                    return
                end

                local now = os.clock()
                if now - last_manip_update < manip_update_interval then
                    return
                end
                last_manip_update = now

                ApplyManipulation()

                if states.legit_state.silent_aim.visualize then
                    if manip_visualizer then
                        manip_visualizer.CFrame = manip_cf
                    else
                        CreateManipVisualizer()
                    end
                elseif manip_visualizer then
                    DestroyManipVisualizer()
                end
            end))
        end

        EnsureManipVisualizer()
    end)

    local function StopManipulation()
        manipulation = false
        manip_cf = nil
        last_manip_update = 0

        if manip_conn then
            manip_conn:Disconnect()
            manip_conn = nil
        end

        DestroyManipVisualizer()
        ServerCFSync()
    end

    services.UserInputService.InputEnded:Connect(function(input)
        if manipulation and input.UserInputType == Enum.UserInputType.MouseButton1 then
            StopManipulation()
        end
    end)

    states.legit_state.triggerbot.triggerbot_shot_started.Event:Connect(function()
        states.legit_state.triggerbot.triggerbot_active = true
    end)

    states.legit_state.triggerbot.triggerbot_shot_finished.Event:Connect(function()
        states.legit_state.triggerbot.triggerbot_active = false
        StopManipulation()
        modules.MechanicsController:EquippedItemInput("FinishShooting")
    end)

    local shot_offset_cf = modules.Utility:EncodeCFrame(CFrame.new(0.43, 0.25, 0.42))
    local shot_key_0 = utf8.char(0)
    local shot_key_1 = utf8.char(1)
    local shot_key_2 = utf8.char(2)
    local shot_key_3 = utf8.char(3)

    local BuildShotPayload = LPH_NO_VIRTUALIZE(function(origin, target, part)
        local aim_cf = modules.Utility:EncodeCFrame(CFrame.new(origin, target))
        return {
            [shot_key_0] = aim_cf,
            [shot_key_1] = aim_cf,
            [shot_key_2] = part,
            [shot_key_3] = shot_offset_cf,
        }
    end)

    local old_gun = modules.Gun.StartShooting
    modules.Gun.StartShooting = LPH_NO_VIRTUALIZE(function(self, ...)
        local legit_state = states.legit_state.silent_aim
        local rage_state = states.rage_state.rage_bot
        local pluggwalk_state = states.rage_state.pluggwalk
        local part = states.target_part

        if not self.ClientFighter.IsLocalPlayer or not part then
            return old_gun(self, ...)
        end

        local results = {old_gun(self, ...)}

        if results[1] ~= true or results[2] ~= "StartShooting" then
            return unpack(results)
        end

        if not legit_state.enabled and not rage_state.enabled then
            return unpack(results)
        end

        if pluggwalk_state.enabled and not rage_state.void_spam then
            flip_pluggwalk:Fire()
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root then
            return unpack(results)
        end

        if rage_state.enabled then
            results[3] = BuildShotPayload(states.server_cf.Position, part.Position, part)
            return unpack(results)
        end

        if math.random(1, 100) > legit_state.hit_chance then
            return unpack(results)
        end

        local origin = root.Position
        local target = part.Position

        if legit_state.manipulation and not pluggwalk_state.enabled then
            local offset = GetCachedValidPosition(part) or Vector3.new(0, 5, 5)
            local fake_cf = part.CFrame * CFrame.new(offset)
            StartManipulation:Fire(fake_cf)
            origin = fake_cf.Position
        end

        results[3] = BuildShotPayload(origin, target, part)
        return unpack(results)
    end)

    local old_melee = modules.Melee.StartShooting
    modules.Melee.StartShooting = LPH_JIT_MAX(function(self, ...)
        local rage_state = states.rage_state.rage_bot
        local part = states.target_part

        if not self.ClientFighter.IsLocalPlayer or not part then
            return old_melee(self, ...)
        end

        local results = {old_melee(self, ...)}

        if results[1] ~= true or results[2] ~= "StartShooting" then
            return unpack(results)
        end

        if not rage_state.enabled then
            return unpack(results)
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root then
            return unpack(results)
        end

        if rage_state.enabled then
            results[3] = BuildShotPayload(states.server_cf.Position, part.Position, part)
            return unpack(results)
        end

        return unpack(results)
    end)

    local old_knife = modules.Knife.StartAiming
    modules.Knife.StartAiming = LPH_JIT_MAX(function(self, ...)
        local rage_state = states.rage_state.rage_bot
        local part = states.target_part

        if not self.ClientFighter.IsLocalPlayer or not part then
            return old_knife(self, ...)
        end

        local results = {old_knife(self, ...)}

        if results[1] ~= true or results[2] ~= "StartAiming" then
            return unpack(results)
        end

        if not rage_state.enabled then
            return unpack(results)
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root then
            return unpack(results)
        end

        if rage_state.enabled then
            results[3] = BuildShotPayload(states.server_cf.Position, part.Position, part)
            return unpack(results)
        end

        return unpack(results)
    end)
end)

--[[
    Rage Bot
]]

states.rage_state.rage_bot.sync_void_state.Parent = nil

pcall(function()
    local void_phase = false
    local last_switch = 0
    local rage_active = false
    local last_action_time = 0
    local entity = modules.ClientEntity
    local orig_rplfromserv = entity.ReplicateFromServer
    local orig_hurteffect = entity._HurtEffect
    local prev = {}

    local rage_hud_frame = Instance.new("Frame")
    rage_hud_frame.Name = ""
    rage_hud_frame.Parent = states.screen_gui
    rage_hud_frame.AnchorPoint = Vector2.new(0.5, 0)
    rage_hud_frame.BackgroundTransparency = 1
    rage_hud_frame.ZIndex = 5
    rage_hud_frame.Size = UDim2.fromOffset(250, 120)
    rage_hud_frame.Visible = false

    local hud_layout = Instance.new("UIListLayout")
    hud_layout.Parent = rage_hud_frame
    hud_layout.SortOrder = Enum.SortOrder.LayoutOrder
    hud_layout.HorizontalAlignment = Enum.HorizontalAlignment.Center
    hud_layout.VerticalAlignment = Enum.VerticalAlignment.Top
    hud_layout.Padding = UDim.new(0, 2)

    local function CreateHUDText(text, order)
        local label = Instance.new("TextLabel")
        label.Name = ""
        label.Parent = rage_hud_frame
        label.BackgroundTransparency = 1
        label.Size = UDim2.new(1, 0, 0, 14)
        label.Font = Enum.Font.Arial
        label.TextSize = 14
        label.TextColor3 = Color3.fromRGB(255, 255, 255)

        label.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
        label.TextStrokeTransparency = 0

        label.Text = text
        label.TextXAlignment = Enum.TextXAlignment.Center
        label.TextYAlignment = Enum.TextYAlignment.Center

        label.LayoutOrder = order
        label.ZIndex = 6

        return label
    end

    local function ResetVoidState()
        void_phase = false
        last_switch = 0
    end

    local function GetShootCooldown()
        local fighter = modules.FighterController:GetFighter(LocalPlayer)
        local equipped_item = fighter and fighter.EquippedItem
        local info = equipped_item and equipped_item.Info

        if info and info.ShootCooldown then
            return math.max(0.02, info.ShootCooldown)
        end

        return 0.05
    end

    local shoot_ready_at = 0
    local shoot_pending = false

    states.rage_state.rage_bot.sync_void_state.Event:Connect(function()
        local state = states.rage_state.rage_bot
        if not state.enabled then
            ResetVoidState()
            ServerCFSync()
        else
            ResetVoidState()
            if state.void_spam then
                last_switch = tick()
            end
        end
    end)

    local EditServerCF = LPH_JIT_MAX(function(force_hide)
        local state = states.rage_state.rage_bot
        if not state.enabled or states.rage_state.pluggwalk.enabled then
            return
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root or not root.Parent then
            return
        end

        local target = states.target_part
        if not target then
            return
        end

        local target_cf = target.CFrame * CFrame.new(0, 0, 2)

        if not state.void_spam then
            states.server_cf = target_cf
            return
        end

        if force_hide then
            void_phase = true
        else
            local now = tick()
            local duration = void_phase and state.hide or state.attack
            if now - last_switch >= duration then
                void_phase = not void_phase
                last_switch = now
            end
        end

        if void_phase then
            local pos = target_cf.Position
            local far_pos = Vector3.new(math.random(-10000, 10000), -999999999, math.random(-10000, 10000))
            states.server_cf = CFrame.new(far_pos) * (target_cf - pos)
        else
            states.server_cf = target_cf
        end
    end)

    local function HasAmmo(item)
        if not item then
            return false
        end
        return (item:Get("Ammo") or 0) > 0 or (item:Get("AmmoReserve") or 0) > 0
    end

    local EquipBestWeapon = LPH_JIT_MAX(function()
        local state = states.rage_state.rage_bot
        local fighter = modules.FighterController:GetFighter(LocalPlayer)
        if not fighter then
            return
        end

        local desired_slot

        if state.attack_mode == "Knife" or state.attack_mode == "Melee" then
            desired_slot = 3
        else
            local primary = fighter.Items and fighter.Items[1]
            local secondary = fighter.Items and fighter.Items[2]
            if not primary and not secondary then
                return
            end

            if state.preferred == "Secondary" then
                if HasAmmo(secondary) then
                    desired_slot = 2
                elseif HasAmmo(primary) then
                    desired_slot = 1
                end
            else
                if HasAmmo(primary) then
                    desired_slot = 1
                elseif HasAmmo(secondary) then
                    desired_slot = 2
                end
            end
        end

        if not desired_slot then
            return
        end

        if not fighter.Items[desired_slot].IsEquipped then
            fighter:EquipItem(desired_slot)
        end
    end)

    local function StartRage()
        rage_active = true
    end

    local function FinishRage()
        rage_active = false
        last_action_time = 0
        shoot_pending = false
        shoot_ready_at = 0
        modules.MechanicsController:EquippedItemInput("FinishShooting")
        ResetVoidState()
        ServerCFSync()
    end

    local rage_status = CreateHUDText("rage bot: idle", 1)
    local rage_target = CreateHUDText("target: none", 2)

    local UpdateRageHUD = LPH_NO_VIRTUALIZE(function()
        local state = states.rage_state.rage_bot
        local center_screen = workspace.CurrentCamera.ViewportSize / 2
        rage_hud_frame.Visible = state.enabled and state.rage_hud
        rage_hud_frame.Position = UDim2.fromOffset(center_screen.X, center_screen.Y + 25)

        if states.is_reloading then
            rage_status.Text = "rage bot: reloading"
        elseif void_phase then
            rage_status.Text = "rage bot: void"
        elseif shoot_pending or (state.attack_mode == "Knife" and modules.MechanicsController:IsAiming()) then
            rage_status.Text = "rage bot: shoot"
        else
            rage_status.Text = "rage bot: idle"
        end

        local target = states.target
        if target == nil then
            rage_target.Text = "target: none"
        else
            rage_target.Text = "target: " .. target.Name
        end
    end)

    services.RunService.RenderStepped:Connect(LPH_NO_VIRTUALIZE(function()
        UpdateRageHUD()
        setthreadidentity(2)
        local state = states.rage_state.rage_bot
        if not state.enabled then
            if rage_active then
                FinishRage()
            end
            setthreadidentity(8)
            return
        end

        if states.rage_state.pluggwalk.enabled then
            if rage_active then
                FinishRage()
            end
            setthreadidentity(8)
            return
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root then
            if rage_active then
                FinishRage()
            end
            setthreadidentity(8)
            return
        end

        local can_attack = states.target_part and not states.is_reloading
        if not can_attack then
            shoot_pending = false
            shoot_ready_at = 0
            modules.MechanicsController:EquippedItemInput("FinishShooting")
            if state.void_spam then
                ServerCFDesync()
                EditServerCF(true)
            else
                ServerCFSync()
            end

            setthreadidentity(8)
            return
        else
            ServerCFDesync()
            EquipBestWeapon()
            EditServerCF()
        end

        if not rage_active then
            StartRage()
        end

        local now = os.clock()
        if not void_phase then
            if not shoot_pending then
                if now - last_action_time >= GetShootCooldown() then
                    local ping_delay = LocalPlayer:GetNetworkPing()
                    shoot_ready_at = now + math.max(0.03, ping_delay)
                    shoot_pending = true
                end
            else
                if now >= shoot_ready_at then
                    last_action_time = now
                    shoot_pending = false

                    for _ = 1, state.shoot_attempts do
                        local action = (state.attack_mode == "Knife") and "StartAiming" or "StartShooting"
                        modules.MechanicsController:EquippedItemInput(action)
                    end
                end
            end
        end

        setthreadidentity(8)
    end))

    local notify_bindable = Instance.new("BindableEvent")
    notify_bindable.Parent = nil

    notify_bindable.Event:Connect(function(name, dmg)
        ui_objects.Window:Notify({
            Title = "Hit Notification",
            Content = ("Hit %s for %.1f"):format(name, dmg),
            Duration = 5
        })
    end)

    local FireHitNotification = LPH_JIT_MAX(function(obj)
        local hum = obj.Model:FindFirstChildOfClass("Humanoid")
        if not hum then
            return
        end

        local previous = prev[obj]

        if previous == nil then
            prev[obj] = hum.Health
            return
        end

        task.defer(function()
            if not hum.Parent then
                return
            end

            local new_health = hum.Health
            local damage = previous - new_health

            prev[obj] = new_health

            if damage <= 0 then
                return
            end

            if not (states.rage_state.rage_bot.enabled and states.rage_state.rage_bot.hit_notifications and states.target and states.target.Name == obj.Model.Name) then
                return
            end

            notify_bindable:Fire(obj.Model.Name, damage)
        end)
    end)

    entity._HurtEffect = function(self, ...)
        FireHitNotification(self)
        return orig_hurteffect(self, ...)
    end

    entity.ReplicateFromServer = function(self, enum, ...)
        if enum == "Died" then
            prev[self] = nil
        end
        return orig_rplfromserv(self, enum, ...)
    end
end)

local function SetRageBotEnabled(state)
    if state == states.rage_state.rage_bot.enabled then
        return
    end

    states.rage_state.rage_bot.enabled = state
    states.rage_state.rage_bot.sync_void_state:Fire()

    ui_objects.RageBotEnabled:Set(state)
    ui_objects.RageBotKeybind:SetPressed(state)
end

local function SetVoidSpamEnabled(state)
    if state == states.rage_state.rage_bot.void_spam then
        return
    end

    states.rage_state.rage_bot.void_spam = state
    states.rage_state.rage_bot.sync_void_state:Fire()
end

--[[
    Anti Aim
]]

pcall(function()
    local StrongRandom = LPH_JIT_MAX(function(min, max, entropy)
        local seed = (os.clock() * 1e9 + tick() * 1e6 + math.random(1, 1e9) + (entropy or 0) * 1337)
        seed = math.abs(math.sin(seed) * 1e14)

        local rng = Random.new(seed % 2^31)
        return rng:NextNumber(min, max)
    end)

    local RandomAngle = LPH_JIT_MAX(function(min, max, entropy)
        return math.rad(StrongRandom(min, max, entropy))
    end)

    local spin_angle = 0
    local jitter_angle = 0
    local last_jitter = 0

    local pitch_handlers = {
        Offset = function(state)
            return math.rad(state.pitch_angle)
        end,

        Custom = function(state)
            return math.rad(state.pitch_angle)
        end,

        Random = function(state)
            return RandomAngle(-89, 89, state.pitch_angle)
        end,

        ["Look Up"] = function()
            return math.rad(-89)
        end,

        ["Look Down"] = function()
            return math.rad(89)
        end,
    }

    local yaw_handlers = {
        Offset = function(state)
            return math.rad(state.yaw_angle)
        end,

        Custom = function(state)
            return math.rad(state.yaw_angle)
        end,

        Random = function(state)
            return RandomAngle(-180, 180, state.yaw_angle)
        end,

        Spin = function(state)
            spin_angle += math.rad(state.speed)

            if spin_angle >= math.pi * 2 then
                spin_angle -= math.pi * 2
            end

            return spin_angle
        end,

        Jitter = function(state)
            local now = tick()

            local interval = 1 / math.max(state.speed, 1)

            if now - last_jitter >= interval then
                last_jitter = now
                jitter_angle = math.rad(StrongRandom(-state.jitter_angle, state.jitter_angle, jitter_angle))
            end

            return jitter_angle
        end,

        Backwards = function()
            return math.pi
        end,
    }

    local rayparams = RaycastParams.new()
    rayparams.FilterType = Enum.RaycastFilterType.Exclude

    local floor_cache_pos
    local floor_cache_cf
    local floor_cache_time = 0
    local floor_cache_ttl = 0.2

    local GetFloorBelow = LPH_NO_VIRTUALIZE(function(pos)
        local now = os.clock()
        if floor_cache_cf and floor_cache_pos and (floor_cache_pos - pos).Magnitude < 3 and (now - floor_cache_time) < floor_cache_ttl then
            return floor_cache_cf
        end

        local ray_origin = pos
        local ray_dir = Vector3.new(0, -500, 0)
        rayparams.FilterDescendantsInstances = {LocalChar}

        local result = workspace:Raycast(ray_origin, ray_dir, rayparams)
        local cf = nil
        if result then
            cf = CFrame.new(Vector3.new(pos.X, result.Position.Y - 2, pos.Z))
        end

        floor_cache_pos = pos
        floor_cache_cf = cf
        floor_cache_time = now

        return cf
    end)

    local GetFakeRot = LPH_JIT_MAX(function(vec)
        local state = states.rage_state.anti_aim

        if not state.enabled then
            return vec
        end

        local pitch_func = pitch_handlers[state.pitch]
        local yaw_func = yaw_handlers[state.yaw]

        if pitch_func then
            vec = Vector2.new(pitch_func(state), vec.Y)
        end

        if yaw_func then
            vec = Vector2.new(vec.X, vec.Y + yaw_func(state))
        end

        return vec
    end)

    local orig = modules.Utility.EncodeCameraRotation
    modules.Utility.EncodeCameraRotation = LPH_JIT_MAX(function(self, vec)
        local fake_rot = GetFakeRot(vec)
        local root = LocalChar.PrimaryPart
        if root then
            root.CFrame = root.CFrame * CFrame.Angles(fake_rot.X, fake_rot.Y, math.rad(root.CFrame.Rotation.Z))
        end
        return orig(self, fake_rot)
    end)

    services.RunService.Heartbeat:Connect(LPH_NO_VIRTUALIZE(function()
        if not states.rage_state.anti_aim.enabled or states.rage_state.pluggwalk.enabled or states.rage_state.rage_bot.void_spam then
            return
        end

        if not states.rage_state.anti_aim.underground then
            return
        end

        local root = LocalChar and LocalChar.PrimaryPart
        if not root or not root.Parent then
            return
        end

        local cf = root.CFrame
        if not cf then
            return
        end

        local pos = cf.Position
        local floor_cf = GetFloorBelow(pos)
        if not floor_cf then
            return
        end

        root.CFrame = floor_cf
    end))
end)

local function SetAntiAimEnabled(state)
    if state == states.rage_state.anti_aim.enabled then
        return
    end

    states.rage_state.anti_aim.enabled = state

    ui_objects.AntiAimEnabled:Set(state)
    ui_objects.AntiAimKeybind:SetPressed(state)
end

--[[
    Movement
]]

pcall(function()
    local fly_bp = nil
    local fly_bg
    services.RunService.RenderStepped:Connect(LPH_NO_VIRTUALIZE(function(dt)
        local state = states.rage_state.movement
        local root = LocalChar and LocalChar.PrimaryPart
        local hum = LocalChar and LocalChar:FindFirstChildOfClass("Humanoid")
        if not root or not hum then
            return
        end

        if state.velocity then
            local move_dir = hum.MoveDirection
            if move_dir.Magnitude > 0 then
                local target_vel = move_dir * state.velocity_speed
                root.AssemblyLinearVelocity = Vector3.new(target_vel.X, root.AssemblyLinearVelocity.Y, target_vel.Z)
            end
        end

        if not state.fly then
            return
        end

        if not fly_bp then
            fly_bp = Instance.new("BodyPosition")
            fly_bp.MaxForce = Vector3.new(1e5, 1e5, 1e5)
            fly_bp.D = 1000
            fly_bp.P = 10000
            fly_bp.Position = root.Position
            fly_bp.Parent = root
        end

        if not fly_bg then
            fly_bg = Instance.new("BodyGyro")
            fly_bg.MaxTorque = Vector3.new(1e5, 1e5, 1e5)
            fly_bg.D = 400
            fly_bg.P = 10000
            fly_bg.CFrame = root.CFrame
            fly_bg.Parent = root
        end

        local cam = workspace.CurrentCamera
        local look = cam.CFrame.LookVector
        local right = cam.CFrame.RightVector
        local move = Vector3.new()

        if services.UserInputService:IsKeyDown(Enum.KeyCode.W) then
            move += look
        end

        if services.UserInputService:IsKeyDown(Enum.KeyCode.S) then
            move -= look
        end

        if services.UserInputService:IsKeyDown(Enum.KeyCode.A) then
            move -= right
        end

        if services.UserInputService:IsKeyDown(Enum.KeyCode.D) then
            move += right
        end

        if services.UserInputService:IsKeyDown(Enum.KeyCode.Space) then
            move += Vector3.new(0, 1, 0)
        end

        if services.UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then
            move -= Vector3.new(0, 1, 0)
        end

        if move.Magnitude > 0 then
            move = move.Unit
        end

        fly_bp.Position = root.Position + (move * state.fly_speed * dt * 10)
        fly_bp.MaxForce = Vector3.new(1e5, 1e5, 1e5)

        fly_bg.CFrame = CFrame.new(root.Position, root.Position + look * Vector3.new(1, 0, 1))
    end))

    local fighter = modules.FighterController:GetFighter(LocalPlayer)
    local old_fighterget = fighter.Get
    fighter.Get = function(self, idx, ...)
        local state = states.rage_state.movement
        if idx == "SlidingSpeedMax" then
            if state.slide_boost then
                local val = old_fighterget(self, idx, ...)
                return (typeof(val) == "number") and val * state.slide_boost_value or 3 * state.slide_boost_value
            end
        end
        if idx == "DisableDoubleJumping" then
            if state.infinite_double_jump then
                return false
            end
        end
        return old_fighterget(self, idx, ...)
    end

    local old_isgrounded = fighter.IsGrounded
    fighter.IsGrounded = function(self)
        local state = states.rage_state.movement
        if state.infinite_double_jump then
            return false
        end
        return old_isgrounded(self)
    end

    --[[
    local orig_dj = modules.MechanicsController.DoubleJump
    modules.MechanicsController.DoubleJump = LPH_JIT_MAX(function(self)
        local state = states.rage_state.movement
        if not state.double_jump_height then
            return orig_dj(self)
        end

        if self:IsAlive() and not self:IsFrozen() then
            local move = self.LocalFighter:GetMoveVector(true, true)
            local hum = self.LocalFighter.Entity.Humanoid
            local root = self.LocalFighter.Entity.RootPart

            local boost = states.rage_state.movement.double_jump_height_value or 1.5

            root.Velocity = move * hum.WalkSpeed + Vector3.new(0, hum.JumpPower * 1.1 * boost, 0)

            self.LocalFighter.Entity:AirborneRedirect()
            self:PlayMechanicsSound("DoubleJump")
        end
    end)

    ]]
end)

--[[
    Visuals
]]

local function UpdateEspOptions()
    if not EspInterface then
        return
    end

    local state = states.visuals_state

    EspInterface.sharedSettings.useTeamColor = state.team_colors
    EspInterface.sharedSettings.limitDistance = true
    EspInterface.sharedSettings.maxDistance = state.max_distance
    EspInterface.sharedSettings.chamMaterial = kConstants.kMaterialMap[state.cham_material]
    EspInterface.sharedSettings.chamTextureId = state.cham_texture

    local enemy_settings = EspInterface.teamSettings.enemy
    local friendly_settings = EspInterface.teamSettings.friendly

    enemy_settings.enabled = state.visuals_enabled
    enemy_settings.box = state.outlines.Box
    enemy_settings.boxOutline = state.outlines.Box
    enemy_settings.boxFill = state.box_filled
    enemy_settings.skeletons = state.outlines.Skeletons
    enemy_settings.chams = state.outlines.Chams
    enemy_settings.healthBar = state.outlines.Health
    enemy_settings.name = state.outlines.Name
    enemy_settings.tracer = state.outlines.Tracers
    enemy_settings.tracerOrigin = state.tracer_origin
    enemy_settings.weapon = state.outlines.Weapon
    enemy_settings.distance = state.outlines.Distance
    enemy_settings.targetHighlight = state.target_highlights

    friendly_settings.enabled = state.visuals_enabled and state.teammates
    friendly_settings.box = state.outlines.Box
    friendly_settings.boxOutline = state.outlines.Box
    friendly_settings.boxFill = state.box_filled
    friendly_settings.skeletons = state.outlines.Skeletons
    friendly_settings.chams = state.outlines.Chams
    friendly_settings.healthBar = state.outlines.Health
    friendly_settings.name = state.outlines.Name
    friendly_settings.tracer = state.outlines.Tracers
    friendly_settings.tracerOrigin = state.tracer_origin
    friendly_settings.weapon = state.outlines.Weapon
    friendly_settings.distance = state.outlines.Distance
    friendly_settings.targetHighlight = state.target_highlights

    enemy_settings.boxOutlineColor[1] = state.colors.enemy_box_outline_color
    enemy_settings.boxFillColor[1] = state.colors.enemy_box_fill_color
    enemy_settings.chamsFillColor[1] = state.colors.enemy_chams_fill_color
    enemy_settings.tracerColor[1] = state.colors.enemy_tracer_color
    enemy_settings.targetHighlightColor[1] = state.colors.target_highlight_color

    friendly_settings.boxOutlineColor[1] = state.colors.friendly_box_outline_color
    friendly_settings.boxFillColor[1] = state.colors.friendly_box_fill_color
    friendly_settings.chamsFillColor[1] = state.colors.friendly_chams_fill_color
    friendly_settings.tracerColor[1] = state.colors.friendly_tracer_color
    friendly_settings.targetHighlightColor[1] = state.colors.target_highlight_color

    enemy_settings.chamsFillColor[2] = state.colors.chams_fill_transparency
    enemy_settings.tracerColor[2] = state.colors.tracer_transparency

    friendly_settings.chamsFillColor[2] = state.colors.chams_fill_transparency
    friendly_settings.tracerColor[2] = state.colors.tracer_transparency
end

local function SetVisualsEnabled(state)
    if state == states.visuals_state.visuals_enabled then
        return
    end

    states.visuals_state.visuals_enabled = state

    ui_objects.VisualsEnabled:Set(state)
    ui_objects.VisualsKeybind:SetPressed(state)

    if state then
        if not EspInterface._hasLoaded then
            EspInterface.Load()
        end
        UpdateEspOptions()
    else
        if EspInterface._hasLoaded then
            EspInterface.Cleanup()
        end
    end
end

pcall(LPH_NO_VIRTUALIZE(function()
    local trajectory_part_event = Instance.new("BindableEvent")
    trajectory_part_event.Parent = nil

    local bullet_trail_budget = 16
    local bullet_trail_active = 0
    local bullet_trail_last_emit = 0
    local bullet_trail_emit_interval = 0.01
    local bullet_trail_lifetime = 0.45

    trajectory_part_event.Event:Connect(function(start_pos, end_pos)
        local now = os.clock()
        if now - bullet_trail_last_emit < bullet_trail_emit_interval then
            return
        end
        bullet_trail_last_emit = now

        if bullet_trail_active >= bullet_trail_budget then
            return
        end

        local distance = (end_pos - start_pos).Magnitude
        if distance <= 0 then return end

        bullet_trail_active += 1

        local part = Instance.new("Part")
        part.Name = ""
        part.Anchored = true
        part.CanCollide = false
        part.CanQuery = false
        part.CanTouch = false
        part.Color = states.visuals_state.colors.trail_color
        part.Material = kConstants.kMaterialMap[states.visuals_state.cham_material]
        part.Size = Vector3.new(0.1, 0.1, distance)
        part.CFrame = CFrame.new(start_pos, end_pos) * CFrame.new(0, 0, -distance / 2)
        part.Parent = EspInterface.GlobalChamRenderer.Viewport

        local tween = services.TweenService:Create(part, TweenInfo.new(bullet_trail_lifetime, Enum.EasingStyle.Linear), {
            Transparency = 1
        })

        tween:Play()

        tween.Completed:Connect(function()
            bullet_trail_active = math.max(0, bullet_trail_active - 1)
            part:Destroy()
        end)

        task.delay(bullet_trail_lifetime, function()
            if part.Parent then
                bullet_trail_active = math.max(0, bullet_trail_active - 1)
                part:Destroy()
            end
        end)

        return part
    end)

    local function CreateThrowableTrail(throwable_part)
	    local base_color = states.visuals_state.colors.trail_color
	    local bright = base_color:Lerp(Color3.new(1, 1, 1), 0.6)
	    local very_dark = base_color:Lerp(Color3.new(0, 0, 0), 0.6)
	    local haze_color = base_color:Lerp(Color3.new(1, 1, 1), 0.3)
	
	    local fake_part = throwable_part:Clone()
	    fake_part.Name = ""
	    fake_part.Parent = workspace
	    fake_part.Transparency = 1
	    fake_part.CanCollide = false
	    fake_part.CanTouch = false
	
		local a0 = Instance.new("Attachment")
		a0.Position = Vector3.new(0, 0.03, 0)
		a0.Name = ""
		a0.Parent = fake_part
	
		local a1 = Instance.new("Attachment")
		a1.Position = Vector3.new(0, -0.03, 0)
		a1.Name = ""
		a1.Parent = fake_part
	
		local core = Instance.new("Trail")
		core.Attachment0 = a0
		core.Attachment1 = a1
	    core.FaceCamera = true
		core.Lifetime = 5
		core.MinLength = 0.15
		core.Color = ColorSequence.new({
			ColorSequenceKeypoint.new(0, bright),
			ColorSequenceKeypoint.new(0.4, base_color),
			ColorSequenceKeypoint.new(1, very_dark),
		})
		core.Transparency = NumberSequence.new({
			NumberSequenceKeypoint.new(0, 0),
			NumberSequenceKeypoint.new(0.3, 0.05),
			NumberSequenceKeypoint.new(0.65, 0.35),
			NumberSequenceKeypoint.new(1, 1),
		})
		core.WidthScale = NumberSequence.new({
	        NumberSequenceKeypoint.new(0, 3.2),
	        NumberSequenceKeypoint.new(0.5, 2.0),
	        NumberSequenceKeypoint.new(1, 0.2),
	    })
		core.LightEmission = 1
		core.LightInfluence = 0
		core.Texture = "rbxasset://textures/particles/smoke_main.dds"
		core.TextureMode = Enum.TextureMode.Stretch
		core.Parent = fake_part
	
		local haze = core:Clone()
		haze.Name = ""
		haze.Lifetime = 5
		haze.Color = ColorSequence.new(haze_color)
		haze.Transparency = NumberSequence.new({
			NumberSequenceKeypoint.new(0, 0.1),
			NumberSequenceKeypoint.new(0.4, 0.35),
			NumberSequenceKeypoint.new(1, 1),
		})
		haze.WidthScale = NumberSequence.new({
	        NumberSequenceKeypoint.new(0, 4.2),
	        NumberSequenceKeypoint.new(0.5, 3.0),
	        NumberSequenceKeypoint.new(1, 0.6),
	    })
		haze.Parent = fake_part
	
		
		local a0h = a0:Clone()
	    a0h.Position = Vector3.new(0, 1.4/2, 0)
	    a0h.Parent = fake_part
	
		local a1h = a1:Clone()
	    a1h.Position = Vector3.new(0, -1.4/2, 0)
	    a1h.Parent = fake_part
	
		haze.Attachment0, haze.Attachment1 = a0h, a1h
		a0.Position = Vector3.new(0, 0.7/2, 0)
		a1.Position = Vector3.new(0, -0.7/2, 0)
	
	    local last_t = -1
		local conn = services.RunService.Heartbeat:Connect(function()
	        if throwable_part then
	            fake_part.CFrame = throwable_part.CFrame
	        end
			local speed = throwable_part.AssemblyLinearVelocity.Magnitude
			local t = math.clamp(speed / 80, 0.4, 1)
	
			if math.abs(t - last_t) > 0.02 then
	            last_t = t
	            core.Transparency = NumberSequence.new({
	                NumberSequenceKeypoint.new(0, (1 - t) * 0.1),
	                NumberSequenceKeypoint.new(0.3, 0.05 + (1 - t) * 0.1),
	                NumberSequenceKeypoint.new(0.65, 0.35),
	                NumberSequenceKeypoint.new(1, 1),
	            })
	        end
		end)
	
	    task.delay(math.max(core.Lifetime, haze.Lifetime), function()
	        if conn.Connected then
	            conn:Disconnect()
	        end
	
	        core:Clear()
			haze:Clear()
	        fake_part:Destroy()
	    end)
	end
	
	local orig_tracers = modules.Gun._Tracers
	modules.Gun._Tracers = function(p118, p119, p120)
	    local muzzle_pos = p118.ViewModel:GetMuzzlePosition()
	    local result = p119.RaycastResults[1]
	
	    if states.visuals_state.trails.Bullets and p119.IsLocal then
	        if result and result.Position then
	            trajectory_part_event:Fire(muzzle_pos, result.Position)
	        end
	    end
	
	    return orig_tracers(p118, p119, p120)
	end
	
	local orig_throwable_replfromserver = modules.Throwable.ReplicateFromServer
	modules.Throwable.ReplicateFromServer = function(self, event_name, ...)
		if event_name == "ThrowEffect" then
			local throwable_part = ...
	
			local results = orig_throwable_replfromserver(self, event_name, ...)
	
			if states.visuals_state.trails.Throwables and throwable_part then
				CreateThrowableTrail(throwable_part)
			end
	
	        return results
		else
			return orig_throwable_replfromserver(self, event_name, ...)
		end
	end
end))

--[[
    Viewmodel
]]

pcall(LPH_NO_VIRTUALIZE(function()
    local desc_cache = nil

    local function DestroyViewmodelCham()
	    local state = states.visuals_state.viewmodel
	
	    for _, conn in ipairs(state.vm_cham_connections) do
	        conn:Disconnect()
	    end
	    table.clear(state.vm_cham_connections)
	
	    for part, info in pairs(state.vm_cham_parts) do
	        if info.glow then
	            info.glow:Destroy()
	        end
	        state.vm_cham_parts[part] = nil
	    end
	end
	
	local function CreateViewmodelCham(model)
	    local state = states.visuals_state.viewmodel
	    if not model then
	        return
	    end
	
	    local function AddPart(part)
	        if state.vm_cham_parts[part] then
	            return
	        end
	
	        local glow = part:Clone()
	
	        for _, child in ipairs(glow:GetDescendants()) do
	            if child:IsA("Script")
	            or child:IsA("LocalScript")
	            or child:IsA("Animator")
	            or child:IsA("Motor6D")
	            or child:IsA("Weld")
	            or child:IsA("WeldConstraint")
	            or child:IsA("Attachment")
	            or child:IsA("Decal")
	            or child:IsA("Texture")
	            or child:IsA("SurfaceAppearance") then
	                child:Destroy()
	            end
	        end
	
	        local mesh = glow:FindFirstChildOfClass("SpecialMesh")
	
	        if glow:IsA("MeshPart") then
	            glow.TextureID = ""
	            glow.MaterialVariant = ""
	        end
	
	        if mesh then
	            mesh.TextureId = ""
	        end
	
	        glow.Name = ""
	        glow.Anchored = true
	        glow.CanCollide = false
	        glow.CanQuery = false
	        glow.CanTouch = false
	        glow.CastShadow = false
	
	        glow.Color = states.visuals_state.colors.viewmodel_chams_color
	        glow.Material = kConstants.kMaterialMap[state.cham_material]
	        glow.Transparency = state.cham_transparency or 0
	        glow.Reflectance = 0
	
	        if state.cham_texture and state.cham_texture ~= 0 then
	            local tex = "rbxassetid://" .. tostring(state.cham_texture)
	
	            if glow:IsA("MeshPart") then
	                glow.TextureID = tex
	            elseif mesh then
	                mesh.TextureId = tex
	            end
	        end
	
	        glow.Parent = EspInterface.GlobalChamRenderer.Viewport
	
	        state.vm_cham_parts[part] = {
	            glow = glow,
	            mesh = mesh,
	        }
	
	        table.insert(state.vm_cham_connections,
	            part.Destroying:Connect(function()
	                local cham = state.vm_cham_parts[part]
	                if cham then
	                    cham.glow:Destroy()
	                    state.vm_cham_parts[part] = nil
	                end
	            end)
	        )
	
	        table.insert(state.vm_cham_connections,
	            part.AncestryChanged:Connect(function(_, parent)
	                if not parent then
	                    local cham = state.vm_cham_parts[part]
	                    if cham then
	                        cham.glow:Destroy()
	                        state.vm_cham_parts[part] = nil
	                    end
	                end
	            end)
	        )
	    end
	
	    for _, v in ipairs(model:GetDescendants()) do
	        if v:IsA("BasePart") and not string.find(v.Name, "HumanoidRootPart") and not string.find(v.Name, "Camera") and not string.find(v.Name, "Primary") and v.Name ~= "LeftItem" and v.Name ~= "RightItem" then
	            AddPart(v)
	        end
	    end
	
	    table.insert(state.vm_cham_connections,
	        model.DescendantAdded:Connect(function(desc)
	            desc_cache = nil
	            if desc:IsA("BasePart") and not string.find(desc.Name, "HumanoidRootPart") and not string.find(desc.Name, "Camera") and not string.find(desc.Name, "Primary") and desc.Name ~= "LeftItem" and desc.Name ~= "RightItem" then
	                AddPart(desc)
	            end
	        end)
	    )
	
	    table.insert(state.vm_cham_connections,
	        model.DescendantRemoving:Connect(function()
	            desc_cache = nil
	        end)
	    )
	end
	
	states.visuals_state.viewmodel.set_vm_event = Instance.new("BindableEvent", nil)
	states.visuals_state.viewmodel._pending_vm_set = false
	
	states.visuals_state.viewmodel.set_vm_event.Event:Connect(function(model)
	    local state = states.visuals_state.viewmodel
	
	    DestroyViewmodelCham()
	
	    for _, wf in pairs(state.wireframe_cache) do
	        if wf then
	            pcall(function()
	                wf:Destroy()
	            end)
	        end
	    end
	
	    state.wireframe_cache = {}
	    state.appearance_cache = {}
	
	    state.vm_cham_model = model
	
	    if not model then
	        return
	    end
	
	    CreateViewmodelCham(model)
	
	    table.insert(state.vm_cham_connections,
	        model.Destroying:Connect(function()
	            if state.vm_cham_model == model then
	                state.vm_cham_model = nil
	                DestroyViewmodelCham()
	
	                for _, wf in pairs(state.wireframe_cache) do
	                    if wf then
	                        pcall(function()
	                            wf:Destroy()
	                        end)
	                    end
	                end
	
	                state.wireframe_cache = {}
	                state.appearance_cache = {}
	            end
	        end)
	    )
	end)
	
    services.RunService.RenderStepped:Connect(function()
	    local state = states.visuals_state.viewmodel
	
	    if not state.chams or not next(state.vm_cham_parts) then
	        return
	    end
	
	    for source, info in pairs(state.vm_cham_parts) do
	        if not source.Parent or not info.glow then
	            continue
	        end
	
	        info.glow.CFrame = source.CFrame
	        info.glow.Size = source.Size
	    end
	end)
	
	local function GetAppearanceCache(inst)
	    local cache = states.visuals_state.viewmodel.appearance_cache[inst]
	
	    if cache then
	        return cache
	    end
	
	    cache = {}
	
	    if inst:IsA("BasePart") then
	        cache.Color = inst.Color
	        cache.Material = inst.Material
	    elseif inst:IsA("Texture")
	        or inst:IsA("Decal")
	        or inst.Name == "ShirtTexture" then
	
	        cache.Parent = inst.Parent
	    end
	
	    states.visuals_state.viewmodel.appearance_cache[inst] = cache
	
	    return cache
	end
	
	local function GetWireframe(part)
	    local wf = states.visuals_state.viewmodel.wireframe_cache[part]
	
	    if wf then
	        return wf
	    end
	
	    wf = Instance.new("WireframeHandleAdornment")
	    wf.Adornee = part
	    wf.AlwaysOnTop = true
	    wf.ZIndex = 10
	    wf.Transparency = 0
	    wf.Parent = workspace.CurrentCamera
	
	    states.visuals_state.viewmodel.wireframe_cache[part] = wf
	
	    return wf
	end
	
	task.spawn(function()
	    task.wait(3)
	    pcall(function()
	        local vm_module = LocalPlayer.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem:FindFirstChild("ClientViewModel")
	        if vm_module then
	            local ClientViewModel = require(vm_module)
	            if ClientViewModel.Update then
	                local orig = ClientViewModel.Update
	                ClientViewModel.Update = function(u76, p77, p78, p79)
                        local state = states.visuals_state.viewmodel
	                    if not u76.ClientItem.ClientFighter.IsLocalPlayer or not u76:IsEquipped() then
	                        return orig(u76, p77, p78, p79)
	                    end
	
	                    local old = {}
	
	                    if state.vm_cham_model_name == nil or state.vm_cham_model_name ~= u76.Name then
	                        if not state._pending_vm_set then
	                            state._pending_vm_set = true
	                            task.defer(function()
	                                if not u76:IsEquipped() then
	                                    return
	                                end
	
	                                if state.vm_cham_model == u76.Model then
	                                    return
	                                end
	
	                                state.vm_cham_model = u76.Model
	                                state.vm_cham_model_name = u76.Name
	                                state.set_vm_event:Fire(u76.Model)
	                                state._pending_vm_set = false
	                            end)
	                        end
	                    end
	
	                    if state.override_fps then
	                        old.Info = u76.Info
	                        u76.Info.FramesPerSecond = state.fps_multi
	                    end
	
	                    if state.offset then
	                        if state.last_x ~= state.x_offset or state.last_y ~= state.y_offset or state.last_z ~= state.z_offset then
                                state.last_x = state.x_offset
                                state.last_y = state.y_offset
                                state.last_z = state.z_offset

                                state._offset = CFrame.new(state.x_offset, state.y_offset, state.z_offset)
                                state._offset_inv = state._offset:Inverse()
                            end

                            u76._root_part_offset_override = state._offset
                            u76._root_part_offset_override_inverse = state._offset_inv
	                    end
	
	                    local descs = desc_cache or u76.Model:GetDescendants()
	                    desc_cache = descs
	                    for _, v in descs do
	                        if v.Name == "ShirtTexture" or v:IsA("Texture") or v:IsA("Decal") then
	                            local cache = GetAppearanceCache(v)
	
	                            local should_hide =
	                                (v.Name == "ShirtTexture" and state.no_clothes)
	                                or
	                                ((v:IsA("Texture") or v:IsA("Decal")) and state.no_textures)
	
	                            if should_hide then
	                                if v.Parent then
	                                    cache.Parent = v.Parent
	                                    v.Parent = nil
	                                end
	                            else
	                                if cache.Parent and v.Parent ~= cache.Parent then
	                                    v.Parent = cache.Parent
	                                end
	                            end
	
	                            continue
	                        end
	
	                        if v:IsA("BasePart") and not string.find(v.Name, "HumanoidRootPart") and not string.find(v.Name, "Camera") and not string.find(v.Name, "Primary") and v.Name ~= "LeftItem" and v.Name ~= "RightItem" then
	                            local cache = GetAppearanceCache(v)
                                local color = state.color
                                local material = kConstants.kMaterialMap[state.material]
                                local transparency = state.transparency

	                            if state.appearance then
                                    if v.Color ~= color then
                                        v.Color = color
                                    end

                                    if v.Material ~= material then
                                        v.Material = material
                                    end

                                    if v.LocalTransparencyModifier ~= transparency then
                                        v.LocalTransparencyModifier = transparency
                                    end
	                            else
	                                if v.Color ~= cache.Color then
                                        v.Color = cache.Color
                                    end

                                    if v.Material ~= cache.Material then
                                        v.Material = cache.Material
                                    end

                                    if v.LocalTransparencyModifier ~= 0 then
                                        v.LocalTransparencyModifier = 0
                                    end
	                            end
	
	                            local wf = GetWireframe(v)
	
	                            if state.wireframe then
                                    if not wf.Visible then
                                        wf.Visible = true
                                    end

                                    if wf.Color3 ~= color then
                                        wf.Color3 = color
                                    end
	                            else
	                                if wf.Visible then
                                        wf.Visible = false
                                    end
	                            end
	                            continue
	                        end
	                    end
	
	                    if table.find(state.disable, "sway") then
	                        old._sway_spring = u76._sway_spring
	                        u76._sway_spring.Value = Vector2.zero
	                    end
	
	                    if table.find(state.disable, "bobbing") then
	                        old._bobbing_value_spring = u76._bobbing_value_spring
	                        u76._bobbing_value_spring.Target = Vector2.zero
	                        u76._bobbing_value_spring.Value = Vector2.zero
	                    end
	
	                    if table.find(state.disable, "tilt") then
	                        old._tilt_spring = u76._tilt_spring
	                        u76._tilt_spring.Target = Vector2.zero
	                        u76._tilt_spring.Value = Vector2.zero
	                    end
	
	                    if table.find(state.disable, "equip animation") then
	                        old._equip_spring = u76._equip_spring
	                        u76._equip_spring.Value = 0
	                    end
	
	                    if table.find(state.disable, "slide animation") then
	                        old._sliding_spring = u76._sliding_spring
	                        u76._sliding_spring.Target = 0
	                        u76._sliding_spring.Value = 0
	                    end
	
	                    if table.find(state.disable, "sprint animation") then
	                        old._sprinting_spring = u76._sprinting_spring
	                        u76._sprinting_spring.Target = 0
	                        u76._sprinting_spring.Value = 0
	                    end
	
	                    if table.find(state.disable, "jump animation") then
	                        old._landing_spring = u76._landing_spring
	                        u76._landing_spring.Velocity = 0
	                        u76._landing_spring.Target = 0
	                        u76._landing_spring.Value = 0
	
	                        old._jump_spring = u76._jump_spring
	                        u76._jump_spring.Target = 0
	                        u76._jump_spring.Value = 0
	                    end
	
	                    if table.find(state.disable, "aiming animation") then
	                        old._aim_spring = u76._aim_spring
	                        u76._aim_spring.Value = u76._aim_spring.Target
	                    end
	
	                    if table.find(state.disable, "shoot animation") then
	                        old._recoil_spring = u76._recoil_spring
	                        u76._recoil_spring.Target = Vector3.zero
	                        u76._recoil_spring.Value = Vector3.zero
	
	                        old._unrecoil_spring = u76._unrecoil_spring
	                        u76._unrecoil_spring.Target = Vector3.zero
	                        u76._unrecoil_spring.Value = Vector3.zero
	                    end
	
	                    local res = orig(u76, p77, p78, p79)
	
	                    for spring, rest in pairs(old) do
	                        u76[spring] = rest
	                    end
	
	                    return res
	                end
	            end
	            
	            if ClientViewModel.MuzzleFlash then
	                local orig = ClientViewModel.MuzzleFlash
	                ClientViewModel.MuzzleFlash = function(self)
	                    if not self.ClientItem.ClientFighter.IsLocalPlayer or not self:IsEquipped() then
	                        return orig(self)
	                    end
	
	                    if table.find(states.visuals_state.viewmodel.disable, "muzzle flash") then
	                        return
	                    end
	
	                    return orig(self)
	                end
	            end
	
	            if ClientViewModel.ApplyRecoil then
	                local orig = ClientViewModel.ApplyRecoil
	                ClientViewModel.ApplyRecoil = function(p62, p63)
	                    if not p62.ClientItem.ClientFighter.IsLocalPlayer or not p62:IsEquipped() then
	                        return orig(p62, p63)
	                    end
	
	                    if table.find(states.visuals_state.viewmodel.disable, "shoot animation") then
	                        return
	                    end
	
	                    return orig(p62, p63)
	                end
	            end
	        end
	        local animator_module = vm_module:FindFirstChild("ViewModelAnimator")
	        if animator_module then
	            local Animator = require(animator_module)
	            if Animator.PlayIdleAnimation then
	                local orig = Animator.PlayIdleAnimation
	                Animator.PlayIdleAnimation = function(self)
	                    local res = orig(self)
	
	                    if table.find(states.visuals_state.viewmodel.disable, "idle animation") then
	                        local track = self:GetAnimationTrack(self._idle_animation)
	                        if track then
	                            track.TimePosition = 0
	                            track:AdjustSpeed(0)
	                        end
	                    end
	
	                    return res
	                end
	            end
	            if Animator.PlayEquipAnimation then
	                local orig = Animator.PlayEquipAnimation
	                Animator.PlayEquipAnimation = function(self)
	                    if table.find(states.visuals_state.viewmodel.disable, "equip animation") then
	                        return true
	                    end
	
	                    return orig(self)
	                end
	            end
	            if Animator.PlaySprintAnimation then
	                local orig = Animator.PlaySprintAnimation
	                Animator.PlaySprintAnimation = function(self)
	                    if table.find(states.visuals_state.viewmodel.disable, "sprint animation") then
	                        return
	                    end
	
	                    return orig(self)
	                end
	            end
	        end
	    end)
	end)
end))

local function UpdateViewmodelChams()
	local state = states.visuals_state.viewmodel
	
	for _, info in pairs(state.vm_cham_parts) do
	    local glow = info.glow
	    if not glow then
	        continue
	    end
	
	    glow.Transparency = state.cham_transparency
	    glow.Color = states.visuals_state.colors.viewmodel_chams_color
	    glow.Material = kConstants.kMaterialMap[state.cham_material]
	
	    if glow:IsA("MeshPart") then
	        if state.cham_texture and state.cham_texture ~= 0 then
	            glow.TextureID = "rbxassetid://" .. state.cham_texture
	        else
	            glow.TextureID = ""
	        end
	    elseif info.mesh then
	        local mesh = info.mesh
	        if state.cham_texture and state.cham_texture ~= 0 then
	            mesh.TextureId = "rbxassetid://" .. state.cham_texture
	        else
	            mesh.TextureId = ""
	        end
	    end
	end
end

--[[
    Animations
]]

pcall(LPH_NO_VIRTUALIZE(function()
    local last_anim_set

    services.RunService.Heartbeat:Connect(function()
        local animate = LocalChar and LocalChar:FindFirstChild("Animate")
        if not animate then
            return
        end

        local anims = kConstants
            and kConstants.kCharacterAnimsMap
            and kConstants.kCharacterAnimsMap[states.visuals_state.animations.char_anims]

        if not anims or anims == last_anim_set then
            return
        end

        last_anim_set = anims

        local function SetAnimation(folder_name, anim_name, id)
            if not id then
                return
            end

            local folder = animate:FindFirstChild(folder_name)
            if not folder then
                return
            end

            local anim = folder:FindFirstChild(anim_name)
            if anim and anim:IsA("Animation") and anim.AnimationId ~= id then
                anim.AnimationId = id
            end
        end

        SetAnimation("idle", "Animation1", anims.idle)
        SetAnimation("idle", "Animation2", anims.idle)
        SetAnimation("walk", "WalkAnim", anims.walk)
        SetAnimation("run", "RunAnim", anims.run)
        SetAnimation("jump", "JumpAnim", anims.jump)
        SetAnimation("fall", "FallAnim", anims.fall)
        SetAnimation("climb", "ClimbAnim", anims.climb)
    end)
end))

--[[
    Skybox
]]

local function GetCustomImage(url)
    if not url or url == "" then
        return nil
    end

    local cache = caches.image_cache[url]
    if cache and cache.Asset then
        return cache.Asset
    end

    local filename = url:match("([^/]+)%?.*$") or url:match("([^/]+)$")
    if not filename then
        return nil
    end

    local filePath = string.format("%s/assets/%s", kConstants.kBaseFolderName, filename)

    if not isfile(filePath) then
        local ok, data = pcall(game.HttpGet, game, url)
        if not ok or not data then
            return nil
        end

        local writeOk = pcall(writefile, filePath, data)
        if not writeOk then
            return nil
        end
    end

    local assetOk, asset = pcall(getcustomasset, filePath)
    if not assetOk then
        return nil
    end

    caches.image_cache[url] = {
        Url = url,
        Asset = asset
    }

    return asset
end

local function SanitizeTextureId(id)
    if type(id) ~= "string" then
        return
    end

    if string.sub(id, 1, 8) == "rbxasset" then
        return id
    end

    if string.sub(id, 1, 8) == "https://" then
        return GetCustomImage(id)
    end

    if string.match(id, "^%d+$") then
        return "rbxassetid://" .. id
    end

    return
end

local function UpdateSkybox()
    local state = states.visuals_state.skybox

    if state.lighting_skybox == nil then
        local original = services.Lighting:FindFirstChildOfClass("Sky")
        state.lighting_skybox = original:Clone()
        state.lighting_skybox.Parent = original.Parent
        original:Destroy()

        services.Lighting.ChildAdded:Connect(function(child)
            if child:IsA("Sky") then
                task.defer(function()
                    child:Destroy()
                end)
            end
        end)
    end

    local back_texture = ""
    local down_texture = ""
    local front_texture = ""
    local left_texture = ""
    local right_texture = ""
    local up_texture = ""
    local sun_texture = ""
    local moon_texture = ""

    if state.skybox_value == "Use Custom" then
        back_texture = state.skybox_back
        down_texture = state.skybox_down
        front_texture = state.skybox_front
        left_texture = state.skybox_left
        right_texture = state.skybox_right
        up_texture = state.skybox_up
        sun_texture = state.sun_texture
        moon_texture = state.moon_texture
    else
        local skybox = kConstants.kSkyboxMap[state.skybox_value]
        back_texture = skybox.skybox_back
        down_texture = skybox.skybox_down
        front_texture = skybox.skybox_front
        left_texture = skybox.skybox_left
        right_texture = skybox.skybox_right
        up_texture = skybox.skybox_up
        sun_texture = skybox.sun_texture
        moon_texture = skybox.moon_texture
    end

    state.lighting_skybox.SkyboxBk = SanitizeTextureId(back_texture)
    state.lighting_skybox.SkyboxDn = SanitizeTextureId(down_texture)
    state.lighting_skybox.SkyboxFt = SanitizeTextureId(front_texture)
    state.lighting_skybox.SkyboxLf = SanitizeTextureId(left_texture)
    state.lighting_skybox.SkyboxRt = SanitizeTextureId(right_texture)
    state.lighting_skybox.SkyboxUp = SanitizeTextureId(up_texture)
    state.lighting_skybox.SunTextureId = SanitizeTextureId(sun_texture)
    state.lighting_skybox.MoonTextureId = SanitizeTextureId(moon_texture)
    state.lighting_skybox.StarCount = state.star_count
    state.lighting_skybox.SunAngularSize = state.sun_angular_size
    state.lighting_skybox.MoonAngularSize = state.moon_angular_size
end

local function SetSkyboxAutoRotate()
    local state = states.visuals_state.skybox

    if state.lighting_skybox == nil then
        local original = services.Lighting:FindFirstChildOfClass("Sky")
        state.lighting_skybox = original:Clone()
        state.lighting_skybox.Parent = original.Parent
        original:Destroy()

        services.Lighting.ChildAdded:Connect(function(child)
            if child:IsA("Sky") then
                task.defer(function()
                    child:Destroy()
                end)
            end
        end)
    end

    if state.auto_rotate then
        state.auto_rotate_conn = services.RunService.Heartbeat:Connect(LPH_NO_VIRTUALIZE(function(dt)
            state.lighting_skybox.SkyboxOrientation = Vector3.new(0, (state.lighting_skybox.SkyboxOrientation.Y + state.auto_rotate_speed * dt) % 360, 0)
        end))
    else
        state.auto_rotate_conn:Disconnect()
        state.auto_rotate_conn = nil
    end
end

--[[
    Crosshair
]]

SolveLine = LPH_NO_VIRTUALIZE(function(a, r)
    local rad = math.rad(a)
    return Vector2.new(math.sin(rad) * r, math.cos(rad) * r)
end)

pcall(function()
    local lines = {}
    for i = 1, 8 do
        lines[i] = Drawing.new("Line")
    end

    local angles = {
        0,
        90,
        180,
        270
    }

    local current_pos = workspace.CurrentCamera.ViewportSize / 2

    services.RunService.RenderStepped:Connect(LPH_NO_VIRTUALIZE(function()
        local t = os.clock()
        local state = states.visuals_state.crosshair

        local target_pos = workspace.CurrentCamera.ViewportSize / 2
        if table.find(state.position, "Barrel") and not states.target_part then
            local muzzle_pos = GetMuzzlePos()
            if muzzle_pos then
                local screenPos, on_screen = WorldToScreen(muzzle_pos)
                if on_screen then
                    target_pos = Vector2.new(screenPos.X, screenPos.Y)
                else
                    target_pos = workspace.CurrentCamera.ViewportSize / 2
                end
            end
        end

        if table.find(state.position, "Target") and states.target_part then
            local hitbox_pos = states.target_part.Position
            if hitbox_pos then
                local screenPos, on_screen = WorldToScreen(hitbox_pos)
                if on_screen then
                    target_pos = Vector2.new(screenPos.X, screenPos.Y)
                else
                    target_pos = workspace.CurrentCamera.ViewportSize / 2
                end
            end
        end

        if state.lerp and state.lerp > 0 then
            current_pos = current_pos:Lerp(target_pos, state.lerp)
        else
            current_pos = target_pos
        end

        if not state.enabled then
            for i = 1, 8 do
                lines[i].Visible = false
            end
            return
        end

        local scale = 1 + (math.sin(t * state.bounce_speed) * (1 - 1))

        local length = state.length
        local thickness = state.thickness * 2
        local anim_speed = state.bounce_speed * 0.5
        local rot_speed = state.rotation_speed * 0.5

        if state.bounce_speed > 0 and state.bounce > 0 then
            local phase = t * anim_speed * math.pi * 2
            local alpha = (math.sin(phase) + 1) * 0.5
            length = state.length + alpha * state.bounce
        end

        if state.enabled then
            local spinangle = state.rotation
            if state.rotation_speed > 0 then
                spinangle = (state.rotation + t * rot_speed * 360) % 360
            end

            for i = 1, 4 do
                local basea = angles[i] + spinangle
                local p1 = current_pos + SolveLine(basea, state.offset * scale)
                local p2 = current_pos + SolveLine(basea, (state.offset + length) * scale)

                local fill = lines[i + 4]
                fill.Visible = true
                fill.Color = state.fill_color
                fill.From = p1
                fill.To = p2
                fill.Thickness = thickness

                local outline = lines[i]
                outline.Visible = true
                outline.Color = state.outline_color
                outline.From = current_pos + SolveLine(basea, state.offset * scale - 1)
                outline.To = current_pos + SolveLine(basea, (state.offset + length) * scale + 1)
                outline.Thickness = thickness + 2
            end
        else
            for i = 1, 8 do
                lines[i].Visible = false
            end
        end
    end))
end)

--[[
    SunRays
]]

local function UpdateSunRaysOptions()
    local state = states.visuals_state.sunrays

    if state.lighting_sunrays == nil then
        local original = services.Lighting:FindFirstChildOfClass("SunRaysEffect")
        if original then
            state.lighting_sunrays = original:Clone()
            state.lighting_sunrays.Parent = original.Parent
            original:Destroy()
        else
            state.lighting_sunrays = Instance.new("SunRaysEffect")
            state.lighting_sunrays.Parent = services.Lighting
        end

        services.Lighting.ChildAdded:Connect(function(child)
            if child:IsA("SunRaysEffect") then
                task.defer(function()
                    child:Destroy()
                end)
            end
        end)
    end

    state.lighting_sunrays.Enabled = state.sunrays_enabled
    state.lighting_sunrays.Intensity = state.sunrays_intensity
    state.lighting_sunrays.Spread = state.sunrays_spread
end

--[[
    Lighting
]]

local debounce = false
UpdateLightingOptions = LPH_JIT_MAX(function()
    local state = states.visuals_state.lighting

    debounce = true
    services.Lighting.Ambient = state.ambient_color
    services.Lighting.OutdoorAmbient = state.outdoor_ambient_color
    services.Lighting.ColorShift_Top = state.shift_top
    services.Lighting.ColorShift_Bottom = state.shift_bottom
    services.Lighting.ExposureCompensation = state.exposure
    services.Lighting.Brightness = state.brightness
    services.Lighting.ShadowSoftness = state.shadow_softness
    services.Lighting.EnvironmentDiffuseScale = state.diffuse_scale
    services.Lighting.EnvironmentSpecularScale = state.specular_scale
    services.Lighting.GlobalShadows = state.global_shadows
    services.Lighting.LightingStyle = kConstants.kLightingStyleMap[state.lighting_style]
    debounce = false
end)

pcall(function()
    local function ReapplyLightingIfNeeded()
	    if debounce then
	        return
	    end
	
	    local state = states.visuals_state.lighting
	    local desired_style = kConstants.kLightingStyleMap[state.lighting_style]
	
	    if services.Lighting.Ambient ~= state.ambient_color
	        or services.Lighting.OutdoorAmbient ~= state.outdoor_ambient_color
	        or services.Lighting.ColorShift_Top ~= state.shift_top
	        or services.Lighting.ColorShift_Bottom ~= state.shift_bottom
	        or services.Lighting.ExposureCompensation ~= state.exposure
	        or services.Lighting.Brightness ~= state.brightness
	        or services.Lighting.ShadowSoftness ~= state.shadow_softness
	        or services.Lighting.EnvironmentDiffuseScale ~= state.diffuse_scale
	        or services.Lighting.EnvironmentSpecularScale ~= state.specular_scale
	        or services.Lighting.GlobalShadows ~= state.global_shadows
	        or services.Lighting.LightingStyle ~= desired_style
	    then
	        UpdateLightingOptions()
	    end
	end
	
	local lighting_change_connections = {}
	local function ConnectLightingChangeHandlers()
	    if next(lighting_change_connections) ~= nil then
	        return
	    end
	
	    local properties = {
	        "Ambient",
	        "OutdoorAmbient",
	        "ColorShift_Top",
	        "ColorShift_Bottom",
	        "ExposureCompensation",
	        "Brightness",
	        "ShadowSoftness",
	        "EnvironmentDiffuseScale",
	        "EnvironmentSpecularScale",
	        "GlobalShadows",
	        "LightingStyle",
	    }
	
	    for _, property_name in ipairs(properties) do
	        table.insert(lighting_change_connections, services.Lighting:GetPropertyChangedSignal(property_name):Connect(ReapplyLightingIfNeeded))
	    end
	end
	
	ConnectLightingChangeHandlers()
end)

--[[
    Atmosphere
]]

local function UpdateAtmosphereOptions()
    local state = states.visuals_state.atmosphere

    if state.lighting_atmosphere == nil then
        local original = services.Lighting:FindFirstChildOfClass("Atmosphere")
        state.lighting_atmosphere = original:Clone()
        state.lighting_atmosphere.Parent = original.Parent
        original:Destroy()

        services.Lighting.ChildAdded:Connect(function(child)
            if child:IsA("Atmosphere") then
                task.defer(function()
                    child:Destroy()
                end)
            end
        end)
    end

    state.lighting_atmosphere.Density = state.density
    state.lighting_atmosphere.Offset = state.offset
    state.lighting_atmosphere.Color = state.color
    state.lighting_atmosphere.Decay = state.decay
    state.lighting_atmosphere.Glare = state.glare
    state.lighting_atmosphere.Haze = state.haze
end

--[[
    ColorCorrection
]]

local function UpdateColorCorrectionOptions()
    local state = states.visuals_state.color_correction

    if state.lighting_cc == nil then
        state.lighting_cc = Instance.new("ColorCorrectionEffect")
        state.lighting_cc.Parent = services.Lighting
    end

    state.lighting_cc.Enabled = state.enabled
    state.lighting_cc.Brightness = state.brightness
    state.lighting_cc.Contrast = state.contrast
    state.lighting_cc.Saturation = state.saturation
    state.lighting_cc.TintColor = state.tint_color
end

--[[
    Weather
]]

local function StartWeatherThunder()
    local state = states.visuals_state.weather

    if state.thunder_active then
        return
    end

    state.thunder_active = true

    state.thunder_loop = task.spawn(LPH_JIT_MAX(function()
        while state.thunder_active do
            task.wait(math.random(5, 15))

            if not state.thunder_active then
                break
            end

            local base = states.visuals_state.lighting.brightness

            states.visuals_state.lighting.brightness = base + 10
            UpdateLightingOptions()

            task.wait(0.08)

            states.visuals_state.lighting.brightness = base + 6
            UpdateLightingOptions()

            task.wait(0.12)

            states.visuals_state.lighting.brightness = base + 8
            UpdateLightingOptions()

            task.wait(0.08)

            states.visuals_state.lighting.brightness = base
            UpdateLightingOptions()
        end
    end))
end

local function StopWeatherThunder()
	states.visuals_state.weather.thunder_active = false
	states.visuals_state.weather.thunder_loop = nil
end

local function UpdateWeatherOptions()
    local state = states.visuals_state.weather

    if state.emitter_part == nil then
        state.emitter_part = Instance.new("Part")
        state.emitter_part.Name = ""
        state.emitter_part.Parent = workspace
        state.emitter_part.Size = Vector3.new(50, 1, 50)
        state.emitter_part.Anchored = true
        state.emitter_part.Transparency = 1
        state.emitter_part.Orientation = Vector3.new(0, -90, 0)
        state.emitter_part.CanCollide = false
        state.emitter_part.CanQuery = false
        state.emitter_part.CanTouch = false

        services.RunService.RenderStepped:Connect(LPH_NO_VIRTUALIZE(function()
            if not state.emitter_part then return end
            state.emitter_part.Position = workspace.CurrentCamera.CFrame.Position + Vector3.new(0, 25, 0)
        end))
    end

    for _, child in ipairs(state.emitter_part:GetChildren()) do
        child:Destroy()
    end

    if state.thunder_active or not state.enabled then
        StopWeatherThunder()
    end

    if not state.enabled then
        return
    end

    if state.type == "Rain" then
        state.emitter_part.Color = Color3.fromRGB(163, 162, 165)

        local emitter = Instance.new("ParticleEmitter")
        emitter.Name = ""
        emitter.Parent = state.emitter_part
        emitter.Brightness = 2
        emitter.Orientation = Enum.ParticleOrientation.VelocityParallel
        emitter.Color = ColorSequence.new(Color3.fromRGB(255, 255, 255))
        emitter.Rate = state.rate * 500
        emitter.Lifetime = NumberRange.new(0.5, 0.5)
        emitter.Speed = NumberRange.new(100, 100)
        emitter.Size = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 1, 0),
            NumberSequenceKeypoint.new(0.1, 0.708511, 0),
            NumberSequenceKeypoint.new(0.2, 0.522806, 0),
            NumberSequenceKeypoint.new(0.3, 0.386288, 0),
            NumberSequenceKeypoint.new(0.4, 0.280422, 0),
            NumberSequenceKeypoint.new(0.5, 0.196475, 0),
            NumberSequenceKeypoint.new(0.6, 0.12965, 0),
            NumberSequenceKeypoint.new(0.7, 0.0771794, 0),
            NumberSequenceKeypoint.new(0.8, 0.0376439, 0),
            NumberSequenceKeypoint.new(0.9, 0.0109769, 0),
            NumberSequenceKeypoint.new(1, 0, 0)
        })
        emitter.Squash = NumberSequence.new(-3)
        emitter.Texture = GetCustomImage(kConstants.kBaseURL .. "Textures/rain.png")
        emitter.Transparency = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 1, 0),
            NumberSequenceKeypoint.new(0.196451, 0.83125, 0),
            NumberSequenceKeypoint.new(1, 1, 0)
        })
        emitter.ZOffset = 1
        emitter.Rotation = NumberRange.new(180)
        emitter.RotSpeed = NumberRange.new(0, 0)
        emitter.SpreadAngle = Vector2.new(0, 0)
        emitter.EmissionDirection = Enum.NormalId.Bottom
        emitter.LockedToPart = true
        emitter.LightEmission = 1
        emitter.LightInfluence = 0
        emitter.TimeScale = state.timescale

        emitter:SetAttribute("EmitDelay", 0)
        services.CollectionService:AddTag(emitter, "AuraInstance")

        emitter:Clone().Parent = emitter.Parent
        emitter:Clone().Parent = emitter.Parent
    elseif state.type == "Snow" then
        state.emitter_part.Color = Color3.fromRGB(0, 255, 255)

        local emitter = Instance.new("ParticleEmitter")
        emitter.Name = ""
        emitter.Parent = state.emitter_part
        emitter.Brightness = 2
        emitter.Orientation = Enum.ParticleOrientation.VelocityParallel
        emitter.Color = ColorSequence.new(Color3.fromRGB(255, 255, 255))
        emitter.Rate = state.rate * 500
        emitter.Lifetime = NumberRange.new(3, 3)
        emitter.Speed = NumberRange.new(10, 10)
        emitter.Size = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 0.125, 0),
            NumberSequenceKeypoint.new(1, 0.05, 0)
        })
        emitter.Texture = GetCustomImage(kConstants.kBaseURL .. "Textures/snow.png")
        emitter.Transparency = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 1, 0),
            NumberSequenceKeypoint.new(0.02, 0.4, 0),
            NumberSequenceKeypoint.new(0.95, 0.4, 0),
            NumberSequenceKeypoint.new(1, 1, 0)
        })
        emitter.ZOffset = 0
        emitter.Rotation = NumberRange.new(0, 360)
        emitter.RotSpeed = NumberRange.new(-5, 5)
        emitter.SpreadAngle = Vector2.new(-15, 15)
        emitter.EmissionDirection = Enum.NormalId.Bottom
        emitter.LockedToPart = true
        emitter.LightEmission = 0
        emitter.LightInfluence = 1
        emitter.TimeScale = state.timescale
    else
        state.emitter_part.Color = Color3.fromRGB(163, 162, 165)

        local emitter = Instance.new("ParticleEmitter")
        emitter.Name = ""
        emitter.Parent = state.emitter_part
        emitter.Brightness = 2
        emitter.Orientation = Enum.ParticleOrientation.VelocityParallel
        emitter.Color = ColorSequence.new(Color3.fromRGB(255, 255, 255))
        emitter.Rate = state.rate * 500
        emitter.Lifetime = NumberRange.new(0.5, 0.5)
        emitter.Speed = NumberRange.new(100, 100)
        emitter.Size = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 1, 0),
            NumberSequenceKeypoint.new(0.1, 0.708511, 0),
            NumberSequenceKeypoint.new(0.2, 0.522806, 0),
            NumberSequenceKeypoint.new(0.3, 0.386288, 0),
            NumberSequenceKeypoint.new(0.4, 0.280422, 0),
            NumberSequenceKeypoint.new(0.5, 0.196475, 0),
            NumberSequenceKeypoint.new(0.6, 0.12965, 0),
            NumberSequenceKeypoint.new(0.7, 0.0771794, 0),
            NumberSequenceKeypoint.new(0.8, 0.0376439, 0),
            NumberSequenceKeypoint.new(0.9, 0.0109769, 0),
            NumberSequenceKeypoint.new(1, 0, 0)
        })
        emitter.Squash = NumberSequence.new(-5)
        emitter.Texture = GetCustomImage(kConstants.kBaseURL .. "Textures/rain.png")
        emitter.Transparency = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 1, 0),
            NumberSequenceKeypoint.new(0.196451, 0.83125, 0),
            NumberSequenceKeypoint.new(1, 1, 0)
        })
        emitter.ZOffset = 1
        emitter.Rotation = NumberRange.new(180)
        emitter.RotSpeed = NumberRange.new(0, 0)
        emitter.SpreadAngle = Vector2.new(0, 0)
        emitter.EmissionDirection = Enum.NormalId.Bottom
        emitter.LockedToPart = true
        emitter.LightEmission = 1
        emitter.LightInfluence = 0
        emitter.TimeScale = state.timescale

        emitter:SetAttribute("EmitDelay", 0)
        services.CollectionService:AddTag(emitter, "AuraInstance")

        emitter:Clone().Parent = emitter.Parent
        emitter:Clone().Parent = emitter.Parent
        emitter:Clone().Parent = emitter.Parent
        emitter:Clone().Parent = emitter.Parent
        emitter:Clone().Parent = emitter.Parent
        emitter:Clone().Parent = emitter.Parent

        StartWeatherThunder()
    end
end

--[[
    Ambience
]]

GetThunderSound = LPH_JIT_MAX(function()
    local sound = services.SoundService:FindFirstChild("AmbienceThunder")

    if not sound then
        sound = Instance.new("Sound")
        sound.Name = ""
        sound.SoundId = "rbxassetid://6409267922"
        sound.Volume = 1
        sound.Parent = services.SoundService
    end

    return sound
end)

local function StartAmbienceThunder()
    local state = states.visuals_state.ambience

    if state.thunder_active then
        return
    end

    state.thunder_active = true

    state.thunder_loop = task.spawn(LPH_JIT_MAX(function()
        while state.thunder_active do
            task.wait(math.random(5, 15))

            if not state.thunder_active then
                break
            end

            local thunder = GetThunderSound()

            thunder:Stop()
            thunder.TimePosition = 0
            thunder:Play()
        end
    end))
end

local function StopAmbienceThunder()
	states.visuals_state.ambience.thunder_active = false
	states.visuals_state.ambience.thunder_loop = nil
    local thunder = GetThunderSound()
    thunder:Destroy()
end

local function UpdateAmbienceOptions()
    local state = states.visuals_state.ambience

    if state.sound_inst == nil then
        state.sound_inst = Instance.new("Sound")
        state.sound_inst.Parent = services.SoundService
        state.sound_inst.Looped = true
    end

    state.sound_inst:Stop()

    if state.thunder_active or not state.enabled then
        StopAmbienceThunder()
    end

    state.sound_inst.SoundId = kConstants.kAmbienceMap[state.type]
    state.sound_inst.Volume = state.volume

    if state.enabled then
        state.sound_inst:Play()
    end

    if state.type == "Thunder" and state.enabled then
        StartAmbienceThunder()
    end
end

--[[
    Camera
]]

local old_getpublicstate
local function SetStateChangerEnabled(state)
    if state == states.visuals_state.camera.state_changer then
        return
    end

    states.visuals_state.camera.state_changer = state

    ui_objects.StateChangerEnabled:Set(state)
    ui_objects.StateChangerKeybind:SetPressed(state)

    local old_state = modules.CameraController.CameraState._public_state

    if state then
        old_getpublicstate = modules.CameraController.CameraState.GetPublicState
        modules.CameraController.CameraState.GetPublicState = function()
            return states.visuals_state.camera.camera_state
        end
    else
        modules.CameraController.CameraState.GetPublicState = old_getpublicstate
    end

    modules.CameraController.CameraState.StateChanged:Fire(states.visuals_state.camera.camera_state, old_state)
end

local orig_flashbang_replfromserver = modules.Flashbang.ReplicateFromServer
modules.Flashbang.ReplicateFromServer = function(p4, p5, ...)
    if states.visuals_state.camera.anti_flashbang and p5 == "BlindEffect" then
        if p4:IsRendered() then
            local v6, _ = ...;
            p4._play_flash_sound_callback(v6)
        end;
        return
    end

    return orig_flashbang_replfromserver(p4, p5, ...)
end

local orig_smokeclouds_objadded = modules.SmokeClouds._ObjectAdded
modules.SmokeClouds._ObjectAdded = function(p12, p13)
    local result = orig_smokeclouds_objadded(p12, p13)

    if states.visuals_state.camera.anti_smoke then
        if p12._smoke_clouds[p13].Model then
            p12._smoke_clouds[p13].Model:Destroy();
            p12._smoke_clouds[p13].Model = nil;
        end
    end

    return result
end

local SmokeScreen = modules.FighterController:GetFighter(LocalPlayer).FighterInterface.SmokeScreen
local orig_smokescreen_upd = SmokeScreen.Update
SmokeScreen.Update = LPH_NO_VIRTUALIZE(function(self, ...)
    if states.visuals_state.camera.anti_smoke then
        self:Hide()
        return
    end
    orig_smokescreen_upd(self, ...)
end)

services.RunService.RenderStepped:Connect(LPH_NO_VIRTUALIZE(function()
    workspace.CurrentCamera.CFrame = workspace.CurrentCamera.CFrame * CFrame.new(0, 0, 0, 1, 0, 0, 0, states.visuals_state.camera.camera_resolution, 0, 0, 0, 1)
    modules.CameraController._base_fov = states.visuals_state.camera.camera_fov
    services.Lighting.ClockTime = states.visuals_state.skybox.clocktime
end))

--[[
    Unlocker
]]

CloneCosmetic = LPH_JIT_MAX(function(name, cosmetic_type, options)
    if not modules.CosmeticLibrary or not modules.CosmeticLibrary.Cosmetics then return nil end

    local base = modules.CosmeticLibrary.Cosmetics[name]
    if not base then return nil end

    local data = table.clone(base)
    data.Name = name
    data.Type = data.Type or cosmetic_type
    data.Seed = math.random(1, 1000000)

    if modules.EnumLibrary then
        pcall(function()
            local enum_id = modules.EnumLibrary:ToEnum(name)
            if enum_id then
                data.Enum, data.ObjectID = enum_id, enum_id
            end
        end)
    end

    if options then
        if options.inverted then
            data.Inverted = true
        end

        if options.favorites_only then
            data.OnlyUseFavorites = true
        end
    end

    return data
end)

local ownscosnorm_original = modules.CosmeticLibrary.OwnsCosmeticNormally
modules.CosmeticLibrary.OwnsCosmeticNormally = LPH_JIT_MAX(function(p1, p2, p3)
    local entry = states.skinchanger_state.fake_owned[p3]
    if entry then return true end
    return ownscosnorm_original(p1, p2, p3)
end)

local ownscosuni_original = modules.CosmeticLibrary.OwnsCosmeticUniversally
modules.CosmeticLibrary.OwnsCosmeticUniversally = LPH_JIT_MAX(function(p1, p2, p3)
    local entry = states.skinchanger_state.fake_owned[p3]
    if entry then return true end
    return ownscosuni_original(p1, p2, p3)
end)

local ownscosforsm_original = modules.CosmeticLibrary.OwnsCosmeticForSomething
modules.CosmeticLibrary.OwnsCosmeticForSomething = LPH_JIT_MAX(function(p1, p2, p3)
    local entry = states.skinchanger_state.fake_owned[p3]
    if entry then return true end
    return ownscosforsm_original(p1, p2, p3)
end)

local ownscosforwp_original = modules.CosmeticLibrary.OwnsCosmeticForWeapon
modules.CosmeticLibrary.OwnsCosmeticForWeapon = LPH_JIT_MAX(function(p1, p2, p3, p4)
    local entry = states.skinchanger_state.fake_owned[p3]
    if entry then return true end
	return ownscosforwp_original(p1, p2, p3, p4)
end)

local owns_cosmetic_original = modules.CosmeticLibrary.OwnsCosmetic
modules.CosmeticLibrary.OwnsCosmetic = LPH_JIT_MAX(function(self, inventory, name, weapon)
    local entry = states.skinchanger_state.fake_owned[name]
    if entry then return true end
    return owns_cosmetic_original(self, inventory, name, weapon)
end)

local hasgamepass_original = modules.PlayerDataController.HasGamepass
modules.PlayerDataController.HasGamepass = LPH_JIT_MAX(function(p11, ...)
    local has_gamepass = hasgamepass_original(p11, ...)
    local name = ({...})[1]

    return states.spoofer_state.marketplace.fake_bundles_owned[name] or has_gamepass
end)

local dataget_original = modules.PlayerDataController.Get
modules.PlayerDataController.Get = LPH_JIT_MAX(function(p1, ...)
    local data = dataget_original(p1, ...)
    local key = ({...})[1]

    if key == "CosmeticInventory" then
        return states.skinchanger_state.fake_owned or data
    end
    if key == "UnclaimedRewards" then
        return states.inventory_state.fake_owned or data
    end
    if key == "GiftRobuxSpentProgress" then
        return states.spoofer_state.marketplace.fake_gift_robux_spent or data
    end
    if key == "GiftRobuxSpentRewardsClaimed" then
        return states.spoofer_state.marketplace.fake_gift_rewards_claimed or data
    end
    if key == "GamepassBundlesClaimed" then
        return states.spoofer_state.marketplace.fake_bundles_owned or data
    end
    if key == "DuelHistory" then
        return states.spoofer_state.duel_history.duel_history_value or data
    end
    if key == "LoggedELOEvents" then
        return states.spoofer_state.duel_history.logged_elo_events or data
    end
    if key == "WeaponKeys" then
        return states.spoofer_state.currency.weapon_keys_value or data
    end
    if key == "UnlockTokens" then
        return states.spoofer_state.currency.unlock_tokens_value or data
    end
    if key == "EventCurrency" then
        return states.spoofer_state.currency.event_currency_value or data
    end
    if key == "Glory" then
        return states.spoofer_state.currency.glory_value or data
    end
    if key == "SkinTickets" then
        return states.spoofer_state.currency.skin_tickets_value or data
    end
    if key == "WeaponInventory" then
        return states.skinchanger_state.fake_weapon_owned or data
    end
    if key == "FreeWeaponUnlockCheck" then
        return states.skinchanger_state.fake_weapon_owned or data
    end
    if key == "FavoritedCosmetics" then
        return states.skinchanger_state.favorites or data
    end
    return data
end)

local getweapondata_original = modules.PlayerDataController.GetWeaponData
modules.PlayerDataController.GetWeaponData = LPH_JIT_MAX(function(p1, ...)
    local weapon_name = ({...})[1]
    local original_data, index = getweapondata_original(p1, ...)

    local fake_owned = false
    for _, weapon in ipairs(states.skinchanger_state.fake_weapon_owned) do
        if weapon.Name == weapon_name then
            fake_owned = true
            break
        end
    end

    if fake_owned and not original_data then
        local fake_data = {
            Name = weapon_name,
            Level = 1,
            XP = 0,
            IsFavorited = false,
            Skin = nil,
        }

        if states.skinchanger_state.equipped
            and states.skinchanger_state.equipped[weapon_name] then

            for cos_type, cos_data in pairs(
                states.skinchanger_state.equipped[weapon_name]
            ) do
                if type(cos_data) == "table" and (cos_data.Name == "NONE_COSMETIC" or cos_data.Name == "None") then
                    fake_data[cos_type] = nil
                else
                    fake_data[cos_type] = cos_data
                end
            end
        end

        return fake_data, index
    end

    if original_data
        and states.skinchanger_state.equipped
        and states.skinchanger_state.equipped[weapon_name] then

        for cos_type, cos_data in pairs(
            states.skinchanger_state.equipped[weapon_name]
        ) do
            if type(cos_data) == "table" and (cos_data.Name == "NONE_COSMETIC" or cos_data.Name == "None") then
                original_data[cos_type] = nil
            else
                original_data[cos_type] = cos_data
            end
        end
    end

    return original_data, index
end)

local function PatchCurrentDataGet(current_data)
    if not current_data or type(current_data.Get) ~= "function" or current_data._fakeWeaponOwnedPatched then
        return
    end

    local old_get = current_data.Get
    current_data.Get = function(self, ...)
        local data = old_get(self, ...)
        local key = ({...})[1]

        if key == "CosmeticInventory" then
            return states.skinchanger_state.fake_owned or data
        end

        if key == "UnclaimedRewards" then
            return states.inventory_state.fake_owned or data
        end

        if key == "WeaponInventory" then
            return states.skinchanger_state.fake_weapon_owned or data
        end

        if key == "FreeWeaponUnlockCheck" then
            return states.skinchanger_state.fake_weapon_owned or data
        end

        return data
    end

    current_data._fakeWeaponOwnedPatched = true
end

local function GetRandomCosmetic(cosmetic_type, weapon_name, is_inverted, only_use_favorites)
    local available = {}

    for cosmetic_name, cosmetic_data in pairs(modules.CosmeticLibrary.Cosmetics) do
        if cosmetic_type == "Skin" then
            if cosmetic_data.Type == cosmetic_type and  modules.CosmeticLibrary:OwnsCosmetic(modules.PlayerDataController:Get("CosmeticInventory"), cosmetic_name, weapon_name) and cosmetic_data.ItemName == weapon_name then
                table.insert(available, cosmetic_name)
            end
        else
            if cosmetic_data.Type == cosmetic_type and modules.CosmeticLibrary:OwnsCosmetic(modules.PlayerDataController:Get("CosmeticInventory"), cosmetic_name, weapon_name) then
                table.insert(available, cosmetic_name)
            end
        end
    end

    if #available == 0 then
        return nil
    end

    return CloneCosmetic(
        available[math.random(#available)],
        cosmetic_type,
        {
            inverted = is_inverted,
            favorites_only = only_use_favorites
        }
    )
end

ResolveCosmetic = LPH_JIT_MAX(function(weaponName, cosmeticType)
    local equipped = states.skinchanger_state.equipped[weaponName] and states.skinchanger_state.equipped[weaponName][cosmeticType]

    if not equipped then
        return nil
    end

    if equipped.Name == "None" or equipped.Name == "NONE_COSMETIC" then
        return nil
    end

    if equipped.Name == "Random" or equipped.Name == "RANDOM_COSMETIC" then
        return GetRandomCosmetic(
            cosmeticType,
            weaponName,
            equipped.Inverted,
            equipped.OnlyUseFavorites
        )
    end

    return equipped
end)

task.spawn(LPH_NO_VIRTUALIZE(function()
    while not modules.PlayerDataController.CurrentData do
        task.wait(0.1)
    end
    PatchCurrentDataGet(modules.PlayerDataController.CurrentData)
end))

RebuildObjectIDMap = LPH_NO_VIRTUALIZE(function()
    if not modules.FighterController then return end
    pcall(function()
        local fighter = modules.FighterController:GetFighter(LocalPlayer)
        if not fighter or not fighter.Items then return end
        for _, item in pairs(fighter.Items) do
            local ok, oid = pcall(function()
                return item:Get("ObjectID")
            end)

            if ok and oid ~= nil then
                caches.objectid_to_weapon_cache[tostring(oid)] = item.Name
            end
        end
    end)
end)

task.spawn(LPH_NO_VIRTUALIZE(function()
    while true do
        RebuildObjectIDMap()
        task.wait(5)
    end
end))

task.spawn(LPH_JIT_MAX(function()
    task.wait(1)

    local function HandleUseItem(args)
        if not modules.FighterController then return end

        local oid_str = args[1] ~= nil and tostring(args[1]) or nil
        if not oid_str then return end

        local cached = caches.objectid_to_weapon_cache[oid_str]
        if cached then
            states.skinchanger_state.last_used_weapon = cached
            return
        end

        task.spawn(function()
            pcall(function()
                local fighter = modules.FighterController:GetFighter(LocalPlayer)
                if not fighter or not fighter.Items then return end
                for _, item in pairs(fighter.Items) do
                    local ok, oid = pcall(function() return item:Get("ObjectID") end)
                    if ok and oid ~= nil and tostring(oid) == oid_str then
                        states.skinchanger_state.last_used_weapon = item.Name
                        caches.objectid_to_weapon_cache[oid_str] = item.Name
                        break
                    end
                end
            end)
        end)
    end

    local function HandleEquip(args)
        local weapon_name = args[1]
        local cosmetic_type = args[2]
        local cosmetic_name = args[3]
        local options = args[4] or {}

        states.skinchanger_state.equipped[weapon_name] = states.skinchanger_state.equipped[weapon_name] or {}

        if not cosmetic_name or cosmetic_name == "" or cosmetic_name == "None" or cosmetic_name == "NONE_COSMETIC" then
            states.skinchanger_state.equipped[weapon_name] = states.skinchanger_state.equipped[weapon_name] or {}
            states.skinchanger_state.equipped[weapon_name][cosmetic_type] = { Name = "NONE_COSMETIC" }
        elseif cosmetic_name == "Random" or cosmetic_name == "RANDOM_COSMETIC" then
            local data = {}
            data.Name = cosmetic_name
            data.Type = cosmetic_type
            data.Inverted = options.IsInverted
            data.OnlyUseFavorites = options.OnlyUseFavorites
            data.Seed = math.random(1, 1000000)

            states.skinchanger_state.equipped[weapon_name][cosmetic_type] = data
        else
            local cloned = CloneCosmetic(
                cosmetic_name,
                cosmetic_type,
                {
                    inverted = options.IsInverted,
                    favorites_only = options.OnlyUseFavorites
                }
            )

            if cloned then
                states.skinchanger_state.equipped[weapon_name][cosmetic_type] = cloned
            end
        end

        task.spawn(function()
            task.wait(0.1)

            pcall(function()
                if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
                    modules.PlayerDataController.CurrentData:Replicate("WeaponInventory")
                end
            end)
        end)
    end

    local function HandleFavorite(args)
        local weapon_name = args[1]
        local cosmetic_name = args[2]
        local state = args[3]

        states.skinchanger_state.favorites[weapon_name] = states.skinchanger_state.favorites[weapon_name] or {}
        states.skinchanger_state.favorites[weapon_name][cosmetic_name] = state or nil
    end

    NamecallDispatcher:Register(function(self, method, ...)
        if method ~= "FireServer" then
            return false
        end

        local args = { ... }

        if self.Name == "UseItem" then
            HandleUseItem(args)
            return NamecallDispatcher:CallOriginal(self, ...)
        end

        if self.Name == "EquipCosmetic" then
            HandleEquip(args)
            return true
        end

        if self.Name == "FavoriteCosmetic" then
            HandleFavorite(args)
            return true
        end

        return false
    end)
end))

local getviewmodelimage_original = modules.ItemLibrary.GetViewModelImageFromWeaponData
modules.ItemLibrary.GetViewModelImageFromWeaponData = function(p1, p2, p3)
    if not p2 then return getviewmodelimage_original(p1, p2, p3) end

    local weapon_name = p2.Name
    local should_show_skin = (p2.Skin and states.skinchanger_state.equipped[weapon_name] and p2.Skin == ResolveCosmetic(weapon_name, "Skin")) or (states.skinchanger_state.viewing_profile == LocalPlayer and states.skinchanger_state.equipped[weapon_name] and ResolveCosmetic(weapon_name, "Skin"))

    if should_show_skin and states.skinchanger_state.equipped[weapon_name] and ResolveCosmetic(weapon_name, "Skin") then
        local skin_info = p1.ViewModels[ResolveCosmetic(weapon_name, "Skin").Name]

        if skin_info then
            return skin_info[p3 and "ImageHighResolution" or "Image"] or skin_info.Image
        end
    end
    return getviewmodelimage_original(p1, p2, p3)
end

task.spawn(LPH_JIT_MAX(function()
    task.wait(3)
    pcall(function()
        local clientItemPath = LocalPlayer.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem
        local ClientItem = require(clientItemPath)
        if ClientItem._CreateViewModel then
            local orig = ClientItem._CreateViewModel
            ClientItem._CreateViewModel = function(self, viewmodelRef)
                local weaponName = self.Name
                local weaponPlayer = self.ClientFighter and self.ClientFighter.Player
                states.skinchanger_state.constructing_weapon = (weaponPlayer == LocalPlayer) and weaponName or nil

                if weaponPlayer == LocalPlayer and states.skinchanger_state.equipped[weaponName] and ResolveCosmetic(weaponName, "Skin") and viewmodelRef then
                    pcall(function()
                        local dataKey, skinKey, nameKey = self:ToEnum("Data"), self:ToEnum("Skin"), self:ToEnum("Name")

                        if viewmodelRef[dataKey] then
                            viewmodelRef[dataKey][skinKey] = ResolveCosmetic(weaponName, "Skin")
                            viewmodelRef[dataKey][nameKey] = ResolveCosmetic(weaponName, "Skin").Name
                        elseif viewmodelRef.Data then
                            viewmodelRef.Data.Skin = ResolveCosmetic(weaponName, "Skin")
                            viewmodelRef.Data.Name = ResolveCosmetic(weaponName, "Skin").Name
                        end
                    end)
                end

                local result = orig(self, viewmodelRef)
                states.skinchanger_state.constructing_weapon = nil

                return result
            end
        end
    end)
    pcall(function()
        local viewModelModule = LocalPlayer.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem:FindFirstChild("ClientViewModel")
        if viewModelModule then
            local ClientViewModel = require(viewModelModule)
            if ClientViewModel.GetWrap then
                local orig = ClientViewModel.GetWrap
                ClientViewModel.GetWrap = function(self)
                    local weaponName = self.ClientItem and self.ClientItem.Name
                    local weaponPlayer = self.ClientItem and self.ClientItem.ClientFighter and self.ClientItem.ClientFighter.Player

                    if weaponName and weaponPlayer == LocalPlayer and states.skinchanger_state.equipped[weaponName] and ResolveCosmetic(weaponName, "Wrap") then
                        return ResolveCosmetic(weaponName, "Wrap")
                    end
                    return orig(self)
                end
            end
            local origNew = ClientViewModel.new
            ClientViewModel.new = function(replicatedData, clientItem)
                local weaponPlayer = clientItem.ClientFighter and clientItem.ClientFighter.Player
                local weaponName = states.skinchanger_state.constructing_weapon or clientItem.Name

                if weaponPlayer == LocalPlayer and states.skinchanger_state.equipped[weaponName] then
                    pcall(function()
                        local ReplicatedClass = require(services.ReplicatedStorage.Modules.ReplicatedClass)
                        local dataKey = ReplicatedClass:ToEnum("Data")
                        replicatedData[dataKey] = replicatedData[dataKey] or {}

                        if ResolveCosmetic(weaponName, "Skin") then
                            replicatedData[dataKey][ReplicatedClass:ToEnum("Skin")] = ResolveCosmetic(weaponName, "Skin")
                        end

                        if ResolveCosmetic(weaponName, "Wrap") then
                            replicatedData[dataKey][ReplicatedClass:ToEnum("Wrap")] = ResolveCosmetic(weaponName, "Wrap")
                        end

                        if ResolveCosmetic(weaponName, "Charm") then
                            replicatedData[dataKey][ReplicatedClass:ToEnum("Charm")] = ResolveCosmetic(weaponName, "Charm")
                        end
                    end)
                end
                local result = origNew(replicatedData, clientItem)
                pcall(function()
                    local objectID = nil
                    pcall(function()
                        local ReplicatedClass = require(services.ReplicatedStorage.Modules.ReplicatedClass)
                        local dataKey = ReplicatedClass:ToEnum("Data")
                        local objKey  = ReplicatedClass:ToEnum("ObjectID")
                        if replicatedData[dataKey] then
                            objectID = replicatedData[dataKey][objKey]
                        end
                    end)
                    if objectID == nil then
                        pcall(function() objectID = result:Get("ObjectID") or result.ObjectID end)
                    end
                    if objectID and weaponPlayer == LocalPlayer and states.skinchanger_state.equipped[weaponName] then
                        states.skinchanger_state.placed_object_map = states.skinchanger_state.placed_object_map or {}
                        states.skinchanger_state.placed_object_map[objectID] = weaponName
                    end
                end)
                if weaponPlayer == LocalPlayer and states.skinchanger_state.equipped[weaponName] and ResolveCosmetic(weaponName, "Wrap") and result._UpdateWrap then
                    task.spawn(function()
                        result:_UpdateWrap()
                        task.wait(0.1)
                        if not result._destroyed then result:_UpdateWrap() end
                    end)
                end
                return result
            end
        end
    end)
    pcall(function()
        local ViewProfile = require(LocalPlayer.PlayerScripts.Modules.Pages.ViewProfile)
        if ViewProfile and ViewProfile.Fetch then
            local orig = ViewProfile.Fetch
            ViewProfile.Fetch = function(self, targetPlayer)
                states.skinchanger_state.viewing_profile = targetPlayer
                return orig(self, targetPlayer)
            end
        end
    end)
    pcall(function()
        local ClientEntity = require(LocalPlayer.PlayerScripts.Modules.ClientReplicatedClasses.ClientEntity)
        if not ClientEntity or not ClientEntity.ReplicateFromServer then return end

        local orig = ClientEntity.ReplicateFromServer

        local function DecodeKillerArg(value)
            if value == nil then return nil end

            if typeof(value) == "Instance" then
                if value:IsA("Player") then
                    return value.Name
                end
                return nil
            end

            if type(value) == "number" then
                return value == LocalPlayer.UserId and LocalPlayer.Name or nil
            end

            if type(value) == "string" then
                return value
            end

            if type(value) == "userdata" then
                if modules.EnumLibrary and modules.EnumLibrary.FromEnum then
                    local ok, decoded = pcall(function() return modules.EnumLibrary:FromEnum(value) end)
                    if ok and decoded ~= nil then
                        return tostring(decoded)
                    end
                end
                return tostring(value)
            end

            return tostring(value)
        end

        local function IsLocalPlayerKiller(args)
            local lname_lower = LocalPlayer.Name:lower()
            local decoded = DecodeKillerArg(args[3])
            if decoded and decoded:lower() == lname_lower then
                return true
            end
            return false
        end

        local function ResolveFinisherWeapon()
            local primary = states.skinchanger_state.last_used_weapon
            if primary
                and states.skinchanger_state.equipped[primary]
                and ResolveCosmetic(primary, "Finisher")
            then
                return primary
            end

            for weaponName, _ in pairs(states.skinchanger_state.equipped) do
                if ResolveCosmetic(weaponName, "Finisher") then
                    return weaponName
                end
            end

            return nil
        end

        local function ResolveFinisherEnum(finisherData)
            if not finisherData then
                return nil, "finisherData is nil"
            end

            if finisherData.Enum ~= nil then
                return finisherData.Enum, nil
            end

            if modules.EnumLibrary then
                if modules.EnumLibrary.ToEnum then
                    local ok, result = pcall(function()
                        return modules.EnumLibrary:ToEnum(finisherData.Name)
                    end)
                    if ok and result ~= nil then
                        finisherData.Enum = result
                        return result, nil
                    end
                end
            end

            if finisherData.ObjectID ~= nil then
                finisherData.Enum = finisherData.ObjectID
                return finisherData.ObjectID, nil
            end

            return nil, "could not resolve enum for finisher: " .. tostring(finisherData.Name)
        end

        ClientEntity.ReplicateFromServer = function(self, action, ...)
            if action ~= "FinisherEffect" then
                return orig(self, action, ...)
            end

            local args = { ... }

            if not IsLocalPlayerKiller(args) then
                return orig(self, action, ...)
            end

            local weaponName = ResolveFinisherWeapon()
            if not weaponName then
                return orig(self, action, ...)
            end

            local finisherData = ResolveCosmetic(weaponName, "Finisher")
            local finisherEnum, _ = ResolveFinisherEnum(finisherData)

            if finisherEnum == nil then
                return orig(self, action, ...)
            end

            if not self:IsRendered() then return end

            local ok, decoded = pcall(function()
                return self:FromEnum(finisherEnum)
            end)
            if not ok or decoded == nil then
                decoded = finisherData.Name
            end

            if decoded == nil then
                return orig(self, action, ...)
            end

            local v2, v3, v4 = args[2], args[3], args[4]
            pcall(function()
                self:_PlayFinisher(decoded, v2, v3, v4)
            end)

            return
        end
    end)
    pcall(function()
        if not modules.FighterController or not modules.FighterController.GetWrap then return end

        local orig_GetWrap = modules.FighterController.GetWrap
        modules.FighterController.GetWrap = function(self, objectID)
            local result = orig_GetWrap(self, objectID)
            if result then return result end

            if objectID and states.skinchanger_state.placed_object_map then
                local weaponName = states.skinchanger_state.placed_object_map[objectID]
                if weaponName and states.skinchanger_state.equipped[weaponName] then
                    local wrap = ResolveCosmetic(weaponName, "Wrap")
                    if wrap then return wrap end
                end
            end
            return nil
        end
    end)
    pcall(function()
        local JumpPads = require(LocalPlayer.PlayerScripts.Modules.GameComponents.JumpPads)
        if not JumpPads or not JumpPads.CreateJumpPadVisual then return end

        local orig_CreateVisual = JumpPads.CreateJumpPadVisual
        JumpPads.CreateJumpPadVisual = function(self, name, size)
            if states.skinchanger_state.equipped["Jump Pad"] then
                pcall(function()
                    local skin = ResolveCosmetic("Jump Pad", "Skin")
                    if skin and skin.Name then
                        name = skin.Name
                    end
                end)
            end
            return orig_CreateVisual(self, name, size)
        end
    end)
end))

local function GetCosmeticsByRarity(rarity)
    local results = {}
    for name, cosmetic in pairs(modules.CosmeticLibrary.Cosmetics) do
        if cosmetic.Rarity == rarity then
            table.insert(results, name)
        end
    end
    return results
end

local function GetCosmeticsByType(type_name)
    local results = {}
    for name, cosmetic in pairs(modules.CosmeticLibrary.Cosmetics) do
        if cosmetic.Type == type_name then
            table.insert(results, name)
        end
    end
    return results
end

local function GetSpecificCosmetic(type_name, cos_name, weapon_name)
    local result;
    for name, cosmetic in pairs(modules.CosmeticLibrary.Cosmetics) do
        if type_name == "Skin" then
            if name == cos_name and cosmetic.Type == type_name and cosmetic.ItemName == weapon_name then
                result = name
            end
        else
            if name == cos_name and cosmetic.Type == type_name then
                result = name
            end
        end
    end
    return result
end

local function GetAllCosmeticsOfWeapon(weapon_name)
    local results = {}
    for name, cosmetic in pairs(modules.CosmeticLibrary.Cosmetics) do
        if cosmetic.Type == "Skin" then
            if cosmetic.ItemName == weapon_name then
                table.insert(results, name)
            end
        else
            table.insert(results, name)
        end
    end
    return results
end

local function GetAllCosmetics()
    local results = {}
    for name, _ in pairs(modules.CosmeticLibrary.Cosmetics) do
        table.insert(results, name)
    end
    return results
end

local function UnlockSelectedRarity()
    local rarity = states.skinchanger_state.general_unlocker.unlock_rarity
    local list = GetCosmeticsByRarity(rarity)

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = true
    end
end

local function LockSelectedRarity()
    local rarity = states.skinchanger_state.general_unlocker.unlock_rarity
    local list = GetCosmeticsByRarity(rarity)

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = nil
    end
end

local function UnlockAllOfType()
    local type_name = states.skinchanger_state.general_unlocker.unlock_type
    local list = GetCosmeticsByType(type_name)

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = true
    end
end

local function LockAllOfType()
    local type_name = states.skinchanger_state.general_unlocker.unlock_type
    local list = GetCosmeticsByType(type_name)

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = nil
    end
end

local function UnlockSpecific()
    local type_name = states.skinchanger_state.specific_unlocker.unlock_type
    local cosmetic_name = states.skinchanger_state.specific_unlocker.cosmetic_name
    local weapon_name = states.skinchanger_state.specific_unlocker.weapon_name

    local cosmetic = GetSpecificCosmetic(type_name, cosmetic_name, weapon_name)
    if cosmetic:find("MISSING_") then return end
    states.skinchanger_state.fake_owned[cosmetic] = true
end

local function LockSpecific()
    local type_name = states.skinchanger_state.specific_unlocker.unlock_type
    local cosmetic_name = states.skinchanger_state.specific_unlocker.cosmetic_name
    local weapon_name = states.skinchanger_state.specific_unlocker.weapon_name

    local cosmetic = GetSpecificCosmetic(type_name, cosmetic_name, weapon_name)
    if cosmetic:find("MISSING_") then return end
    states.skinchanger_state.fake_owned[cosmetic] = nil
end

local function UnlockSpecificWeapon()
    local weapon_name = states.skinchanger_state.specific_unlocker.weapon_name
    local current_data = modules.PlayerDataController.CurrentData
    if not current_data then return end

    local inventory = current_data:Get("WeaponInventory")
    local owned = {}
    if type(inventory) == "table" then
        for _, weapon_data in pairs(inventory) do
            if type(weapon_data) == "table" and weapon_data.Name then
                owned[weapon_data.Name] = true
            end
        end
    end

    if not owned[weapon_name] then
        table.insert(states.skinchanger_state.fake_weapon_owned, {
            Name = weapon_name,
            Level = 1,
            XP = 0,
            IsFavorited = false,
            Skin = nil,
        })
    end
end

local function LockSpecificWeapon()
    local weapon_name = states.skinchanger_state.specific_unlocker.weapon_name

    for i, weapon in ipairs(states.skinchanger_state.fake_weapon_owned) do
        if weapon.Name == weapon_name then
            table.remove(states.skinchanger_state.fake_weapon_owned, i)
            break
        end
    end
end

local function UnlockAllWeapons()
    local current_data = modules.PlayerDataController.CurrentData
    if not current_data then return end

    local inventory = current_data:Get("WeaponInventory")
    local owned = {}
    if type(inventory) == "table" then
        for _, weapon_data in pairs(inventory) do
            if type(weapon_data) == "table" and weapon_data.Name then
                owned[weapon_data.Name] = true
            end
        end
    end

    local ownables = modules.ShopLibrary:GetReleasedOwnableWeapons()
    for _, weapon_name in pairs(ownables) do
        if not owned[weapon_name] then
            table.insert(states.skinchanger_state.fake_weapon_owned, {
                Name = weapon_name,
                Level = 1,
                XP = 0,
                IsFavorited = false,
                Skin = nil,
            })
        end
    end
end

local function LockAllWeapons()
    for weapon_name in pairs(states.skinchanger_state.fake_weapon_owned) do
        for i, weapon in ipairs(states.skinchanger_state.fake_weapon_owned) do
            if weapon.Name == weapon_name then
                table.remove(states.skinchanger_state.fake_weapon_owned, i)
                break
            end
        end
    end
end

local function UnlockAllForWeapon()
    local weapon_name = states.skinchanger_state.specific_unlocker.weapon_name
    local list = GetAllCosmeticsOfWeapon(weapon_name)

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = true
    end
end

local function LockAllForWeapon()
    local weapon_name = states.skinchanger_state.specific_unlocker.weapon_name
    local list = GetAllCosmeticsOfWeapon(weapon_name)

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = nil
    end
end

local function UnlockAll()
    local list = GetAllCosmetics()

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = true
    end
end

local function LockAll()
    local list = GetAllCosmetics()

    for _, cosmetic in ipairs(list) do
        if cosmetic:find("MISSING_") then continue end
        states.skinchanger_state.fake_owned[cosmetic] = nil
    end
end

local function EquipApply()
    local EquipCosmeticRemote = services.ReplicatedStorage.Remotes.Data.EquipCosmetic
    local unlock_type = states.skinchanger_state.equip_unlocker.unlock_type
    local cosmetic_name = states.skinchanger_state.equip_unlocker.cosmetic_name
    local weapon_name = states.skinchanger_state.equip_unlocker.weapon_name
    local is_inverted = states.skinchanger_state.equip_unlocker.inverted

    if typeof(weapon_name) ~= "string" or weapon_name == "" then
		return
	end

	local name_to_send = if cosmetic_name ~= nil and cosmetic_name ~= "" then cosmetic_name else nil

	local options = {}
	if unlock_type == "Wrap" then
		options.IsInverted = if is_inverted then true else nil
	end

	EquipCosmeticRemote:FireServer(weapon_name, unlock_type, name_to_send, options)
end

local function EquipApplyAll()
    local EquipCosmeticRemote = services.ReplicatedStorage.Remotes.Data.EquipCosmetic
    local unlock_type = states.skinchanger_state.equip_unlocker.unlock_type
    local cosmetic_name = states.skinchanger_state.equip_unlocker.cosmetic_name
    local is_inverted = states.skinchanger_state.equip_unlocker.inverted

    if unlock_type == "Skin" then return end

	for weapon_name, weapon_data in pairs(modules.ItemLibrary.Items) do
		if unlock_type == "Finisher" and not weapon_data.CanEliminate then
			continue
		end

        if typeof(weapon_name) ~= "string" or weapon_name == "" then
		    return
	    end

	    local name_to_send = if cosmetic_name ~= nil and cosmetic_name ~= "" then cosmetic_name else nil

	    local options = {}
	    if unlock_type == "Wrap" then
		    options.IsInverted = if is_inverted then true else nil
	    end

	    EquipCosmeticRemote:FireServer(weapon_name, unlock_type, name_to_send, options)
	end
end

local function GetCustomVmSound(url)
    if not url or url == "" then
        return nil
    end

    if caches.sound_cache[url] and caches.sound_cache[url].Url == url and caches.sound_cache[url].Asset then
        return caches.sound_cache[url].Asset
    end

    local file_path = kConstants.kBaseFolderName .. "/assets/ShootSound.mp3"

    local ok, encoded = pcall(function()
        return request({
            Url = url,
            Method = "GET",
            Headers = {
                ["Content-Type"] = "application/json"
            }
        }).Body
    end)

    if not ok then
        warn("Failed to download sound:", encoded)
        return nil
    end

    local decode_ok, decoded = pcall(base64decode, encoded)

    if not decode_ok or not decoded then
        warn("Failed to decode sound")
        return nil
    end

    local write_ok = pcall(writefile, file_path, decoded)

    if not write_ok then
        warn("Failed to write sound")
        return nil
    end

    local asset_ok, asset = pcall(getcustomasset, file_path)

    if not asset_ok then
        warn("Failed to create custom asset")
        return nil
    end

    caches.sound_cache[url].Url = url
    caches.sound_cache[url].Asset = asset

    return asset
end

ResolveSoundId = LPH_JIT_MAX(function(sound_table)
    local sound_value = sound_table.sound_value

    if sound_value == "None" or sound_value == nil or sound_value == "" then
        return nil
    end

    if sound_value == "Use Asset Id" and sound_table.sound_asset_id then
        return "rbxassetid://" .. tostring(sound_table.sound_asset_id)
    end

    if sound_value == "Use URL" then
        return GetCustomVmSound(sound_table.sound_url)
    end

    return Assets.Get("sound_" .. string.lower(sound_value))
end)

pcall(LPH_JIT_MAX(function()
    task.spawn(function()
        local shoot_key_set = {}
        local reload_key_set = {}

        do
            local shoot = kConstants.kShootSemanticKeys
            for i = 1, #shoot do
                shoot_key_set[shoot[i]] = true
            end

            local reload = kConstants.kReloadSemanticKeys
            for i = 1, #reload do
                reload_key_set[reload[i]] = true
            end
        end
    
        local vms = modules.ItemLibrary.ViewModels
        for _, vm in pairs(vms) do
            local anims = vm.Animations
            if type(anims) == "table" then
                for key, name in pairs(anims) do
                    if type(key) == "string" and type(name) == "string" then
                        if shoot_key_set[key] then
                            shoot_anim_names[name] = true
                        elseif reload_key_set[key] then
                            reload_anim_names[name] = true
                        elseif key:byte(1) == 83 then
                            if string.match(key, "^Shoot%d+$") then
                                shoot_anim_names[name] = true
                            end
                        elseif key:byte(1) == 82 then
                            if string.match(key, "^Reload%d*$") then
                                reload_anim_names[name] = true
                            end
                        end
                    end
                end
            end
        end
    end)
    task.spawn(function()
        local anim_info = modules.AnimationLibrary.Info
        for name, info in pairs(anim_info) do
            local original = info.SoundCallback
            if original then
                info.SoundCallback = function(vm, speed, hash)
                    vm._sc_activeAnimName = name
                    local ok, err = pcall(original, vm, speed, hash)
                    vm._sc_activeAnimName = nil
                    return ok, err
                end
            end
        end
    end)
    task.spawn(function()
	    task.wait(3)
	    pcall(function()
	        local vm_module = LocalPlayer.PlayerScripts.Modules.ClientReplicatedClasses.ClientFighter.ClientItem:FindFirstChild("ClientViewModel")
	        if vm_module then
	            local ClientViewModel = require(vm_module)
	
	            local original_createsound = ClientViewModel.CreateSound
	            ClientViewModel.CreateSound = function(self, sound_id, volume, pitch, ...)
	                local ctx = self._sc_activeAnimName
	                local ctx_player = self.ClientItem and self.ClientItem.ClientFighter and self.ClientItem.ClientFighter.Player
	
	                if ctx_player == LocalPlayer and ctx ~= nil then
	                    if shoot_anim_names[ctx] then
	                        local shoot_volume = states.skinchanger_state.shoot_sound.sound_volume
	                        local shoot_pitch = states.skinchanger_state.shoot_sound.sound_pitch
	                        local override = ResolveSoundId(states.skinchanger_state.shoot_sound) or sound_id
	
	                        return original_createsound(self, override, shoot_volume / 100, shoot_pitch / 10, ...)
	                    elseif reload_anim_names[ctx] then
	                        local reload_volume = states.skinchanger_state.reload_sound.sound_volume
	                        local reload_pitch = states.skinchanger_state.reload_sound.sound_pitch
	                        local override = ResolveSoundId(states.skinchanger_state.reload_sound) or sound_id
	
	                        return original_createsound(self, override, reload_volume / 100, reload_pitch / 10, ...)
	                    end
	                end
	
	                return original_createsound(self, sound_id, volume, pitch, ...)
	            end
	
	            local original_playhitmarkersound = ClientViewModel.PlayHitmarkerSound
	            ClientViewModel.PlayHitmarkerSound = function(self, is_crit, distance)
	                local ctx_player = self.ClientItem and self.ClientItem.ClientFighter and self.ClientItem.ClientFighter.Player
	
	                if ctx_player == LocalPlayer then
	                    while #self._last_hitmarker_sounds > 10 do
	                        table.remove(self._last_hitmarker_sounds, 1):Destroy()
	                    end
	
	                    if is_crit then
	                        local pitch = states.skinchanger_state.crit_sound.sound_pitch
	                        local id1 = ResolveSoundId(states.skinchanger_state.crit_sound) or kConstants.kOriginalHitmarkers.kill_layer1
	                        local id2 = ResolveSoundId(states.skinchanger_state.crit_sound) or kConstants.kOriginalHitmarkers.kill_layer2
	
	                        self:_CreateHitmarkerSound(id1, (3 / distance), pitch / 10, vm_module, true, 1)
	                        self:_CreateHitmarkerSound(id2, (2 / distance), pitch / 10, vm_module, true, 1)
	                    else
	                        local pitch = states.skinchanger_state.hit_sound.sound_pitch
	                        local id = ResolveSoundId(states.skinchanger_state.hit_sound) or kConstants.kOriginalHitmarkers.hit
	
	                        self:_CreateHitmarkerSound(id, (1.5 / distance), pitch / 10, vm_module, true, 1)
	                    end
	
	                    return
	                end
	
	                return original_playhitmarkersound(self, is_crit, distance)
	            end
	        end
	    end)
	end)
	
	local original_enemydeathsounds = table.clone(modules.SoundLibrary.EnemyDeathSounds)
	modules.SoundLibrary.EnemyDeathSounds = setmetatable({}, {
	    __index = function(_, key)
	        return ResolveSoundId(states.skinchanger_state.death_sound) or original_enemydeathsounds[key]
	    end
	})
	
	local original_eliminationsounds = table.clone(modules.SoundLibrary.EliminationSounds)
	modules.SoundLibrary.EliminationSounds = setmetatable({}, {
	    __index = function(_, key)
	        return ResolveSoundId(states.skinchanger_state.kill_sound) or original_eliminationsounds[key]
	    end
	})
end))

local sound_previewing = false
local function PlayPreviewSound(sound_table)
    if sound_previewing then return end
    sound_previewing = true

    local sound_id = ResolveSoundId(sound_table)
    if sound_id == nil then
        sound_previewing = false
        return
    end

    local volume = sound_table.sound_volume
    local pitch = sound_table.sound_pitch

    local sound = Instance.new("Sound")
    sound.Parent = services.SoundService
    sound.SoundId = sound_id
    sound.Volume = volume / 100
    sound.PlaybackSpeed = pitch / 10
    sound:Play()

    sound.Ended:Connect(function()
        sound:Destroy()
        sound_previewing = false
    end)
end

local function ShootSoundPreview()
    PlayPreviewSound(states.skinchanger_state.shoot_sound)
end

local function HitSoundPreview()
    PlayPreviewSound(states.skinchanger_state.hit_sound)
end

local function KillSoundPreview()
    PlayPreviewSound(states.skinchanger_state.kill_sound)
end

local function CritSoundPreview()
    PlayPreviewSound(states.skinchanger_state.crit_sound)
end

local function ReloadSoundPreview()
    PlayPreviewSound(states.skinchanger_state.reload_sound)
end

local function DeathSoundPreview()
    PlayPreviewSound(states.skinchanger_state.death_sound)
end

--[[
    Inventory
]]

local function ReplicateInventory()
    pcall(function()
        if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
            modules.PlayerDataController.CurrentData:Replicate("UnclaimedRewards")
        end
    end)
end

local function RollLootboxReward(lootbox_name, weapon_name)
    local reward_info = modules.CosmeticLibrary.Rewards[lootbox_name]
    if not reward_info or not reward_info.GetContents then return nil end

    local ok, contents = pcall(function() return reward_info:GetContents() end)
    if not ok or not contents or #contents == 0 then return nil end

    local inventory = modules.PlayerDataController:Get("CosmeticInventory")
    local available_rewards = {}

    for _, cosmetic_name in ipairs(contents) do
        if not modules.CosmeticLibrary:OwnsCosmetic(inventory, cosmetic_name) then
            table.insert(available_rewards, cosmetic_name)
        end
    end

    if #available_rewards == 0 then
        available_rewards = contents
    end

    local rolled_name = available_rewards[math.random(#available_rewards)]

    local cosmetic = modules.CosmeticLibrary.Cosmetics[rolled_name]
    local is_weapon_cosmetic =
        cosmetic
        and modules.CosmeticLibrary.Types
        and modules.CosmeticLibrary.Types[cosmetic.Type]
        and modules.CosmeticLibrary.Types[cosmetic.Type].IsWeaponCosmetic

    return {
        Name = rolled_name,
        Quantity = 1,
        Weapon = is_weapon_cosmetic and weapon_name or nil,
        ExpireTime = nil,
    }
end

local function UseUnclaimedReward(index, quantity)
    local backpack = states.inventory_state.fake_owned
    local entry = backpack[index]
    if not entry then return "" end

    local lootbox_name = entry.Name
    local reward_info = modules.CosmeticLibrary.Rewards[lootbox_name]

    local current = entry.Quantity or 1
    if current > quantity then
        entry.Quantity = current - quantity
    else
        table.remove(backpack, index)
    end

    ReplicateInventory()

    if reward_info and reward_info.SoundProfile then
        local char = LocalPlayer.Character
        if char and char:FindFirstChild("HumanoidRootPart") then
            local pos = char.HumanoidRootPart.Position
            for i = 1, quantity do
                local reward_data = RollLootboxReward(lootbox_name, entry.Weapon)
                if reward_data then
                    local cosmetic = modules.CosmeticLibrary.Cosmetics[reward_data.Name]
                    if cosmetic then
                        states.skinchanger_state.fake_owned[reward_data.Name] = true
                    else
                        table.insert(states.skinchanger_state.fake_weapon_owned, {
                            Name = reward_data.Name,
                            Level = 1,
                            XP = 0,
                            IsFavorited = false,
                            Skin = nil,
                        })
                    end
                    local delay = (i - 1) * 3
                    task.spawn(function()
                        modules.LootboxEffect(pos, lootbox_name, {{ RewardData = reward_data }}, delay, nil, LocalPlayer)

                        if not cosmetic or cosmetic.Type ~= "Skin" then return end

                        local rarity = cosmetic.Rarity or "Common"
                        local rarity_color = Color3.fromRGB(255, 255, 255)

                        if modules.CosmeticLibrary.Rarities then
                            local rarityInfo = modules.CosmeticLibrary.Rarities[rarity]
                            if rarityInfo and rarityInfo.Color then
                                rarity_color = rarityInfo.Color
                            end
                        end

                        local message = string.format("[SERVER] %s (@%s) just unboxed a %s %s skin for the %s!", LocalPlayer.DisplayName, LocalPlayer.Name, rarity, reward_data.Name, cosmetic.ItemName)

                        modules.SendChat({
                            Text = message,
                            Color = rarity_color
                        })
                    end)
                end
            end
        end
    end
    return "Success"
end

task.spawn(function()
    task.wait(3)
    pcall(function()
        modules.InspectBackpackReward.Use = function(p5, p6)
            if modules.FighterController.LocalFighter and not (modules.FighterController.LocalFighter:Get("IsInDuel") or modules.FighterController.LocalFighter:Get("IsInShootingRange")) then
                local reward_info = p5._reward_info;
                if reward_info then
                    reward_info = p5._reward_info.Type == "Lootbox";
                end

                local result = services.ReplicatedStorage.Remotes.Data.UseUnclaimedReward:InvokeServer(p5._index, p6)

                if result ~= "Success" then
                    result = UseUnclaimedReward(p5._index, p6)
                end

                if result == "Success" then
                    if reward_info then
                        if p5._reward_info.SoundProfile then
                            p5.ClosePage:Fire()
                            return
                        end
                        p5:CloseRequest()
                    end
                elseif reward_info then
                    p5.OpenPrompt:Fire("ErrorMessage", "Woops!", "Failed to open, you probably already have everything!")
                elseif p5._cosmetic_info and modules.CosmeticLibrary.Types[p5._cosmetic_info.Type].IsWeaponCosmetic then
                    p5.OpenPrompt:Fire("ErrorMessage", "Woops!", "Failed to use, this item is probably already unlocked for all possible weapons!")
                else
                    p5.OpenPrompt:Fire("ErrorMessage", "Woops!", "Failed to use, this item is probably already unlocked!")
                end
            end
        end
    end)
end)

local function AddToBackpack()
    local item_name = states.inventory_state.specific.lootbox_name
    local new_entry = states.inventory_state.specific.new_entry
    local quantity = states.inventory_state.specific.quantity
    local weapon_name = states.inventory_state.specific.weapon_name

    if not modules.CosmeticLibrary or not modules.CosmeticLibrary.Rewards then return end
    if not modules.CosmeticLibrary.Rewards[item_name] then return end

    if not weapon_name or weapon_name == "" then
        weapon_name = "IsRandom"
    end

    local reward_entry = {
        Name = item_name,
        Quantity = quantity or 1,
        Weapon = weapon_name,
        ExpireTime = nil
    }

    if new_entry then
        table.insert(states.inventory_state.fake_owned, reward_entry)
    else
        local found = false

        for _, entry in ipairs(states.inventory_state.fake_owned) do
            if entry.Name == reward_entry.Name and entry.Weapon == reward_entry.Weapon and entry.Quantity < 99 then
                entry.Quantity = (entry.Quantity or 1) + (reward_entry.Quantity or 1)
                found = true
                break
            end
        end

        if not found then
            table.insert(states.inventory_state.fake_owned, reward_entry)
        end
    end

    ReplicateInventory()
end

local function AddAllCases()
    local quantity = states.inventory_state.bulk.quantity

    if not modules.CosmeticLibrary or not modules.CosmeticLibrary.Rewards then return end

    local total = {}
    for name, info in pairs(modules.CosmeticLibrary.Rewards) do
        if info.Type == "Lootbox" then
            table.insert(total, name)
        end
    end

    for _, name in ipairs(total) do
        if not modules.CosmeticLibrary.Rewards[name] then return end

        local reward_entry = {
            Name = name,
            Quantity = quantity or 1,
            Weapon = "IsRandom",
            ExpireTime = nil
        }

        table.insert(states.inventory_state.fake_owned, reward_entry)
    end

    ReplicateInventory()
end

local function GetBackpackEntries()
    if modules.PlayerDataController then
        local backpack = modules.PlayerDataController:Get("UnclaimedRewards") or {}
        local results = {}
        for _, info in ipairs(backpack) do
            table.insert(results, info.Name)
        end
        return results
    end

    return {"None"}
end

local function DeleteAllBackpack()
    table.clear(states.inventory_state.fake_owned)
    ReplicateInventory()
end

local function DeleteQuantity()
    local backpack_entry = states.inventory_state.delete.backpack_entry
    local quantity = states.inventory_state.delete.quantity

    for i, info in ipairs(states.inventory_state.fake_owned) do
        if info.Name ~= backpack_entry then
            continue
        end

        if info.Quantity > quantity then
            states.inventory_state.fake_owned[i].Quantity -= quantity
        else
            table.remove(states.inventory_state.fake_owned, i)
        end
    end

    ReplicateInventory()
end

local function DeleteAllOfEntry()
    local backpack_entry = states.inventory_state.delete.backpack_entry

    for i, info in ipairs(states.inventory_state.fake_owned) do
        if info.Name ~= backpack_entry then
            continue
        end

        table.remove(states.inventory_state.fake_owned, i)
    end

    ReplicateInventory()
end

local function InjectIntoBackpack()
    local item_type = states.inventory_state.inject.item_type
    local cosmetic_name = states.inventory_state.inject.cosmetic_name
    local weapon_name = states.inventory_state.inject.weapon_name
    local stack_duplicates = states.inventory_state.inject.stack_duplicates

    local reward_entry
    if item_type == "Skin" then
        if not weapon_name or weapon_name == "" then
            return
        end

        reward_entry = {
            Name = cosmetic_name,
            Quantity = 1,
            Weapon = weapon_name,
        }
    else
        reward_entry = {
            Name = cosmetic_name,
            Quantity = 1,
        }
    end

    if not stack_duplicates then
        table.insert(states.inventory_state.fake_owned, reward_entry)
    else
        local found = false

        for _, entry in ipairs(states.inventory_state.fake_owned) do
            if entry.Name == reward_entry.Name and entry.Weapon == reward_entry.Weapon and entry.Quantity < 99 then
                entry.Quantity = (entry.Quantity or 1) + (reward_entry.Quantity or 1)
                found = true
                break
            end
        end

        if not found then
            table.insert(states.inventory_state.fake_owned, reward_entry)
        end
    end

    ReplicateInventory()
end

--[[
    Spoofer
]]

local device_cancel = 0
SetDevice = LPH_JIT_MAX(function(use_old)
    local map = {
        Desktop = "MouseKeyboard",
        Mobile = "Touch",
        Console = "Gamepad",
        VR = "VR"
    }
    local dev = map[use_old and states.spoofer_state.old_device or states.spoofer_state.device] or "MouseKeyboard"
    services.ReplicatedStorage.Remotes.Replication.Fighter.SetControls:FireServer(dev)
end)

local function SpoofDevice()
    if states.spoofer_state.spoof_device then
        SetDevice(false)
    else
        SetDevice(true)
    end
end

local function DeviceSpam()
    device_cancel += 1
    local token = device_cancel

    task.spawn(LPH_JIT_MAX(function()
        while states.spoofer_state.device_spam and token == device_cancel do
            local list = {
                "Desktop",
                "Mobile",
                "Console",
                "VR"
            }
            states.spoofer_state.device = list[math.random(1,#list)]
            SetDevice(false)
            task.wait(states.spoofer_state.spam_rate)
        end
        SetDevice(true)
    end))
end

local function WeldAttachments(attach1, attach2)
    local weld = Instance.new("Weld")
    weld.Part0 = attach1.Parent
    weld.Part1 = attach2.Parent
    weld.C0 = attach1.CFrame
    weld.C1 = attach2.CFrame
    weld.Parent = attach1.Parent
    return weld
end

local function BuildWeld(weld_name, parent, part0, part1, c0, c1)
    local weld = Instance.new("Weld")
    weld.Name = weld_name
    weld.Part0 = part0
    weld.Part1 = part1
    weld.C0 = c0
    weld.C1 = c1
    weld.Parent = parent
    return weld
end

FindFirstMatchingAttachment = LPH_JIT_MAX(function(model, name)
    for _, child in pairs(model:GetChildren()) do
        if child:IsA("Attachment") and child.Name == name then
            return child
        elseif not child:IsA("Accoutrement") and not child:IsA("Tool") then
            local found = FindFirstMatchingAttachment(child, name)
            if found then
                return found
            end
        end
    end
end)

FindHeadPart = LPH_JIT_MAX(function(instance)
    if not instance then
        return nil
    end

    if instance:IsA("BasePart") then
        return instance
    end

    local head = instance:FindFirstChild("Head")
    if head and head:IsA("BasePart") then
        return head
    end

    for _, descendant in ipairs(instance:GetDescendants()) do
        if descendant:IsA("BasePart") and descendant.Name == "Head" then
            return descendant
        end
    end

    for _, descendant in ipairs(instance:GetDescendants()) do
        if descendant:IsA("BasePart") then
            return descendant
        end
    end

    return nil
end)

AddAccoutrement = LPH_JIT_MAX(function(character, accoutrement)
    accoutrement.Parent = character
    local handle = accoutrement:FindFirstChild("Handle")
    if handle then
        local attachment = handle:FindFirstChildOfClass("Attachment")
        if attachment then
            local char_attachment = FindFirstMatchingAttachment(character, attachment.Name)
            if char_attachment then
                WeldAttachments(char_attachment, attachment)
            end
        else
            local head = character:FindFirstChild("Head")
            if head then
                local attachmentCFrame = CFrame.new(0, 0.5, 0)
                local hatCFrame = accoutrement.AttachmentPoint
                BuildWeld("HeadWeld", head, head, handle, attachmentCFrame, hatCFrame)
            end
        end
    end
end)

CopyHeadVisuals = LPH_JIT_MAX(function(real_head, source_head)
    if not real_head or not source_head then
        return
    end

    if not real_head:IsA("BasePart") or not source_head:IsA("BasePart") then
        return
    end

    for _, child in ipairs(real_head:GetChildren()) do
        if child:IsA("Decal") or child:IsA("Texture") or child:IsA("SpecialMesh") or child:IsA("Mesh") then
            child:Destroy()
        end
    end

    real_head.Material = source_head.Material
    real_head.Color = source_head.Color
    real_head.Reflectance = source_head.Reflectance
    real_head.Transparency = source_head.Transparency
    real_head.LocalTransparencyModifier = source_head.LocalTransparencyModifier
    real_head.CastShadow = source_head.CastShadow
    real_head.CanCollide = false

    if real_head:IsA("MeshPart") and source_head:IsA("MeshPart") then
        real_head.MeshId = source_head.MeshId
        real_head.TextureID = source_head.TextureID
        real_head.Size = source_head.Size
    end

    for _, child in ipairs(source_head:GetChildren()) do
        if child:IsA("Decal") or child:IsA("Texture") or child:IsA("SpecialMesh") or child:IsA("Mesh") then
            local clone = child:Clone()
            clone.Parent = real_head
        end
    end
end)

ApplyFakeHead = LPH_JIT_MAX(function(character, source_head)
    if not character or not source_head then return end

    local real_head = character:FindFirstChild("Head")
    if not real_head or not real_head:IsA("BasePart") then
        return
    end

    CopyHeadVisuals(real_head, source_head)
end)

ApplyThumbnailSpoof = LPH_JIT_MAX(function(obj)
    if not obj:IsA("ImageLabel") then
        return
    end

    local image = obj.Image
    if typeof(image) ~= "string" then
        return
    end

    if states.spoofer_state.spoof_avatar and obj.Name == "AvatarThumbnail" then
        image = image:gsub(
            LocalPlayer.UserId,
            states.spoofer_state.avatar_userid
        )
    end

    if states.spoofer_state.spoof_avatar and obj.Parent.Name == "Thumbnail" and obj.Name == "ImageLabel" then
        image = image:gsub(
            LocalPlayer.UserId,
            states.spoofer_state.avatar_userid
        )
    end

    if states.spoofer_state.spoof_avatar and obj.Name == "Headshot" then
        image = image:gsub(
            LocalPlayer.UserId,
            states.spoofer_state.avatar_userid
        )
    end

    if obj.Image ~= image then
        obj.Image = image
    end
end)

RefreshAllThumbnailSpoofs = LPH_JIT_MAX(function()
    for obj, _ in pairs(states.spoofer_state.thumb_spoof_conn) do
        if obj and obj.Parent then
            ApplyThumbnailSpoof(obj)
        end
    end
end)

RegisterImageObject = LPH_JIT_MAX(function(obj)
    if not obj:IsA("ImageLabel") then
        return
    end

    local kAllowed = {
        AvatarThumbnail = true,
        ImageLabel = true,
        Headshot = true
    }

    if not kAllowed[obj.Name] then
        return
    end

    ApplyThumbnailSpoof(obj)

    if states.spoofer_state.thumb_spoof_conn[obj] then
        return
    end

    states.spoofer_state.thumb_spoof_conn[obj] = obj:GetPropertyChangedSignal("Image"):Connect(function()
        ApplyThumbnailSpoof(obj)
    end)

    obj.Destroying:Connect(function()
        if states.spoofer_state.thumb_spoof_conn[obj] then
            states.spoofer_state.thumb_spoof_conn[obj]:Disconnect()
            states.spoofer_state.thumb_spoof_conn[obj] = nil
        end
    end)
end)

for _, obj in ipairs(game:GetDescendants()) do
    RegisterImageObject(obj)
end

game.DescendantAdded:Connect(RegisterImageObject)

SetAvatar = LPH_JIT_MAX(function(use_old)
    local user_id = use_old and LocalPlayer.UserId or states.spoofer_state.avatar_userid
    if not user_id then return end

    if not LocalChar or not LocalChar.Parent then
        LocalChar = GetCharacter()
    end

    local ok, rig_model = pcall(function()
        return services.Players:CreateHumanoidModelFromUserId(user_id)
    end)
    
    if not ok or not rig_model then return end

    for _, v in ipairs(LocalChar:GetDescendants()) do
        local isFaceDecal = v:IsA("Decal") and v.Name == "face"
        if v:IsA("Accessory")
        or v:IsA("Shirt")
        or v:IsA("Pants")
        or v:IsA("ShirtGraphic")
        or v:IsA("BodyColors")
        or v:IsA("CharacterMesh")
        or v:IsA("LayeredClothing")
        or isFaceDecal then
            pcall(function()
                v:Destroy()
            end)
        end
    end
    
    for _, item in ipairs(rig_model:GetChildren()) do
        if item:IsA("Accessory") then
            pcall(function()
                local acc = item:Clone()
                AddAccoutrement(LocalChar, acc)
            end)
        elseif item:IsA("Shirt")
        or item:IsA("Pants")
        or item:IsA("ShirtGraphic")
        or item:IsA("BodyColors")
        or item:IsA("LayeredClothing")
        or item:IsA("CharacterMesh") then
            pcall(function()
                local clone = item:Clone()
                clone.Parent = LocalChar
            end)
        end
    end

    local target_head = FindHeadPart(rig_model)
    if target_head then
        ApplyFakeHead(LocalChar, target_head)
        task.wait(0.1)
    end

    pcall(function()
        rig_model:Destroy()
    end)
end)

local function SpoofAvatar()
    if states.spoofer_state.spoof_avatar then
        SetAvatar(false)
    else
        SetAvatar(true)
    end
end

LocalPlayer.CharacterAdded:Connect(SpoofAvatar)

local function IsTextObject(obj)
    return obj:IsA("TextLabel") or obj:IsA("TextButton") or obj:IsA("TextBox")
end

local function FormatNumber(n)
	n = tostring(n)
	return n:reverse():gsub("%d%d%d", "%1,"):reverse():gsub("^,", "")
end

ApplyNameSpoof = LPH_JIT_MAX(function(obj)
    if not IsTextObject(obj) then
        return
    end

    local text = obj.Text
    if typeof(text) ~= "string" then
        return
    end

    if states.spoofer_state.display_name and obj.Name == "DisplayName" then
        text = text:gsub(
            LocalPlayer.DisplayName,
            states.spoofer_state.display_name_value
        )
    end

    if states.spoofer_state.username and obj.Name == "Username" then
        text = text:gsub(
            LocalPlayer.Name,
            states.spoofer_state.username_value
        )
    end

    if states.spoofer_state.display_name and obj.Parent.Name == "NameContainer" and obj.Name == "Name" then
        text = text:gsub(
            LocalPlayer.DisplayName,
            states.spoofer_state.display_name_value
        )
    end

    if states.spoofer_state.username and obj.Parent.Name == "NameContainer" and obj.Name == "Handle" then
        text = text:gsub(
            LocalPlayer.Name,
            states.spoofer_state.username_value
        )
    end

    if states.spoofer_state.display_name and obj.Parent.Name == "Title" and obj.Name == "TitleText" then
        text = text:gsub(
            LocalPlayer.DisplayName,
            states.spoofer_state.display_name_value
        )
    end

    if states.spoofer_state.username and obj.Parent.Name == "Subtitle" and obj.Name == "SubtitleText" then
        text = text:gsub(
            LocalPlayer.Name,
            states.spoofer_state.username_value
        )
    end

    if states.spoofer_state.display_name and obj.Name == "HeaderText" then
        text = text:gsub(
            LocalPlayer.DisplayName,
            states.spoofer_state.display_name_value
        )
    end

    if states.spoofer_state.display_name and obj.Name == "Title" then
        text = text:gsub(
            LocalPlayer.DisplayName,
            states.spoofer_state.display_name_value
        )
    end

    if states.spoofer_state.leaderboard.Wins and obj.Name == "Wins" then
        text = FormatNumber(states.spoofer_state.leaderboard.wins_value)
    end

    if states.spoofer_state.leaderboard.Level and obj.Parent.Name == "Level" and obj.Name == "Value" then
        text = FormatNumber(states.spoofer_state.leaderboard.level_value)
    end

    if states.spoofer_state.leaderboard.Streak and obj.Parent.Name == "Streak" and obj.Name == "Value" then
        text = FormatNumber(states.spoofer_state.leaderboard.streak_value)
    end

    if obj.Text ~= text then
        obj.Text = text
    end
end)

local function RefreshAllNameSpoofs()
    for obj, _ in pairs(states.spoofer_state.name_spoof_conn) do
        if obj and obj.Parent then
            ApplyNameSpoof(obj)
        end
    end
end

RegisterTextObject = LPH_JIT_MAX(function(obj)
    if not IsTextObject(obj) then
        return
    end

    local kAllowed = {
        DisplayName = true,
        Username = true,
        Name = true,
        Handle = true,
        TitleText = true,
        SubtitleText = true,
        HeaderText = true,
        Title = true,
        Wins = true,
        Value = true,
    }

    if not kAllowed[obj.Name] then
        return
    end

    ApplyNameSpoof(obj)

    if states.spoofer_state.name_spoof_conn[obj] then
        return
    end

    states.spoofer_state.name_spoof_conn[obj] = obj:GetPropertyChangedSignal("Text"):Connect(function()
        ApplyNameSpoof(obj)
    end)

    obj.Destroying:Connect(function()
        if states.spoofer_state.name_spoof_conn[obj] then
            states.spoofer_state.name_spoof_conn[obj]:Disconnect()
            states.spoofer_state.name_spoof_conn[obj] = nil
        end
    end)
end)

for _, obj in ipairs(game:GetDescendants()) do
    RegisterTextObject(obj)
end

game.DescendantAdded:Connect(RegisterTextObject)

GenerateRandomName = LPH_JIT_MAX(function()
    local result = ""

    for i = 1, math.random(2, 4) do
        local index = math.random(1, #kConstants.kWordList)
        result ..= kConstants.kWordList[index]
    end

    return result .. tostring(math.random(12, 36))
end)

GetFakeName = LPH_JIT_MAX(function(player)
    if not states.spoofer_state.fake_names[player] then
        states.spoofer_state.fake_names[player] = GenerateRandomName()
    end

    return states.spoofer_state.fake_names[player]
end)

local AnonymousRigTemplate
GetAnonymousRig = LPH_JIT_MAX(function()
    if AnonymousRigTemplate and AnonymousRigTemplate.Parent then
        return AnonymousRigTemplate:Clone()
    end

    local ok, rig = pcall(function()
        return services.Players:CreateHumanoidModelFromUserId(6942067)
    end)

    if not ok or not rig then
        return nil
    end

    AnonymousRigTemplate = rig
    AnonymousRigTemplate.Parent = nil

    return AnonymousRigTemplate:Clone()
end)

ApplyAnonymousNameSpoof = LPH_JIT_MAX(function(obj)
    if not IsTextObject(obj) then
        return
    end

    local text = obj.Text

    for _, player in ipairs(services.Players:GetPlayers()) do
        local fakeName = GetFakeName(player)

        text = text:gsub(player.Name, fakeName)
        text = text:gsub(player.DisplayName, fakeName)
    end

    if obj.Text ~= text then
        obj.Text = text
    end
end)

ApplyAnonymousThumbnailSpoof = LPH_JIT_MAX(function(obj)
    if not obj:IsA("ImageLabel") then
        return
    end

    local image = obj.Image

    for _, player in ipairs(services.Players:GetPlayers()) do
        image = image:gsub(tostring(player.UserId), tostring(6942067))
    end

    if obj.Image ~= image then
        obj.Image = image
    end
end)

ApplyAnonymousAvatar = LPH_JIT_MAX(function(character)
    if not character then
        return
    end

    local rig = GetAnonymousRig()

    if not rig then
        return
    end

    for _, v in ipairs(character:GetDescendants()) do
        local isFaceDecal = v:IsA("Decal") and v.Name == "face"

        if v:IsA("Accessory")
            or v:IsA("Shirt")
            or v:IsA("Pants")
            or v:IsA("ShirtGraphic")
            or v:IsA("BodyColors")
            or v:IsA("CharacterMesh")
            or v:IsA("LayeredClothing")
            or isFaceDecal then

            pcall(function()
                v:Destroy()
            end)
        end
    end

    for _, item in ipairs(rig:GetChildren()) do
        if item:IsA("Accessory") then
            AddAccoutrement(character, item:Clone())
        elseif item:IsA("Shirt")
            or item:IsA("Pants")
            or item:IsA("ShirtGraphic")
            or item:IsA("BodyColors")
            or item:IsA("CharacterMesh")
            or item:IsA("LayeredClothing") then

            item:Clone().Parent = character
        end
    end

    local head = FindHeadPart(rig)
    if head then
        ApplyFakeHead(character, head)
    end

    rig:Destroy()
end)

local function RegisterAnonymousObject(obj)
    if IsTextObject(obj) then
        ApplyAnonymousNameSpoof(obj)

        obj:GetPropertyChangedSignal("Text"):Connect(function()
            ApplyAnonymousNameSpoof(obj)
        end)
    elseif obj:IsA("ImageLabel") then
        ApplyAnonymousThumbnailSpoof(obj)

        obj:GetPropertyChangedSignal("Image"):Connect(function()
            ApplyAnonymousThumbnailSpoof(obj)
        end)
    end
end

local function DisableAnonymousMode()
    for _, connection in ipairs(states.spoofer_state.anon_connections) do
        if connection and connection.Disconnect then
            connection:Disconnect()
        end
    end

    table.clear(states.spoofer_state.anon_connections)
    table.clear(states.spoofer_state.fake_names)
end

AnonymousMode = LPH_JIT_MAX(function()
    if not states.spoofer_state.anonymous_mode then
        DisableAnonymousMode()
        return
    end

    DisableAnonymousMode()

    math.randomseed(os.clock() * 100000)

    for _, player in ipairs(services.Players:GetPlayers()) do
        GetFakeName(player)

        if player.Character then
            task.defer(ApplyAnonymousAvatar, player.Character)
        end

        table.insert(
            states.spoofer_state.anon_connections,
            player.CharacterAdded:Connect(function(character)
                task.defer(ApplyAnonymousAvatar, character)
            end)
        )
    end

    table.insert(
        states.spoofer_state.anon_connections,
        services.Players.PlayerAdded:Connect(function(player)
            GetFakeName(player)

            player.CharacterAdded:Connect(function(character)
                task.defer(ApplyAnonymousAvatar, character)
            end)
        end)
    )

    for _, obj in ipairs(game:GetDescendants()) do
        RegisterAnonymousObject(obj)
    end

    table.insert(
        states.spoofer_state.anon_connections,
        game.DescendantAdded:Connect(RegisterAnonymousObject)
    )
end)

local function InsertPlayerByValue(list, user_id, value)
    for i = #list, 1, -1 do
        if tonumber(list[i].key) == user_id then
            table.remove(list, i)
            break
        end
    end

    local rank = 1
    for i, entry in ipairs(list) do
        if tonumber(entry.value) >= value then
            rank = i + 1
        else
            break
        end
    end

    table.insert(list, rank, {
        key = tostring(user_id),
        value = value,
    })
end

ResetLeaderboard = LPH_JIT_MAX(function(name, config_idx)
    if not modules.LeaderboardController then
        return
    end

    Unbind(config_idx)

    local serial = modules.LeaderboardController.LeaderboardSerials[name]
    if serial and serial.Players then
        local user_id = LocalPlayer.UserId

        for i = #serial.Players, 1, -1 do
            local player = serial.Players[i]

            if player.UserId == user_id
                or player.UserID == user_id
                or player.PlayerId == user_id then
                table.remove(serial.Players, i)
            end
        end

        if modules.LeaderboardController.Refreshed then
            modules.LeaderboardController.Refreshed:Fire(name)
        end
    end
end)

ModifyLeaderboard = LPH_JIT_MAX(function(config_idx, name, value)
    if not modules.LeaderboardController then
        return
    end

    while not modules.LeaderboardController.LeaderboardSerials[name]
        or not modules.LeaderboardController.LeaderboardSerials[name].Players
        or #modules.LeaderboardController.LeaderboardSerials[name].Players <= 0 do
        task.wait(0.5)
    end

    local user_id = LocalPlayer.UserId
    local serial = modules.LeaderboardController.LeaderboardSerials[name]

    if serial and serial.Players then
        InsertPlayerByValue(serial.Players, user_id, value)

        if modules.LeaderboardController.Refreshed then
            modules.LeaderboardController.Refreshed:Fire(name)
        end
    end

    local UpdateRemote = services.ReplicatedStorage:FindFirstChild("Remotes")
        and services.ReplicatedStorage.Remotes:FindFirstChild("Misc")
        and services.ReplicatedStorage.Remotes.Misc:FindFirstChild("UpdateLeaderboard")

    if not (UpdateRemote and UpdateRemote:IsA("RemoteEvent")) then
        return
    end

    Bind(config_idx, UpdateRemote.OnClientEvent, function(data)
        local lb_name = data and data.Name
        if not lb_name or lb_name ~= name then
            return
        end

        if not states.spoofer_state.leaderboard[config_idx] then
            return
        end

        task.defer(function()
            local serial = modules.LeaderboardController.LeaderboardSerials[name]
            if serial and serial.Players then
                InsertPlayerByValue(serial.Players, user_id, value)

                if modules.LeaderboardController.Refreshed then
                    modules.LeaderboardController.Refreshed:Fire(name)
                end
            end
        end)
    end)
end)

local function UpdateLeaderboardOptions()
    if states.spoofer_state.leaderboard.ELO then
        Unbind("ELO")
        ModifyLeaderboard("ELO", "Highest ELO", states.spoofer_state.leaderboard.elo_value)
    end

    if states.spoofer_state.leaderboard.Streak then
        Unbind("Streak")
        ModifyLeaderboard("Streak", "Current Highest Win Streak", states.spoofer_state.leaderboard.streak_value)

        states.spoofer_state.leaderboard.old_streak_value = LocalPlayer:GetAttribute("StatisticDuelsWinStreak")
        LocalPlayer:SetAttribute("StatisticDuelsWinStreak", states.spoofer_state.leaderboard.streak_value)
    end

    if states.spoofer_state.leaderboard.Kills then
        Unbind("Kills")
        ModifyLeaderboard("Kills", "Most Eliminations", states.spoofer_state.leaderboard.kills_value)
    end

    if states.spoofer_state.leaderboard.Wins then
        Unbind("Wins")
        ModifyLeaderboard("Wins", "Most Wins", states.spoofer_state.leaderboard.wins_value)
    end

    if states.spoofer_state.leaderboard.Level then
        Unbind("Level")
        ModifyLeaderboard("Level", "Highest Level", states.spoofer_state.leaderboard.level_value)

        states.spoofer_state.leaderboard.old_level_value = LocalPlayer:GetAttribute("Level")
        LocalPlayer:SetAttribute("Level", states.spoofer_state.leaderboard.level_value)
    end

    if not states.spoofer_state.leaderboard.ELO then
        ResetLeaderboard("Highest ELO", "ELO")
    end

    if not states.spoofer_state.leaderboard.Streak then
        ResetLeaderboard("Current Highest Win Streak", "Streak")
        if states.spoofer_state.leaderboard.old_streak_value ~= nil then
            LocalPlayer:SetAttribute("StatisticDuelsWinStreak", states.spoofer_state.leaderboard.old_streak_value)
        end
    end

    if not states.spoofer_state.leaderboard.Kills then
        ResetLeaderboard("Most Eliminations", "Kills")
    end

    if not states.spoofer_state.leaderboard.Wins then
        ResetLeaderboard("Most Wins", "Wins")
    end

    if not states.spoofer_state.leaderboard.Level then
        ResetLeaderboard("Highest Level", "Level")
        if states.spoofer_state.leaderboard.old_level_value ~= nil then
            LocalPlayer:SetAttribute("Level", states.spoofer_state.leaderboard.old_level_value)
        end
    end
end

local old_namecall; old_namecall = hookmetamethod(game, "__index", LPH_NO_VIRTUALIZE(function(self, key)
    if self == LocalPlayer then
        if key == "MembershipType" and states.spoofer_state.badges.Premium then
            return Enum.MembershipType.Premium
        end
        if key == "HasVerifiedBadge" and states.spoofer_state.badges.Verified then
            return true
        end
    end
    return old_namecall(self, key)
end))

local function UpdateBadgesOptions()
    LocalPlayer:SetAttribute("IsInfluencer", states.spoofer_state.badges.Influencer and true or false)
    LocalPlayer:SetAttribute("IsRobloxEmployee", states.spoofer_state.badges.Admin and true or false)
end

local original_fsrc = modules.SeasonLibrary.FormatSeasonRankCharm
modules.SeasonLibrary.FormatSeasonRankCharm = function(self, p2, p3, p4, p5)
    local season_num = kConstants.kSeasonNameMap[p3]
	local elo = kConstants.kCharmEloMap[states.spoofer_state.charm.charm_rank] or states.spoofer_state.leaderboard.elo_value

	if season_num and kConstants.kSeasonToggleMap[season_num] and states.spoofer_state.charm[kConstants.kSeasonToggleMap[season_num]] then
		p4 = elo or p4
        p5 = states.spoofer_state.charm.arch_rank
	end

	return original_fsrc(self, p2, p3, p4, p5)
end

local function UpdateCharmOptions()
    task.wait(2)

    for _, descendant in ipairs(workspace:GetDescendants()) do
		if not descendant:IsA("Model") then
			continue
		end

        if not descendant:FindFirstChild("Extra") then
            continue
        end

        local name = descendant.Name
		if string.sub(name, 1, 7) ~= "Season " then
			continue
		end

        local season_num = tonumber(string.sub(name, 8))
		if not season_num then
			continue
		end

        if not kConstants.kSeasonToggleMap[season_num] then
            continue
        end

        if not states.spoofer_state.charm[kConstants.kSeasonToggleMap[season_num]] then
            continue
        end

        local season_name = kConstants.kSeasonNameMap[season_num]
		if not season_name then
			continue
		end

        local elo = kConstants.kCharmEloMap[states.spoofer_state.charm.charm_rank] or states.spoofer_state.leaderboard.elo_value
		local rank = states.spoofer_state.charm.arch_rank

		modules.SeasonLibrary:FormatSeasonRankCharm(
			descendant,
			season_name,
			elo,
			rank
		)
	end
end

local function UpdateCurrencyOptions()
    pcall(function()
        if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
            modules.PlayerDataController.CurrentData:Replicate("WeaponKeys")
            modules.PlayerDataController.CurrentData:Replicate("UnlockTokens")
            modules.PlayerDataController.CurrentData:Replicate("EventCurrency")
            modules.PlayerDataController.CurrentData:Replicate("Glory")
            modules.PlayerDataController.CurrentData:Replicate("SkinTickets")
        end
    end)
end

local function UpdateDuelHistory()
    local match = states.spoofer_state.duel_history.duel_history_value[states.spoofer_state.duel_history.match_index]
    if not match then
        return false
    end

    match.QueueName = states.spoofer_state.duel_history.mode == "Ranked" and "Ranked" or "Casual"

    match.Map = states.spoofer_state.duel_history.map
    match.Scores = {states.spoofer_state.duel_history.team1score, states.spoofer_state.duel_history.team2score}

    if states.spoofer_state.duel_history.result == "Victory" then
        match.WinningTeamIndex = 1
    else
        match.WinningTeamIndex = 2
    end

    local me = match.Duelers[states.spoofer_state.duel_history.dueler_index]

    me.Username = states.spoofer_state.duel_history.username
    me.DisplayName = states.spoofer_state.duel_history.display_name

    me.Eliminations = states.spoofer_state.duel_history.kills
    me.Deaths = states.spoofer_state.duel_history.deaths
    me.Assists = states.spoofer_state.duel_history.assists
    me.Damage = states.spoofer_state.duel_history.damage

    if states.spoofer_state.duel_history.mode == "Ranked" then
        me.DisplayELO = states.spoofer_state.duel_history.elo

        states.spoofer_state.duel_history.logged_elo_events[states.spoofer_state.duel_history.match_index].CurrentELO = states.spoofer_state.duel_history.elo
        states.spoofer_state.duel_history.logged_elo_events[states.spoofer_state.duel_history.match_index].ELOIncrement = states.spoofer_state.duel_history.elo_change or 0
    end

    pcall(function()
        if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
            modules.PlayerDataController.CurrentData:Replicate("DuelHistory")
            modules.PlayerDataController.CurrentData:Replicate("LoggedELOEvents")
        end
    end)
end

local function FindContainerWithRobuxPrice()
    for _, child in ipairs(services.CoreGui:GetChildren()) do
        local found = child:FindFirstChild("RobuxPrice", true)
        if found then
            return child
        end
    end
    return nil
end

local function AddGamepass(gamepass_id)
    states.spoofer_state.marketplace.fake_bundles_owned[modules.MonetizationLibrary:GetGamepassName(gamepass_id)] = true
    pcall(function()
        if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
            modules.PlayerDataController.CurrentData:Replicate("GamepassBundlesClaimed")
        end
    end)
end

local function AddReward(reward_name, reward_amount, reward_weapon)    
    if reward_name == "Key" then
        states.spoofer_state.currency.weapon_keys_value += reward_amount

        pcall(function()
            if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
                modules.PlayerDataController.CurrentData:Replicate("WeaponKeys")
            end
        end)
    elseif modules.CosmeticLibrary and modules.CosmeticLibrary.Cosmetics and modules.CosmeticLibrary.Cosmetics[reward_name] then
        local reward_info = modules.CosmeticLibrary.Cosmetics[reward_name]
        if reward_info.Type == "Skin" or reward_info.Type == "Wrap" or reward_info.Type == "Charm" or reward_info.Type == "Finisher" then
            states.skinchanger_state.fake_owned[reward_name] = true
        end
    elseif modules.ShopLibrary and modules.ShopLibrary.Weapons and modules.ShopLibrary.Weapons[reward_name] then
        local owned = {}
        for _, weapon_data in pairs(states.skinchanger_state.fake_weapon_owned) do
            if type(weapon_data) == "table" and weapon_data.Name then
                owned[weapon_data.Name] = true
            end
        end

        if not owned[reward_name] then
            table.insert(states.skinchanger_state.fake_weapon_owned, {
                Name = reward_name,
                Level = 1,
                XP = 0,
                IsFavorited = false,
                Skin = nil,
            })
        end

        pcall(function()
            if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
                modules.PlayerDataController.CurrentData:Replicate("WeaponInventory")
            end
        end)
    elseif modules.CosmeticLibrary and modules.CosmeticLibrary.Rewards and modules.CosmeticLibrary.Rewards[reward_name] then
        local reward_info = modules.CosmeticLibrary.Rewards[reward_name]

        local reward_entry
        if reward_info.Type == "Skin" then
            if not reward_weapon or reward_weapon == "" then
                return
            end

            reward_entry = {
                Name = reward_name,
                Quantity = reward_amount,
                Weapon = reward_weapon,
            }
        else
            reward_entry = {
                Name = reward_name,
                Quantity = reward_amount,
            }
        end

        local found = false

        for _, entry in ipairs(states.inventory_state.fake_owned) do
            if entry.Name == reward_entry.Name and entry.Weapon == reward_entry.Weapon and entry.Quantity < 99 then
                entry.Quantity = (entry.Quantity or 1) + (reward_entry.Quantity or 1)
                found = true
                break
            end
        end

        if not found then
            table.insert(states.inventory_state.fake_owned, reward_entry)
        end

        pcall(function()
            if modules.PlayerDataController and modules.PlayerDataController.CurrentData then
                modules.PlayerDataController.CurrentData:Replicate("UnclaimedRewards")
            end
        end)
    end
end

local product_type = "product"
local marketplace_asset_id = 0
local function UpdateMarketplace()
    if states.spoofer_state.marketplace.fake_robux then
        local foundation_overlay = FindContainerWithRobuxPrice()
        if not foundation_overlay or not foundation_overlay:FindFirstChild("SafeAreaFrame") then
            return
        end

        if not marketplace_asset_id or marketplace_asset_id == 0 then
            return
        end

        local robux_text = string.format(
            '<font family="rbxasset://LuaPackages/Packages/_Index/BuilderIcons/BuilderIcons/BuilderIcons.json" weight="400">robux</font> %s',
            FormatNumber(states.spoofer_state.marketplace.robux_amount)
        )

        local info_type = product_type == "gamepass" and Enum.InfoType.GamePass or product_type == "product" and Enum.InfoType.Product or Enum.InfoType.Asset
        local product_info = services.MarketplaceService:GetProductInfo(marketplace_asset_id, info_type)
        local has_enough = product_info.PriceInRobux <= states.spoofer_state.marketplace.robux_amount

        local BuyButton
        local PromptTitle
        local RobuxBalance
        local SheetContentContainer

        for _, descendant in ipairs(foundation_overlay:GetDescendants()) do
            local parent = descendant.Parent
            local grandparent = parent and parent.Parent

            if descendant.Name == "RobuxPrice" and descendant:IsA("TextLabel") and grandparent and grandparent.Name == "ModalHeader" then
                descendant.RichText = true
                descendant.Text = robux_text
                RobuxBalance = descendant
            elseif descendant.Name == "RobuxAmount" and descendant:IsA("TextLabel") and grandparent and grandparent.Name == "ModalHeader" then
                descendant.Text = has_enough and "Buy item" or "Buy Robux and item"
                PromptTitle = descendant
            elseif descendant:IsA("ImageButton") and parent and parent.Name == "1" then
                BuyButton = descendant
            elseif descendant.Name == "SheetContentContainer" and descendant:IsA("Frame") and parent and parent.Name == "ScrollingFrame" then
                SheetContentContainer = descendant
            elseif descendant.Name == "UpsellSuggestions" and descendant:IsA("Frame") and parent and parent.Name == "SheetContentContainer" and has_enough then
                descendant:Destroy()
            elseif descendant.Name == "DisclosureTerms" and descendant:IsA("Frame") and parent and parent.Name == "1" and has_enough then
                descendant:Destroy()
            end
        end

        if BuyButton then
            local OverlayButton = foundation_overlay:FindFirstChild("nigga")

            if OverlayButton then
                return
            end

            OverlayButton = Instance.new("TextButton")
            OverlayButton.Name = "nigga"
            OverlayButton.BackgroundTransparency = 1
            OverlayButton.Text = ""
            OverlayButton.AutoButtonColor = false
            OverlayButton.ZIndex = BuyButton.ZIndex + 100
            OverlayButton.Size = UDim2.fromOffset(BuyButton.AbsoluteSize.X, BuyButton.AbsoluteSize.Y)
            OverlayButton.Position = UDim2.fromOffset(BuyButton.AbsolutePosition.X, BuyButton.AbsolutePosition.Y + BuyButton.AbsoluteSize.Y + (BuyButton.AbsoluteSize.Y / 2))
            OverlayButton.AnchorPoint = BuyButton.AnchorPoint
            OverlayButton.Parent = foundation_overlay

            BuyButton.Destroying:Connect(function()
                OverlayButton:Destroy()
                product_type = "product"
                marketplace_asset_id = 0
            end)

            services.RunService.Heartbeat:Connect(LPH_NO_VIRTUALIZE(function()
                OverlayButton.Position = UDim2.fromOffset(BuyButton.AbsolutePosition.X, BuyButton.AbsolutePosition.Y + BuyButton.AbsoluteSize.Y + (BuyButton.AbsoluteSize.Y / 2))
            end))

            task.wait(3)

            local purchased = false
            OverlayButton.MouseButton1Click:Connect(function()
                local current_id = getthreadidentity()
                setthreadidentity(2)

                if purchased then
                    services.GuiService:InspectPlayerFromUserId(LocalPlayer.UserId)
                    services.GuiService:CloseInspectMenu()
                    return
                end

                local currency_rewards = {}

                for _, bundle in pairs(modules.MonetizationLibrary.Bundles) do
                    if bundle.ProductID == marketplace_asset_id or bundle.GamepassName == modules.MonetizationLibrary:GetGamepassName(marketplace_asset_id) then
                        currency_rewards = bundle.Rewards
                        break
                    end
                end

                setthreadidentity(current_id)

                local original_bgcolor = BuyButton.BackgroundColor3
                BuyButton.BackgroundColor3 = Color3.fromRGB(38, 61, 143)

                local bgcolor_conn = BuyButton:GetPropertyChangedSignal("BackgroundColor3"):Connect(function()
                    BuyButton.BackgroundColor3 = Color3.fromRGB(38, 61, 143)
                end)

                task.wait(2)

                bgcolor_conn:Disconnect()
                BuyButton.BackgroundColor3 = original_bgcolor

                if product_type == "gamepass" then
                    services.MarketplaceService:SignalPromptGamePassPurchaseFinished(LocalPlayer, marketplace_asset_id, has_enough)
                elseif product_type == "product" then
                    services.MarketplaceService:SignalPromptProductPurchaseFinished(LocalPlayer.UserId, marketplace_asset_id, has_enough)
                elseif product_type == "asset" then
                    services.MarketplaceService:SignalPromptPurchaseFinished(LocalPlayer, marketplace_asset_id, has_enough)
                end

                PromptTitle.Text = "Purchase completed"
                PromptTitle.Name = "Title"
                RobuxBalance:Destroy()

                local BodyContainer = Instance.new("Frame")
                BodyContainer.Name = "Body"
                BodyContainer.Parent = SheetContentContainer.Parent
                BodyContainer.AutomaticSize = Enum.AutomaticSize.Y
                BodyContainer.BackgroundTransparency = 1
                BodyContainer.BorderSizePixel = 0
                BodyContainer.LayoutOrder = 1
                BodyContainer.Size = UDim2.fromScale(1, 0)
                BodyContainer.AutoLocalize = false
                SheetContentContainer:Destroy()

                local UIListLayout = Instance.new("UIListLayout")
                UIListLayout.Parent = BodyContainer
                UIListLayout.Padding = UDim.new(0, 16)
                UIListLayout.SortOrder = Enum.SortOrder.LayoutOrder
                UIListLayout.HorizontalAlignment = Enum.HorizontalAlignment.Center
                UIListLayout.VerticalAlignment = Enum.VerticalAlignment.Center

                local UIPadding = Instance.new("UIPadding")
                UIPadding.Parent = BodyContainer
                UIPadding.PaddingTop = UDim.new(0, 8)

                local Icon = Instance.new("TextLabel")
                Icon.Name = "Icon"
                Icon.Parent = BodyContainer
                Icon.BackgroundTransparency = 1
                Icon.BorderSizePixel = 0
                Icon.LayoutOrder = 0
                Icon.Size = UDim2.fromOffset(48, 48)
                Icon.AutoLocalize = false
                Icon.FontFace = Font.new("rbxasset://LuaPackages/Packages/_Index/BuilderIcons/BuilderIcons/BuilderIcons.json", Enum.FontWeight.Regular)
                Icon.Text = "circle-check"
                Icon.TextColor3 = Color3.fromRGB(213, 215, 221)
                Icon.TextSize = 48

                local Message = Instance.new("TextLabel")
                Message.Name = "Message"
                Message.Parent = BodyContainer
                Message.AutomaticSize = Enum.AutomaticSize.XY
                Message.BackgroundTransparency = 1
                Message.BorderSizePixel = 0
                Message.Size = UDim2.new(0, 0, 0, 0)
                Message.AutoLocalize = false
                Message.FontFace = Font.new("rbxasset://fonts/families/LegacyArimo.json", Enum.FontWeight.Regular)
                Message.Text = "You have successfully bought " .. product_info.Name .. "."
                Message.TextColor3 = Color3.fromRGB(213, 215, 221)
                Message.TextSize = 15
                Message.TextWrapped = true
                Message.TextXAlignment = Enum.TextXAlignment.Left

                local label = BuyButton:FindFirstChildOfClass("TextLabel")
                if label then
                    local clone = label:Clone()
                    clone.Text = "OK"
                    clone.Parent = label.Parent
                    label:Destroy()
                end

                setthreadidentity(2)

                task.wait()
                modules.MonetizationController:_FinishPrompt(has_enough)

                if has_enough and product_type == "gamepass" then
                    AddGamepass(marketplace_asset_id)
                end

                for _, reward in ipairs(currency_rewards) do
                    AddReward(reward.Type or reward.Name, reward.Quantity or 1, reward.Weapon)
                end

                if has_enough and modules.MonetizationLibrary.Gifts[tostring(marketplace_asset_id)] and states.spoofer_state.marketplace.fake_gifting then
                    local marketplace = states.spoofer_state.marketplace

                    marketplace.fake_gift_robux_spent += product_info.PriceInRobux

                    while true do
                        local required = modules.MonetizationLibrary:GetGiftRewardRobuxSpentRequirement(
                            marketplace.fake_gift_rewards_claimed
                        )

                        if marketplace.fake_gift_robux_spent < required then
                            break
                        end

                        marketplace.fake_gift_robux_spent -= required
                        marketplace.fake_gift_rewards_claimed += 1
                    end

                    modules.PlayerDataController.CurrentData:Replicate("GiftRobuxSpentProgress")
                    modules.PlayerDataController.CurrentData:Replicate("GiftRobuxSpentRewardsClaimed")
                end

                purchased = true
            end)
        end
    end
end

services.CoreGui.DescendantAdded:Connect(UpdateMarketplace)

task.spawn(function()
    pcall(function()
        local original = modules.MonetizationController.PromptProductPurchase

        modules.MonetizationController.PromptProductPurchase = function(self, product_id, ...)
            if product_id and product_id ~= 0 then
                marketplace_asset_id = product_id
                product_type = "product"
            end

            local results = {original(self, product_id, ...)}
            return unpack(results)
        end
    end)

    pcall(function()
        local original = modules.MonetizationController.PromptGamePassPurchase

        modules.MonetizationController.PromptGamePassPurchase = function(self, gamepass_id, ...)
            if gamepass_id and gamepass_id ~= 0 then
                marketplace_asset_id = gamepass_id
                product_type = "gamepass"
            end

            local results = {original(self, gamepass_id, ...)}
            return unpack(results)
        end
    end)

    pcall(function()
        local original = modules.MonetizationController.PromptPurchase

        modules.MonetizationController.PromptPurchase = function(self, asset_id)
            if asset_id and asset_id ~= 0 then
                marketplace_asset_id = asset_id
                product_type = "asset"
            end

            local results = {original(self, asset_id)}
            return unpack(results)
        end
    end)

    pcall(function()
        local remote = services.ReplicatedStorage.Remotes.Misc.PromptGiftProductPurchase

        NamecallDispatcher:Register(LPH_JIT_MAX(function(self, method, ...)
            if method ~= "InvokeServer" or self ~= remote then
                return false
            end

            local args = { ... }

            if args[1] and args[1] ~= 0 then
                marketplace_asset_id = args[1]
                product_type = "product"
            end

            return NamecallDispatcher:CallOriginal(self, ...)
        end))
    end)
end)

--[[
    User Interface
]]

ui_objects.Window = Library:CreateWindow({
    Title = tostring(LP_SCRIPT_NAME),
    Version = "v1.0.0",
    Icon = kConstants.kAethereaLogo
})

ui_objects.Window:CreateConfigFlag(
	"fake_owned",
	function()
		return states.skinchanger_state.fake_owned
	end,
	function(value)
		states.skinchanger_state.fake_owned = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"fake_weapon_owned",
	function()
		return states.skinchanger_state.fake_weapon_owned
	end,
	function(value)
		states.skinchanger_state.fake_weapon_owned = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"equipped",
	function()
		return states.skinchanger_state.equipped
	end,
	function(value)
		states.skinchanger_state.equipped = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"favorites",
	function()
		return states.skinchanger_state.favorites
	end,
	function(value)
		states.skinchanger_state.favorites = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"inventory_fake_owned",
	function()
		return states.inventory_state.fake_owned
	end,
	function(value)
		states.inventory_state.fake_owned = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"fake_bundles_owned",
	function()
		return states.spoofer_state.marketplace.fake_bundles_owned
	end,
	function(value)
		states.spoofer_state.marketplace.fake_bundles_owned = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"fake_gift_robux_spent",
	function()
		return states.spoofer_state.marketplace.fake_gift_robux_spent
	end,
	function(value)
		states.spoofer_state.marketplace.fake_gift_robux_spent = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"fake_gift_rewards_claimed",
	function()
		return states.spoofer_state.marketplace.fake_gift_rewards_claimed
	end,
	function(value)
		states.spoofer_state.marketplace.fake_gift_rewards_claimed = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"duel_history_value",
	function()
		return states.spoofer_state.duel_history.duel_history_value
	end,
	function(value)
		states.spoofer_state.duel_history.duel_history_value = value
	end
)

ui_objects.Window:CreateConfigFlag(
	"logged_elo_events",
	function()
		return states.spoofer_state.duel_history.logged_elo_events
	end,
	function(value)
		states.spoofer_state.duel_history.logged_elo_events = value
	end
)

--[[
    Main
]]

ui_objects.MainTab = ui_objects.Window:CreateTab("Main", nil, kConstants.kLucideHome)

ui_objects.AccountSection = ui_objects.MainTab:CreateSection("Account", kConstants.kLucideUser)

ui_objects.AccountSection:CreateLabel({
    Title = "Welcome back, "..LP_DISCORD
})

ui_objects.AccountSection:CreateLabel({
    Title = "Account Age: " .. LocalPlayer.AccountAge
})

ui_objects.PingLabel = ui_objects.AccountSection:CreateLabel({
    Title = "Ping: " .. tostring(math.floor(LocalPlayer:GetNetworkPing() * 1000))
})

ui_objects.TimeWastedLabel = ui_objects.AccountSection:CreateLabel({
    Title = "Time Wasted: " .. tostring(0)
})

ui_objects.TimeLeftLabel = ui_objects.AccountSection:CreateLabel({
    Title = "Time Left: " .. tostring(LP_TIMELEFT)
})

ui_objects.AccountSection:CreateEmpty()

task.spawn(LPH_NO_VIRTUALIZE(function()
    local start = tick()
	while task.wait(1) do
        local ping = tostring(math.floor(LocalPlayer:GetNetworkPing() * 1000))
        local time = tostring(math.floor(tick() - start))

        ui_objects.PingLabel:Set("Ping: " .. ping, nil)
        ui_objects.TimeWastedLabel:Set("Time Wasted: " .. time, nil)
	end
end))

ui_objects.StatusSection = ui_objects.MainTab:CreateSection("Status", kConstants.kLucideHeart)

ui_objects.StatusSection:CreateLabel({
    Title = "[+] RIVALS",
    Type = "Success"
})

ui_objects.StatusSection:CreateLabel({
    Title = "[+] Prison Life",
    Type = "Success"
})

ui_objects.StatusSection:CreateLabel({
    Title = "[+] Bloxburg",
    Type = "Success"
})

ui_objects.StatusSection:CreateLabel({
    Title = "[+] Murder Mystery 2",
    Type = "Success"
})

ui_objects.ChangelogsSection = ui_objects.MainTab:CreateSection("Changelogs", kConstants.kLucideClipboard)

pcall(function()
    local changelog_table = {}

    for line in string.gmatch(ChangeLogs, "[^\r\n]+") do
        table.insert(changelog_table, line)
    end

    for _, str  in ipairs(changelog_table) do
        local data = {
            Title = str
        }

        if str:sub(1, 3) == "[+]" then
            data.Type = "Success"
        elseif str:sub(1, 3) == "[-]" then
            data.Type = "Error"
        end

        ui_objects.ChangelogsSection:CreateLabel(data)
    end
end)

ui_objects.CompatabilitySection = ui_objects.MainTab:CreateSection("Compatability", kConstants.kLucideCheckCircle)

pcall(function()
    local funcs_passed = 0

    for _, func in ipairs(kConstants.kFunctionsUsed) do
        if getgenv()[func] ~= nil then
            funcs_passed += 1
        end
    end

    ui_objects.CompatabilitySection:CreateLabel({
        Title = "Result: " .. funcs_passed .. "/" .. #kConstants.kFunctionsUsed .. " passed",
        Type = "Success"
    })

    ui_objects.CompatabilitySection:CreateDivider()

    for _, func in ipairs(kConstants.kFunctionsUsed) do
        local exists = getgenv()[func] ~= nil

        ui_objects.CompatabilitySection:CreateLabel({
            Title = (exists and "[+] " or "[-] ") .. func,
            Type = exists and "Success" or "Error"
        })
    end
end)

--[[
    Legit
]]

ui_objects.LegitTab = ui_objects.Window:CreateTab("Legit", "Legit Hacks.", kConstants.kLucideCheckCircle)

ui_objects.SilentAimSection = ui_objects.LegitTab:CreateSection("Silent Aim", kConstants.kLucideCrosshair)

ui_objects.SilentAimEnabled = ui_objects.SilentAimSection:CreateToggle({
    Name = "Enabled",
    Flag = "silentaim_enabled",
    CurrentValue = states.legit_state.silent_aim.enabled,
    Callback = function(v)
        if states.legit_state.silent_aim.enabled ~= v then
            SetSilentAimEnabled(v)
        end
    end
})

ui_objects.SilentAimKeybind = ui_objects.SilentAimSection:CreateKeybind({
    Name = "SilentAim Keybind",
    Flag = "silentaim_keybind",
    Callback = function(v)
        if states.legit_state.silent_aim.enabled ~= v then
            SetSilentAimEnabled(v)
        end

        if v then
            ui_objects.Window:Notify({
                Title = "Silent Aim Enabled",
                Content = "Aim enhancements enabled.",
                Duration = 5
            })
        else
            ui_objects.Window:Notify({
                Title = "Silent Aim Disabled",
                Content = "Aim enhancements disabled.",
                Duration = 5
            })
        end
    end
})

ui_objects.SilentAimSection:CreateSlider({
    Name = "Hit Chance",
    Flag = "silent_hit_chance",
    Range = {0, 100},
    Increment = 1,
    CurrentValue = states.legit_state.silent_aim.hit_chance,
    Callback = function(v)
        states.legit_state.silent_aim.hit_chance = v
    end
})

ui_objects.SilentAimSection:CreateChecklist({
    Name = "Options",
    Flag = "silentaim_options",
    Options = {
        {
            Name = "Manipulation",
            Default = states.legit_state.silent_aim.manipulation
        },
        {
            Name = "Visualize",
            Default = states.legit_state.silent_aim.visualize
        },
    },
    Callback = function(o)
        states.legit_state.silent_aim.manipulation = o["Manipulation"]
        states.legit_state.silent_aim.visualize = o["Visualize"]
    end
})

ui_objects.TriggerbotSection = ui_objects.LegitTab:CreateSection("Triggerbot", kConstants.kLucideView)

ui_objects.TriggerbotEnabled = ui_objects.TriggerbotSection:CreateToggle({
    Name = "Enabled",
    Flag = "triggerbot_enabled",
    CurrentValue = states.legit_state.triggerbot.enabled,
    Callback = function(v)
        if states.legit_state.triggerbot.enabled ~= v then
            SetTriggerbotEnabled(v)
        end
    end
})

ui_objects.TriggerbotKeybind = ui_objects.TriggerbotSection:CreateKeybind({
    Name = "Triggerbot Keybind",
    Flag = "triggerbot_keybind",
    Callback = function(v)
        if states.legit_state.triggerbot.enabled ~= v then
            SetTriggerbotEnabled(v)
        end

        if v then
            ui_objects.Window:Notify({
                Title = "Triggerbot Enabled",
                Content = "Aim enhancements enabled.",
                Duration = 5
            })
        else
            ui_objects.Window:Notify({
                Title = "Triggerbot Disabled",
                Content = "Aim enhancements disabled.",
                Duration = 5
            })
        end
    end
})

ui_objects.TriggerbotSection:CreateSlider({
    Name = "Shoot delay",
    Flag = "triggerbot_shoot_delay",
    Range = {0, 300},
    Increment = 1,
    CurrentValue = states.legit_state.triggerbot.shoot_delay,
    Callback = function(v)
        states.legit_state.triggerbot.shoot_delay = v
    end
})

ui_objects.TriggerbotSection:CreateDropdown({
    Name = "Check scoped",
    Flag = "triggerbot_check_scoped",
    Options = kConstants.kCheckScoped,
    CurrentOption = states.legit_state.triggerbot.check_scoped,
    MultipleOptions = true,
    AllowNone = false,
    Callback = function(v)
        states.legit_state.triggerbot.check_scoped = v
    end
})

ui_objects.TargetingSection = ui_objects.LegitTab:CreateSection("Targeting", kConstants.kLucideEye)

ui_objects.TargetingSection:CreateDropdown({
    Name = "Target Group",
    Flag = "targeting_target_group",
    Options = kConstants.kTargetList,
    CurrentOption = states.targeting_state.target_group,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.targeting_state.target_group = v
    end
})

ui_objects.TargetingSection:CreateDropdown({
    Name = "Ignore",
    Flag = "targeting_ignore",
    Options = kConstants.kGunIgnoreList,
    CurrentOption = states.targeting_state.ignore,
    MultipleOptions = true,
    AllowNone = false,
    Callback = function(v)
        states.targeting_state.ignore = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Radius",
    Flag = "targeting_radius",
    Range = {0, 500},
    Increment = 1,
    CurrentValue = states.targeting_state.radius,
    Callback = function(v)
        states.targeting_state.radius = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Max Distance",
    Flag = "targeting_max_distance",
    Range = {50, 1000},
    Increment = 1,
    CurrentValue = states.targeting_state.max_distance,
    Callback = function(v)
        states.targeting_state.max_distance = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Weight Ratio",
    Flag = "targeting_weight_ratio",
    Range = {0, 1},
    Increment = 0.1,
    CurrentValue = states.targeting_state.weight_ratio,
    Callback = function(v)
        states.targeting_state.weight_ratio = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Reaction time",
    Flag = "targeting_reaction_time",
    Range = {0, 300},
    Increment = 1,
    CurrentValue = states.targeting_state.reaction_time,
    Callback = function(v)
        states.targeting_state.reaction_time = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Forget time",
    Flag = "targeting_forget_time",
    Range = {0, 10},
    Increment = 0.1,
    CurrentValue = states.targeting_state.forget_time,
    Callback = function(v)
        states.targeting_state.forget_time = v
    end
})

ui_objects.TargetingSection:CreateDropdown({
    Name = "Target",
    Flag = "targeting_target",
    Options = {
        "Closest Part",
        "Head",
        "HumanoidRootPart",
        "UpperTorso",
        "LowerTorso",
        "LeftFoot",
        "LeftLowerLeg",
        "LeftUpperLeg",
        "RightFoot",
        "RightLowerLeg",
        "RightUpperLeg",
        "LeftHand",
        "LeftLowerArm",
        "LeftUpperArm",
        "RightHand",
        "RightLowerArm",
        "RightUpperArm",
    },
    CurrentOption = states.targeting_state.target,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.targeting_state.target = v
    end
})

ui_objects.TargetingSection:CreateDropdown({
    Name = "Include Parts",
    Flag = "targeting_include_parts",
    Options = kConstants.kBodyParts,
    CurrentOption = states.targeting_state.include_parts,
    MultipleOptions = true,
    AllowNone = false,
    Callback = function(v)
        states.targeting_state.include_parts = v
    end
})

ui_objects.TargetingSection:CreateChecklist({
    Name = "Options",
    Flag = "targeting_options",
    Options = {
        {
            Name = "Wallcheck",
            Default = states.targeting_state.wallcheck
        },
        {
            Name = "Show FOV",
            Default = states.targeting_state.show_fov
        },
    },
    Callback = function(o)
        states.targeting_state.wallcheck = o["Wallcheck"]
        states.targeting_state.show_fov = o["Show FOV"]
    end
})

ui_objects.TargetingSection:CreateChecklist({
    Name = "FOV",
    Flag = "targeting_fov",
    Options = {
        {
            Name = "FOV Outline",
            Default = states.targeting_state.fov_outline
        },
        {
            Name = "FOV Fill",
            Default = states.targeting_state.fov_fill
        },
    },
    Callback = function(o)
        states.targeting_state.fov_outline = o["FOV Outline"]
        states.targeting_state.fov_fill = o["FOV Fill"]
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Lerp",
    Flag = "fov_lerp",
    Range = {0.1, 1},
    Increment = 0.01,
    CurrentValue = states.targeting_state.fov_lerp,
    Callback = function(v)
        states.targeting_state.fov_lerp = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Rotation",
    Flag = "fov_rotation",
    Range = {0, 360},
    Increment = 1,
    CurrentValue = states.targeting_state.fov_rotation,
    Callback = function(v)
        states.targeting_state.fov_rotation = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Rotation Speed",
    Flag = "fov_rotation_speed",
    Range = {0, 5},
    Increment = 0.1,
    CurrentValue = states.targeting_state.fov_rotation_speed,
    Callback = function(v)
        states.targeting_state.fov_rotation_speed = v
    end
})

ui_objects.TargetingSection:CreateColorPicker({
    Name = "Start Color",
    Flag = "fov_start_color",
    Color = states.targeting_state.fov_start_color,
    Callback = function(c)
        states.targeting_state.fov_start_color = c
    end
})

ui_objects.TargetingSection:CreateColorPicker({
    Name = "Mid Color",
    Flag = "fov_mid_color",
    Color = states.targeting_state.fov_mid_color,
    Callback = function(c)
        states.targeting_state.fov_mid_color = c
    end
})

ui_objects.TargetingSection:CreateColorPicker({
    Name = "End Color",
    Flag = "fov_end_color",
    Color = states.targeting_state.fov_end_color,
    Callback = function(c)
        states.targeting_state.fov_end_color = c
    end
})

ui_objects.TargetingSection:CreateColorPicker({
    Name = "Outline Start Color",
    Flag = "fov_outline_start_color",
    Color = states.targeting_state.fov_outline_start_color,
    Callback = function(c)
        states.targeting_state.fov_outline_start_color = c
    end
})

ui_objects.TargetingSection:CreateColorPicker({
    Name = "Outline Mid Color",
    Flag = "fov_outline_mid_color",
    Color = states.targeting_state.fov_outline_mid_color,
    Callback = function(c)
        states.targeting_state.fov_outline_mid_color = c
    end
})

ui_objects.TargetingSection:CreateColorPicker({
    Name = "Outline End Color",
    Flag = "fov_outline_end_color",
    Color = states.targeting_state.fov_outline_end_color,
    Callback = function(c)
        states.targeting_state.fov_outline_end_color = c
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Transparency",
    Flag = "fov_transparency",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.targeting_state.fov_transparency,
    Callback = function(v)
        states.targeting_state.fov_transparency = v
    end
})

ui_objects.TargetingSection:CreateSlider({
    Name = "Outline Transparency",
    Flag = "fov_outline_transparency",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.targeting_state.fov_outline_transparency,
    Callback = function(v)
        states.targeting_state.fov_outline_transparency = v
    end
})

ui_objects.TargetingSection:CreateDropdown({
    Name = "Position",
    Flag = "fov_position",
    Options = kConstants.kLerpPos,
    CurrentOption = states.targeting_state.fov_position,
    MultipleOptions = true,
    AllowNone = false,
    Callback = function(v)
        table.clear(states.targeting_state.fov_position)

        for _, pos in v do
            states.targeting_state.fov_position[pos] = true
        end
    end
})

--[[
    Rage
]]

ui_objects.RageTab = ui_objects.Window:CreateTab("Rage", "Rage Hacks.", kConstants.kLucideCrosshair)

ui_objects.WeaponsSection = ui_objects.RageTab:CreateSection("Weapons", kConstants.kLucideCrosshair)

ui_objects.WeaponsSection:CreateChecklist({
    Name = "Exploits",
    Flag = "exploits",
    Options = {
        {
            Name = "No recoil",
            Default = states.rage_state.weapons.no_recoil
        },
        {
            Name = "No spread",
            Default = states.rage_state.weapons.no_spread
        },
        {
            Name = "Full auto",
            Default = states.rage_state.weapons.full_auto
        },
    },
    Callback = function(o)
        states.rage_state.weapons.no_recoil = o["No recoil"]
        states.rage_state.weapons.no_spread = o["No spread"]
        states.rage_state.weapons.full_auto = o["Full auto"]
    end
})

ui_objects.WeaponsSection:CreateSlider({
    Name = "Firerate",
    Flag = "firerate",
    Range = {10, 100},
    Increment = 1,
    CurrentValue = states.rage_state.weapons.firerate,
    Callback = function(v)
        states.rage_state.weapons.firerate = v
    end
})

ui_objects.PluggWalkSection = ui_objects.RageTab:CreateSection("PluggWalk", kConstants.kLucideCat)

ui_objects.PluggWalkSection:CreateLabel({
    Title = "Show me yo PluggWalk"
})

ui_objects.PluggWalkEnabled = ui_objects.PluggWalkSection:CreateToggle({
    Name = "PluggWalk Enabled",
    Flag = "pluggwalk_enabled",
    CurrentValue = states.rage_state.pluggwalk.enabled,
    Callback = function(v)
        if states.rage_state.pluggwalk.enabled ~= v then
            SetPluggWalkEnabled(v)
        end
    end
})

ui_objects.PluggWalkKeybind = ui_objects.PluggWalkSection:CreateKeybind({
    Name = "PluggWalk Keybind",
    Flag = "pluggwalk_keybind",
    Callback = function(v)
        if states.rage_state.pluggwalk.enabled ~= v then
            SetPluggWalkEnabled(v)
        end

        if v then
            ui_objects.Window:Notify({
                Title = "PluggWalk Enabled",
                Content = "yo didywalk :skull:",
                Duration = 5
            })
        else
            ui_objects.Window:Notify({
                Title = "PluggWalk Disabled",
                Content = "yo didywalk :skull:",
                Duration = 5
            })
        end
    end
})

ui_objects.RageMiscSection = ui_objects.RageTab:CreateSection("Misc", kConstants.kLucideBox)

ui_objects.RageMiscSection:CreateChecklist({
    Name = "Options",
    Flag = "rage_misc_options",
    Options = {
        {
            Name = "Anti Tripmine",
            Default = states.rage_state.misc.anti_tripmine
        },
        {
            Name = "TP Throwables",
            Default = states.rage_state.misc.tp_throwables
        },
    },
    Callback = function(o)
        states.rage_state.misc.anti_tripmine = o["Anti Tripmine"]
        states.rage_state.misc.tp_throwables = o["TP Throwables"]
    end
})

ui_objects.RageBotSection = ui_objects.RageTab:CreateSection("Rage Bot", kConstants.kLucideCrosshair)

ui_objects.RageBotEnabled = ui_objects.RageBotSection:CreateToggle({
    Name = "Rage Bot Enabled",
    Flag = "rage_bot_enabled",
    CurrentValue = states.rage_state.rage_bot.enabled,
    Callback = function(v)
        if states.rage_state.rage_bot.enabled ~= v then
            SetRageBotEnabled(v)
        end
    end
})

ui_objects.RageBotKeybind = ui_objects.RageBotSection:CreateKeybind({
    Name = "Rage Bot Keybind",
    Flag = "rage_bot_keybind",
    Callback = function(v)
        if states.rage_state.rage_bot.enabled ~= v then
            SetRageBotEnabled(v)
        end

        if v then
            ui_objects.Window:Notify({
                Title = "Rage Bot Enabled",
                Content = "Rage is enabled",
                Duration = 5
            })
        else
            ui_objects.Window:Notify({
                Title = "Rage Bot Disabled",
                Content = "Rage is disabled",
                Duration = 5
            })
        end
    end
})

ui_objects.RageBotSection:CreateToggle({
    Name = "Void Spam",
    Flag = "void_spam",
    CurrentValue = states.rage_state.rage_bot.void_spam,
    Callback = function(v)
        SetVoidSpamEnabled(v)
    end
})

ui_objects.RageBotSection:CreateSlider({
    Name = "Hide",
    Flag = "rage_bot_hide",
    Range = {0.01, 1},
    Increment = 0.01,
    CurrentValue = states.rage_state.rage_bot.hide,
    Callback = function(v)
        states.rage_state.rage_bot.hide = v
    end
})

ui_objects.RageBotSection:CreateSlider({
    Name = "Attack",
    Flag = "rage_bot_attack",
    Range = {0.01, 1},
    Increment = 0.01,
    CurrentValue = states.rage_state.rage_bot.attack,
    Callback = function(v)
        states.rage_state.rage_bot.attack = v
    end
})

ui_objects.RageBotSection:CreateSlider({
    Name = "Shoot Attempts",
    Flag = "rage_bot_shoot_attempts",
    Range = {1, 2},
    Increment = 1,
    CurrentValue = states.rage_state.rage_bot.shoot_attempts,
    Callback = function(v)
        states.rage_state.rage_bot.shoot_attempts = v
    end
})

ui_objects.RageBotSection:CreateDropdown({
    Name = "Attack mode",
    Flag = "rage_bot_attack_mode",
    Options = {
        "Gun",
        "Knife",
        "Melee"
    },
    CurrentOption = states.rage_state.rage_bot.attack_mode,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.rage_state.rage_bot.attack_mode = v
    end
})

ui_objects.RageBotSection:CreateDropdown({
    Name = "Preferred",
    Flag = "rage_bot_preferred",
    Options = {
        "Primary",
        "Secondary",
    },
    CurrentOption = states.rage_state.rage_bot.preferred,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.rage_state.rage_bot.preferred = v
    end
})

ui_objects.RageBotSection:CreateChecklist({
    Name = "Options",
    Flag = "rage_bot_options",
    Options = {
        {
            Name = "Hit Notifications",
            Default = states.rage_state.rage_bot.hit_notifications
        },
        {
            Name = "Rage HUD",
            Default = states.rage_state.rage_bot.rage_hud
        },
    },
    Callback = function(o)
        states.rage_state.rage_bot.hit_notifications = o["Hit Notifications"]
        states.rage_state.rage_bot.rage_hud = o["Rage HUD"]
    end
})

ui_objects.AntiAimSection = ui_objects.RageTab:CreateSection("Anti Aim", kConstants.kLucideCrosshair)

ui_objects.AntiAimEnabled = ui_objects.AntiAimSection:CreateToggle({
    Name = "Anti Aim Enabled",
    Flag = "anti_aim_enabled",
    CurrentValue = states.rage_state.anti_aim.enabled,
    Callback = function(v)
        if states.rage_state.anti_aim.enabled ~= v then
            SetAntiAimEnabled(v)
        end
    end
})

ui_objects.AntiAimKeybind = ui_objects.AntiAimSection:CreateKeybind({
    Name = "Anti Aim Keybind",
    Flag = "anti_aim_keybind",
    Callback = function(v)
        if states.rage_state.anti_aim.enabled ~= v then
            SetAntiAimEnabled(v)
        end

        if v then
            ui_objects.Window:Notify({
                Title = "Anti Aim Enabled",
                Content = "Aim prevention enabled",
                Duration = 5
            })
        else
            ui_objects.Window:Notify({
                Title = "Anti Aim Disabled",
                Content = "Aim prevention disabled",
                Duration = 5
            })
        end
    end
})

ui_objects.AntiAimSection:CreateDropdown({
    Name = "Pitch",
    Flag = "anti_aim_pitch",
    Options = kConstants.kPitchOptions,
    CurrentOption = states.rage_state.anti_aim.pitch,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.rage_state.anti_aim.pitch = v
    end
})

ui_objects.AntiAimSection:CreateSlider({
    Name = "Pitch Angle",
    Flag = "anti_aim_pitch_angle",
    Range = {-180, 180},
    Increment = 1,
    CurrentValue = states.rage_state.anti_aim.pitch_angle,
    Callback = function(v)
        states.rage_state.anti_aim.pitch_angle = v
    end
})

ui_objects.AntiAimSection:CreateDropdown({
    Name = "Yaw",
    Flag = "anti_aim_yaw",
    Options = kConstants.kYawOptions,
    CurrentOption = states.rage_state.anti_aim.yaw,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.rage_state.anti_aim.yaw = v
    end
})

ui_objects.AntiAimSection:CreateSlider({
    Name = "Yaw Angle",
    Flag = "anti_aim_yaw_angle",
    Range = {-180, 180},
    Increment = 1,
    CurrentValue = states.rage_state.anti_aim.yaw_angle,
    Callback = function(v)
        states.rage_state.anti_aim.yaw_angle = v
    end
})

ui_objects.AntiAimSection:CreateSlider({
    Name = "Jitter Angle",
    Flag = "anti_aim_jitter_angle",
    Range = {-180, 180},
    Increment = 1,
    CurrentValue = states.rage_state.anti_aim.jitter_angle,
    Callback = function(v)
        states.rage_state.anti_aim.jitter_angle = v
    end
})

ui_objects.AntiAimSection:CreateSlider({
    Name = "Spin/Jitter Speed",
    Flag = "anti_aim_speed",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.rage_state.anti_aim.speed,
    Callback = function(v)
        states.rage_state.anti_aim.speed = v
    end
})

ui_objects.AntiAimSection:CreateChecklist({
    Name = "Options",
    Flag = "anti_aim_options",
    Options = {
        {
            Name = "Underground",
            Default = states.rage_state.anti_aim.underground
        },
    },
    Callback = function(o)
        states.rage_state.anti_aim.underground = o["Underground"]
    end
})

ui_objects.MovementSection = ui_objects.RageTab:CreateSection("Movement", kConstants.kLucideUser)

ui_objects.MovementSection:CreateChecklist({
    Name = "Options",
    Flag = "movement_options",
    Options = {
        {
            Name = "Fly",
            Default = states.rage_state.movement.fly
        },
        {
            Name = "Velocity",
            Default = states.rage_state.movement.velocity
        },
        {
            Name = "Slide boost",
            Default = states.rage_state.movement.slide_boost
        },
        {
            Name = "Double jump height",
            Default = states.rage_state.movement.double_jump_height
        },
        {
            Name = "Infinite double jump",
            Default = states.rage_state.movement.infinite_double_jump
        },
    },
    Callback = function(o)
        states.rage_state.movement.fly = o["Fly"]
        states.rage_state.movement.velocity = o["Velocity"]
        states.rage_state.movement.slide_boost = o["Slide boost"]
        states.rage_state.movement.double_jump_height = o["Double jump height"]
        states.rage_state.movement.infinite_double_jump = o["Infinite double jump"]
    end
})

ui_objects.MovementSection:CreateSlider({
    Name = "Fly Speed",
    Flag = "fly_speed",
    Range = {10, 85},
    Increment = 1,
    CurrentValue = states.rage_state.movement.fly_speed,
    Callback = function(v)
        states.rage_state.movement.fly_speed = v
    end
})

ui_objects.MovementSection:CreateSlider({
    Name = "Velocity Speed",
    Flag = "velocity_speed",
    Range = {10, 85},
    Increment = 1,
    CurrentValue = states.rage_state.movement.velocity_speed,
    Callback = function(v)
        states.rage_state.movement.velocity_speed = v
    end
})

ui_objects.MovementSection:CreateSlider({
    Name = "Slide boost",
    Flag = "slide_boost_value",
    Range = {1, 5},
    Increment = 0.1,
    CurrentValue = states.rage_state.movement.slide_boost_value,
    Callback = function(v)
        states.rage_state.movement.slide_boost_value = v
    end
})

ui_objects.MovementSection:CreateSlider({
    Name = "Double jump height",
    Flag = "double_jump_height_value",
    Range = {1, 10},
    Increment = 0.1,
    CurrentValue = states.rage_state.movement.double_jump_height_value,
    Callback = function(v)
        states.rage_state.movement.double_jump_height_value = v
    end
})

--[[
    Visuals
]]

ui_objects.VisualsTab = ui_objects.Window:CreateTab("Visuals", "Visual Hacks.", kConstants.kLucideEye)

ui_objects.VisualsSection = ui_objects.VisualsTab:CreateSection("Visuals", kConstants.kLucideView)

ui_objects.VisualsEnabled = ui_objects.VisualsSection:CreateToggle({
    Name = "Visuals Enabled",
    Flag = "visuals_enabled",
    CurrentValue = states.visuals_state.visuals_enabled,
    Callback = function(v)
        if states.visuals_state.visuals_enabled ~= v then
            SetVisualsEnabled(v)
        end
    end
})

ui_objects.VisualsKeybind = ui_objects.VisualsSection:CreateKeybind({
    Name = "Visuals Keybind",
    Flag = "visuals_keybind",
    Callback = function(v)
        if states.visuals_state.visuals_enabled ~= v then
            SetVisualsEnabled(v)
        end

        if v then
            ui_objects.Window:Notify({
                Title = "Visuals Enabled",
                Content = "Visual enhancements enabled.",
                Duration = 5
            })
        else
            ui_objects.Window:Notify({
                Title = "Visuals Disabled",
                Content = "Visual enhancements disabled.",
                Duration = 5
            })
        end
    end
})

ui_objects.VisualsSection:CreateDivider()

ui_objects.VisualsSection:CreateChecklist({
    Name = "Visual Checks",
    Flag = "visual_checks",
    Options = {
        {
            Name = "Show Teammates",
            Default = states.visuals_state.teammates
        },
        {
            Name = "Show Team Colors",
            Default = states.visuals_state.team_colors
        },
        {
            Name = "Show Target Highlights",
            Default = states.visuals_state.target_highlights
        }
    },
    Callback = function(o)
        states.visuals_state.teammates = o["Show Teammates"]
        states.visuals_state.team_colors = o["Show Team Colors"]
        states.visuals_state.target_highlights = o["Show Target Highlights"]
        UpdateEspOptions()
    end
})

ui_objects.VisualsSection:CreateDivider()

ui_objects.VisualsSection:CreateChecklist({
    Name = "Outlines",
    Flag = "visual_outlines",
    Options = {
        {
            Name = "Box",
            Default = states.visuals_state.outlines.Box
        },
        {
            Name = "Skeletons",
            Default = states.visuals_state.outlines.Skeletons
        },
        {
            Name = "Chams",
            Default = states.visuals_state.outlines.Chams
        },
        {
            Name = "Health",
            Default = states.visuals_state.outlines.Health
        },
        {
            Name = "Name",
            Default = states.visuals_state.outlines.Name
        },
        {
            Name = "Tracers",
            Default = states.visuals_state.outlines.Tracers
        },
        {
            Name = "Weapon",
            Default = states.visuals_state.outlines.Weapon
        },
        {
            Name = "Distance",
            Default = states.visuals_state.outlines.Distance
        }
    },
    Callback = function(o)
        states.visuals_state.outlines.Box = o.Box
        states.visuals_state.outlines.Skeletons = o.Skeletons
        states.visuals_state.outlines.Chams = o.Chams
        states.visuals_state.outlines.Health = o.Health
        states.visuals_state.outlines.Name = o.Name
        states.visuals_state.outlines.Tracers = o.Tracers
        states.visuals_state.outlines.Weapon = o.Weapon
        states.visuals_state.outlines.Distance = o.Distance
        UpdateEspOptions()
    end
})

ui_objects.VisualsSection:CreateToggle({
    Name = "Box Filled",
    Flag = "box_filled",
    CurrentValue = states.visuals_state.box_filled,
    Callback = function(v)
        states.visuals_state.box_filled = v
        UpdateEspOptions()
    end
})

ui_objects.VisualsSection:CreateDropdown({
    Name = "Tracer Origin",
    Flag = "tracer_origin",
    Options = {
        "Bottom",
        "Middle",
        "Top"
    },
    CurrentOption = states.visuals_state.tracer_origin,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.tracer_origin = v
        UpdateEspOptions()
    end
})

ui_objects.VisualsSection:CreateDivider()

ui_objects.VisualsSection:CreateChecklist({
    Name = "Trails",
    Flag = "visual_trails",
    Options = {
        {
            Name = "Bullets",
            Default = states.visuals_state.trails.Bullets
        },
        {
            Name = "Throwables",
            Default = states.visuals_state.trails.Throwables
        },
    },
    Callback = function(o)
        states.visuals_state.trails.Bullets = o.Bullets
        states.visuals_state.trails.Throwables = o.Throwables
    end
})

ui_objects.VisualsSection:CreateDivider()

ui_objects.VisualsSection:CreateSlider({
    Name = "Max Distance",
    Flag = "max_distance",
    Range = {50, 1000},
    Increment = 1,
    CurrentValue = states.visuals_state.max_distance,
    Callback = function(v)
        states.visuals_state.max_distance = v
        UpdateEspOptions()
    end
})

ui_objects.VisualsSection:CreateDropdown({
    Name = "Cham Material",
    Flag = "cham_material",
    Options = kConstants.kMaterialList,
    CurrentOption = states.visuals_state.cham_material,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.cham_material = v
        UpdateEspOptions()
    end
})

ui_objects.VisualsSection:CreateInput({
    Name = "Cham Texture",
    Flag = "cham_texture",
    PlaceholderText = "e.g. 1478668577",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.visuals_state.cham_texture = v
        UpdateEspOptions()
    end
})

ui_objects.ViewmodelSection = ui_objects.VisualsTab:CreateSection("Viewmodel", kConstants.kLucideUser)

ui_objects.ViewmodelSection:CreateDropdown({
    Name = "Disable",
    Flag = "viewmodel_disable",
    Options = kConstants.kViewmodelDisable,
    CurrentOption = states.visuals_state.viewmodel.disable,
    MultipleOptions = true,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.viewmodel.disable = v
    end
})

ui_objects.ViewmodelSection:CreateToggle({
    Name = "Override fps",
    Flag = "viewmodel_override_fps",
    CurrentValue = states.visuals_state.viewmodel.override_fps,
    Callback = function(v)
        states.visuals_state.viewmodel.override_fps = v
    end
})

ui_objects.ViewmodelSection:CreateSlider({
    Name = "Fps",
    Flag = "viewmodel_fps_multi",
    Range = {1, 60},
    Increment = 1,
    CurrentValue = states.visuals_state.viewmodel.fps_multi,
    Callback = function(v)
        states.visuals_state.viewmodel.fps_multi = v
    end
})

ui_objects.ViewmodelSection:CreateToggle({
    Name = "Chams",
    Flag = "viewmodel_chams",
    CurrentValue = states.visuals_state.viewmodel.chams,
    Callback = function(v)
        states.visuals_state.viewmodel.chams = v
    end
})

ui_objects.ViewmodelSection:CreateSlider({
    Name = "Cham Transparency",
    Flag = "viewmodel_cham_transparency",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = 0,
    Callback = function(v)
        states.visuals_state.viewmodel.cham_transparency = v
        UpdateViewmodelChams()
    end
})

ui_objects.ViewmodelSection:CreateDropdown({
    Name = "Cham Material",
    Flag = "viewmodel_cham_material",
    Options = kConstants.kMaterialList,
    CurrentOption = "ForceField",
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.viewmodel.cham_material = v
        UpdateViewmodelChams()
    end
})

ui_objects.ViewmodelSection:CreateInput({
    Name = "Cham Texture",
    Flag = "viewmodel_cham_texture",
    PlaceholderText = "e.g. 1478668577",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.visuals_state.viewmodel.cham_texture = v
        UpdateViewmodelChams()
    end
})

ui_objects.ViewmodelSection:CreateToggle({
    Name = "Offset",
    Flag = "viewmodel_offset",
    CurrentValue = states.visuals_state.viewmodel.offset,
    Callback = function(v)
        states.visuals_state.viewmodel.offset = v
    end
})

ui_objects.ViewmodelSection:CreateSlider({
    Name = "X Offset",
    Flag = "viewmodel_x_offset",
    Range = {-3, 3},
    Increment = 0.01,
    CurrentValue = states.visuals_state.viewmodel.x_offset,
    Callback = function(v)
        states.visuals_state.viewmodel.x_offset = v
    end
})

ui_objects.ViewmodelSection:CreateSlider({
    Name = "Y Offset",
    Flag = "viewmodel_y_offset",
    Range = {-3, 3},
    Increment = 0.01,
    CurrentValue = states.visuals_state.viewmodel.y_offset,
    Callback = function(v)
        states.visuals_state.viewmodel.y_offset = v
    end
})

ui_objects.ViewmodelSection:CreateSlider({
    Name = "Z Offset",
    Flag = "viewmodel_z_offset",
    Range = {-3, 3},
    Increment = 0.01,
    CurrentValue = states.visuals_state.viewmodel.z_offset,
    Callback = function(v)
        states.visuals_state.viewmodel.z_offset = v
    end
})

ui_objects.ViewmodelSection:CreateDivider()

ui_objects.ViewmodelSection:CreateToggle({
    Name = "Appearance",
    Flag = "viewmodel_appearance",
    CurrentValue = states.visuals_state.viewmodel.appearance,
    Callback = function(v)
        states.visuals_state.viewmodel.appearance = v
    end
})

ui_objects.ViewmodelSection:CreateColorPicker({
    Name = "Color",
    Flag = "viewmodel_color",
    Color = states.visuals_state.viewmodel.color,
    Callback = function(c)
        states.visuals_state.viewmodel.color = c
    end
})

ui_objects.ViewmodelSection:CreateDropdown({
    Name = "Material",
    Flag = "viewmodel_material",
    Options = kConstants.kMaterialList,
    CurrentOption = states.visuals_state.viewmodel.material,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.viewmodel.material = v
    end
})

ui_objects.ViewmodelSection:CreateSlider({
    Name = "Transparency",
    Flag = "viewmodel_transparency",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.viewmodel.transparency,
    Callback = function(v)
        states.visuals_state.viewmodel.transparency = v
    end
})

ui_objects.ViewmodelSection:CreateChecklist({
    Name = "Options",
    Flag = "viewmodel_options",
    Options = {
        {
            Name = "Wireframe",
            Default = states.visuals_state.viewmodel.wireframe
        },
        {
            Name = "No Textures",
            Default = states.visuals_state.viewmodel.no_textures
        },
        {
            Name = "No Clothes",
            Default = states.visuals_state.viewmodel.no_clothes
        },
    },
    Callback = function(o)
        states.visuals_state.viewmodel.wireframe = o["Wireframe"]
        states.visuals_state.viewmodel.no_textures = o["No Textures"]
        states.visuals_state.viewmodel.no_clothes = o["No Clothes"]
    end
})

ui_objects.AnimationsSection = ui_objects.VisualsTab:CreateSection("Animations", kConstants.kLucideUser)

ui_objects.AnimationsSection:CreateDropdown({
    Name = "Char Anims",
    Flag = "char_anims",
    Options = kConstants.kCharacterAnims,
    CurrentOption = states.visuals_state.animations.char_anims,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.animations.char_anims = v
    end
})

ui_objects.SkyboxSection = ui_objects.VisualsTab:CreateSection("Skybox", kConstants.kLucideCloud)

ui_objects.SkyboxSection:CreateDropdown({
    Name = "Skybox",
    Flag = "skybox_value",
    Options = kConstants.kSkyboxList,
    CurrentOption = states.visuals_state.skybox.skybox_value,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.skybox.skybox_value = v
        UpdateSkybox()
    end
})

ui_objects.SkyboxSection:CreateLabel({
    Title = "Asset IDs or URLs are accepted."
})

ui_objects.SkyboxSection:CreateInput({
    Name = "Back",
    Flag = "skybox_back",
    PlaceholderText = "1234567890",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.visuals_state.skybox.skybox_back = v
        UpdateSkybox()
    end
})

ui_objects.SkyboxSection:CreateInput({
    Name = "Front",
    Flag = "skybox_front",
    PlaceholderText = "1234567890",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.visuals_state.skybox.skybox_front = v
        UpdateSkybox()
    end
})

ui_objects.SkyboxSection:CreateInput({
    Name = "Left",
    Flag = "skybox_left",
    PlaceholderText = "1234567890",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.visuals_state.skybox.skybox_left = v
        UpdateSkybox()
    end
})

ui_objects.SkyboxSection:CreateInput({
    Name = "Right",
    Flag = "skybox_right",
    PlaceholderText = "1234567890",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.visuals_state.skybox.skybox_right = v
        UpdateSkybox()
    end
})

ui_objects.SkyboxSection:CreateInput({
    Name = "Up",
    Flag = "skybox_up",
    PlaceholderText = "1234567890",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.visuals_state.skybox.skybox_up = v
        UpdateSkybox()
    end
})

ui_objects.SkyboxSection:CreateDivider()

ui_objects.SkyboxSection:CreateSlider({
    Name = "StarCount",
    Flag = "star_count",
    Range = {0, 5000},
    Increment = 1,
    CurrentValue = states.visuals_state.skybox.star_count,
    Callback = function(v)
        states.visuals_state.skybox.star_count = v
    end
})

ui_objects.SkyboxSection:CreateSlider({
    Name = "Sun Size",
    Flag = "sun_size",
    Range = {0, 60},
    Increment = 0.01,
    CurrentValue = states.visuals_state.skybox.sun_angular_size,
    Callback = function(v)
        states.visuals_state.skybox.sun_angular_size = v
    end
})

ui_objects.SkyboxSection:CreateSlider({
    Name = "Moon Size",
    Flag = "moon_size",
    Range = {0, 60},
    Increment = 0.01,
    CurrentValue = states.visuals_state.skybox.moon_angular_size,
    Callback = function(v)
        states.visuals_state.skybox.moon_angular_size = v
    end
})

ui_objects.SkyboxSection:CreateSlider({
    Name = "ClockTime",
    Flag = "clocktime",
    Range = {0, 24},
    Increment = 0.01,
    CurrentValue = states.visuals_state.skybox.clocktime,
    Callback = function(v)
        states.visuals_state.skybox.clocktime = v
    end
})

ui_objects.SkyboxSection:CreateDivider()

ui_objects.SkyboxSection:CreateToggle({
    Name = "Auto Rotate",
    Flag = "auto_rotate",
    CurrentValue = states.visuals_state.skybox.auto_rotate,
    Callback = function(v)
        states.visuals_state.skybox.auto_rotate = v
        SetSkyboxAutoRotate()
    end
})

ui_objects.SkyboxSection:CreateSlider({
    Name = "Rotation Speed",
    Flag = "rotation_speed",
    Range = {0, 50},
    Increment = 0.01,
    CurrentValue = states.visuals_state.skybox.auto_rotate_speed,
    Callback = function(v)
        states.visuals_state.skybox.auto_rotate_speed = v
    end
})

ui_objects.CrosshairSection = ui_objects.VisualsTab:CreateSection("Crosshair", kConstants.kLucideCrosshair)

ui_objects.CrosshairSection:CreateToggle({
    Name = "Enabled",
    Flag = "crosshair_enabled",
    CurrentValue = states.visuals_state.crosshair.enabled,
    Callback = function(v)
        states.visuals_state.crosshair.enabled = v
    end
})

ui_objects.CrosshairSection:CreateColorPicker({
    Name = "Fill Color",
    Flag = "crosshair_fill_color",
    Color = states.visuals_state.crosshair.fill_color,
    Callback = function(c)
        states.visuals_state.crosshair.fill_color = c
    end
})

ui_objects.CrosshairSection:CreateColorPicker({
    Name = "OutlineColor",
    Flag = "crosshair_outline_color",
    Color = states.visuals_state.crosshair.outline_color,
    Callback = function(c)
        states.visuals_state.crosshair.outline_color = c
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Rotation",
    Flag = "crosshair_rotation",
    Range = {0, 360},
    Increment = 1,
    CurrentValue = states.visuals_state.crosshair.rotation,
    Callback = function(v)
        states.visuals_state.crosshair.rotation = v
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Rotation Speed",
    Flag = "crosshair_rotation_speed",
    Range = {0, 5},
    Increment = 0.1,
    CurrentValue = states.visuals_state.crosshair.rotation_speed,
    Callback = function(v)
        states.visuals_state.crosshair.rotation_speed = v
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Bounce",
    Flag = "crosshair_bounce",
    Range = {0, 300},
    Increment = 1,
    CurrentValue = states.visuals_state.crosshair.bounce,
    Callback = function(v)
        states.visuals_state.crosshair.bounce = v
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Bounce Speed",
    Flag = "crosshair_bounce_speed",
    Range = {0, 5},
    Increment = 0.1,
    CurrentValue = states.visuals_state.crosshair.bounce_speed,
    Callback = function(v)
        states.visuals_state.crosshair.bounce_speed = v
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Offset",
    Flag = "crosshair_offset",
    Range = {0, 100},
    Increment = 1,
    CurrentValue = states.visuals_state.crosshair.offset,
    Callback = function(v)
        states.visuals_state.crosshair.offset = v
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Length",
    Flag = "crosshair_length",
    Range = {0, 500},
    Increment = 1,
    CurrentValue = states.visuals_state.crosshair.length,
    Callback = function(v)
        states.visuals_state.crosshair.length = v
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Thickness",
    Flag = "crosshair_thickness",
    Range = {0, 10},
    Increment = 1,
    CurrentValue = states.visuals_state.crosshair.thickness,
    Callback = function(v)
        states.visuals_state.crosshair.thickness = v
    end
})

ui_objects.CrosshairSection:CreateSlider({
    Name = "Lerp",
    Flag = "crosshair_lerp",
    Range = {0.1, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.crosshair.lerp,
    Callback = function(v)
        states.visuals_state.crosshair.lerp = v
    end
})

ui_objects.CrosshairSection:CreateDropdown({
    Name = "Position",
    Flag = "crosshair_position",
    Options = kConstants.kLerpPos,
    CurrentOption = states.visuals_state.crosshair.position,
    MultipleOptions = true,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.crosshair.position = v
    end
})

ui_objects.ColorsSection = ui_objects.VisualsTab:CreateSection("Colors", kConstants.kLucideRainbow)

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Enemy Box Fill",
    Flag = "enemy_box_fill_color",
    Color = Color3.fromRGB(106, 13, 173),
    Callback = function(c)
        states.visuals_state.colors.enemy_box_fill_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Enemy Box Outline",
    Flag = "enemy_box_outline_color",
    Color = Color3.fromRGB(181, 126, 220),
    Callback = function(c)
        states.visuals_state.colors.enemy_box_outline_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Enemy Tracer",
    Flag = "enemy_tracer_color",
    Color = Color3.fromRGB(131, 38, 198),
    Callback = function(c)
        states.visuals_state.colors.enemy_tracer_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Enemy Chams Fill",
    Flag = "enemy_chams_fill_color",
    Color = Color3.fromRGB(106, 13, 173),
    Callback = function(c)
        states.visuals_state.colors.enemy_chams_fill_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Friendly Box Fill",
    Flag = "friendly_box_fill_color",
    Color = Color3.fromRGB(50, 138, 220),
    Callback = function(c)
        states.visuals_state.colors.friendly_box_fill_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Friendly Box Outline",
    Flag = "friendly_box_outline_color",
    Color = Color3.fromRGB(120, 180, 255),
    Callback = function(c)
        states.visuals_state.colors.friendly_box_outline_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Friendly Tracer",
    Flag = "friendly_tracer_color",
    Color = Color3.fromRGB(50, 138, 220),
    Callback = function(c)
        states.visuals_state.colors.friendly_tracer_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Friendly Chams Fill",
    Flag = "friendly_chams_fill_color",
    Color = Color3.fromRGB(50, 138, 220),
    Callback = function(c)
        states.visuals_state.colors.friendly_chams_fill_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateDivider()

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Trail Color",
    Flag = "trail_color",
    Color = Color3.fromRGB(181, 126, 220),
    Callback = function(c)
        states.visuals_state.colors.trail_color = c
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Viewmodel Chams Color",
    Flag = "viewmodel_chams_color",
    Color = Color3.fromRGB(181, 126, 220),
    Callback = function(c)
        states.visuals_state.colors.viewmodel_chams_color = c
        UpdateViewmodelChams()
    end
})

ui_objects.ColorsSection:CreateColorPicker({
    Name = "Target Highlight",
    Flag = "target_highlight_color",
    Color = Color3.fromRGB(255, 255, 255),
    Callback = function(c)
        states.visuals_state.colors.target_highlight_color = c
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateDivider()

ui_objects.ColorsSection:CreateSlider({
    Name = "Chams Transparency",
    Flag = "chams_transparency",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.colors.chams_fill_transparency,
    Callback = function(v)
        states.visuals_state.colors.chams_fill_transparency = v
        UpdateEspOptions()
    end
})

ui_objects.ColorsSection:CreateSlider({
    Name = "Tracer Transparency",
    Flag = "tracer_transparency",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.colors.tracer_transparency,
    Callback = function(v)
        states.visuals_state.colors.tracer_transparency = v
        UpdateEspOptions()
    end
})

ui_objects.SunRaysSection = ui_objects.VisualsTab:CreateSection("SunRays", kConstants.kLucideCloud)

ui_objects.SunRaysSection:CreateToggle({
    Name = "SunRays Enabled",
    Flag = "sunrays_enabled",
    CurrentValue = states.visuals_state.sunrays.sunrays_enabled,
    Callback = function(v)
        states.visuals_state.sunrays.sunrays_enabled = v
        UpdateSunRaysOptions()
    end
})

ui_objects.SunRaysSection:CreateSlider({
    Name = "Intensity",
    Flag = "sunrays_intensity",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.sunrays.sunrays_intensity,
    Callback = function(v)
        states.visuals_state.sunrays.sunrays_intensity = v
        UpdateSunRaysOptions()
    end
})

ui_objects.SunRaysSection:CreateSlider({
    Name = "Spread",
    Flag = "sunrays_spread",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.sunrays.sunrays_spread,
    Callback = function(v)
        states.visuals_state.sunrays.sunrays_spread = v
        UpdateSunRaysOptions()
    end
})

ui_objects.CameraSection = ui_objects.VisualsTab:CreateSection("Camera", kConstants.kLucideEye)

ui_objects.StateChangerEnabled = ui_objects.CameraSection:CreateToggle({
    Name = "State Changer Enabled",
    Flag = "state_changer_enabled",
    CurrentValue = states.visuals_state.camera.state_changer,
    Callback = function(v)
        if states.visuals_state.camera.state_changer ~= v then
            SetStateChangerEnabled(v)
        end
    end
})

ui_objects.StateChangerKeybind = ui_objects.CameraSection:CreateKeybind({
    Name = "State Changer Keybind",
    Flag = "state_changer_keybind",
    Callback = function(v)
        if states.visuals_state.camera.state_changer ~= v then
            SetStateChangerEnabled(v)
        end
    end
})

ui_objects.CameraSection:CreateDropdown({
    Name = "Camera State",
    Flag = "camera_state",
    Options = kConstants.kCameraStates,
    CurrentOption = states.visuals_state.camera.camera_state,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        local old_state = modules.CameraController.CameraState._public_state
        states.visuals_state.camera.camera_state = v
        modules.CameraController.CameraState.StateChanged:Fire(states.visuals_state.camera.camera_state, old_state)
    end
})

ui_objects.CameraSection:CreateDivider()

ui_objects.CameraSection:CreateToggle({
    Name = "Anti Flashbang",
    Flag = "anti_flashbang",
    CurrentValue = states.visuals_state.camera.anti_flashbang,
    Callback = function(v)
        states.visuals_state.camera.anti_flashbang = v
    end
})

ui_objects.CameraSection:CreateToggle({
    Name = "Anti Smoke",
    Flag = "anti_smoke",
    CurrentValue = states.visuals_state.camera.anti_smoke,
    Callback = function(v)
        states.visuals_state.camera.anti_smoke = v
    end
})

ui_objects.CameraSection:CreateDivider()

ui_objects.CameraSection:CreateSlider({
    Name = "FOV",
    Flag = "camera_fov",
    Range = {10, 120},
    Increment = 1,
    CurrentValue = states.visuals_state.camera.camera_fov,
    Callback = function(v)
        states.visuals_state.camera.camera_fov = v
    end
})

ui_objects.CameraSection:CreateSlider({
    Name = "Resolution",
    Flag = "camera_resolution",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.camera.camera_resolution,
    Callback = function(v)
        states.visuals_state.camera.camera_resolution = v
    end
})

ui_objects.LightingSection = ui_objects.VisualsTab:CreateSection("Lighting", kConstants.kLucideCloud)

ui_objects.LightingSection:CreateColorPicker({
    Name = "Ambient",
    Flag = "ambient_color",
    Color = states.visuals_state.lighting.ambient_color,
    Callback = function(c)
        states.visuals_state.lighting.ambient_color = c
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateColorPicker({
    Name = "OutdoorAmbient",
    Flag = "outdoor_ambient_color",
    Color = states.visuals_state.lighting.outdoor_ambient_color,
    Callback = function(c)
        states.visuals_state.lighting.outdoor_ambient_color = c
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateColorPicker({
    Name = "Shift Top",
    Flag = "shift_top",
    Color = states.visuals_state.lighting.shift_top,
    Callback = function(c)
        states.visuals_state.lighting.shift_top = c
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateColorPicker({
    Name = "Shift Bottom",
    Flag = "shift_bottom",
    Color = states.visuals_state.lighting.shift_bottom,
    Callback = function(c)
        states.visuals_state.lighting.shift_bottom = c
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateSlider({
    Name = "Exposure",
    Flag = "lighting_exposure",
    Range = {-3, 3},
    Increment = 0.01,
    CurrentValue = states.visuals_state.lighting.exposure,
    Callback = function(v)
        states.visuals_state.lighting.exposure = v
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateSlider({
    Name = "Brightness",
    Flag = "lighting_brightness",
    Range = {0, 10},
    Increment = 0.01,
    CurrentValue = states.visuals_state.lighting.brightness,
    Callback = function(v)
        states.visuals_state.lighting.brightness = v
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateSlider({
    Name = "Shadow Softness",
    Flag = "shadow_softness",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.lighting.shadow_softness,
    Callback = function(v)
        states.visuals_state.lighting.shadow_softness = v
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateSlider({
    Name = "Diffuse Scale",
    Flag = "diffuse_scale",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.lighting.diffuse_scale,
    Callback = function(v)
        states.visuals_state.lighting.diffuse_scale = v
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateSlider({
    Name = "Specular Scale",
    Flag = "specular_scale",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.lighting.specular_scale,
    Callback = function(v)
        states.visuals_state.lighting.specular_scale = v
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateToggle({
    Name = "GlobalShadows",
    Flag = "globalshadows",
    CurrentValue = states.visuals_state.lighting.global_shadows,
    Callback = function(v)
        states.visuals_state.lighting.global_shadows = v
        UpdateLightingOptions()
    end
})

ui_objects.LightingSection:CreateDropdown({
    Name = "LightingStyle",
    Flag = "lightingstyle",
    Options = kConstants.kLightingStyles,
    CurrentOption = states.visuals_state.lighting.lighting_style,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.lighting.lighting_style = v
        UpdateLightingOptions()
    end
})

ui_objects.AtmosphereSection = ui_objects.VisualsTab:CreateSection("Atmosphere", kConstants.kLucideCloud)

ui_objects.AtmosphereSection:CreateSlider({
    Name = "Density",
    Flag = "atmosphere_density",
    Range = {0, 1},
    Increment = 0.001,
    CurrentValue = states.visuals_state.atmosphere.density,
    Callback = function(v)
        states.visuals_state.atmosphere.density = v
        UpdateAtmosphereOptions()
    end
})

ui_objects.AtmosphereSection:CreateSlider({
    Name = "Offset",
    Flag = "atmosphere_offset",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.atmosphere.offset,
    Callback = function(v)
        states.visuals_state.atmosphere.offset = v
        UpdateAtmosphereOptions()
    end
})

ui_objects.AtmosphereSection:CreateColorPicker({
    Name = "Color",
    Flag = "atmosphere_color",
    Color = states.visuals_state.atmosphere.color,
    Callback = function(c)
        states.visuals_state.atmosphere.color = c
        UpdateAtmosphereOptions()
    end
})

ui_objects.AtmosphereSection:CreateColorPicker({
    Name = "Decay",
    Flag = "atmosphere_decay",
    Color = states.visuals_state.atmosphere.decay,
    Callback = function(c)
        states.visuals_state.atmosphere.decay = c
        UpdateAtmosphereOptions()
    end
})

ui_objects.AtmosphereSection:CreateSlider({
    Name = "Glare",
    Flag = "atmosphere_glare",
    Range = {0, 10},
    Increment = 0.01,
    CurrentValue = states.visuals_state.atmosphere.glare,
    Callback = function(v)
        states.visuals_state.atmosphere.glare = v
        UpdateAtmosphereOptions()
    end
})

ui_objects.AtmosphereSection:CreateSlider({
    Name = "Haze",
    Flag = "atmosphere_haze",
    Range = {0, 10},
    Increment = 0.01,
    CurrentValue = states.visuals_state.atmosphere.haze,
    Callback = function(v)
        states.visuals_state.atmosphere.haze = v
        UpdateAtmosphereOptions()
    end
})

ui_objects.ColorCorrectionSection = ui_objects.VisualsTab:CreateSection("ColorCorrection", kConstants.kLucideCloud)

ui_objects.ColorCorrectionSection:CreateToggle({
    Name = "Enabled",
    Flag = "cc_enabled",
    CurrentValue = states.visuals_state.color_correction.enabled,
    Callback = function(v)
        states.visuals_state.color_correction.enabled = v
        UpdateColorCorrectionOptions()
    end
})

ui_objects.ColorCorrectionSection:CreateSlider({
    Name = "Brightness",
    Flag = "cc_brightness",
    Range = {-1, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.color_correction.brightness,
    Callback = function(v)
        states.visuals_state.color_correction.brightness = v
        UpdateColorCorrectionOptions()
    end
})

ui_objects.ColorCorrectionSection:CreateSlider({
    Name = "Contrast",
    Flag = "cc_contrast",
    Range = {-1, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.color_correction.contrast,
    Callback = function(v)
        states.visuals_state.color_correction.contrast = v
        UpdateColorCorrectionOptions()
    end
})

ui_objects.ColorCorrectionSection:CreateSlider({
    Name = "Saturation",
    Flag = "cc_saturation",
    Range = {-1, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.color_correction.saturation,
    Callback = function(v)
        states.visuals_state.color_correction.saturation = v
        UpdateColorCorrectionOptions()
    end
})

ui_objects.ColorCorrectionSection:CreateColorPicker({
    Name = "TintColor",
    Flag = "cc_tintcolor",
    Color = states.visuals_state.color_correction.tint_color,
    Callback = function(c)
        states.visuals_state.color_correction.tint_color = c
        UpdateColorCorrectionOptions()
    end
})

ui_objects.WeatherSection = ui_objects.VisualsTab:CreateSection("Weather", kConstants.kLucideCloud)

ui_objects.WeatherSection:CreateToggle({
    Name = "Enabled",
    Flag = "weather_enabled",
    CurrentValue = states.visuals_state.weather.enabled,
    Callback = function(v)
        states.visuals_state.weather.enabled = v
        UpdateWeatherOptions()
    end
})

ui_objects.WeatherSection:CreateDropdown({
    Name = "Type",
    Flag = "weather_type",
    Options = kConstants.kWeatherTypes,
    CurrentOption = states.visuals_state.weather.type,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.weather.type = v
        UpdateWeatherOptions()
    end
})

ui_objects.WeatherSection:CreateSlider({
    Name = "Rate",
    Flag = "weather_rate",
    Range = {0, 10},
    Increment = 0.01,
    CurrentValue = states.visuals_state.weather.rate,
    Callback = function(v)
        states.visuals_state.weather.rate = v
        UpdateWeatherOptions()
    end
})

ui_objects.WeatherSection:CreateSlider({
    Name = "TimeScale",
    Flag = "weather_timescale",
    Range = {0, 1},
    Increment = 0.01,
    CurrentValue = states.visuals_state.weather.timescale,
    Callback = function(v)
        states.visuals_state.weather.timescale = v
        UpdateWeatherOptions()
    end
})

ui_objects.AmbienceSection = ui_objects.VisualsTab:CreateSection("Ambience", kConstants.kLucideVolume2)

ui_objects.AmbienceSection:CreateToggle({
    Name = "Enabled",
    Flag = "ambience_enabled",
    CurrentValue = states.visuals_state.ambience.enabled,
    Callback = function(v)
        states.visuals_state.ambience.enabled = v
        UpdateAmbienceOptions()
    end
})

ui_objects.AmbienceSection:CreateDropdown({
    Name = "Type",
    Flag = "ambience_type",
    Options = kConstants.kAmbienceTypes,
    CurrentOption = states.visuals_state.ambience.type,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.visuals_state.ambience.type = v
        UpdateAmbienceOptions()
    end
})

ui_objects.AmbienceSection:CreateSlider({
    Name = "Volume",
    Flag = "ambience_volume",
    Range = {0, 10},
    Increment = 0.1,
    CurrentValue = states.visuals_state.ambience.volume,
    Callback = function(v)
        states.visuals_state.ambience.volume = v
        UpdateAmbienceOptions()
    end
})

--[[
    Skin Changer
]]

ui_objects.SkinChangerTab = ui_objects.Window:CreateTab("Skin Changer", "Settings for Skin Changer.", kConstants.kLucideSparkles)

ui_objects.UnlockerSection = ui_objects.SkinChangerTab:CreateSection("Unlocker", kConstants.kLucideUnlock)

ui_objects.UnlockerSection:CreateDropdown({
    Name = "Type",
    Flag = "unlocker_type",
    Options = kConstants.kCosmeticTypes,
    CurrentOption = states.skinchanger_state.general_unlocker.unlock_type,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.general_unlocker.unlock_type = v
    end
})

ui_objects.UnlockerSection:CreateDropdown({
    Name = "Rarity",
    Flag = "unlocker_rarity",
    Options = kConstants.kCosmeticRarities,
    CurrentOption = states.skinchanger_state.general_unlocker.unlock_rarity,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.general_unlocker.unlock_rarity = v
    end
})

ui_objects.UnlockerSection:CreateButton({
    Name = "Unlock Selected Rarity",
    Callback = function()
        UnlockSelectedRarity()
        ui_objects.Window:Notify({
            Title = "Unlocked Rarity!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.UnlockerSection:CreateButton({
    Name = "Lock Selected Rarity",
    Callback = function()
        LockSelectedRarity()
        ui_objects.Window:Notify({
            Title = "Locked Rarity!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.UnlockerSection:CreateButton({
    Name = "Unlock All of Type",
    Callback = function()
        UnlockAllOfType()
        ui_objects.Window:Notify({
            Title = "Unlocked Type!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.UnlockerSection:CreateButton({
    Name = "Lock All of Type",
    Callback = function()
        LockAllOfType()
        ui_objects.Window:Notify({
            Title = "Locked Type!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.SpecificSection = ui_objects.SkinChangerTab:CreateSection("Specific", kConstants.kLucideSearch)

ui_objects.SpecificSection:CreateDropdown({
    Name = "Type",
    Flag = "specific_type",
    Options = kConstants.kCosmeticTypes,
    CurrentOption = states.skinchanger_state.specific_unlocker.unlock_type,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.specific_unlocker.unlock_type = v
    end
})

ui_objects.SpecificSection:CreateInput({
    Name = "Cosmetic",
    Flag = "cosmetic_name",
    PlaceholderText = "e.g. 10B Visits",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.specific_unlocker.cosmetic_name = v
    end
})

ui_objects.SpecificSection:CreateInput({
    Name = "Weapon",
    Flag = "weapon_name",
    PlaceholderText = "e.g. Assault Rifle",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.specific_unlocker.weapon_name = v
    end
})

ui_objects.SpecificSection:CreateButton({
    Name = "Unlock Specific",
    Callback = function()
        UnlockSpecific()
        ui_objects.Window:Notify({
            Title = "Unlocked Cosmetic!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.SpecificSection:CreateButton({
    Name = "Lock Specific",
    Callback = function()
        LockSpecific()
        ui_objects.Window:Notify({
            Title = "Locked Cosmetic!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.SpecificSection:CreateButton({
    Name = "Unlock Specific Weapon",
    Callback = function()
        UnlockSpecificWeapon()
        ui_objects.Window:Notify({
            Title = "Unlocked Weapon!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.SpecificSection:CreateButton({
    Name = "Lock Specific Weapon",
    Callback = function()
        LockSpecificWeapon()
        ui_objects.Window:Notify({
            Title = "Locked Weapon!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.EquipSection = ui_objects.SkinChangerTab:CreateSection("Equip", kConstants.kLucideBox)

ui_objects.EquipSection:CreateDropdown({
    Name = "Type",
    Flag = "equip_type",
    Options = kConstants.kCosmeticTypes,
    CurrentOption = states.skinchanger_state.equip_unlocker.unlock_type,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.equip_unlocker.unlock_type = v
    end
})

ui_objects.EquipSection:CreateInput({
    Name = "Cosmetic",
    Flag = "equip_cosmetic",
    PlaceholderText = "e.g. 10B Visits",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.equip_unlocker.cosmetic_name = v
    end
})

ui_objects.EquipSection:CreateInput({
    Name = "Weapon",
    Flag = "equip_weapon",
    PlaceholderText = "e.g. Assault Rifle",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.equip_unlocker.weapon_name = v
    end
})

ui_objects.EquipSection:CreateToggle({
    Name = "Inverted",
    Flag = "equip_inverted",
    CurrentValue = states.skinchanger_state.equip_unlocker.inverted,
    Callback = function(v)
        states.skinchanger_state.equip_unlocker.inverted = v
    end
})

ui_objects.EquipSection:CreateButton({
    Name = "Apply",
    Callback = function()
        EquipApply()
        ui_objects.Window:Notify({
            Title = "Applied!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.EquipSection:CreateButton({
    Name = "Apply to all weapons",
    Callback = function()
        EquipApplyAll()
        ui_objects.Window:Notify({
            Title = "Applied!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.BulkSection = ui_objects.SkinChangerTab:CreateSection("Bulk", kConstants.kLucideBox)

ui_objects.BulkSection:CreateButton({
    Name = "Unlock All Weapons",
    Callback = function()
        UnlockAllWeapons()
        ui_objects.Window:Notify({
            Title = "Unlocked All Weapons!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.BulkSection:CreateButton({
    Name = "Lock All Weapons",
    Callback = function()
        LockAllWeapons()
        ui_objects.Window:Notify({
            Title = "Locked All Weapons!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.BulkSection:CreateButton({
    Name = "Unlock All for Weapon",
    Callback = function()
        UnlockAllForWeapon()
        ui_objects.Window:Notify({
            Title = "Unlocked All for Weapon!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.BulkSection:CreateButton({
    Name = "Lock All for Weapon",
    Callback = function()
        LockAllForWeapon()
        ui_objects.Window:Notify({
            Title = "Locked All for Weapon!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.BulkSection:CreateButton({
    Name = "Unlock All",
    Callback = function()
        UnlockAll()
        ui_objects.Window:Notify({
            Title = "Unlocked All Cosmetics!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.BulkSection:CreateButton({
    Name = "Lock All",
    Callback = function()
        LockAll()
        ui_objects.Window:Notify({
            Title = "Locked All Cosmetics!",
            Content = "Please check weapons.",
            Duration = 5
        })
    end
})

ui_objects.ShootSoundSection = ui_objects.SkinChangerTab:CreateSection("Shoot Sound", kConstants.kLucideVolume2)

ui_objects.ShootSoundSection:CreateDropdown({
    Name = "Sound",
    Flag = "shoot_sound_value",
    Options = kConstants.kSoundMods,
    CurrentOption = states.skinchanger_state.shoot_sound.sound_value,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.shoot_sound.sound_value = v
    end
})

ui_objects.ShootSoundSection:CreateInput({
    Name = "Asset ID",
    Flag = "shoot_sound_asset_id",
    PlaceholderText = "1234567890",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.skinchanger_state.shoot_sound.sound_asset_id = v
    end
})

ui_objects.ShootSoundSection:CreateInput({
    Name = "URL",
    Flag = "shoot_sound_url",
    PlaceholderText = "https://example.com/example.mp3",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.shoot_sound.sound_url = v
    end
})

ui_objects.ShootSoundSection:CreateSlider({
    Name = "Volume",
    Flag = "shoot_sound_volume",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.shoot_sound.sound_volume,
    Callback = function(v)
        states.skinchanger_state.shoot_sound.sound_volume = v
    end
})

ui_objects.ShootSoundSection:CreateSlider({
    Name = "Pitch",
    Flag = "shoot_sound_pitch",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.shoot_sound.sound_pitch,
    Callback = function(v)
        states.skinchanger_state.shoot_sound.sound_pitch = v
    end
})

ui_objects.ShootSoundSection:CreateButton({
    Name = "Preview",
    Callback = function()
        ShootSoundPreview()
        ui_objects.Window:Notify({
            Title = "Shoot Sound",
            Content = "Preview Playing!",
            Duration = 5
        })
    end
})

ui_objects.HitSoundSection = ui_objects.SkinChangerTab:CreateSection("Hit Sound", kConstants.kLucideVolume2)

ui_objects.HitSoundSection:CreateDropdown({
    Name = "Sound",
    Flag = "hit_sound_value",
    Options = kConstants.kSoundMods,
    CurrentOption = states.skinchanger_state.hit_sound.sound_value,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.hit_sound.sound_value = v
    end
})

ui_objects.HitSoundSection:CreateInput({
    Name = "Asset ID",
    Flag = "hit_sound_asset_id",
    PlaceholderText = "1234567890",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.skinchanger_state.hit_sound.sound_asset_id = v
    end
})

ui_objects.HitSoundSection:CreateInput({
    Name = "URL",
    Flag = "hit_sound_url",
    PlaceholderText = "https://example.com/example.mp3",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.hit_sound.sound_url = v
    end
})

ui_objects.HitSoundSection:CreateSlider({
    Name = "Volume",
    Flag = "hit_sound_volume",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.hit_sound.sound_volume,
    Callback = function(v)
        states.skinchanger_state.hit_sound.sound_volume = v
    end
})

ui_objects.HitSoundSection:CreateSlider({
    Name = "Pitch",
    Flag = "hit_sound_pitch",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.hit_sound.sound_pitch,
    Callback = function(v)
        states.skinchanger_state.hit_sound.sound_pitch = v
    end
})

ui_objects.HitSoundSection:CreateDropdown({
    Name = "Crit Sound",
    Flag = "crit_sound_value",
    Options = kConstants.kSoundMods,
    CurrentOption = states.skinchanger_state.crit_sound.sound_value,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.crit_sound.sound_value = v
    end
})

ui_objects.HitSoundSection:CreateInput({
    Name = "Crit Asset ID",
    Flag = "crit_sound_asset_id",
    PlaceholderText = "1234567890",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.skinchanger_state.crit_sound.sound_asset_id = v
    end
})

ui_objects.HitSoundSection:CreateInput({
    Name = "Crit URL",
    Flag = "crit_sound_url",
    PlaceholderText = "https://example.com/example.mp3",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.crit_sound.sound_url = v
    end
})

ui_objects.HitSoundSection:CreateSlider({
    Name = "Crit Pitch",
    Flag = "crit_sound_pitch",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.crit_sound.sound_pitch,
    Callback = function(v)
        states.skinchanger_state.crit_sound.sound_pitch = v
    end
})

ui_objects.HitSoundSection:CreateButton({
    Name = "Preview Hit",
    Callback = function()
        HitSoundPreview()
        ui_objects.Window:Notify({
            Title = "Hit Sound",
            Content = "Preview Playing!",
            Duration = 5
        })
    end
})

ui_objects.HitSoundSection:CreateButton({
    Name = "Preview Crit",
    Callback = function()
        CritSoundPreview()
        ui_objects.Window:Notify({
            Title = "Crit Sound",
            Content = "Preview Playing!",
            Duration = 5
        })
    end
})

ui_objects.KillSoundSection = ui_objects.SkinChangerTab:CreateSection("Kill Sound", kConstants.kLucideVolume2)

ui_objects.KillSoundSection:CreateDropdown({
    Name = "Sound",
    Flag = "kill_sound_value",
    Options = kConstants.kSoundMods,
    CurrentOption = states.skinchanger_state.kill_sound.sound_value,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.kill_sound.sound_value = v
    end
})

ui_objects.KillSoundSection:CreateInput({
    Name = "Asset ID",
    Flag = "kill_sound_asset_id",
    PlaceholderText = "1234567890",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.skinchanger_state.kill_sound.sound_asset_id = v
    end
})

ui_objects.KillSoundSection:CreateInput({
    Name = "URL",
    Flag = "kill_sound_url",
    PlaceholderText = "https://example.com/example.mp3",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.kill_sound.sound_url = v
    end
})

ui_objects.KillSoundSection:CreateSlider({
    Name = "Volume",
    Flag = "kill_sound_volume",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.kill_sound.sound_volume,
    Callback = function(v)
        states.skinchanger_state.kill_sound.sound_volume = v
    end
})

ui_objects.KillSoundSection:CreateSlider({
    Name = "Pitch",
    Flag = "kill_sound_pitch",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.kill_sound.sound_pitch,
    Callback = function(v)
        states.skinchanger_state.kill_sound.sound_pitch = v
    end
})

ui_objects.KillSoundSection:CreateButton({
    Name = "Preview",
    Callback = function()
        KillSoundPreview()
        ui_objects.Window:Notify({
            Title = "Kill Sound",
            Content = "Preview Playing!",
            Duration = 5
        })
    end
})

ui_objects.ReloadSoundSection = ui_objects.SkinChangerTab:CreateSection("Reload Sound", kConstants.kLucideVolume2)

ui_objects.ReloadSoundSection:CreateDropdown({
    Name = "Sound",
    Flag = "reload_sound_value",
    Options = kConstants.kSoundMods,
    CurrentOption = states.skinchanger_state.reload_sound.sound_value,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.reload_sound.sound_value = v
    end
})

ui_objects.ReloadSoundSection:CreateInput({
    Name = "Asset ID",
    Flag = "reload_sound_asset_id",
    PlaceholderText = "1234567890",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.skinchanger_state.reload_sound.sound_asset_id = v
    end
})

ui_objects.ReloadSoundSection:CreateInput({
    Name = "URL",
    Flag = "reload_sound_url",
    PlaceholderText = "https://example.com/example.mp3",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.reload_sound.sound_url = v
    end
})

ui_objects.ReloadSoundSection:CreateSlider({
    Name = "Volume",
    Flag = "reload_sound_volume",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.reload_sound.sound_volume,
    Callback = function(v)
        states.skinchanger_state.reload_sound.sound_volume = v
    end
})

ui_objects.ReloadSoundSection:CreateSlider({
    Name = "Pitch",
    Flag = "reload_sound_pitch",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.reload_sound.sound_pitch,
    Callback = function(v)
        states.skinchanger_state.reload_sound.sound_pitch = v
    end
})

ui_objects.ReloadSoundSection:CreateButton({
    Name = "Preview",
    Callback = function()
        ReloadSoundPreview()
        ui_objects.Window:Notify({
            Title = "Reload Sound",
            Content = "Preview Playing!",
            Duration = 5
        })
    end
})

ui_objects.DeathSoundSection = ui_objects.SkinChangerTab:CreateSection("Death Sound", kConstants.kLucideVolume2)

ui_objects.DeathSoundSection:CreateDropdown({
    Name = "Sound",
    Flag = "death_sound_value",
    Options = kConstants.kSoundMods,
    CurrentOption = states.skinchanger_state.death_sound.sound_value,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.skinchanger_state.death_sound.sound_value = v
    end
})

ui_objects.DeathSoundSection:CreateInput({
    Name = "Asset ID",
    Flag = "death_sound_asset_id",
    PlaceholderText = "1234567890",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.skinchanger_state.death_sound.sound_asset_id = v
    end
})

ui_objects.DeathSoundSection:CreateInput({
    Name = "URL",
    Flag = "death_sound_url",
    PlaceholderText = "https://example.com/example.mp3",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.skinchanger_state.death_sound.sound_url = v
    end
})

ui_objects.DeathSoundSection:CreateSlider({
    Name = "Volume",
    Flag = "death_sound_volume",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.death_sound.sound_volume,
    Callback = function(v)
        states.skinchanger_state.death_sound.sound_volume = v
    end
})

ui_objects.DeathSoundSection:CreateSlider({
    Name = "Pitch",
    Flag = "death_sound_pitch",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.skinchanger_state.death_sound.sound_pitch,
    Callback = function(v)
        states.skinchanger_state.death_sound.sound_pitch = v
    end
})

ui_objects.DeathSoundSection:CreateButton({
    Name = "Preview",
    Callback = function()
        DeathSoundPreview()
        ui_objects.Window:Notify({
            Title = "Death Sound",
            Content = "Preview Playing!",
            Duration = 5
        })
    end
})

--[[
    Inventory
]]

ui_objects.InventoryTab = ui_objects.Window:CreateTab("Inventory", "Quick inventory manager.", kConstants.kLucideBox)

ui_objects.InventorySpecificSection = ui_objects.InventoryTab:CreateSection("Specific", kConstants.kLucideSearch)

ui_objects.InventorySpecificSection:CreateDropdown({
    Name = "Case / Box",
    Flag = "inv_specific_name",
    Options = kConstants.kLootboxNames,
    CurrentOption = states.inventory_state.specific.lootbox_name,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.inventory_state.specific.lootbox_name = v
    end
})

ui_objects.InventorySpecificSection:CreateSlider({
    Name = "Quantity",
    Flag = "inv_quantity",
    Range = {1, 99},
    Increment = 1,
    CurrentValue = states.inventory_state.specific.quantity,
    Callback = function(v)
        states.inventory_state.specific.quantity = v
    end
})

ui_objects.InventorySpecificSection:CreateInput({
    Name = "Weapon",
    Flag = "inv_weapon_name",
    PlaceholderText = "e.g. Assault Rifle",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.inventory_state.specific.weapon_name = v
    end
})

ui_objects.InventorySpecificSection:CreateToggle({
    Name = "New Entry",
    Flag = "inv_new_entry",
    CurrentValue = states.inventory_state.specific.new_entry,
    Callback = function(v)
        states.inventory_state.specific.new_entry = v
    end
})

ui_objects.InventorySpecificSection:CreateButton({
    Name = "Add to Backpack",
    Callback = function()
        AddToBackpack()
        ui_objects.Window:Notify({
            Title = "Added!",
            Content = "Please check backpack.",
            Duration = 5
        })
    end
})

ui_objects.InventoryBulkSection = ui_objects.InventoryTab:CreateSection("Bulk", kConstants.kLucideBox)

ui_objects.InventoryBulkSection:CreateSlider({
    Name = "Quantity",
    Flag = "inv_bulk_quantity",
    Range = {1, 99},
    Increment = 1,
    CurrentValue = states.inventory_state.bulk.quantity,
    Callback = function(v)
        states.inventory_state.bulk.quantity = v
    end
})

ui_objects.InventoryBulkSection:CreateButton({
    Name = "Add All Cases",
    Callback = function()
        AddAllCases()
        ui_objects.Window:Notify({
            Title = "Added!",
            Content = "Please check backpack.",
            Duration = 5
        })
    end
})

ui_objects.InventoryDeleteSection = ui_objects.InventoryTab:CreateSection("Delete", kConstants.kLucideX)

local bp_entries = GetBackpackEntries()
ui_objects.InventoryDeleteEntry = ui_objects.InventoryDeleteSection:CreateDropdown({
    Name = "Backpack Entry",
    Flag = "inv_delete_backpack_entry",
    Options = bp_entries,
    CurrentOption = bp_entries[1],
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.inventory_state.delete.backpack_entry = v
    end
})

ui_objects.InventoryDeleteSection:CreateSlider({
    Name = "Quantity",
    Flag = "inv_delete_quantity",
    Range = {1, 99},
    Increment = 1,
    CurrentValue = states.inventory_state.delete.quantity,
    Callback = function(v)
        states.inventory_state.delete.quantity = v
    end
})

ui_objects.InventoryDeleteSection:CreateButton({
    Name = "Refresh List",
    Callback = function()
        table.clear(bp_entries)
        bp_entries = GetBackpackEntries()

        ui_objects.InventoryDeleteEntry:Refresh(bp_entries, bp_entries[1])
        ui_objects.Window:Notify({
            Title = "Refreshed!",
            Content = "Please check dropdowns.",
            Duration = 5
        })
    end
})

ui_objects.InventoryDeleteSection:CreateButton({
    Name = "Delete ALL Backpack",
    Callback = function()
        DeleteAllBackpack()
        ui_objects.Window:Notify({
            Title = "Deleted!",
            Content = "Please check backpack.",
            Duration = 5
        })
    end
})

ui_objects.InventoryDeleteSection:CreateButton({
    Name = "Delete (Qty)",
    Callback = function()
        DeleteQuantity()
        ui_objects.Window:Notify({
            Title = "Deleted!",
            Content = "Please check backpack.",
            Duration = 5
        })
    end
})

ui_objects.InventoryDeleteSection:CreateButton({
    Name = "Delete ALL of Entry",
    Callback = function()
        DeleteAllOfEntry()
        ui_objects.Window:Notify({
            Title = "Deleted!",
            Content = "Please check backpack.",
            Duration = 5
        })
    end
})

ui_objects.InventoryInjectSection = ui_objects.InventoryTab:CreateSection("Inject", kConstants.kLucideView)

ui_objects.InventoryInjectSection:CreateDropdown({
    Name = "Type",
    Flag = "inv_inject_type",
    Options = kConstants.kItemTypes,
    CurrentOption = states.inventory_state.inject.item_type,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.inventory_state.inject.item_type = v
    end
})

ui_objects.InventoryInjectSection:CreateInput({
    Name = "Weapon",
    Flag = "inv_inject_weapon",
    PlaceholderText = "e.g. Assault Rifle",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.inventory_state.inject.weapon_name = v
    end
})

ui_objects.InventoryInjectSection:CreateInput({
    Name = "Cosmetic",
    Flag = "inv_inject_cosmetic",
    PlaceholderText = "e.g. 10B Visits",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.inventory_state.inject.cosmetic_name = v
    end
})

ui_objects.InventoryInjectSection:CreateToggle({
    Name = "Stack duplicates",
    Flag = "inv_inject_stack_dupe",
    CurrentValue = states.inventory_state.inject.stack_duplicates,
    Callback = function(v)
        states.inventory_state.inject.stack_duplicates = v
    end
})

ui_objects.InventoryInjectSection:CreateButton({
    Name = "Inject into Backpack",
    Callback = function()
        InjectIntoBackpack()
        ui_objects.Window:Notify({
            Title = "Injected!",
            Content = "Please check backpack.",
            Duration = 5
        })
    end
})

--[[
    Spoofer
]]

ui_objects.SpooferTab = ui_objects.Window:CreateTab("Spoofer", "Advanced RIVALS spoofer.", kConstants.kLucideRainbow)

ui_objects.PlatformSection = ui_objects.SpooferTab:CreateSection("Platform", kConstants.kLucideSmartphone)

ui_objects.PlatformSection:CreateDropdown({
    Name = "Device",
    Flag = "device",
    Options = {
        "Desktop",
        "Mobile",
        "Console",
        "VR"
    },
    CurrentOption = states.spoofer_state.device,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.spoofer_state.device = v
    end
})

ui_objects.PlatformSection:CreateToggle({
    Name = "Spoof Device",
    Flag = "spoof_device",
    CurrentValue = states.spoofer_state.spoof_device,
    Callback = function(v)
        states.spoofer_state.spoof_device = v
        SpoofDevice()
    end
})

ui_objects.PlatformSection:CreateToggle({
    Name = "Device Spam",
    Flag = "device_spam",
    CurrentValue = states.spoofer_state.device_spam,
    Callback = function(v)
        states.spoofer_state.device_spam = v
        DeviceSpam()
    end
})

ui_objects.PlatformSection:CreateSlider({
    Name = "Spam Rate",
    Flag = "spam_rate",
    Range = {0.1, 5},
    Increment = 0.1,
    CurrentValue = states.spoofer_state.spam_rate,
    Callback = function(v)
        states.spoofer_state.spam_rate = v
    end
})

ui_objects.PlayerSection = ui_objects.SpooferTab:CreateSection("Player", kConstants.kLucideUser)

ui_objects.PlayerSection:CreateInput({
    Name = "Display Name",
    Flag = "display_name_value",
    PlaceholderText = "Enter string...",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.spoofer_state.display_name_value = v
    end
})

ui_objects.PlayerSection:CreateInput({
    Name = "Username",
    Flag = "userrname_value",
    PlaceholderText = "Enter string...",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.spoofer_state.username_value = v
    end
})

ui_objects.PlayerSection:CreateChecklist({
    Name = "Spoofs",
    Flag = "player_spoofs",
    Options = {
        {
            Name = "Display Name",
            Default = states.spoofer_state.display_name
        },
        {
            Name = "Username",
            Default = states.spoofer_state.username
        }
    },
    Callback = function(o)
        states.spoofer_state.display_name = o["Display Name"]
        states.spoofer_state.username = o.Username
        RefreshAllNameSpoofs()
    end
})

ui_objects.PlayerSection:CreateDivider()

ui_objects.PlayerSection:CreateInput({
    Name = "Victim User Id",
    Flag = "victim_user_id",
    PlaceholderText = "Enter UserId...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.avatar_userid = tonumber(v)
        SpoofAvatar()
        RefreshAllThumbnailSpoofs()
    end
})

ui_objects.PlayerSection:CreateToggle({
    Name = "Spoof Avatar",
    Flag = "spoof_avatar",
    CurrentValue = states.spoofer_state.spoof_avatar,
    Callback = function(v)
        states.spoofer_state.spoof_avatar = v
        SpoofAvatar()
        RefreshAllThumbnailSpoofs()
    end
})

ui_objects.PlayerSection:CreateDivider()

ui_objects.PlayerSection:CreateToggle({
    Name = "Anonymous Mode",
    Flag = "anonymous_mode",
    CurrentValue = states.spoofer_state.anonymous_mode,
    Callback = function(v)
        states.spoofer_state.anonymous_mode = v
        AnonymousMode()
    end
})

ui_objects.PlayerSection:CreateDivider()

ui_objects.PlayerSection:CreateChecklist({
    Name = "Badges Spoofs",
    Flag = "player_badges_spoofs",
    Options = {
        {
            Name = "Premium",
            Default = states.spoofer_state.badges.Premium
        },
        {
            Name = "Verified",
            Default = states.spoofer_state.badges.Verified
        },
        {
            Name = "Influencer",
            Default = states.spoofer_state.badges.Influencer
        },
        {
            Name = "Admin",
            Default = states.spoofer_state.badges.Admin
        }
    },
    Callback = function(o)
        states.spoofer_state.badges.Premium = o.Premium
        states.spoofer_state.badges.Verified = o.Verified
        states.spoofer_state.badges.Influencer = o.Influencer
        states.spoofer_state.badges.Admin = o.Admin
        UpdateBadgesOptions()
    end
})

ui_objects.LeaderboardSection = ui_objects.SpooferTab:CreateSection("Leaderboard", kConstants.kLucideList)

ui_objects.LeaderboardSection:CreateInput({
    Name = "ELO",
    Flag = "elo_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.leaderboard.elo_value = tonumber(v)
        UpdateLeaderboardOptions()
    end
})

ui_objects.LeaderboardSection:CreateInput({
    Name = "Streak",
    Flag = "streak_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.leaderboard.streak_value = tonumber(v)
        UpdateLeaderboardOptions()
    end
})

ui_objects.LeaderboardSection:CreateInput({
    Name = "Kills",
    Flag = "kills_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.leaderboard.kills_value = tonumber(v)
        UpdateLeaderboardOptions()
    end
})

ui_objects.LeaderboardSection:CreateInput({
    Name = "Wins",
    Flag = "wins_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.leaderboard.wins_value = tonumber(v)
        UpdateLeaderboardOptions()
    end
})

ui_objects.LeaderboardSection:CreateInput({
    Name = "Level",
    Flag = "level_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.leaderboard.level_value = tonumber(v)
        UpdateLeaderboardOptions()
    end
})

ui_objects.LeaderboardSection:CreateChecklist({
    Name = "Spoofs",
    Flag = "leaderboard_spoofs",
    Options = {
        {
            Name = "ELO",
            Default = states.spoofer_state.leaderboard.ELO
        },
        {
            Name = "Streak",
            Default = states.spoofer_state.leaderboard.Streak
        },
        {
            Name = "Kills",
            Default = states.spoofer_state.leaderboard.Kills
        },
        {
            Name = "Wins",
            Default = states.spoofer_state.leaderboard.Wins
        },
        {
            Name = "Level",
            Default = states.spoofer_state.leaderboard.Level
        }
    },
    Callback = function(o)
        states.spoofer_state.leaderboard.ELO = o.ELO
        states.spoofer_state.leaderboard.Streak = o.Streak
        states.spoofer_state.leaderboard.Kills = o.Kills
        states.spoofer_state.leaderboard.Wins = o.Wins
        states.spoofer_state.leaderboard.Level = o.Level
        UpdateLeaderboardOptions()
        RefreshAllNameSpoofs()
    end
})

ui_objects.CharmSection = ui_objects.SpooferTab:CreateSection("Charm", kConstants.kLucideStar)

ui_objects.CharmSection:CreateDropdown({
    Name = "Charm Rank",
    Flag = "charm_rank",
    Options = kConstants.kCharmRanks,
    CurrentOption = states.spoofer_state.charm.charm_rank,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.spoofer_state.charm.charm_rank = v
        UpdateCharmOptions()
    end
})

ui_objects.CharmSection:CreateSlider({
    Name = "Arch Rank",
    Flag = "arch_rank",
    Range = {1, 100},
    Increment = 1,
    CurrentValue = states.spoofer_state.charm.arch_rank,
    Callback = function(v)
        states.spoofer_state.charm.arch_rank = tonumber(v)
        UpdateCharmOptions()
    end
})

ui_objects.CharmSection:CreateChecklist({
    Name = "Spoofs",
    Flag = "charm_spoofs",
    Options = {
        {
            Name = "Season 0 Charm",
            Default = states.spoofer_state.charm.s0_charm
        },
        {
            Name = "Season 1 Charm",
            Default = states.spoofer_state.charm.s1_charm
        },
        {
            Name = "Season 2 Charm",
            Default = states.spoofer_state.charm.s2_charm
        },
        {
            Name = "Season 3 Charm",
            Default = states.spoofer_state.charm.s3_charm
        }
    },
    Callback = function(o)
        states.spoofer_state.charm.s0_charm = o["Season 0 Charm"]
        states.spoofer_state.charm.s1_charm = o["Season 1 Charm"]
        states.spoofer_state.charm.s2_charm = o["Season 2 Charm"]
        states.spoofer_state.charm.s3_charm = o["Season 3 Charm"]
        UpdateCharmOptions()
    end
})

ui_objects.CurrencySection = ui_objects.SpooferTab:CreateSection("Currency", kConstants.kLucideCircleDollarSign)

ui_objects.CurrencySection:CreateInput({
    Name = "Keys",
    Flag = "keys_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.currency.weapon_keys_value = tonumber(v)
        UpdateCurrencyOptions()
    end
})

ui_objects.CurrencySection:CreateInput({
    Name = "Tokens",
    Flag = "tokens_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.currency.unlock_tokens_value = tonumber(v)
        UpdateCurrencyOptions()
    end
})

ui_objects.CurrencySection:CreateInput({
    Name = "Event Currency",
    Flag = "event_currency_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.currency.event_currency_value = tonumber(v)
        UpdateCurrencyOptions()
    end
})

ui_objects.CurrencySection:CreateInput({
    Name = "Glory",
    Flag = "glory_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.currency.glory_value = tonumber(v)
        UpdateCurrencyOptions()
    end
})

ui_objects.CurrencySection:CreateInput({
    Name = "Tickets",
    Flag = "tickets_value",
    PlaceholderText = "Enter number...",
    NumbersOnly = true,
    ChangedCallback = function(v)
        states.spoofer_state.currency.skin_tickets_value = tonumber(v)
        UpdateCurrencyOptions()
    end
})

ui_objects.CurrencySection:CreateChecklist({
    Name = "Spoofs",
    Flag = "currency_spoofs",
    Options = {
        {
            Name = "Keys",
            Default = states.spoofer_state.currency.weapon_keys
        },
        {
            Name = "Tokens",
            Default = states.spoofer_state.currency.unlock_tokens
        },
        {
            Name = "Event Currency",
            Default = states.spoofer_state.currency.event_currency
        },
        {
            Name = "Glory",
            Default = states.spoofer_state.currency.glory
        },
        {
            Name = "Tickets",
            Default = states.spoofer_state.currency.skin_tickets
        }
    },
    Callback = function(o)
        states.spoofer_state.currency.weapon_keys = o["Keys"]
        states.spoofer_state.currency.unlock_tokens = o["Tokens"]
        states.spoofer_state.currency.event_currency = o["Event Currency"]
        states.spoofer_state.currency.glory = o["Glory"]
        states.spoofer_state.currency.skin_tickets = o["Tickets"]
        UpdateCurrencyOptions()
    end
})

ui_objects.DuelHistorySection = ui_objects.SpooferTab:CreateSection("Duel History", kConstants.kLucideList)

ui_objects.DuelHistorySection:CreateInput({
    Name = "Match Index",
    Flag = "duel_match_index",
    Text = "1",
    PlaceholderText = "e.g. 1",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.match_index = tonumber(v) or 1
    end
})

ui_objects.DuelHistorySection:CreateDropdown({
    Name = "Mode",
    Flag = "duel_mode",
    Options = {
        "Ranked",
        "Casual"
    },
    CurrentOption = states.spoofer_state.duel_history.mode,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.spoofer_state.duel_history.mode = v
        UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateDropdown({
    Name = "Result",
    Flag = "duel_result",
    Options = kConstants.kDuelResults,
    CurrentOption = states.spoofer_state.duel_history.result,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.spoofer_state.duel_history.result = v
        UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateDropdown({
    Name = "Map",
    Flag = "duel_map",
    Options = kConstants.kDuelMaps,
    CurrentOption = states.spoofer_state.duel_history.map,
    MultipleOptions = false,
    AllowNone = false,
    Callback = function(v)
        states.spoofer_state.duel_history.map = v
        UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Team 1 Score",
    Flag = "duel_team_1_score",
    Text = "5",
    PlaceholderText = "e.g. 5",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.team1score = tonumber(v) or 5
       UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Team 2 Score",
    Flag = "duel_team_2_score",
    Text = "0",
    PlaceholderText = "e.g. 0",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.team2score = tonumber(v) or 0
       UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateDivider()

ui_objects.DuelHistorySection:CreateInput({
    Name = "Dueler Index",
    Flag = "duel_dueler_index",
    Text = "1",
    PlaceholderText = "e.g. 1",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.dueler_index = tonumber(v) or 1
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Display Name",
    Flag = "duel_display_name",
    PlaceholderText = "Enter string...",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.spoofer_state.duel_history.display_name = v
        UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Username",
    Flag = "duel_username",
    PlaceholderText = "Enter string...",
    NumbersOnly = false,
    ChangedCallback = function(v)
        states.spoofer_state.duel_history.username = v
        UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Kills",
    Flag = "duel_kills",
    Text = "15",
    PlaceholderText = "e.g. 15",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.kills = tonumber(v) or 15
       UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Deaths",
    Flag = "duel_deaths",
    Text = "2",
    PlaceholderText = "e.g. 2",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.deaths = tonumber(v) or 2
       UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Assists",
    Flag = "duel_assists",
    Text = "6",
    PlaceholderText = "e.g. 6",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.assists = tonumber(v) or 6
       UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "Damage",
    Flag = "duel_damage",
    Text = "5000",
    PlaceholderText = "e.g. 5000",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.damage = tonumber(v) or 5000
       UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "ELO",
    Flag = "duel_elo",
    Text = "2000",
    PlaceholderText = "e.g. 2000",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.elo = tonumber(v) or 2000
       UpdateDuelHistory()
    end
})

ui_objects.DuelHistorySection:CreateInput({
    Name = "ELO Change",
    Flag = "duel_elo_change",
    Text = "35",
    PlaceholderText = "e.g. 35",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.duel_history.elo_change = tonumber(v) or 35
       UpdateDuelHistory()
    end
})

ui_objects.MarketplaceSection = ui_objects.SpooferTab:CreateSection("Marketplace", kConstants.kLucideCircleDollarSign)

ui_objects.MarketplaceSection:CreateToggle({
    Name = "Fake Robux",
    Flag = "fake_robux",
    CurrentValue = states.spoofer_state.marketplace.fake_robux,
    Callback = function(v)
        states.spoofer_state.marketplace.fake_robux = v
        UpdateMarketplace()
    end
})

ui_objects.MarketplaceSection:CreateInput({
    Name = "Robux Amount",
    Flag = "robux_amount",
    PlaceholderText = "e.g. 999999",
    NumbersOnly = true,
    ChangedCallback = function(v)
       states.spoofer_state.marketplace.robux_amount = tonumber(v) or 0
       UpdateMarketplace()
    end
})

ui_objects.MarketplaceSection:CreateToggle({
    Name = "Fake Gifting",
    Flag = "fake_gifting",
    CurrentValue = states.spoofer_state.marketplace.fake_gifting,
    Callback = function(v)
        states.spoofer_state.marketplace.fake_gifting = v
        UpdateMarketplace()
    end
})

--[[
    Settings
]]

ui_objects.SettingsTab = ui_objects.Window:CreateTab("Settings", nil, kConstants.kLucideSettings)

ui_objects.GeneralSection = ui_objects.SettingsTab:CreateSection("General", kConstants.kLucideGlobe)

ui_objects.GeneralSection:CreateKeybind({
    Name = "Menu Keybind",
    Flag = "menu_keybind",
    CurrentKeybind = "RightShift",
    HoldToInteract = false,
    Callback = function(v)
        if v then
            ui_objects.Window:Show()
        else
            ui_objects.Window:Hide()
        end
    end
}):SetPressed(true)

ui_objects.GeneralSection:CreateToggle({
    Name = "Keybind Window",
    Flag = "keybind_window_enabled",
    CurrentValue = true,
    Callback = function(v)
        if v then
            ui_objects.Window:ShowKeybindWindow()
        else
            ui_objects.Window:HideKeybindWindow()
        end
    end
})

ui_objects.GeneralSection:CreateToggle({
    Name = "Watermark",
    Flag = "watermark_enabled",
    CurrentValue = true,
    Callback = function(v)
        if v then
            ui_objects.Window:ShowWatermark()
        else
            ui_objects.Window:HideWatermark()
        end
    end
})

ui_objects.GeneralSection:CreateToggle({
    Name = "Silent Load",
    Flag = "silent_load_enabled",
    CurrentValue = false,
    Callback = function(v)
        ui_objects.Window:SetSilentLoad(v)
    end
})

ui_objects.ConfigSection = ui_objects.SettingsTab:CreateSection("Config", kConstants.kLucideView)

local selected_config
local save_config_name
local rename_config_name

ui_objects.ConfigDropdown = ui_objects.ConfigSection:CreateDropdown({
	Name = "Config",
	Options = ui_objects.Window:ListConfigs(),
	CurrentOption = ui_objects.Window:GetActiveConfigName(),
	Callback = function(selected)
		selected_config = selected
	end,
})

ui_objects.ConfigSection:CreateInput({
	Name = "Save As",
	PlaceholderText = "Config name",
	Callback = function(text)
		if text ~= "" then
			save_config_name = text
		end
	end,
})

ui_objects.ConfigSection:CreateInput({
	Name = "Rename To",
	PlaceholderText = "New config name",
	Callback = function(text)
		if text ~= "" then
			rename_config_name = text
		end
	end,
})

ui_objects.ConfigSection:CreateButton({
    Name = "Load Config",
    Callback = function()
        ui_objects.Window:Notify({
            Title = "Loading config",
            Content = "Please wait..",
            Duration = 5
        })
        ui_objects.Window:LoadConfigByName(selected_config)
    end
})

ui_objects.ConfigSection:CreateButton({
    Name = "Save Config",
    Callback = function()
        if save_config_name == nil then return end
        ui_objects.Window:Notify({
            Title = "Saving config",
            Content = "Please wait..",
            Duration = 5
        })
        ui_objects.Window:SaveConfigAs(save_config_name)
		ui_objects.ConfigDropdown:Refresh(ui_objects.Window:ListConfigs(), save_config_name)
		selected_config = save_config_name
    end
})

ui_objects.ConfigSection:CreateButton({
    Name = "Rename Config",
    Callback = function()
        if selected_config == nil or rename_config_name == nil or rename_config_name == "" then return end
        local ok = ui_objects.Window:RenameConfig(selected_config, rename_config_name)
        if ok then
            ui_objects.ConfigDropdown:Refresh(ui_objects.Window:ListConfigs(), rename_config_name)
            selected_config = rename_config_name
            ui_objects.Window:Notify({
                Title = "Config renamed",
                Content = "Renamed to " .. rename_config_name,
                Duration = 3
            })
        end
    end
})

ui_objects.ConfigSection:CreateButton({
    Name = "Delete Config",
    Callback = function()
        if selected_config == nil then return end
        local ok = ui_objects.Window:DeleteConfig(selected_config)
        if ok then
            ui_objects.ConfigDropdown:Refresh(ui_objects.Window:ListConfigs(), ui_objects.Window:GetActiveConfigName())
            selected_config = ui_objects.Window:GetActiveConfigName()
            ui_objects.Window:Notify({
                Title = "Config deleted",
                Content = "The selected config was removed.",
                Duration = 3
            })
        end
    end
})

ui_objects.ConfigSection:CreateButton({
    Name = "Set Auto-Load",
    Callback = function()
        if selected_config == nil then return end
        local ok = ui_objects.Window:SetAutoLoadConfig(selected_config)
        if ok then
            ui_objects.Window:Notify({
                Title = "Auto-load updated",
                Content = "This config will load automatically next time.",
                Duration = 3
            })
        end
    end
})

ui_objects.ConfigSection:CreateButton({
    Name = "Clear Auto-Load",
    Callback = function()
        ui_objects.Window:ClearAutoLoadConfig()
        ui_objects.Window:Notify({
            Title = "Auto-load cleared",
            Content = "The window will stop loading a specific config automatically.",
            Duration = 3
        })
    end
})

ui_objects.ThemeSection = ui_objects.SettingsTab:CreateSection("Theme", kConstants.kLucideStar)

local selected_theme

ui_objects.ThemeDropdown = ui_objects.ThemeSection:CreateDropdown({
	Name = "Theme",
	Options = Library:ListThemes(),
	CurrentOption = ui_objects.Window:GetActiveConfigName() and ui_objects.Window.theme_name or "default",
	Callback = function(selected)
        selected_theme = selected
	end,
})

ui_objects.ThemeSection:CreateButton({
    Name = "Load Theme",
    Callback = function()
        ui_objects.Window:Notify({
            Title = "Loading theme",
            Content = "Please wait..",
            Duration = 5
        })
        ui_objects.Window:SetTheme(selected_theme)
    end
})

ui_objects.ThemeSection:CreateButton({
    Name = "Refresh",
    Callback = function()
		ui_objects.ThemeDropdown:Refresh(Library:ListThemes(), ui_objects.ThemeDropdown.CurrentOption)
    end
})

if not ui_objects.Window:IsSilentLoadEnabled() then
    ui_objects.Window:ShowAll()
    ui_objects.Window:Notify({
        Title = "Aetherea Loaded",
        Content = "Press RightShift to toggle.",
        Duration = 5
    })
end