local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")
local Workspace = game:GetService("Workspace")
local LocalPlayer = Players.LocalPlayer
local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
local Humanoid = Character:WaitForChild("Humanoid")
local HumanoidRootPart = Character:WaitForChild("HumanoidRootPart")
local CurrentCamera = Workspace.CurrentCamera

local function generateRandomString(length)
    local chars = {}
    for i = 1, length do
        chars[i] = string.char(math.random(97, 122))
    end
    table.concat(chars)
end

local Names = {
    gui = generateRandomString(12),
    main = generateRandomString(10),
    header = generateRandomString(9),
    logo = generateRandomString(8),
    title = generateRandomString(7),
    status = generateRandomString(9),
    close = generateRandomString(6),
    content = generateRandomString(11),
    stats = generateRandomString(8)
}

local CoreGui = game:GetService("CoreGui").RobloxGui

local Config = {
    BackgroundPrimary = Color3.fromRGB(10, 10, 10),
    BackgroundSecondary = Color3.fromRGB(20, 20, 20),
    BackgroundTertiary = Color3.fromRGB(30, 30, 30),
    AccentPrimary = Color3.fromRGB(255, 30, 30),
    AccentSecondary = Color3.fromRGB(180, 20, 20),
    TextPrimary = Color3.fromRGB(255, 255, 255),
    TextSecondary = Color3.fromRGB(180, 180, 180),
    Success = Color3.fromRGB(30, 255, 30),
    Warning = Color3.fromRGB(255, 200, 30),
    ToggleKey = Enum.KeyCode.RightControl,
    DesyncEnabled = false,
    ShowServerModel = false,
    NoclipEnabled = false
}

local State = {
    FrozenCFrame = nil,
    FrozenPosition = nil,
    ServerModel = nil,
    IsActive = false,
    Connections = {},
    CameraAnchor = nil,
    RealPlayerCFrame = nil,
    NoclipConnection = nil,
    OriginalHipHeight = nil,
    PhysicsOptimized = false
}

local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = Names.gui
ScreenGui.ResetOnSpawn = false
ScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
ScreenGui.Parent = CoreGui

local function playTween(instance, properties, duration, easingStyle)
    local tween = TweenService:Create(instance, TweenInfo.new(duration or 0.3, easingStyle or Enum.EasingStyle.Quad), properties)
    tween:Play()
end

local function createGlowEffect(parent, color, transparency)
    local glow = Instance.new("ImageLabel")
    glow.Name = generateRandomString(6)
    glow.BackgroundTransparency = 1
    glow.Position = UDim2.new(0.5, 0, 0.5, 0)
    glow.Size = UDim2.new(1, 40, 1, 40)
    glow.AnchorPoint = Vector2.new(0.5, 0.5)
    glow.Image = "rbxasset://textures/ui/Glow.png"
    glow.ImageColor3 = color
    glow.ImageTransparency = transparency or 0.5
    glow.ZIndex = parent.ZIndex - 1
    glow.Parent = parent
end

local function createGradientEffect(instance, colorSequenceStart, colorSequenceEnd, rotation)
    local gradient = Instance.new("UIGradient")
    gradient.Name = generateRandomString(5)
    gradient.Color = ColorSequence.new(colorSequenceStart, colorSequenceEnd)
    gradient.Rotation = rotation or 90
    gradient.Parent = instance
end

local function showNotification(title, text, duration, type)
    local accentColor = (type == "success" and Config.Success) or (type == "warning" and Config.Warning) or Config.AccentPrimary
    local notificationFrame = Instance.new("Frame")
    notificationFrame.Name = generateRandomString(7)
    notificationFrame.BackgroundColor3 = Config.BackgroundPrimary
    notificationFrame.BorderSizePixel = 0
    notificationFrame.Position = UDim2.new(1, 20, 0.95, 0)
    notificationFrame.Size = UDim2.new(0, 300, 0, 80)
    notificationFrame.AnchorPoint = Vector2.new(0, 1)
    notificationFrame.ZIndex = 10000
    notificationFrame.Parent = ScreenGui

    local uiCorner = Instance.new("UICorner")
    uiCorner.Name = generateRandomString(5)
    uiCorner.CornerRadius = UDim.new(0, 12)
    uiCorner.Parent = notificationFrame

    local uiStroke = Instance.new("UIStroke")
    uiStroke.Name = generateRandomString(6)
    uiStroke.Color = accentColor
    uiStroke.Thickness = 2
    uiStroke.Parent = notificationFrame

    createGlowEffect(notificationFrame, accentColor, 0.7)

    local titleLabel = Instance.new("TextLabel")
    titleLabel.Name = generateRandomString(8)
    titleLabel.BackgroundTransparency = 1
    titleLabel.Position = UDim2.new(0, 15, 0, 10)
    titleLabel.Size = UDim2.new(1, -30, 0, 22)
    titleLabel.Font = Enum.Font.GothamBold
    titleLabel.Text = title
    titleLabel.TextColor3 = accentColor
    titleLabel.TextSize = 14
    titleLabel.TextXAlignment = Enum.TextXAlignment.Left
    titleLabel.ZIndex = 10001
    titleLabel.Parent = notificationFrame

    local textLabel = Instance.new("TextLabel")
    textLabel.Name = generateRandomString(9)
    textLabel.BackgroundTransparency = 1
    textLabel.Position = UDim2.new(0, 15, 0, 35)
    textLabel.Size = UDim2.new(1, -30, 0, 35)
    textLabel.Font = Enum.Font.Gotham
    textLabel.Text = text
    textLabel.TextColor3 = Config.TextSecondary
    textLabel.TextSize = 11
    textLabel.TextWrapped = true
    textLabel.TextXAlignment = Enum.TextXAlignment.Left
    textLabel.TextYAlignment = Enum.TextYAlignment.Top
    textLabel.ZIndex = 10001
    textLabel.Parent = notificationFrame

    playTween(notificationFrame, {
        Position = UDim2.new(1, -320, 0.95, 0)
    }, 0.5, Enum.EasingStyle.Back)

    task.delay(duration or 3, function()
        playTween(notificationFrame, {
            Position = UDim2.new(1, 20, 0.95, 0)
        }, 0.4)
        task.wait(0.4)
        notificationFrame:Destroy()
    end)
end

local DesyncModule = {}

DesyncModule.CreateCameraAnchor = function()
    local anchorPart = Instance.new("Part")
    anchorPart.Name = generateRandomString(10)
    anchorPart.Size = Vector3.new(2, 2, 2)
    anchorPart.Transparency = 1
    anchorPart.CanCollide = false
    anchorPart.Anchored = true
    anchorPart.CFrame = HumanoidRootPart.CFrame
    anchorPart.Parent = Workspace
    State.CameraAnchor = anchorPart
end

DesyncModule.UpdateCameraAnchor = function()
    State.Connections.AnchorUpdate = RunService.RenderStepped:Connect(function()
        if not State.CameraAnchor or not HumanoidRootPart or not Config.DesyncEnabled then
            return
        end
        State.CameraAnchor.CFrame = HumanoidRootPart.CFrame
    end)
end

DesyncModule.SetupCamera = function()
    DesyncModule:CreateCameraAnchor()
    DesyncModule:UpdateCameraAnchor()
    CurrentCamera.CameraSubject = State.CameraAnchor
    State.Connections.CameraControl = RunService.RenderStepped:Connect(function()
        if not Config.DesyncEnabled or not State.CameraAnchor then
            return
        end
        if CurrentCamera.CameraSubject ~= State.CameraAnchor then
            CurrentCamera.CameraSubject = State.CameraAnchor
        end
    end)
end

DesyncModule.RestoreCamera = function()
    if State.CameraAnchor then
        State.CameraAnchor:Destroy()
        State.CameraAnchor = nil
    end
    CurrentCamera.CameraSubject = Humanoid
end

DesyncModule.CreateServerModel = function()
    if State.ServerModel then
        State.ServerModel:Destroy()
    end
    if not Config.ShowServerModel then
        return
    end
    local model = Instance.new("Model")
    model.Name = "ServerPosition_" .. generateRandomString(5)
    local basePart = Instance.new("Part")
    basePart.Name = generateRandomString(8)
    basePart.Size = Vector3.new(4, 0.2, 4)
    basePart.CFrame = State.FrozenCFrame * CFrame.new(0, -3, 0)
    basePart.Anchored = true
    basePart.CanCollide = false
    basePart.Transparency = 0.3
    basePart.Material = Enum.Material.Neon
    basePart.Color = Config.AccentPrimary
    basePart.Parent = model
    Instance.new("CylinderMesh").Parent = basePart

    local polePart = Instance.new("Part")
    polePart.Name = generateRandomString(7)
    polePart.Size = Vector3.new(0.3, 50, 0.3)
    polePart.CFrame = State.FrozenCFrame * CFrame.new(0, 25, 0)
    polePart.Anchored = true
    polePart.CanCollide = false
    polePart.Transparency = 0.5
    polePart.Material = Enum.Material.Neon
    polePart.Color = Config.AccentPrimary
    polePart.Parent = model

    local playerPart = Instance.new("Part")
    playerPart.Name = generateRandomString(8)
    playerPart.Size = Character.PrimaryPart.Size
    playerPart.CFrame = State.FrozenCFrame
    playerPart.Anchored = true
    playerPart.CanCollide = false
    playerPart.Transparency = 0.7
    playerPart.Material = Enum.Material.ForceField
    playerPart.Color = Config.AccentPrimary
    playerPart.CastShadow = false
    playerPart.Parent = model

    model.Parent = Workspace
    State.ServerModel = model

    spawn(function()
        local rotation = 0
        while State.ServerModel and State.ServerModel.Parent do
            rotation = rotation + 2
            if basePart and basePart.Parent then
                basePart.CFrame = State.FrozenCFrame * CFrame.new(0, -3, 0) * CFrame.Angles(0, math.rad(rotation), 0)
            end
            RunService.Heartbeat:Wait()
        end
    end)
end

DesyncModule.UpdateServerModel = function()
    if not State.ServerModel or not Config.ShowServerModel then
        return
    end
end

DesyncModule.OptimizePhysics = function()
    if State.PhysicsOptimized then
        return
    end
    State.OriginalHipHeight = Humanoid.HipHeight
    Humanoid.HipHeight = Humanoid.HipHeight
    State.PhysicsOptimized = true
end

DesyncModule.RestorePhysics = function()
    if not State.PhysicsOptimized then
        return
    end
    if State.OriginalHipHeight then
        Humanoid.HipHeight = State.OriginalHipHeight
    end
    State.PhysicsOptimized = false
end

DesyncModule.EnableNoclip = function()
    if State.NoclipConnection then
        return
    end
    State.NoclipConnection = RunService.Stepped:Connect(function()
        if not Config.NoclipEnabled then
            return
        end
        for _, descendant in pairs(Character:GetDescendants()) do
            if descendant:IsA("BasePart") then
                descendant.CanCollide = false
            end
        end
    end)
end

DesyncModule.DisableNoclip = function()
    if State.NoclipConnection then
        State.NoclipConnection:Disconnect()
        State.NoclipConnection = nil
    end
    for _, descendant in pairs(Character:GetDescendants()) do
        if descendant:IsA("BasePart") and descendant.Name ~= "HumanoidRootPart" then
            descendant.CanCollide = true
        end
    end
end

DesyncModule.Start = function()
    if State.IsActive then
        return
    end
    State.IsActive = true
    State.FrozenCFrame = HumanoidRootPart.CFrame
    State.FrozenPosition = HumanoidRootPart.Position
    DesyncModule:SetupCamera()
    DesyncModule:CreateServerModel()
    DesyncModule:OptimizePhysics()
    pcall(function()
        HumanoidRootPart:SetNetworkOwner(nil)
    end)
    State.Connections.MainLoop = RunService.Heartbeat:Connect(function()
        if not Config.DesyncEnabled or not HumanoidRootPart then
            return
        end
        local originalCFrame = HumanoidRootPart.CFrame
        local originalVelocity = HumanoidRootPart.AssemblyLinearVelocity
        State.RealPlayerCFrame = originalCFrame
        HumanoidRootPart.CFrame = State.FrozenCFrame
        HumanoidRootPart.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
        RunService.RenderStepped:Wait()
        if HumanoidRootPart then
            HumanoidRootPart.CFrame = originalCFrame
            HumanoidRootPart.AssemblyLinearVelocity = originalVelocity
        end
        DesyncModule:UpdateServerModel()
    end)
    showNotification("DESYNC ACTIVE", "Server frozen! Camera following your real position!", 3, "success")
end

DesyncModule.Stop = function()
    if not State.IsActive then
        return
    end
    State.IsActive = false
    DesyncModule:RestoreCamera()
    DesyncModule:RestorePhysics()
    for _, connection in pairs(State.Connections) do
        connection:Disconnect()
    end
    State.Connections = {}
    if Config.NoclipEnabled then
        Config.NoclipEnabled = false
        DesyncModule:DisableNoclip()
    end
    pcall(function()
        HumanoidRootPart:SetNetworkOwnershipAuto()
    end)
    if State.ServerModel then
        State.ServerModel:Destroy()
        State.ServerModel = nil
    end
    State.FrozenCFrame = nil
    State.FrozenPosition = nil
    showNotification("DESYNC DISABLED", "Camera and position restored.", 2, "warning")
end

local MainFrame = Instance.new("Frame")
MainFrame.Name = Names.main
MainFrame.BackgroundColor3 = Config.BackgroundPrimary
MainFrame.BorderSizePixel = 0
MainFrame.Position = UDim2.new(0.5, -225, 0.5, -200)
MainFrame.Size = UDim2.new(0, 450, 0, 400)
MainFrame.ZIndex = 9000
MainFrame.Parent = ScreenGui

local mainUiCorner = Instance.new("UICorner")
mainUiCorner.Name = generateRandomString(6)
mainUiCorner.CornerRadius = UDim.new(0, 16)
mainUiCorner.Parent = MainFrame

local mainUiStroke = Instance.new("UIStroke")
mainUiStroke.Name = generateRandomString(7)
mainUiStroke.Color = Config.AccentPrimary
mainUiStroke.Thickness = 2
mainUiStroke.Transparency = 0.3
mainUiStroke.Parent = MainFrame

createGlowEffect(MainFrame, Config.AccentPrimary, 0.8)

local isDragging = false
local dragStartPos = nil
local originalFramePosition = nil
local dragThreshold = 5

local function onMouseDrag(input)
    local delta = input.Position - dragStartPos
    if isDragging and delta.Magnitude > dragThreshold then
        MainFrame.Position = UDim2.new(originalFramePosition.X.Scale, originalFramePosition.X.Offset + delta.X, originalFramePosition.Y.Scale, originalFramePosition.Y.Offset + delta.Y)
    end
end

MainFrame.InputBegan:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
        isDragging = true
        dragStartPos = input.Position
        originalFramePosition = MainFrame.Position
        input.Changed:Connect(function()
            if input.UserInputState == Enum.UserInputState.End then
                isDragging = false
            end
        end)
    end
end)

MainFrame.InputChanged:Connect(function(input)
    if input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch then
        local lastInput = input
        if isDragging then
            onMouseDrag(lastInput)
        end
    end
end)

UserInputService.InputChanged:Connect(function(input)
    if input == lastInput and isDragging then
        onMouseDrag(input)
    end
end)


local HeaderFrame = Instance.new("Frame")
HeaderFrame.Name = Names.header
HeaderFrame.BackgroundColor3 = Config.BackgroundSecondary
HeaderFrame.BorderSizePixel = 0
HeaderFrame.Size = UDim2.new(1, 0, 0, 60)
HeaderFrame.ZIndex = 9001
HeaderFrame.Parent = MainFrame

local headerUiCorner = Instance.new("UICorner")
headerUiCorner.Name = generateRandomString(5)
headerUiCorner.CornerRadius = UDim.new(0, 16)
headerUiCorner.Parent = HeaderFrame

createGradientEffect(HeaderFrame, Config.BackgroundSecondary, Config.BackgroundTertiary, 90)

local LogoFrame = Instance.new("Frame")
LogoFrame.Name = Names.logo
LogoFrame.BackgroundColor3 = Config.AccentPrimary
LogoFrame.Position = UDim2.new(0, 15, 0.5, -18)
LogoFrame.Size = UDim2.new(0, 36, 0, 36)
LogoFrame.BorderSizePixel = 0
LogoFrame.ZIndex = 9002
LogoFrame.Parent = HeaderFrame

local logoUiCorner = Instance.new("UICorner")
logoUiCorner.Name = generateRandomString(6)
logoUiCorner.CornerRadius = UDim.new(0, 8)
logoUiCorner.Parent = LogoFrame

createGlowEffect(LogoFrame, Config.AccentPrimary, 0.6)

local LogoImageLabel = Instance.new("ImageLabel")
LogoImageLabel.Name = generateRandomString(9)
LogoImageLabel.Image = "rbxassetid://99495807378456"
LogoImageLabel.BackgroundTransparency = 1
LogoImageLabel.Size = UDim2.new(1, 0, 1, 0)
LogoImageLabel.Position = UDim2.new(0, 0, 0, 0)
LogoImageLabel.ScaleType = Enum.ScaleType.Fit
LogoImageLabel.ZIndex = 9003
LogoImageLabel.Parent = LogoFrame

local TitleLabel = Instance.new("TextLabel")
TitleLabel.Name = Names.title
TitleLabel.BackgroundTransparency = 1
TitleLabel.Position = UDim2.new(0, 58, 0, 10)
TitleLabel.Size = UDim2.new(0, 200, 0, 24)
TitleLabel.Font = Enum.Font.GothamBold
TitleLabel.Text = "LURKOUT DESYNC"
TitleLabel.TextColor3 = Config.AccentPrimary
TitleLabel.TextSize = 18
TitleLabel.TextXAlignment = Enum.TextXAlignment.Left
TitleLabel.ZIndex = 9002
TitleLabel.Parent = HeaderFrame

local SubtitleLabel = Instance.new("TextLabel")
SubtitleLabel.Name = generateRandomString(8)
SubtitleLabel.BackgroundTransparency = 1
SubtitleLabel.Position = UDim2.new(0, 58, 0, 36)
SubtitleLabel.Size = UDim2.new(0, 200, 0, 16)
SubtitleLabel.Font = Enum.Font.Gotham
SubtitleLabel.Text = "v1.0.3 | this menu so sexayyy"
SubtitleLabel.TextColor3 = Config.TextSecondary
SubtitleLabel.TextSize = 10
SubtitleLabel.TextXAlignment = Enum.TextXAlignment.Left
SubtitleLabel.ZIndex = 9002
SubtitleLabel.Parent = HeaderFrame

local StatusFrame = Instance.new("Frame")
StatusFrame.Name = Names.status
StatusFrame.BackgroundColor3 = Config.BackgroundTertiary
StatusFrame.BorderSizePixel = 0
StatusFrame.Position = UDim2.new(1, -155, 0.5, -16)
StatusFrame.Size = UDim2.new(0, 95, 0, 32)
StatusFrame.ZIndex = 9002
StatusFrame.Parent = HeaderFrame

Instance.new("UICorner", StatusFrame).CornerRadius = UDim.new(0, 10)

local statusUiStroke = Instance.new("UIStroke")
statusUiStroke.Name = generateRandomString(7)
statusUiStroke.Color = Config.AccentSecondary
statusUiStroke.Thickness = 1.5
statusUiStroke.Transparency = 0.5
statusUiStroke.Parent = StatusFrame

local statusIndicator = Instance.new("Frame")
statusIndicator.Name = generateRandomString(6)
statusIndicator.BackgroundColor3 = Config.AccentSecondary
statusIndicator.BorderSizePixel = 0
statusIndicator.Position = UDim2.new(0, 10, 0.5, -5)
statusIndicator.Size = UDim2.new(0, 10, 0, 10)
statusIndicator.ZIndex = 9003
statusIndicator.Parent = StatusFrame
Instance.new("UICorner", statusIndicator).CornerRadius = UDim.new(1, 0)

local StatusLabel = Instance.new("TextLabel")
StatusLabel.Name = generateRandomString(9)
StatusLabel.BackgroundTransparency = 1
StatusLabel.Position = UDim2.new(0, 24, 0, 0)
StatusLabel.Size = UDim2.new(1, -28, 1, 0)
StatusLabel.Font = Enum.Font.GothamBold
StatusLabel.Text = "SYNCED"
StatusLabel.TextColor3 = Config.TextPrimary
StatusLabel.TextSize = 11
StatusLabel.TextXAlignment = Enum.TextXAlignment.Left
StatusLabel.ZIndex = 9003
StatusLabel.Parent = StatusFrame

local CloseButton = Instance.new("TextButton")
CloseButton.Name = Names.close
CloseButton.BackgroundColor3 = Config.BackgroundTertiary
CloseButton.BorderSizePixel = 0
CloseButton.Position = UDim2.new(1, -45, 0.5, -16)
CloseButton.Size = UDim2.new(0, 32, 0, 32)
CloseButton.Font = Enum.Font.GothamBold
CloseButton.Text = "X"
CloseButton.TextColor3 = Config.TextPrimary
CloseButton.TextSize = 16
CloseButton.ZIndex = 9003
CloseButton.AutoButtonColor = false
CloseButton.Parent = HeaderFrame
Instance.new("UICorner", CloseButton).CornerRadius = UDim.new(0, 10)

CloseButton.MouseEnter:Connect(function()
    playTween(CloseButton, {
        BackgroundColor3 = Config.AccentPrimary
    }, 0.2)
end)
CloseButton.MouseLeave:Connect(function()
    playTween(CloseButton, {
        BackgroundColor3 = Config.BackgroundTertiary
    }, 0.2)
end)
CloseButton.MouseButton1Click:Connect(function()
    MainFrame.Visible = false
end)

local ContentFrame = Instance.new("Frame")
ContentFrame.Name = Names.content
ContentFrame.BackgroundTransparency = 1
ContentFrame.Position = UDim2.new(0, 15, 0, 75)
ContentFrame.Size = UDim2.new(1, -30, 1, -90)
ContentFrame.ZIndex = 9001
ContentFrame.Parent = MainFrame

local function createSettingToggle(parent, label, description, yPosition, callback)
    local settingFrame = Instance.new("Frame")
    settingFrame.Name = generateRandomString(10)
    settingFrame.BackgroundColor3 = Config.BackgroundSecondary
    settingFrame.BorderSizePixel = 0
    settingFrame.Position = UDim2.new(0, 0, 0, yPosition)
    settingFrame.Size = UDim2.new(1, 0, 0, 55)
    settingFrame.ZIndex = 9002
    settingFrame.Parent = parent
    Instance.new("UICorner", settingFrame).CornerRadius = UDim.new(0, 12)
    local uiStroke = Instance.new("UIStroke")
    uiStroke.Name = generateRandomString(6)
    uiStroke.Color = Config.AccentPrimary
    uiStroke.Thickness = 1
    uiStroke.Transparency = 0.8
    uiStroke.Parent = settingFrame

    local labelLabel = Instance.new("TextLabel")
    labelLabel.Name = generateRandomString(7)
    labelLabel.BackgroundTransparency = 1
    labelLabel.Position = UDim2.new(0, 14, 0, 8)
    labelLabel.Size = UDim2.new(1, -100, 0, 18)
    labelLabel.Font = Enum.Font.GothamBold
    labelLabel.Text = label
    labelLabel.TextColor3 = Config.TextPrimary
    labelLabel.TextSize = 13
    labelLabel.TextXAlignment = Enum.TextXAlignment.Left
    labelLabel.ZIndex = 9003
    labelLabel.Parent = settingFrame

    local descriptionLabel = Instance.new("TextLabel")
    descriptionLabel.Name = generateRandomString(8)
    descriptionLabel.BackgroundTransparency = 1
    descriptionLabel.Position = UDim2.new(0, 14, 0, 28)
    descriptionLabel.Size = UDim2.new(1, -100, 0, 20)
    descriptionLabel.Font = Enum.Font.Gotham
    descriptionLabel.Text = description
    descriptionLabel.TextColor3 = Config.TextSecondary
    descriptionLabel.TextSize = 9
    descriptionLabel.TextXAlignment = Enum.TextXAlignment.Left
    descriptionLabel.TextWrapped = true
    descriptionLabel.ZIndex = 9003
    descriptionLabel.Parent = settingFrame

    local toggleSwitchBackground = Instance.new("Frame")
    toggleSwitchBackground.Name = generateRandomString(9)
    toggleSwitchBackground.BackgroundColor3 = Config.BackgroundTertiary
    toggleSwitchBackground.BorderSizePixel = 0
    toggleSwitchBackground.Position = UDim2.new(1, -62, 0.5, -14)
    toggleSwitchBackground.Size = UDim2.new(0, 52, 0, 28)
    toggleSwitchBackground.ZIndex = 9003
    toggleSwitchBackground.Parent = settingFrame
    Instance.new("UICorner", toggleSwitchBackground).CornerRadius = UDim.new(1, 0)

    local toggleSwitch = Instance.new("Frame")
    toggleSwitch.Name = generateRandomString(8)
    toggleSwitch.BackgroundColor3 = Config.TextPrimary
    toggleSwitch.BorderSizePixel = 0
    toggleSwitch.Position = UDim2.new(0, 3, 0.5, -11)
    toggleSwitch.Size = UDim2.new(0, 22, 0, 22)
    toggleSwitch.ZIndex = 9004
    toggleSwitch.Parent = toggleSwitchBackground
    Instance.new("UICorner", toggleSwitch).CornerRadius = UDim.new(1, 0)
    createGlowEffect(toggleSwitch, Config.TextPrimary, 0.7)

    local isToggled = false
    local toggleButton = Instance.new("TextButton")
    toggleButton.Name = generateRandomString(6)
    toggleButton.BackgroundTransparency = 1
    toggleButton.Size = UDim2.new(1, 0, 1, 0)
    toggleButton.Text = ""
    toggleButton.ZIndex = 9005
    toggleButton.Parent = settingFrame

    toggleButton.MouseButton1Click:Connect(function()
        isToggled = not isToggled
        callback(isToggled)
        if isToggled then
            playTween(toggleSwitch, {
                Position = UDim2.new(1, -25, 0.5, -11)
            }, 0.3, Enum.EasingStyle.Back)
            playTween(toggleSwitchBackground, {
                BackgroundColor3 = Config.AccentPrimary
            }, 0.3)
            playTween(uiStroke, {
                Transparency = 0.3
            }, 0.3)
        else
            playTween(toggleSwitch, {
                Position = UDim2.new(0, 3, 0.5, -11)
            }, 0.3, Enum.EasingStyle.Back)
            playTween(toggleSwitchBackground, {
                BackgroundColor3 = Config.BackgroundTertiary
            }, 0.3)
            playTween(uiStroke, {
                Transparency = 0.8
            }, 0.3)
        end
    end)
    toggleButton.MouseEnter:Connect(function()
        playTween(settingFrame, {
            BackgroundColor3 = Config.BackgroundTertiary
        }, 0.2)
    end)
    toggleButton.MouseLeave:Connect(function()
        playTween(settingFrame, {
            BackgroundColor3 = Config.BackgroundSecondary
        }, 0.2)
    end)
end

local SettingsTitle = Instance.new("TextLabel")
SettingsTitle.Name = generateRandomString(10)
SettingsTitle.BackgroundTransparency = 1
SettingsTitle.Size = UDim2.new(1, 0, 0, 25)
SettingsTitle.Font = Enum.Font.GothamBold
SettingsTitle.Text = "DESYNC CONTROLS"
SettingsTitle.TextColor3 = Config.AccentPrimary
SettingsTitle.TextSize = 14
SettingsTitle.TextXAlignment = Enum.TextXAlignment.Left
SettingsTitle.ZIndex = 9002
SettingsTitle.Parent = ContentFrame

local settingsLine = Instance.new("Frame")
settingsLine.Name = generateRandomString(7)
settingsLine.BackgroundColor3 = Config.AccentPrimary
settingsLine.BorderSizePixel = 0
settingsLine.Position = UDim2.new(0, 0, 1, -2)
settingsLine.Size = UDim2.new(0.3, 0, 0, 2)
settingsLine.ZIndex = 9002
settingsLine.Parent = SettingsTitle

createSettingToggle(ContentFrame, "Enable Desync", "Freezes character position on server, allows client control", 30, function(toggled)
    Config.DesyncEnabled = toggled
    if toggled then
        DesyncModule:Start()
        StatusIndicator.BackgroundColor3 = Config.Success
        StatusLabel.Text = "DESYNCED"
        playTween(statusUiStroke, {
            Color = Config.Success,
            Transparency = 0.2
        }, 0.3)
    else
        DesyncModule:Stop()
        StatusIndicator.BackgroundColor3 = Config.AccentSecondary
        StatusLabel.Text = "SYNCED"
        playTween(statusUiStroke, {
            Color = Config.AccentSecondary,
            Transparency = 0.5
        }, 0.3)
    end
end)

createSettingToggle(ContentFrame, "Show Server Position", "Visualize where players see your character", 90, function(toggled)
    Config.ShowServerModel = toggled
    if toggled and Config.DesyncEnabled then
        DesyncModule:CreateServerModel()
    else
        if not toggled and State.ServerModel then
            State.ServerModel:Destroy()
            State.ServerModel = nil
        end
    end
end)

createSettingToggle(ContentFrame, "Noclip", "Walk through walls while desync is active", 150, function(toggled)
    Config.NoclipEnabled = toggled
    if toggled then
        DesyncModule:EnableNoclip()
        showNotification("NOCLIP ENABLED", "You can now walk through walls!", 2, "success")
    else
        DesyncModule:DisableNoclip()
        showNotification("NOCLIP DISABLED", "Collision restored.", 2, "warning")
    end
end)

local StatsFrame = Instance.new("Frame")
StatsFrame.Name = Names.stats
StatsFrame.BackgroundColor3 = Config.BackgroundSecondary
StatsFrame.BorderSizePixel = 0
StatsFrame.Position = UDim2.new(0, 0, 0, 215)
StatsFrame.Size = UDim2.new(1, 0, 0, 95)
StatsFrame.ZIndex = 9002
StatsFrame.Parent = ContentFrame
Instance.new("UICorner", StatsFrame).CornerRadius = UDim.new(0, 12)
createGradientEffect(StatsFrame, Config.BackgroundSecondary, Config.BackgroundTertiary, 135)

local statsTitleLabel = Instance.new("TextLabel")
statsTitleLabel.Name = generateRandomString(9)
statsTitleLabel.BackgroundTransparency = 1
statsTitleLabel.Position = UDim2.new(0, 14, 0, 8)
statsTitleLabel.Size = UDim2.new(1, -28, 0, 18)
statsTitleLabel.Font = Enum.Font.GothamBold
statsTitleLabel.Text = "position monitoring for goobers"
statsTitleLabel.TextColor3 = Config.AccentPrimary
statsTitleLabel.TextSize = 12
statsTitleLabel.TextXAlignment = Enum.TextXAlignment.Left
statsTitleLabel.ZIndex = 9003
statsTitleLabel.Parent = StatsFrame

local statsTextLabel = Instance.new("TextLabel")
statsTextLabel.Name = generateRandomString(10)
statsTextLabel.BackgroundTransparency = 1
statsTextLabel.Position = UDim2.new(0, 14, 0, 30)
statsTextLabel.Size = UDim2.new(1, -28, 1, -38)
statsTextLabel.Font = Enum.Font.Code
statsTextLabel.Text = "Enable desync to monitor...

Client: N/A | Server: N/A
Distance: N/A"
statsTextLabel.TextColor3 = Config.TextSecondary
statsTextLabel.TextSize = 10
statsTextLabel.TextWrapped = true
statsTextLabel.TextXAlignment = Enum.TextXAlignment.Left
statsTextLabel.TextYAlignment = Enum.TextYAlignment.Top
statsTextLabel.ZIndex = 9003
statsTextLabel.Parent = StatsFrame

RunService.RenderStepped:Connect(function()
    if Config.DesyncEnabled and HumanoidRootPart and State.FrozenPosition then
        local clientPos = HumanoidRootPart.Position
        local serverPos = State.FrozenPosition
        local distance = (clientPos - serverPos).Magnitude
        statsTextLabel.Text = string.format("Active - Monitoring positions

Client: [%.0f,%.0f,%.0f]
Server: [%.0f,%.0f,%.0f]
Distance: %.1f studs", clientPos.X, clientPos.Y, clientPos.Z, serverPos.X, serverPos.Y, serverPos.Z, distance)
    else
        statsTextLabel.Text = "Enable desync to monitor...

Client: N/A | Server: N/A
Distance: N/A"
    end
end)

UserInputService.InputBegan:Connect(function(input, gameProcessedEvent)
    if gameProcessedEvent then
        return
    end
    if input.KeyCode == Config.ToggleKey then
        MainFrame.Visible = not MainFrame.Visible
        if MainFrame.Visible then
            playTween(MainFrame, {
                Size = UDim2.new(0, 450, 0, 400)
            }, 0.4, Enum.EasingStyle.Back)
        end
    end
end)

LocalPlayer.CharacterAdded:Connect(function(char)
    task.wait(1)
    Character = char
    Humanoid = char:WaitForChild("Humanoid")
    HumanoidRootPart = char:WaitForChild("HumanoidRootPart")
    CurrentCamera = Workspace.CurrentCamera
    if Config.DesyncEnabled then
        Config.DesyncEnabled = false
        DesyncModule:Stop()
        StatusIndicator.BackgroundColor3 = Config.AccentSecondary
        StatusLabel.Text = "SYNCED"
        showNotification("DESYNC RESET", "Character respawned.", 2, "warning")
    end
end)

MainFrame.Size = UDim2.new(0, 0, 0, 0)
MainFrame.Position = UDim2.new(0.5, 0, 0.5, 0)
task.wait(0.1)
playTween(MainFrame, {
    Size = UDim2.new(0, 450, 0, 400),
    Position = UDim2.new(0.5, -225, 0.5, -200)
}, 0.6, Enum.EasingStyle.Back)
showNotification("LURKOUT DESYNC", "Loaded! Press " .. Config.ToggleKey.Name .. " to toggle", 4, "success")