--[[
    ￢ﾕﾔ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾗ
    ￢ﾕﾑ   okaz reworked  ￂﾷ  V18                                  ￢ﾕﾑ
    ￢ﾕﾑ   hardened build ￂﾷ spectate ￂﾷ distance hud               ￢ﾕﾑ
    ￢ﾕﾚ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾐ￢ﾕﾝ
    K = toggle menu   ￂﾷ   ;cmds for the command list
]]

--=====================================================================
-- SERVICES
--=====================================================================
local Players           = game:GetService("Players")
local RunService        = game:GetService("RunService")
local TweenService      = game:GetService("TweenService")
local UserInputService  = game:GetService("UserInputService")
local CoreGui           = game:GetService("CoreGui")
local Lighting          = game:GetService("Lighting")
local Workspace         = game:GetService("Workspace")
local VirtualUser       = game:GetService("VirtualUser")
local HttpService       = game:GetService("HttpService")
local Stats             = game:GetService("Stats")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local TextChatService   = game:GetService("TextChatService")
local SoundService      = game:GetService("SoundService")
local TeleportService   = game:GetService("TeleportService")

local LP     = Players.LocalPlayer
local Camera = Workspace.CurrentCamera
local Mouse  = LP:GetMouse()

local Okaz = { Name = "okaz_reworked_v18", Connections = {}, Unloaded = false, Errors = {} }

local function conn(signal, fn)
    local c = signal:Connect(fn)
    table.insert(Okaz.Connections, c)
    return c
end

for _, v in ipairs(CoreGui:GetChildren()) do
    if v:IsA("ScreenGui") and v.Name:match("^okaz_reworked") then v:Destroy() end
end
for _, v in ipairs(LP:WaitForChild("PlayerGui"):GetChildren()) do
    if v:IsA("ScreenGui") and v.Name:match("^okaz_reworked") then v:Destroy() end
end

--=====================================================================
-- THEME
--=====================================================================
local Theme = { accent = Color3.fromRGB(255, 46, 122), accent2 = Color3.fromRGB(158, 74, 255) }

local C = {
    bg = Color3.fromRGB(10, 10, 14), panel = Color3.fromRGB(17, 17, 23),
    panel2 = Color3.fromRGB(23, 23, 31), stroke = Color3.fromRGB(43, 43, 57),
    text = Color3.fromRGB(241, 241, 249), dim = Color3.fromRGB(118, 118, 136),
    off = Color3.fromRGB(46, 46, 58), good = Color3.fromRGB(60, 220, 140),
    bad = Color3.fromRGB(255, 84, 84),
}

local retinters = {}
local function retint() for _, fn in ipairs(retinters) do pcall(fn) end end
local function bindColor(obj, prop, key)
    obj[prop] = Theme[key]
    table.insert(retinters, function() obj[prop] = Theme[key] end)
end
local function bindGradient(grad)
    local function paint()
        grad.Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, Theme.accent),
            ColorSequenceKeypoint.new(1, Theme.accent2),
        })
    end
    paint()
    table.insert(retinters, paint)
end

--=====================================================================
-- HELPERS
--=====================================================================
local function new(class, props, parent)
    local i = Instance.new(class)
    for k, v in pairs(props or {}) do i[k] = v end
    if parent then i.Parent = parent end
    return i
end
local function corner(p, r) return new("UICorner", { CornerRadius = UDim.new(0, r or 8) }, p) end
local function stroke(p, c, t, tr)
    return new("UIStroke", { Color = c or C.stroke, Thickness = t or 1, Transparency = tr or 0,
        ApplyStrokeMode = Enum.ApplyStrokeMode.Border }, p)
end
local function pad(p, t, r, b, l)
    return new("UIPadding", { PaddingTop = UDim.new(0, t), PaddingRight = UDim.new(0, r),
        PaddingBottom = UDim.new(0, b), PaddingLeft = UDim.new(0, l) }, p)
end
local function tween(o, t, p, s, d)
    local tw = TweenService:Create(o, TweenInfo.new(t or 0.25, s or Enum.EasingStyle.Quad, d or Enum.EasingDirection.Out), p)
    tw:Play()
    return tw
end

local function getHum() local c = LP.Character; return c and c:FindFirstChildOfClass("Humanoid") end
local function getHRP() local c = LP.Character; return c and c:FindFirstChild("HumanoidRootPart") end
local function getAnimator(ch)
    local h = ch and ch:FindFirstChildOfClass("Humanoid")
    return h and h:FindFirstChildOfClass("Animator")
end

local function say(msg)
    if TextChatService.ChatVersion == Enum.ChatVersion.TextChatService then
        local chans = TextChatService:FindFirstChild("TextChannels")
        local gen = chans and chans:FindFirstChild("RBXGeneral")
        if gen then pcall(function() gen:SendAsync(msg) end) return end
    end
    local ev = ReplicatedStorage:FindFirstChild("DefaultChatSystemChatBar")
    if ev then pcall(function() ev:FireServer(msg, Enum.ChatColor.White) end) end
end

local function groundBelow(dist)
    local hrp = getHRP()
    if not hrp then return nil end
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.FilterDescendantsInstances = { LP.Character }
    return Workspace:Raycast(hrp.Position, Vector3.new(0, -(dist or 6), 0), params)
end

local function nearestPlayer()
    local hrp = getHRP()
    if not hrp then return nil end
    local best, bestD
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LP and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
            local d = (p.Character.HumanoidRootPart.Position - hrp.Position).Magnitude
            if not bestD or d < bestD then best, bestD = p, d end
        end
    end
    return best
end

local function resolvePlayer(name)
    if not name or name == "" then return nil end
    name = name:lower()
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LP and p.Name:lower():sub(1, #name) == name then return p end
    end
    return nil
end

local function wrapAngle(a)
    while a > math.pi do a -= math.pi * 2 end
    while a < -math.pi do a += math.pi * 2 end
    return a
end

--=====================================================================
-- UI SFX
--=====================================================================
local sfxOn = true
local clickSound
task.spawn(function()
    local s = Instance.new("Sound")
    s.SoundId = "rbxassetid://6895079853"
    s.Volume = 0.3
    s.Parent = SoundService
    clickSound = s
end)
local function click()
    if sfxOn and clickSound then pcall(function() clickSound.TimePosition = 0; clickSound:Play() end) end
end

--=====================================================================
-- GUI ROOT
--=====================================================================
local gui = new("ScreenGui", {
    Name = Okaz.Name, ResetOnSpawn = false, IgnoreGuiInset = true,
    ZIndexBehavior = Enum.ZIndexBehavior.Sibling, DisplayOrder = 999,
})
gui.Parent = (gethui and gethui()) or CoreGui

local overlay = new("ScreenGui", {
    Name = Okaz.Name .. "_overlay", ResetOnSpawn = false,
    IgnoreGuiInset = true, DisplayOrder = 998,
}, gui.Parent)

local fovCircle = new("Frame", {
    AnchorPoint = Vector2.new(0.5, 0.5), BackgroundTransparency = 1,
    Size = UDim2.fromOffset(180, 180), Visible = false, ZIndex = 500,
}, overlay)
local fovCorner = corner(fovCircle, 999)
local fovStroke = stroke(fovCircle, Theme.accent, 1.5, 0.35)
table.insert(retinters, function() fovStroke.Color = Theme.accent end)

local cross = new("Frame", {
    AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.fromScale(0.5, 0.5),
    Size = UDim2.fromOffset(16, 16), BackgroundTransparency = 1, Visible = false, ZIndex = 501,
}, overlay)
local chH = new("Frame", { AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.fromScale(0.5, 0.5),
    Size = UDim2.new(1, 0, 0, 1), BackgroundColor3 = Theme.accent, BorderSizePixel = 0 }, cross)
local chV = new("Frame", { AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.fromScale(0.5, 0.5),
    Size = UDim2.new(0, 1, 1, 0), BackgroundColor3 = Theme.accent, BorderSizePixel = 0 }, cross)
table.insert(retinters, function() chH.BackgroundColor3 = Theme.accent; chV.BackgroundColor3 = Theme.accent end)

local targetHud = new("Frame", {
    AnchorPoint = Vector2.new(0.5, 1), Position = UDim2.new(0.5, 0, 1, -70),
    Size = UDim2.fromOffset(220, 44), BackgroundColor3 = C.bg,
    BackgroundTransparency = 0.2, BorderSizePixel = 0, Visible = false, ZIndex = 502,
}, overlay)
corner(targetHud, 10)
local thStroke = stroke(targetHud, Theme.accent, 1, 0.4)
table.insert(retinters, function() thStroke.Color = Theme.accent end)
local thName = new("TextLabel", {
    Size = UDim2.new(1, -18, 0, 16), Position = UDim2.fromOffset(9, 6),
    BackgroundTransparency = 1, Font = Enum.Font.GothamBold, TextSize = 12,
    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text, Text = "",
}, targetHud)
local thInfo = new("TextLabel", {
    Size = UDim2.new(1, -18, 0, 12), Position = UDim2.fromOffset(9, 24),
    BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 10,
    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim, Text = "",
}, targetHud)
local thBar = new("Frame", {
    AnchorPoint = Vector2.new(0, 1), Position = UDim2.new(0, 9, 1, -5),
    Size = UDim2.new(1, -18, 0, 3), BackgroundColor3 = Color3.fromRGB(40, 40, 52),
    BorderSizePixel = 0,
}, targetHud)
corner(thBar, 99)
local thFill = new("Frame", { Size = UDim2.fromScale(1, 1), BackgroundColor3 = C.good, BorderSizePixel = 0 }, thBar)
corner(thFill, 99)

local distHud = new("TextLabel", {
    Position = UDim2.new(1, -20, 0.5, 0), AnchorPoint = Vector2.new(1, 0.5),
    Size = UDim2.fromOffset(160, 18), BackgroundTransparency = 1,
    Font = Enum.Font.Code, TextSize = 11, TextXAlignment = Enum.TextXAlignment.Right,
    TextColor3 = C.text, TextStrokeTransparency = 0.5, Visible = false, Text = "",
}, overlay)

local tracerHolder = new("Frame", { Size = UDim2.fromScale(1, 1), BackgroundTransparency = 1, ZIndex = 400 }, overlay)

--=====================================================================
-- WATERMARK
--=====================================================================
local wm = new("Frame", {
    Position = UDim2.fromOffset(14, 14), Size = UDim2.fromOffset(212, 24),
    BackgroundColor3 = C.bg, BackgroundTransparency = 0.25, BorderSizePixel = 0,
}, gui)
corner(wm, 7)
local wmStroke = stroke(wm, Theme.accent, 1, 0.4)
table.insert(retinters, function() wmStroke.Color = Theme.accent end)
local wmBar = new("Frame", {
    Size = UDim2.new(0, 3, 1, -10), Position = UDim2.fromOffset(0, 5),
    BackgroundColor3 = Theme.accent, BorderSizePixel = 0,
}, wm)
corner(wmBar, 4)
bindColor(wmBar, "BackgroundColor3", "accent")
local wmLabel = new("TextLabel", {
    Size = UDim2.new(1, -14, 1, 0), Position = UDim2.fromOffset(10, 0),
    BackgroundTransparency = 1, Font = Enum.Font.GothamBold, TextSize = 10,
    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text, Text = "okaz v18",
}, wm)

local frames = 0
task.spawn(function()
    while not Okaz.Unloaded do
        task.wait(1)
        local ping = 0
        pcall(function() ping = math.floor(Stats.Network.ServerStatsItem["Data Ping"]:GetValue()) end)
        wmLabel.Text = ("okaz v18  ￂﾷ  %d fps  ￂﾷ  %d ms"):format(frames, ping)
        frames = 0
    end
end)
conn(RunService.RenderStepped, function() frames += 1 end)

--=====================================================================
-- NOTIFICATIONS
--=====================================================================
local notifHolder = new("Frame", {
    AnchorPoint = Vector2.new(1, 1), Position = UDim2.new(1, -18, 1, -18),
    Size = UDim2.fromOffset(284, 400), BackgroundTransparency = 1,
}, gui)
new("UIListLayout", {
    SortOrder = Enum.SortOrder.LayoutOrder,
    VerticalAlignment = Enum.VerticalAlignment.Bottom, Padding = UDim.new(0, 8),
}, notifHolder)

local function notify(title, body, dur)
    dur = dur or 3
    local card = new("Frame", {
        Size = UDim2.new(1, 0, 0, 58), BackgroundColor3 = C.panel2,
        BackgroundTransparency = 1, Position = UDim2.fromOffset(60, 0),
    }, notifHolder)
    corner(card, 11)
    local cs = stroke(card, Theme.accent, 1, 0.5)
    table.insert(retinters, function() if cs.Parent then cs.Color = Theme.accent end end)
    local b2 = new("Frame", {
        Size = UDim2.new(0, 3, 1, -14), Position = UDim2.fromOffset(0, 7),
        BackgroundColor3 = Theme.accent, BorderSizePixel = 0,
    }, card)
    corner(b2, 4)
    bindColor(b2, "BackgroundColor3", "accent")
    new("TextLabel", {
        Size = UDim2.new(1, -22, 0, 18), Position = UDim2.fromOffset(14, 9),
        BackgroundTransparency = 1, Font = Enum.Font.GothamBold, TextSize = 12,
        TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text, Text = title,
    }, card)
    new("TextLabel", {
        Size = UDim2.new(1, -22, 0, 22), Position = UDim2.fromOffset(14, 27),
        BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 11,
        TextXAlignment = Enum.TextXAlignment.Left, TextWrapped = true,
        TextColor3 = C.dim, Text = body,
    }, card)
    local tl = new("Frame", {
        Size = UDim2.new(1, 0, 0, 2), Position = UDim2.new(0, 0, 1, -2),
        BackgroundColor3 = Theme.accent, BorderSizePixel = 0,
    }, card)
    bindColor(tl, "BackgroundColor3", "accent")
    tween(tl, dur, { Size = UDim2.new(0, 0, 0, 2) }, Enum.EasingStyle.Linear)
    tween(card, 0.35, { BackgroundTransparency = 0, Position = UDim2.fromOffset(0, 0) }, Enum.EasingStyle.Back)
    task.delay(dur, function()
        if card.Parent then
            tween(card, 0.25, { BackgroundTransparency = 1, Position = UDim2.fromOffset(60, 0) })
            task.delay(0.3, function() card:Destroy() end)
        end
    end)
end

--=====================================================================
-- WINDOW
--=====================================================================
local W, H = 640, 520

local shadow = new("Frame", {
    AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.fromScale(0.5, 0.5),
    Size = UDim2.fromOffset(W + 34, H + 34), BackgroundColor3 = Color3.new(0, 0, 0),
    BackgroundTransparency = 0.55, BorderSizePixel = 0,
}, gui)
corner(shadow, 28)

local win = new("Frame", {
    AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.fromScale(0.5, 0.5),
    Size = UDim2.fromOffset(W, H), BackgroundColor3 = C.bg, BorderSizePixel = 0,
    ClipsDescendants = true,
}, gui)
corner(win, 18)
local winStroke = stroke(win, C.stroke, 1, 0.15)
new("UIGradient", {
    Color = ColorSequence.new({
        ColorSequenceKeypoint.new(0, Color3.fromRGB(21, 19, 29)),
        ColorSequenceKeypoint.new(1, Color3.fromRGB(9, 9, 13)),
    }), Rotation = 90,
}, win)

task.spawn(function()
    while not Okaz.Unloaded do
        tween(winStroke, 2.5, { Transparency = 0.75, Color = Theme.accent })
        task.wait(2.5)
        tween(winStroke, 2.5, { Transparency = 0.2, Color = C.stroke })
        task.wait(2.5)
    end
end)

local auroraHolder = new("Frame", { Size = UDim2.fromScale(1, 1), BackgroundTransparency = 1, ZIndex = 0 }, win)
local auroras = {}
for i = 1, 3 do
    local a = new("Frame", {
        Size = UDim2.fromOffset(360, 360), BackgroundColor3 = Theme.accent,
        BackgroundTransparency = 0.9, BorderSizePixel = 0, ZIndex = 0,
        Position = UDim2.fromOffset(-80 + i * 160, -140 + i * 100),
    }, auroraHolder)
    corner(a, 999)
    table.insert(auroras, a)
end
table.insert(retinters, function()
    auroras[1].BackgroundColor3 = Theme.accent
    auroras[2].BackgroundColor3 = Theme.accent2
    auroras[3].BackgroundColor3 = Theme.accent
end)
task.spawn(function()
    while not Okaz.Unloaded do
        for i, a in ipairs(auroras) do
            tween(a, 7 + i, { Position = UDim2.fromOffset(math.random(-150, 400), math.random(-150, 340)) }, Enum.EasingStyle.Sine)
        end
        task.wait(7)
    end
end)

local bar = new("Frame", {
    Size = UDim2.new(1, 0, 0, 46), BackgroundColor3 = C.panel,
    BackgroundTransparency = 0.2, BorderSizePixel = 0, ZIndex = 20,
}, win)
corner(bar, 18)
new("Frame", {
    Size = UDim2.new(1, 0, 0, 14), Position = UDim2.new(0, 0, 1, -14),
    BackgroundColor3 = C.panel, BackgroundTransparency = 0.2, BorderSizePixel = 0, ZIndex = 20,
}, bar)

local barGrad = new("UIGradient", {
    Transparency = NumberSequence.new({
        NumberSequenceKeypoint.new(0, 0.55),
        NumberSequenceKeypoint.new(1, 0.97),
    }),
}, bar)
bindGradient(barGrad)
task.spawn(function()
    while not Okaz.Unloaded do
        tween(barGrad, 6, { Rotation = barGrad.Rotation + 360 }, Enum.EasingStyle.Linear)
        task.wait(6)
    end
end)

local logo = new("TextLabel", {
    Size = UDim2.new(0, 200, 1, 0), Position = UDim2.fromOffset(18, 0),
    BackgroundTransparency = 1, Font = Enum.Font.GothamBlack, TextSize = 16,
    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text, Text = "OKAZ", ZIndex = 21,
}, bar)
bindGradient(new("UIGradient", {}, logo))
new("TextLabel", {
    Size = UDim2.new(0, 60, 1, 0), Position = UDim2.fromOffset(60, 1),
    BackgroundTransparency = 1, Font = Enum.Font.GothamBold, TextSize = 10,
    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim, Text = "V18", ZIndex = 21,
}, bar)

local function winBtn(glyph, x, col)
    local b = new("TextButton", {
        Size = UDim2.fromOffset(26, 26), Position = UDim2.new(1, x, 0.5, -13),
        BackgroundColor3 = C.panel2, BackgroundTransparency = 1,
        Font = Enum.Font.GothamBold, TextSize = 13, TextColor3 = col,
        Text = glyph, AutoButtonColor = false, ZIndex = 22,
    }, bar)
    corner(b, 7)
    stroke(b, C.stroke, 1, 0.4)
    b.MouseEnter:Connect(function()
        tween(b, 0.15, { BackgroundTransparency = 0, BackgroundColor3 = col })
        tween(b, 0.15, { TextColor3 = C.bg })
    end)
    b.MouseLeave:Connect(function()
        tween(b, 0.15, { BackgroundTransparency = 1 })
        tween(b, 0.15, { TextColor3 = col })
    end)
    return b
end

local closeBtn  = winBtn("￢ﾜﾕ", -36, C.bad)
local minBtn    = winBtn("￢ﾀﾔ", -68, Color3.fromRGB(255, 200, 80))
local orbBtn    = winBtn("￢ﾀﾢ", -100, Color3.fromRGB(120, 220, 255))
local centerBtn = winBtn("￢ﾗﾎ", -132, Color3.fromRGB(180, 180, 255))

--=====================================================================
-- DRAG
--=====================================================================
local dragging, dragStart, startPos = false, nil, nil
local dragLocked = false
bar.InputBegan:Connect(function(i)
    if i.UserInputType == Enum.UserInputType.MouseButton1 and not dragLocked then
        dragging, dragStart, startPos = true, i.Position, win.Position
    end
end)
conn(UserInputService.InputEnded, function(i)
    if i.UserInputType == Enum.UserInputType.MouseButton1 then dragging = false end
end)
conn(UserInputService.InputChanged, function(i)
    if dragging and i.UserInputType == Enum.UserInputType.MouseMovement then
        local d = i.Position - dragStart
        win.Position = UDim2.new(startPos.X.Scale, startPos.X.Offset + d.X,
            startPos.Y.Scale, startPos.Y.Offset + d.Y)
        shadow.Position = win.Position
    end
end)

--=====================================================================
-- BODY / SIDEBAR
--=====================================================================
local body = new("Frame", {
    Size = UDim2.new(1, 0, 1, -70), Position = UDim2.fromOffset(0, 46),
    BackgroundTransparency = 1, ZIndex = 5,
}, win)
pad(body, 12, 12, 12, 12)

-- pill lives in body (no layout here) so nothing overrides its position
local pill = new("Frame", {
    Size = UDim2.new(0, 146, 0, 27), BackgroundColor3 = Theme.accent,
    BackgroundTransparency = 0.82, BorderSizePixel = 0, ZIndex = 4,
}, body)
corner(pill, 8)
bindGradient(new("UIGradient", {}, pill))

local tabHolder = new("Frame", {
    Size = UDim2.new(0, 146, 1, 0), BackgroundColor3 = C.panel,
    BackgroundTransparency = 0.45, BorderSizePixel = 0, ClipsDescendants = false, ZIndex = 6,
}, body)
corner(tabHolder, 12)
pad(tabHolder, 7, 8, 7, 8)
new("UIListLayout", { Padding = UDim.new(0, 3), SortOrder = Enum.SortOrder.LayoutOrder }, tabHolder)

local content = new("Frame", {
    Size = UDim2.new(1, -158, 1, 0), Position = UDim2.new(0, 158, 0, 0),
    BackgroundTransparency = 1, ClipsDescendants = true, ZIndex = 6,
}, body)

local search = new("TextBox", {
    Size = UDim2.new(1, 0, 0, 26), BackgroundColor3 = C.panel2,
    Font = Enum.Font.Gotham, TextSize = 11, TextColor3 = C.text,
    PlaceholderText = "search tabs", PlaceholderColor3 = C.dim,
    Text = "", ClearTextOnFocus = false, ZIndex = 10, LayoutOrder = 0,
}, tabHolder)
corner(search, 8)
stroke(search, C.stroke, 1, 0.4)

local pages, tabs = {}, {}

local function makePage()
    local p = new("ScrollingFrame", {
        Size = UDim2.fromScale(1, 1), BackgroundTransparency = 1, BorderSizePixel = 0,
        ScrollBarThickness = 3, ScrollBarImageColor3 = Theme.accent,
        CanvasSize = UDim2.new(), AutomaticCanvasSize = Enum.AutomaticSize.Y,
        ScrollingDirection = Enum.ScrollingDirection.Y, Visible = false,
        Position = UDim2.fromOffset(0, 0), ZIndex = 7,
    }, content)
    pad(p, 2, 8, 10, 0)
    new("UIListLayout", { Padding = UDim.new(0, 8), SortOrder = Enum.SortOrder.LayoutOrder }, p)
    table.insert(retinters, function() p.ScrollBarImageColor3 = Theme.accent end)
    table.insert(pages, p)
    return p
end

local selectedTab

local function selectTab(t, p)
    if not t or not p or selectedTab == t then return end
    if selectedTab then
        local ol = selectedTab:FindFirstChild("lbl")
        if ol then tween(ol, 0.2, { TextColor3 = C.dim }) end
    end
    selectedTab = t
    local lbl = t:FindFirstChild("lbl")
    if lbl then tween(lbl, 0.2, { TextColor3 = C.text }) end
    tween(pill, 0.26, {
        Position = UDim2.new(0, 0, 0, t.AbsolutePosition.Y - body.AbsolutePosition.Y - 7),
    }, Enum.EasingStyle.Quint)
    for _, pg in ipairs(pages) do
        if pg == p then
            pg.Visible = true
            pg.Position = UDim2.fromOffset(22, 0)
            pg.CanvasPosition = Vector2.zero
            tween(pg, 0.32, { Position = UDim2.fromOffset(0, 0) }, Enum.EasingStyle.Quint)
        else
            pg.Visible = false
            pg.Position = UDim2.fromOffset(0, 0)
        end
    end
    click()
end

local function makeTab(icon, label, order)
    local t = new("TextButton", {
        Size = UDim2.new(1, 0, 0, 27), BackgroundColor3 = Theme.accent,
        BackgroundTransparency = 1, Text = "", AutoButtonColor = false,
        LayoutOrder = order + 1, ZIndex = 8,
    }, tabHolder)
    corner(t, 8)
    new("TextLabel", {
        Name = "lbl", Size = UDim2.new(1, -14, 1, 0), Position = UDim2.fromOffset(10, 0),
        BackgroundTransparency = 1, Font = Enum.Font.GothamMedium, TextSize = 11,
        TextColor3 = C.dim, TextXAlignment = Enum.TextXAlignment.Left,
        Text = icon .. "  " .. label, ZIndex = 9,
    }, t)
    local page = makePage()
    t.MouseEnter:Connect(function()
        if selectedTab ~= t then tween(t, 0.15, { BackgroundTransparency = 0.93 }) end
    end)
    t.MouseLeave:Connect(function()
        if selectedTab ~= t then tween(t, 0.15, { BackgroundTransparency = 1 }) end
    end)
    t.MouseButton1Click:Connect(function() selectTab(t, page) end)
    table.insert(tabs, { button = t, page = page, label = label:lower() })
    return page
end

search:GetPropertyChangedSignal("Text"):Connect(function()
    local q = search.Text:lower()
    for _, entry in ipairs(tabs) do
        entry.button.Visible = q == "" or entry.label:find(q, 1, true) ~= nil
    end
end)

--=====================================================================
-- STATUS BAR
--=====================================================================
local status = new("Frame", {
    Size = UDim2.new(1, 0, 0, 24), Position = UDim2.new(0, 0, 1, -24),
    BackgroundColor3 = C.panel, BackgroundTransparency = 0.5, BorderSizePixel = 0, ZIndex = 20,
}, win)
local dot = new("Frame", {
    Size = UDim2.fromOffset(6, 6), Position = UDim2.fromOffset(14, 9),
    BackgroundColor3 = C.good, BorderSizePixel = 0, ZIndex = 21,
}, status)
corner(dot, 99)
new("TextLabel", {
    Size = UDim2.new(0, 220, 1, 0), Position = UDim2.fromOffset(26, 0),
    BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 10,
    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim,
    Text = "connected ￂﾷ " .. LP.Name, ZIndex = 21,
}, status)
local statusRight = new("TextLabel", {
    Size = UDim2.new(0, 280, 1, 0), Position = UDim2.new(1, -294, 0, 0),
    BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 10,
    TextXAlignment = Enum.TextXAlignment.Right, TextColor3 = C.dim, Text = "", ZIndex = 21,
}, status)
task.spawn(function()
    while not Okaz.Unloaded do
        task.wait(0.5)
        local hrp = getHRP()
        local pos = hrp and ("%d, %d, %d"):format(hrp.Position.X, hrp.Position.Y, hrp.Position.Z) or "￢ﾀﾔ"
        statusRight.Text = ("%d players ￂﾷ %s"):format(#Players:GetPlayers(), pos)
    end
end)

--=====================================================================
-- ELEMENT FACTORY
--=====================================================================
local function row(page, height, label, desc)
    local r = new("Frame", {
        Size = UDim2.new(1, 0, 0, height), BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.35, BorderSizePixel = 0,
        ClipsDescendants = false, ZIndex = 8,
    }, page)
    corner(r, 10)
    stroke(r, C.stroke, 1, 0.55)
    r.MouseEnter:Connect(function() tween(r, 0.18, { BackgroundTransparency = 0.2 }) end)
    r.MouseLeave:Connect(function() tween(r, 0.18, { BackgroundTransparency = 0.35 }) end)
    if label then
        local lbl = new("TextLabel", {
            Size = UDim2.new(1, -64, 0, 15), BackgroundTransparency = 1,
            Font = Enum.Font.GothamMedium, TextSize = 12,
            TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text,
            Text = label, ZIndex = 9,
        }, r)
        if desc then
            lbl.Position = UDim2.fromOffset(11, 8)
            new("TextLabel", {
                Size = UDim2.new(1, -64, 0, 14), Position = UDim2.fromOffset(11, 24),
                BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 10,
                TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim,
                Text = desc, ZIndex = 9,
            }, r)
        else
            lbl.AnchorPoint = Vector2.new(0, 0.5)
            lbl.Position = UDim2.new(0, 11, 0.5, 0)
        end
    end
    return r
end

local function spacer(page, h)
    new("Frame", { Size = UDim2.new(1, 0, 0, h or 4), BackgroundTransparency = 1 }, page)
end

local function header(page, text)
    local f = new("Frame", { Size = UDim2.new(1, 0, 0, 18), BackgroundTransparency = 1 }, page)
    local acc = new("Frame", {
        Size = UDim2.fromOffset(3, 10), Position = UDim2.fromOffset(0, 4),
        BackgroundColor3 = Theme.accent, BorderSizePixel = 0,
    }, f)
    corner(acc, 2)
    bindColor(acc, "BackgroundColor3", "accent")
    new("TextLabel", {
        Size = UDim2.new(1, -12, 1, 0), Position = UDim2.fromOffset(9, 0),
        BackgroundTransparency = 1, Font = Enum.Font.GothamBlack, TextSize = 10,
        TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim,
        Text = string.upper(text),
    }, f)
    return f
end

local function toggle(page, label, desc, default, cb)
    local r = row(page, desc and 46 or 36, label, desc)
    local state = default or false
    local sw = new("Frame", {
        AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, -11, 0.5, 0),
        Size = UDim2.fromOffset(36, 19),
        BackgroundColor3 = state and Theme.accent or C.off,
        BorderSizePixel = 0, ZIndex = 10,
    }, r)
    corner(sw, 99)
    local sws = stroke(sw, Theme.accent, 1, state and 0.3 or 0.75)
    local knob = new("Frame", {
        AnchorPoint = Vector2.new(0, 0.5),
        Position = state and UDim2.new(1, -17, 0.5, 0) or UDim2.new(0, 2, 0.5, 0),
        Size = UDim2.fromOffset(15, 15), BackgroundColor3 = Color3.fromRGB(235, 235, 245),
        BorderSizePixel = 0, ZIndex = 11,
    }, sw)
    corner(knob, 99)
    local btn = new("TextButton", { Size = UDim2.fromScale(1, 1), BackgroundTransparency = 1, Text = "", ZIndex = 12 }, sw)
    table.insert(retinters, function()
        sw.BackgroundColor3 = state and Theme.accent or C.off
        sws.Color = Theme.accent
    end)
    local function set(v, silent)
        state = v
        tween(sw, 0.25, { BackgroundColor3 = v and Theme.accent or C.off }, Enum.EasingStyle.Back)
        tween(sws, 0.25, { Transparency = v and 0.3 or 0.75 })
        tween(knob, 0.25, { Position = v and UDim2.new(1, -17, 0.5, 0) or UDim2.new(0, 2, 0.5, 0) }, Enum.EasingStyle.Back)
        if not silent then click() end
        if not silent and cb then task.spawn(cb, v) end
    end
    btn.MouseButton1Click:Connect(function() set(not state) end)
    return { Set = set, Get = function() return state end }
end

local function slider(page, label, min, max, default, decimals, cb)
    local r = row(page, 48, label, nil)
    local val = default or min
    local valLabel = new("TextLabel", {
        Size = UDim2.new(0, 64, 0, 15), Position = UDim2.new(1, -75, 0, 8),
        BackgroundTransparency = 1, Font = Enum.Font.GothamBold, TextSize = 11,
        TextXAlignment = Enum.TextXAlignment.Right, TextColor3 = Theme.accent,
        Text = tostring(val), ZIndex = 9,
    }, r)
    bindColor(valLabel, "TextColor3", "accent")
    local track = new("Frame", {
        AnchorPoint = Vector2.new(0, 1), Position = UDim2.new(0, 11, 1, -10),
        Size = UDim2.new(1, -22, 0, 4), BackgroundColor3 = Color3.fromRGB(43, 43, 55),
        BorderSizePixel = 0, ZIndex = 9,
    }, r)
    corner(track, 99)
    local fill = new("Frame", {
        Size = UDim2.fromScale((val - min) / (max - min), 1),
        BackgroundColor3 = Theme.accent, BorderSizePixel = 0, ZIndex = 10,
    }, track)
    corner(fill, 99)
    bindGradient(new("UIGradient", {}, fill))
    local dotF = new("Frame", {
        AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(fill.Size.X.Scale, 0, 0.5, 0),
        Size = UDim2.fromOffset(11, 11), BackgroundColor3 = C.text,
        BorderSizePixel = 0, ZIndex = 11,
    }, track)
    corner(dotF, 99)
    local dotS = stroke(dotF, Theme.accent, 2)
    table.insert(retinters, function() dotS.Color = Theme.accent end)
    local hit = new("TextButton", {
        Size = UDim2.new(1, 0, 2, 0), Position = UDim2.new(0, 0, -0.5, 0),
        BackgroundTransparency = 1, Text = "", ZIndex = 12,
    }, track)
    local function apply(x)
        local rel = math.clamp((x - track.AbsolutePosition.X) / math.max(track.AbsoluteSize.X, 1), 0, 1)
        val = tonumber(string.format("%." .. (decimals or 0) .. "f", min + (max - min) * rel))
        fill.Size = UDim2.fromScale(rel, 1)
        dotF.Position = UDim2.new(rel, 0, 0.5, 0)
        valLabel.Text = tostring(val)
        if cb then task.spawn(cb, val) end
    end
    local drag = false
    hit.MouseButton1Down:Connect(function() drag = true; apply(Mouse.X) end)
    conn(UserInputService.InputChanged, function(i)
        if drag and i.UserInputType == Enum.UserInputType.MouseMovement then apply(i.Position.X) end
    end)
    conn(UserInputService.InputEnded, function(i)
        if i.UserInputType == Enum.UserInputType.MouseButton1 then drag = false end
    end)
    return { Set = function(v)
        apply(track.AbsolutePosition.X + (math.clamp(v, min, max) - min) / (max - min) * track.AbsoluteSize.X)
    end, Get = function() return val end }
end

local function button(page, label, cb)
    local b = new("TextButton", {
        Size = UDim2.new(1, 0, 0, 34), BackgroundColor3 = C.panel2,
        Font = Enum.Font.GothamBold, TextSize = 12, TextColor3 = C.text,
        Text = label, AutoButtonColor = false, ZIndex = 8,
    }, page)
    corner(b, 10)
    stroke(b, C.stroke, 1, 0.5)
    b.MouseButton1Down:Connect(function()
        local rip = new("Frame", {
            AnchorPoint = Vector2.new(0.5, 0.5),
            Position = UDim2.fromOffset(Mouse.X - b.AbsolutePosition.X, Mouse.Y - b.AbsolutePosition.Y),
            Size = UDim2.fromOffset(10, 10), BackgroundColor3 = Theme.accent,
            BackgroundTransparency = 0.4, ZIndex = 9,
        }, b)
        corner(rip, 99)
        tween(rip, 0.5, { Size = UDim2.fromOffset(b.AbsoluteSize.X * 1.6, b.AbsoluteSize.X * 1.6), BackgroundTransparency = 1 })
        task.delay(0.5, function() rip:Destroy() end)
        click()
    end)
    b.MouseEnter:Connect(function() tween(b, 0.15, { BackgroundColor3 = Theme.accent, TextColor3 = C.bg }) end)
    b.MouseLeave:Connect(function() tween(b, 0.15, { BackgroundColor3 = C.panel2, TextColor3 = C.text }) end)
    b.MouseButton1Click:Connect(function() if cb then task.spawn(cb) end end)
    return b
end

local function textbox(page, label, placeholder, default, cb)
    local r = row(page, 38, label, nil)
    local box = new("TextBox", {
        AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, -11, 0.5, 0),
        Size = UDim2.fromOffset(196, 24), BackgroundColor3 = C.panel2,
        Font = Enum.Font.Gotham, TextSize = 11, TextColor3 = C.text,
        PlaceholderText = placeholder, PlaceholderColor3 = C.dim,
        Text = default or "", ClearTextOnFocus = false, ZIndex = 13,
    }, r)
    corner(box, 6)
    stroke(box, C.stroke, 1, 0.4)
    box.Focused:Connect(function() tween(box, 0.15, { BackgroundColor3 = C.panel }) end)
    box.FocusLost:Connect(function()
        tween(box, 0.15, { BackgroundColor3 = C.panel2 })
        if cb then task.spawn(cb, box.Text) end
    end)
    return box
end

local function dropdown(page, label, options, cb)
    local r = row(page, 38, label, nil)
    local current = options[1]
    local open = false
    local sel = new("TextButton", {
        AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, -11, 0.5, 0),
        Size = UDim2.fromOffset(154, 24), BackgroundColor3 = C.panel2,
        Font = Enum.Font.Gotham, TextSize = 11, TextColor3 = C.text,
        Text = current, AutoButtonColor = false, ZIndex = 13,
    }, r)
    corner(sel, 6)
    stroke(sel, C.stroke, 1, 0.4)
    local list = new("Frame", {
        Position = UDim2.new(1, -165, 1, 5), Size = UDim2.fromOffset(154, 0),
        BackgroundColor3 = C.panel2, BorderSizePixel = 0,
        ClipsDescendants = true, Visible = false, ZIndex = 40,
    }, r)
    corner(list, 6)
    local ls = stroke(list, Theme.accent, 1, 0.3)
    table.insert(retinters, function() ls.Color = Theme.accent end)
    new("UIListLayout", { Padding = UDim.new(0, 2), SortOrder = Enum.SortOrder.LayoutOrder }, list)
    pad(list, 4, 4, 4, 4)

    local function refresh()
        for _, ch in ipairs(list:GetChildren()) do
            if ch:IsA("TextButton") then ch:Destroy() end
        end
        for i, opt in ipairs(options) do
            local o = new("TextButton", {
                Size = UDim2.new(1, 0, 0, 22), BackgroundColor3 = Theme.accent,
                BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 11,
                TextColor3 = C.dim, Text = opt, AutoButtonColor = false,
                LayoutOrder = i, ZIndex = 41,
            }, list)
            corner(o, 5)
            bindColor(o, "BackgroundColor3", "accent")
            o.MouseEnter:Connect(function() tween(o, 0.12, { BackgroundTransparency = 0.8, TextColor3 = C.text }) end)
            o.MouseLeave:Connect(function() tween(o, 0.12, { BackgroundTransparency = 1, TextColor3 = C.dim }) end)
            o.MouseButton1Click:Connect(function()
                current = opt
                sel.Text = opt
                open = false
                tween(list, 0.2, { Size = UDim2.fromOffset(154, 0) })
                task.delay(0.2, function() list.Visible = false end)
                click()
                if cb then task.spawn(cb, opt) end
            end)
        end
    end
    refresh()

    sel.MouseButton1Click:Connect(function()
        open = not open
        if open then
            list.Visible = true
            tween(list, 0.25, { Size = UDim2.fromOffset(154, math.min(#options * 24 + 8, 160)) }, Enum.EasingStyle.Back)
        else
            tween(list, 0.2, { Size = UDim2.fromOffset(154, 0) })
            task.delay(0.2, function() list.Visible = false end)
        end
    end)

    return { SetOptions = function(o)
        options = o
        if not table.find(o, current) then current = o[1] or ""; sel.Text = current end
        refresh()
    end, Get = function() return current end, Set = function(v) current = v; sel.Text = v end }
end

--=====================================================================
-- CONFIG
--=====================================================================
local cfg = {
    speed = 16, jump = 50, lockSpeed = true, lockJump = true,
    aimEnabled = false, fov = 140, smooth = 4, teamCheck = true,
    wallCheck = false, prediction = 0.15, deadzone = 0.4, sticky = true,
    targetPart = "HumanoidRootPart", aimMode = mousemoverel and "Mouse" or "Camera",
    aimInput = Enum.KeyCode.E, aimIsMouse = false, targetHud = true,
    flyMode = "CFrame", flySpeed = 55,
    espEnabled = false, espName = true, espHealth = true, espDistance = false,
    tracers = false, tracerThickness = 1, distHud = false,
    flingPower = 1200,
    copyAnim = true, copyChat = true, copyTools = true, copyJump = true,
    copyFollow = true, copySpeed = true,
    hitboxSize = 8, hitboxSelf = true, hitboxOthers = false,
    autoRecover = true, menuKey = Enum.KeyCode.K, crosshair = true,
    chSize = 16, chGap = 0, fovShape = "Circle",
    opacity = 0, scale = 1, cmdPrefix = ";", autoRejoin = false,
    spamMsg = "okaz on top", spamRate = 2,
}

local recover, stopFly, stopCopy, setOpen, panic, playIndex, musicPlayPause, flingChar

local function build(name, fn)
    local ok, err = pcall(fn)
    if not ok then
        table.insert(Okaz.Errors, name .. " ￢ﾀﾔ " .. tostring(err))
    end
end

--=====================================================================
-- TAB: HOME
--=====================================================================
local homePage = makeTab("￢ﾌﾂ", "Home", 1)
build("Home", function()
    header(homePage, "Dashboard")
    local hero = new("Frame", {
        Size = UDim2.new(1, 0, 0, 78), BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.25, BorderSizePixel = 0, ZIndex = 8,
    }, homePage)
    corner(hero, 12)
    bindGradient(new("UIGradient", { Rotation = 25 }, hero))
    new("TextLabel", {
        Size = UDim2.new(1, -24, 0, 22), Position = UDim2.fromOffset(14, 14),
        BackgroundTransparency = 1, Font = Enum.Font.GothamBlack, TextSize = 17,
        TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text,
        Text = "welcome back, " .. LP.Name, ZIndex = 9,
    }, hero)
    new("TextLabel", {
        Size = UDim2.new(1, -24, 0, 16), Position = UDim2.fromOffset(14, 38),
        BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 11,
        TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim,
        Text = "v18 ￂﾷ ;cmds for commands", ZIndex = 9,
    }, hero)

    local statRow = new("Frame", { Size = UDim2.new(1, 0, 0, 56), BackgroundTransparency = 1, ZIndex = 8 }, homePage)
    new("UIListLayout", { FillDirection = Enum.FillDirection.Horizontal, Padding = UDim.new(0, 6) }, statRow)
    local statLabels = {}
    for i, name in ipairs({ "FPS", "PING", "PLAYERS" }) do
        local card = new("Frame", {
            Size = UDim2.new(1 / 3, -4, 1, 0), BackgroundColor3 = C.panel,
            BackgroundTransparency = 0.35, BorderSizePixel = 0, LayoutOrder = i, ZIndex = 8,
        }, statRow)
        corner(card, 10)
        stroke(card, C.stroke, 1, 0.55)
        local val = new("TextLabel", {
            Size = UDim2.new(1, 0, 0, 26), Position = UDim2.fromOffset(0, 8),
            BackgroundTransparency = 1, Font = Enum.Font.GothamBlack, TextSize = 20,
            TextColor3 = Theme.accent, Text = "￢ﾀﾔ", ZIndex = 9,
        }, card)
        bindColor(val, "TextColor3", "accent")
        new("TextLabel", {
            Size = UDim2.new(1, 0, 0, 14), Position = UDim2.fromOffset(0, 34),
            BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 9,
            TextColor3 = C.dim, Text = name,
        }, card)
        statLabels[name] = val
    end
    task.spawn(function()
        while not Okaz.Unloaded do
            task.wait(1)
            statLabels.FPS.Text = tostring(frames)
            local p = 0
            pcall(function() p = math.floor(Stats.Network.ServerStatsItem["Data Ping"]:GetValue()) end)
            statLabels.PING.Text = tostring(p)
            statLabels.PLAYERS.Text = tostring(#Players:GetPlayers())
        end
    end)

    spacer(homePage, 2)
    header(homePage, "Server Info")
    local infoCard = new("Frame", {
        Size = UDim2.new(1, 0, 0, 92), BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.35, BorderSizePixel = 0, ZIndex = 8,
    }, homePage)
    corner(infoCard, 10)
    stroke(infoCard, C.stroke, 1, 0.55)
    local infoText = new("TextLabel", {
        Size = UDim2.new(1, -22, 1, -16), Position = UDim2.fromOffset(11, 8),
        BackgroundTransparency = 1, Font = Enum.Font.Code, TextSize = 10,
        TextXAlignment = Enum.TextXAlignment.Left, TextYAlignment = Enum.TextYAlignment.Top,
        TextColor3 = C.dim, Text = "", ZIndex = 9,
    }, infoCard)
    task.spawn(function()
        while not Okaz.Unloaded do
            infoText.Text = ("place   %d\ndata    %s\njob     %s\nmax     %d players"):format(
                game.PlaceId,
                tostring(game.PlaceVersion),
                (game.JobId ~= "" and game.JobId:sub(1, 22) .. "￢ﾀﾦ") or "private",
                Players.MaxPlayers
            )
            task.wait(2)
        end
    end)

    spacer(homePage, 2)
    header(homePage, "Quick Actions")
    button(homePage, "Fix Stuck", function() recover(5); notify("Recovery", "Position reset", 2) end)
    button(homePage, "Rejoin Server", function()
        notify("Server", "Rejoining...", 2); task.wait(0.5)
        TeleportService:Teleport(game.PlaceId, LP)
    end)
    button(homePage, "Panic ￢ﾀﾔ disable everything", function() panic() end)
end)

--=====================================================================
-- TAB: COMBAT
--=====================================================================
local combatPage = makeTab("￢ﾚﾔ", "Combat", 2)
build("Combat", function()
    header(combatPage, "Aimbot")
    toggle(combatPage, "Aimbot", "Hold the aim key to lock on", false, function(v)
        cfg.aimEnabled = v
        fovCircle.Visible = v
        notify("Aimbot", v and "Enabled" or "Disabled", 2)
    end)
    local keyMap = {
        ["E"] = Enum.KeyCode.E, ["Q"] = Enum.KeyCode.Q, ["F"] = Enum.KeyCode.F,
        ["C"] = Enum.KeyCode.C, ["Left Alt"] = Enum.KeyCode.LeftAlt,
        ["Left Shift"] = Enum.KeyCode.LeftShift, ["Right Mouse"] = Enum.UserInputType.MouseButton2,
    }
    _G.okazKeyMap = keyMap
    dropdown(combatPage, "Aim Key", { "E", "Q", "F", "C", "Left Alt", "Left Shift", "Right Mouse" }, function(v)
        local m = keyMap[v]
        cfg.aimIsMouse = typeof(m) == "EnumItem" and m.EnumType == Enum.UserInputType
        cfg.aimInput = m
    end)
    dropdown(combatPage, "Aim Method", { "Mouse", "Camera" }, function(v)
        if v == "Mouse" and not mousemoverel then
            notify("Aimbot", "No mousemoverel ￢ﾀﾔ using Camera", 3)
            cfg.aimMode = "Camera"
            return
        end
        cfg.aimMode = v
    end)
    dropdown(combatPage, "FOV Shape", { "Circle", "Square" }, function(v)
        cfg.fovShape = v
        fovCorner.CornerRadius = UDim.new(0, v == "Circle" and 999 or 6)
    end)
    slider(combatPage, "FOV", 20, 600, 140, 0, function(v)
        cfg.fov = v
        fovCircle.Size = UDim2.fromOffset(v * 2, v * 2)
    end)
    slider(combatPage, "Smoothing", 1, 20, 4, 0, function(v) cfg.smooth = v end)
    slider(combatPage, "Prediction", 0, 1, 0.15, 2, function(v) cfg.prediction = v end)
    slider(combatPage, "Deadzone", 0, 4, 0.4, 2, function(v) cfg.deadzone = v end)
    toggle(combatPage, "Sticky Target", "Don't swap mid-fight", true, function(v) cfg.sticky = v end)
    toggle(combatPage, "Target HUD", "Show current target", true, function(v) cfg.targetHud = v end)
    toggle(combatPage, "Team Check", "Skip teammates", true, function(v) cfg.teamCheck = v end)
    toggle(combatPage, "Wall Check", "Only visible targets", false, function(v) cfg.wallCheck = v end)
    dropdown(combatPage, "Aim Part", { "HumanoidRootPart", "Head", "UpperTorso", "LowerTorso" }, function(v)
        cfg.targetPart = v
    end)

    spacer(combatPage, 2)
    header(combatPage, "Extras")
    toggle(combatPage, "Auto Clicker", "Spams clicks for you", false, function(v)
        cfg.autoclick = v
        if v then
            task.spawn(function()
                while cfg.autoclick do
                    VirtualUser:CaptureController()
                    VirtualUser:ClickButton1(Vector2.new(0, 0), Camera.CFrame)
                    task.wait(0.02)
                end
            end)
        end
    end)
    toggle(combatPage, "Spin", "Rotate your character", false, function(v)
        local hrp = getHRP()
        if not hrp then return end
        local bav = hrp:FindFirstChild("okazSpin")
        if v and not bav then
            new("BodyAngularVelocity", {
                Name = "okazSpin", AngularVelocity = Vector3.new(0, cfg.spinSpeed or 12, 0),
                MaxTorque = Vector3.new(math.huge, math.huge, math.huge),
            }, hrp)
        elseif not v and bav then bav:Destroy() end
    end)
    slider(combatPage, "Spin Speed", 1, 60, 12, 0, function(v)
        cfg.spinSpeed = v
        local hrp = getHRP()
        local bav = hrp and hrp:FindFirstChild("okazSpin")
        if bav then bav.AngularVelocity = Vector3.new(0, v, 0) end
    end)
    toggle(combatPage, "Crosshair", "Center overlay", true, function(v)
        cfg.crosshair = v
        cross.Visible = v
    end)
    cross.Visible = true
    slider(combatPage, "Crosshair Size", 4, 40, 16, 0, function(v)
        cfg.chSize = v
        cross.Size = UDim2.fromOffset(v, v)
    end)
    slider(combatPage, "Crosshair Gap", 0, 12, 0, 0, function(v) cfg.chGap = v end)
end)

--=====================================================================
-- TAB: PLAYER
--=====================================================================
local playerPage = makeTab("￢ﾚﾡ", "Player", 3)
local flyToggle
local infJump, autoJump, frozen, noclip = false, false, false, false
local antiVoid, antiFling, lastSafe = false, false, nil
local flying, flyConn, flyAnchored, recovering = false, nil, false, false

local function setCollisions(on)
    if not LP.Character then return end
    for _, p in ipairs(LP.Character:GetDescendants()) do
        if p:IsA("BasePart") then p.CanCollide = p.Name ~= "HumanoidRootPart" and on end
    end
end

stopFly = function()
    flying = false
    local hrp, hum = getHRP(), getHum()
    if hrp then
        for _, n in ipairs({ "okazFlyV", "okazFlyG" }) do
            local o = hrp:FindFirstChild(n); if o then o:Destroy() end
        end
        if flyAnchored then hrp.Anchored = false end
    end
    if hum then
        hum.PlatformStand = false
        pcall(function() hum:ChangeState(Enum.HumanoidStateType.GettingUp) end)
    end
    flyAnchored = false
    if flyConn then flyConn:Disconnect(); flyConn = nil end
end

recover = function(lift)
    if recovering then return end
    recovering = true
    local hrp, hum = getHRP(), getHum()
    if flying then stopFly() end
    if hrp then
        for _, n in ipairs({ "okazFlyV", "okazFlyG", "okazSpin" }) do
            local o = hrp:FindFirstChild(n); if o then o:Destroy() end
        end
        hrp.Anchored = false
        hrp.AssemblyLinearVelocity = Vector3.zero
        hrp.AssemblyAngularVelocity = Vector3.zero
        if lift then hrp.CFrame = hrp.CFrame + Vector3.new(0, lift, 0) end
    end
    if hum then
        hum.PlatformStand = false
        hum.AutoRotate = true
        pcall(function() hum:ChangeState(Enum.HumanoidStateType.GettingUp) end)
    end
    task.wait(0.12)
    if hum then pcall(function() hum:ChangeState(Enum.HumanoidStateType.Running) end) end
    recovering = false
end

build("Player", function()
    header(playerPage, "Movement")
    button(playerPage, "Fix Stuck / Unstuck", function() recover(5); notify("Recovery", "Position reset", 2) end)
    slider(playerPage, "WalkSpeed", 16, 500, 16, 0, function(v)
        cfg.speed = v
        local h = getHum(); if h then h.WalkSpeed = v end
    end)
    toggle(playerPage, "Lock Speed", "Fights games that reset it", true, function(v) cfg.lockSpeed = v end)
    slider(playerPage, "JumpPower", 50, 500, 50, 0, function(v)
        cfg.jump = v
        local h = getHum(); if h then h.UseJumpPower = true; h.JumpPower = v end
    end)
    toggle(playerPage, "Lock Jump", "Fights games that reset it", true, function(v) cfg.lockJump = v end)

    conn(RunService.Stepped, function()
        local h = getHum()
        if not h then return end
        if cfg.lockSpeed and h.WalkSpeed ~= cfg.speed then h.WalkSpeed = cfg.speed end
        if cfg.lockJump then
            if not h.UseJumpPower then h.UseJumpPower = true end
            if h.JumpPower ~= cfg.jump then h.JumpPower = cfg.jump end
        end
    end)

    toggle(playerPage, "Infinite Jump", "Jump forever", false, function(v) infJump = v end)
    conn(UserInputService.JumpRequest, function()
        if infJump then
            local h = getHum(); if h then h:ChangeState(Enum.HumanoidStateType.Jumping) end
        end
    end)
    toggle(playerPage, "Auto Jump", "Bunny hop constantly", false, function(v) autoJump = v end)
    conn(RunService.Stepped, function()
        if not autoJump then return end
        local h = getHum()
        if h and h.FloorMaterial ~= Enum.Material.Air then h:ChangeState(Enum.HumanoidStateType.Jumping) end
    end)
    toggle(playerPage, "Freeze Self", "Anchor in place", false, function(v)
        frozen = v
        local hrp = getHRP(); if hrp then hrp.Anchored = v end
    end)
    toggle(playerPage, "Noclip", "Walk through everything", false, function(v)
        noclip = v
        if not v then setCollisions(true); recover(4) end
    end)
    conn(RunService.Stepped, function()
        if not noclip or not LP.Character then return end
        for _, p in ipairs(LP.Character:GetDescendants()) do
            if p:IsA("BasePart") and p.CanCollide then p.CanCollide = false end
        end
    end)

    spacer(playerPage, 2)
    header(playerPage, "Fly")
    dropdown(playerPage, "Fly Mode", { "CFrame", "Velocity", "Humanoid" }, function(v)
        cfg.flyMode = v
        if flying then notify("Fly", "Mode: " .. v .. " ￢ﾀﾔ re-toggle fly", 2) end
    end)
    flyToggle = toggle(playerPage, "Fly", "WASD + Space / Ctrl", false, function(v)
        flying = v
        if not v then stopFly(); recover(2); return end
        local hrp, hum = getHRP(), getHum()
        if not hrp or not hum then flying = false; return end
        local function dirFromInput()
            local d = Vector3.zero
            if UserInputService:IsKeyDown(Enum.KeyCode.W) then d += Camera.CFrame.LookVector end
            if UserInputService:IsKeyDown(Enum.KeyCode.S) then d -= Camera.CFrame.LookVector end
            if UserInputService:IsKeyDown(Enum.KeyCode.A) then d -= Camera.CFrame.RightVector end
            if UserInputService:IsKeyDown(Enum.KeyCode.D) then d += Camera.CFrame.RightVector end
            if UserInputService:IsKeyDown(Enum.KeyCode.Space) then d += Vector3.yAxis end
            if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then d -= Vector3.yAxis end
            return d
        end
        if cfg.flyMode == "CFrame" then
            hum.PlatformStand = true
            hrp.Anchored = true
            flyAnchored = true
            flyConn = RunService.RenderStepped:Connect(function(dt)
                if not flying or not hrp.Parent then return end
                local d = dirFromInput()
                if d.Magnitude > 0 then hrp.CFrame += d.Unit * cfg.flySpeed * dt end
            end)
        elseif cfg.flyMode == "Velocity" then
            hum.PlatformStand = true
            new("BodyVelocity", { Name = "okazFlyV", Velocity = Vector3.zero,
                MaxForce = Vector3.new(1e5, 1e5, 1e5), P = 1250 }, hrp)
            new("BodyGyro", { Name = "okazFlyG", CFrame = hrp.CFrame,
                MaxTorque = Vector3.new(1e5, 1e5, 1e5), P = 1250 }, hrp)
            flyConn = RunService.RenderStepped:Connect(function()
                local bv = hrp:FindFirstChild("okazFlyV")
                if not flying or not bv then return end
                local d = dirFromInput()
                bv.Velocity = d.Magnitude > 0 and d.Unit * cfg.flySpeed or Vector3.zero
            end)
        else
            hum.PlatformStand = false
            flyConn = RunService.Stepped:Connect(function()
                if not flying or not hrp.Parent then return end
                local d = dirFromInput()
                local horiz = Vector3.new(d.X, 0, d.Z)
                hum:Move(horiz.Magnitude > 0 and horiz.Unit or Vector3.zero, false)
                local vert = 0
                if UserInputService:IsKeyDown(Enum.KeyCode.Space) then vert += cfg.flySpeed end
                if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then vert -= cfg.flySpeed end
                hrp.AssemblyLinearVelocity = Vector3.new(hrp.AssemblyLinearVelocity.X, vert, hrp.AssemblyLinearVelocity.Z)
            end)
        end
    end)
    slider(playerPage, "Fly Speed", 10, 400, 55, 0, function(v) cfg.flySpeed = v end)

    local anchoredSince, physicsSince, lastRecover = 0, 0, 0
    conn(RunService.Heartbeat, function()
        if not cfg.autoRecover or recovering then return end
        local hrp, hum = getHRP(), getHum()
        if not hrp or not hum then return end
        local now = os.clock()
        if now - lastRecover < 1 then return end
        if hrp.Anchored and not flying and not frozen then
            anchoredSince = anchoredSince == 0 and now or anchoredSince
            if now - anchoredSince > 0.5 then lastRecover = now; anchoredSince = 0; recover(4); return end
        else anchoredSince = 0 end
        if hum:GetState() == Enum.HumanoidStateType.Physics and not flying then
            physicsSince = physicsSince == 0 and now or physicsSince
            if now - physicsSince > 1.8 then lastRecover = now; physicsSince = 0; recover(4); return end
        else physicsSince = 0 end
        if hum.FloorMaterial ~= Enum.Material.Air and not flying and not noclip then
            if hrp.AssemblyLinearVelocity.Magnitude < 5 then
                local hit = groundBelow(4)
                if hit and (hrp.Position.Y - hit.Position.Y) < 0.7 then
                    lastRecover = now; recover(3)
                end
            end
        end
    end)
    toggle(playerPage, "Auto Fix Stuck", "Detect and escape geometry", true, function(v) cfg.autoRecover = v end)

    spacer(playerPage, 2)
    header(playerPage, "Safety")
    toggle(playerPage, "Anti Void", "Teleport back from falling", false, function(v) antiVoid = v; lastSafe = nil end)
    conn(RunService.Heartbeat, function()
        if not antiVoid or flying or noclip then return end
        local hrp, h = getHRP(), getHum()
        if not hrp or not h then return end
        if h.FloorMaterial ~= Enum.Material.Air then
            lastSafe = hrp.CFrame
        elseif hrp.Position.Y < (Workspace.FallenPartsDestroyHeight + 60) and lastSafe then
            hrp.CFrame = lastSafe + Vector3.new(0, 3, 0)
            hrp.AssemblyLinearVelocity = Vector3.zero
            lastSafe = nil
        end
    end)
    toggle(playerPage, "Anti Fling", "Cancel insane spin on you", false, function(v) antiFling = v end)
    conn(RunService.Stepped, function()
        if not antiFling then return end
        local hrp = getHRP()
        if hrp and hrp.AssemblyAngularVelocity.Magnitude > 40 then hrp.AssemblyAngularVelocity = Vector3.zero end
    end)

    spacer(playerPage, 2)
    header(playerPage, "Hitbox")
    slider(playerPage, "Size", 2, 30, 8, 0, function(v) cfg.hitboxSize = v end)
    toggle(playerPage, "Expand Self", nil, true, function(v) cfg.hitboxSelf = v end)
    toggle(playerPage, "Expand Others", nil, false, function(v) cfg.hitboxOthers = v end)
    task.spawn(function()
        while not Okaz.Unloaded do
            local size = cfg.hitboxSize
            local function apply(ch, want)
                local hrp = ch and ch:FindFirstChild("HumanoidRootPart")
                if not hrp then return end
                local orig = hrp:GetAttribute("okazHB")
                if want and size > 2 then
                    if not orig then hrp:SetAttribute("okazHB", hrp.Size); orig = hrp.Size end
                    hrp.Size = Vector3.new(size, size, size)
                    hrp.Transparency = 0.7
                elseif orig then
                    hrp.Size = orig; hrp.Transparency = 1
                    hrp:SetAttribute("okazHB", nil)
                end
            end
            if LP.Character then apply(LP.Character, cfg.hitboxSelf) end
            for _, p in ipairs(Players:GetPlayers()) do
                if p ~= LP and p.Character then apply(p.Character, cfg.hitboxOthers) end
            end
            task.wait(0.4)
        end
    end)

    spacer(playerPage, 2)
    header(playerPage, "Other")
    toggle(playerPage, "Anti AFK", "Never kicked for idling", false, function(v)
        cfg.antiafk = v
        if v then
            conn(LP.Idled, function()
                if cfg.antiafk then
                    VirtualUser:CaptureController()
                    VirtualUser:ClickButton2(Vector2.new())
                end
            end)
        end
    end)
    toggle(playerPage, "Fullbright", "Kill the darkness", false, function(v)
        if v then
            Lighting.Brightness = 3; Lighting.ClockTime = 14
            Lighting.FogEnd = 1e6; Lighting.GlobalShadows = false
        else
            Lighting.Brightness = 1; Lighting.GlobalShadows = true
        end
    end)
    button(playerPage, "Reset Character", function()
        local h = getHum(); if h then h.Health = 0 end
    end)
end)

--=====================================================================
-- TAB: PLAYERS
--=====================================================================
local listPage = makeTab("￢ﾘﾰ", "Players", 4)
local copyDrop
build("Players", function()
    header(listPage, "Online")
    local listHolder = new("Frame", {
        Size = UDim2.new(1, 0, 0, 0), BackgroundTransparency = 1,
        AutomaticSize = Enum.AutomaticSize.Y, ZIndex = 8,
    }, listPage)
    new("UIListLayout", { Padding = UDim.new(0, 5), SortOrder = Enum.SortOrder.LayoutOrder }, listHolder)

    local function rebuildList()
        for _, ch in ipairs(listHolder:GetChildren()) do
            if ch:IsA("Frame") then ch:Destroy() end
        end
        local n = 0
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LP then
                n += 1
                local r = new("Frame", {
                    Size = UDim2.new(1, 0, 0, 46), BackgroundColor3 = C.panel,
                    BackgroundTransparency = 0.35, BorderSizePixel = 0, LayoutOrder = n, ZIndex = 8,
                }, listHolder)
                corner(r, 9)
                stroke(r, C.stroke, 1, 0.55)
                new("TextLabel", {
                    Size = UDim2.new(1, -150, 0, 15), Position = UDim2.fromOffset(11, 7),
                    BackgroundTransparency = 1, Font = Enum.Font.GothamMedium, TextSize = 12,
                    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text,
                    Text = p.Name, TextTruncate = Enum.TextTruncate.AtEnd, ZIndex = 9,
                }, r)
                local age = "?"
                pcall(function() age = tostring(p.AccountAge) end)
                new("TextLabel", {
                    Size = UDim2.new(1, -150, 0, 13), Position = UDim2.fromOffset(11, 24),
                    BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 9,
                    TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim,
                    Text = age .. " days old", ZIndex = 9,
                }, r)

                local function mini(glyph, x, cb)
                    local b = new("TextButton", {
                        AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, x, 0.5, 0),
                        Size = UDim2.fromOffset(30, 24), BackgroundColor3 = C.panel2,
                        Font = Enum.Font.GothamBold, TextSize = 11, TextColor3 = C.text,
                        Text = glyph, AutoButtonColor = false, ZIndex = 10,
                    }, r)
                    corner(b, 6)
                    b.MouseEnter:Connect(function() tween(b, 0.12, { BackgroundColor3 = Theme.accent, TextColor3 = C.bg }) end)
                    b.MouseLeave:Connect(function() tween(b, 0.12, { BackgroundColor3 = C.panel2, TextColor3 = C.text }) end)
                    b.MouseButton1Click:Connect(function() click(); task.spawn(cb) end)
                end
                mini("￢ﾆﾒ", -11, function()
                    local hrp = getHRP()
                    if hrp and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
                        hrp.CFrame = p.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, 4)
                    end
                end)
                mini("￢ﾜﾷ", -45, function()
                    if p.Character and flingChar then pcall(flingChar, p.Character, "spin", cfg.flingPower) end
                end)
                mini("￢ﾗﾐ", -79, function()
                    if copyDrop then copyDrop.Set(p.Name) end
                    notify("Copycat", "Target: " .. p.Name, 2)
                end)
            end
        end
        if n == 0 then
            local e = new("Frame", { Size = UDim2.new(1, 0, 0, 26), BackgroundTransparency = 1 }, listHolder)
            new("TextLabel", {
                Size = UDim2.fromScale(1, 1), BackgroundTransparency = 1, Font = Enum.Font.Gotham,
                TextSize = 10, TextColor3 = C.dim, TextXAlignment = Enum.TextXAlignment.Left, Text = "nobody here",
            }, e)
        end
    end

    _G.okazRebuildList = rebuildList
    conn(Players.PlayerAdded, function() task.wait(0.5); rebuildList() end)
    conn(Players.PlayerRemoving, function() task.wait(0.2); rebuildList() end)
    rebuildList()
end)

--=====================================================================
-- TAB: COPYCAT
--=====================================================================
local copyPage = makeTab("￢ﾗﾐ", "Copycat", 5)
local copying, copyConns, copyTracks = false, {}, {}
stopCopy = function()
    copying = false
    for _, t in pairs(copyTracks) do pcall(function() t:Stop() end) end
    copyTracks = {}
    for _, c in ipairs(copyConns) do pcall(function() c:Disconnect() end) end
    copyConns = {}
    local h = getHum(); if h then h.WalkSpeed = cfg.speed end
end

build("Copycat", function()
    header(copyPage, "Target")
    copyDrop = dropdown(copyPage, "Player", {}, function() end)
    local function refreshCopy()
        local list = {}
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LP then table.insert(list, p.Name) end
        end
        copyDrop.SetOptions(list)
    end
    refreshCopy()
    conn(Players.PlayerAdded, refreshCopy)
    conn(Players.PlayerRemoving, refreshCopy)

    local function copyAdd(signal, fn)
        local c = signal:Connect(fn)
        table.insert(copyConns, c)
        return c
    end

    toggle(copyPage, "Copycat", "Do everything they do", false, function(v)
        copying = v
        if not v then return stopCopy() end
        local target = Players:FindFirstChild(copyDrop.Get())
        if not target then notify("Copycat", "Pick a player first", 2); copying = false; return end
        notify("Copycat", "Mirroring " .. target.Name, 2)

        if cfg.copyAnim then
            task.spawn(function()
                while copying and target.Parent do
                    local myAnim = getAnimator(LP.Character)
                    local theirAnim = getAnimator(target.Character)
                    if myAnim and theirAnim then
                        local playing = {}
                        for _, tr in ipairs(theirAnim:GetPlayingAnimationTracks()) do
                            local id = tr.Animation and tr.Animation.AnimationId
                            if id and id ~= "" then playing[id] = tr.Speed end
                        end
                        for id, spd in pairs(playing) do
                            local mine = copyTracks[id]
                            if not mine or not mine.IsPlaying then
                                local a = Instance.new("Animation"); a.AnimationId = id
                                local ok, t = pcall(function() return myAnim:LoadAnimation(a) end)
                                if ok and t then
                                    t:Play(); pcall(function() t:AdjustSpeed(spd) end)
                                    copyTracks[id] = t
                                end
                            end
                        end
                        for id, t in pairs(copyTracks) do
                            if not playing[id] and t.IsPlaying then
                                pcall(function() t:Stop() end); copyTracks[id] = nil
                            end
                        end
                    end
                    task.wait(0.1)
                end
            end)
        end

        task.spawn(function()
            while copying and target.Parent do
                local tch = target.Character
                local myHum, myHrp = getHum(), getHRP()
                if tch and myHum and myHrp then
                    local th = tch:FindFirstChildOfClass("Humanoid")
                    local thrp = tch:FindFirstChild("HumanoidRootPart")
                    if th then
                        myHum:Move(th.MoveDirection)
                        if cfg.copySpeed then myHum.WalkSpeed = th.WalkSpeed end
                        if cfg.copyFollow and thrp then
                            local d = (thrp.Position - myHrp.Position).Magnitude
                            if d > 8 then myHrp.CFrame = thrp.CFrame * CFrame.new(0, 0, 4)
                            elseif d > 4 then myHum:Move((thrp.Position - myHrp.Position).Unit) end
                        end
                    end
                end
                RunService.Heartbeat:Wait()
            end
        end)

        if cfg.copyChat then copyAdd(target.Chatted, function(m) if copying then say(m) end end) end
        if cfg.copyJump then
            task.spawn(function()
                while copying and target.Parent do
                    local h = target.Character and target.Character:FindFirstChildOfClass("Humanoid")
                    if h then
                        local c
                        c = h.StateChanged:Connect(function(_, s)
                            if copying and s == Enum.HumanoidStateType.Jumping then
                                local my = getHum(); if my then my:ChangeState(Enum.HumanoidStateType.Jumping) end
                            end
                        end)
                        table.insert(copyConns, c)
                    end
                    task.wait(0.5)
                end
            end)
        end
        if cfg.copyTools then
            task.spawn(function()
                local lastTool
                while copying and target.Parent do
                    local tch = target.Character
                    local theirTool = tch and tch:FindFirstChildOfClass("Tool")
                    if theirTool and theirTool.Parent == tch then
                        if lastTool ~= theirTool.Name then
                            lastTool = theirTool.Name
                            local mine = LP.Character and LP.Character:FindFirstChild(lastTool)
                            if mine and mine:IsA("Tool") then pcall(function() mine:Activate() end) end
                        end
                    else lastTool = nil end
                    task.wait(0.2)
                end
            end)
        end
        copyAdd(target.AncestryChanged, function()
            if copying and not target.Parent then stopCopy(); notify("Copycat", "Target left", 2) end
        end)
    end)

    toggle(copyPage, "Mirror Animations", "Emotes and attacks", true, function(v) cfg.copyAnim = v end)
    toggle(copyPage, "Mirror Chat", "Repeat what they say", true, function(v) cfg.copyChat = v end)
    toggle(copyPage, "Mirror Tools", "Activate matching tools", true, function(v) cfg.copyTools = v end)
    toggle(copyPage, "Mirror Jumps", "Jump when they jump", true, function(v) cfg.copyJump = v end)
    toggle(copyPage, "Follow", "Stay glued behind them", true, function(v) cfg.copyFollow = v end)
    toggle(copyPage, "Match Speed", "Copy their walkspeed", true, function(v) cfg.copySpeed = v end)
end)

--=====================================================================
-- FLING
--=====================================================================
flingChar = function(ch, mode, power)
    local hrp = ch:FindFirstChild("HumanoidRootPart")
    local hum = ch:FindFirstChildOfClass("Humanoid")
    if not hrp then return end
    pcall(function() hrp:SetNetworkOwner(LP) end)
    local wasAnchored = hrp.Anchored
    hrp.Anchored = false
    if hum then
        hum.PlatformStand = true
        pcall(function() hum:ChangeState(Enum.HumanoidStateType.Physics) end)
    end
    local stopAt = os.clock() + 1.4
    task.spawn(function()
        while os.clock() < stopAt and hrp.Parent do
            if mode == "spin" then
                hrp.AssemblyAngularVelocity = Vector3.new(power, power, power)
                hrp.AssemblyLinearVelocity = Vector3.new(0, power * 0.35, 0)
            elseif mode == "velocity" then
                hrp.AssemblyLinearVelocity = Vector3.new(power, power, power)
                hrp.AssemblyAngularVelocity = Vector3.new(power, power, 0)
            elseif mode == "cframe" then
                hrp.CFrame = hrp.CFrame * CFrame.new(0, 0, 0.25) * CFrame.Angles(math.rad(35), math.rad(20), 0)
            end
            RunService.Heartbeat:Wait()
        end
        if hum then
            hum.PlatformStand = false
            pcall(function() hum:ChangeState(Enum.HumanoidStateType.GettingUp) end)
        end
        if wasAnchored then hrp.Anchored = true end
        if ch == LP.Character then recover(3) end
    end)
end

local flingPage = makeTab("￢ﾜﾷ", "Fling", 6)
local autoFling = false
build("Fling", function()
    header(flingPage, "Settings")
    slider(flingPage, "Power", 100, 20000, 1200, 0, function(v) cfg.flingPower = v end)
    local flingDrop = dropdown(flingPage, "Target", { "Nearest", "Everyone", "Self" }, function() end)
    local function refreshFling()
        local list = { "Nearest", "Everyone", "Self" }
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LP then table.insert(list, p.Name) end
        end
        flingDrop.SetOptions(list)
    end
    refreshFling()
    conn(Players.PlayerAdded, refreshFling)
    conn(Players.PlayerRemoving, refreshFling)

    local function resolveTargets()
        local mode = flingDrop.Get()
        if mode == "Self" then return { LP } end
        if mode == "Everyone" then
            local t = {}
            for _, p in ipairs(Players:GetPlayers()) do table.insert(t, p) end
            return t
        elseif mode == "Nearest" then
            local p = nearestPlayer(); return p and { p } or {}
        end
        local p = Players:FindFirstChild(mode); return p and { p } or {}
    end
    local function runFling(mode)
        local targets = resolveTargets()
        if #targets == 0 then notify("Fling", "No target found", 2); return end
        for _, p in ipairs(targets) do
            if p.Character then pcall(flingChar, p.Character, mode, cfg.flingPower) end
        end
        notify("Fling", mode .. " ￢ﾆﾒ " .. #targets, 2)
    end

    header(flingPage, "Methods")
    button(flingPage, "Spin Fling", function() runFling("spin") end)
    button(flingPage, "Velocity Fling", function() runFling("velocity") end)
    button(flingPage, "CFrame Fling", function() runFling("cframe") end)
    spacer(flingPage, 2)
    header(flingPage, "Auto")
    toggle(flingPage, "Auto Fling", "Re-fling nearest repeatedly", false, function(v)
        autoFling = v
        if v then
            task.spawn(function()
                while autoFling do
                    local t = resolveTargets()
                    for _, p in ipairs(t) do
                        if p.Character and p.Character ~= LP.Character then
                            pcall(flingChar, p.Character, "spin", cfg.flingPower)
                        end
                    end
                    task.wait(0.6)
                end
            end)
        end
    end)
end)

--=====================================================================
-- VISUALS
--=====================================================================
local visPage = makeTab("￢ﾗﾈ", "Visuals", 7)
local tracerMap = {}
build("Visuals", function()
    header(visPage, "ESP")
    toggle(visPage, "Player ESP", "Highlight + name + health", false, function(v)
        cfg.espEnabled = v
        if not v then
            for _, p in ipairs(Players:GetPlayers()) do
                local ch = p.Character
                if ch then
                    local h = ch:FindFirstChild("okazHL"); if h then h:Destroy() end
                    local b = ch:FindFirstChild("okazESP"); if b then b:Destroy() end
                end
            end
        end
    end)
    toggle(visPage, "Show Name", nil, true, function(v) cfg.espName = v end)
    toggle(visPage, "Show Health", nil, true, function(v) cfg.espHealth = v end)
    toggle(visPage, "Show Distance", nil, false, function(v) cfg.espDistance = v end)
    toggle(visPage, "Tracers", "Line from you to them", false, function(v)
        cfg.tracers = v
        if not v then
            for _, t in ipairs(tracerHolder:GetChildren()) do t:Destroy() end
            tracerMap = {}
        end
    end)
    slider(visPage, "Tracer Thickness", 1, 4, 1, 0, function(v) cfg.tracerThickness = v end)
    toggle(visPage, "Distance HUD", "Nearest player readout", false, function(v)
        cfg.distHud = v
        distHud.Visible = v
    end)

    local function buildESP(plr)
        if not cfg.espEnabled or plr == LP then return end
        local ch = plr.Character
        if not ch or not ch:FindFirstChild("Head") or ch:FindFirstChild("okazHL") then return end
        local hl = new("Highlight", {
            Name = "okazHL", Adornee = ch, FillColor = Theme.accent,
            FillTransparency = 0.65, OutlineColor = Theme.accent,
            OutlineTransparency = 0, DepthMode = Enum.HighlightDepthMode.AlwaysOnTop,
        }, ch)
        table.insert(retinters, function()
            if hl.Parent then hl.FillColor = Theme.accent; hl.OutlineColor = Theme.accent end
        end)
        local bg = new("BillboardGui", {
            Name = "okazESP", Adornee = ch.Head, Size = UDim2.fromOffset(120, 40),
            StudsOffsetWorldSpace = Vector3.new(0, 2.2, 0), AlwaysOnTop = true,
        }, ch)
        local nm = new("TextLabel", {
            Size = UDim2.new(1, 0, 0, 16), BackgroundTransparency = 1,
            Font = Enum.Font.GothamBold, TextSize = 12, TextColor3 = C.text,
            TextStrokeTransparency = 0.4, Text = plr.Name,
        }, bg)
        local dist = new("TextLabel", {
            Size = UDim2.new(1, 0, 0, 12), Position = UDim2.new(0, 0, 0, 15),
            BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 10,
            TextColor3 = C.dim, TextStrokeTransparency = 0.6, Text = "",
        }, bg)
        local hpBg = new("Frame", {
            Size = UDim2.new(0.7, 0, 0, 4), Position = UDim2.new(0.15, 0, 0, 28),
            BackgroundColor3 = Color3.fromRGB(30, 30, 40), BorderSizePixel = 0,
        }, bg)
        corner(hpBg, 99)
        local hpFill = new("Frame", { Size = UDim2.fromScale(1, 1), BackgroundColor3 = C.good, BorderSizePixel = 0 }, hpBg)
        corner(hpFill, 99)
        task.spawn(function()
            while hl.Parent and cfg.espEnabled do
                local hum = ch:FindFirstChildOfClass("Humanoid")
                local hrp = ch:FindFirstChild("HumanoidRootPart")
                local myHrp = getHRP()
                if hum then
                    local r = hum.Health / math.max(hum.MaxHealth, 1)
                    hpFill.Size = UDim2.fromScale(r, 1)
                    hpFill.BackgroundColor3 = Color3.fromRGB(255 * (1 - r), 220 * r, 90)
                end
                if hrp and myHrp then dist.Text = math.floor((hrp.Position - myHrp.Position).Magnitude) .. "m" end
                nm.Visible = cfg.espName
                dist.Visible = cfg.espDistance
                hpBg.Visible = cfg.espHealth
                bg.Enabled = cfg.espName or cfg.espHealth or cfg.espDistance
                task.wait(0.25)
            end
        end)
    end
    conn(Players.PlayerAdded, function(p)
        p.CharacterAdded:Connect(function() task.wait(1); buildESP(p) end)
    end)
    for _, p in ipairs(Players:GetPlayers()) do task.spawn(buildESP, p) end

    spacer(visPage, 2)
    header(visPage, "World")
    slider(visPage, "Time of Day", 0, 24, 14, 1, function(v) Lighting.ClockTime = v end)
    slider(visPage, "Brightness", 0, 10, 2, 1, function(v) Lighting.Brightness = v end)
    button(visPage, "Remove Fog", function()
        Lighting.FogEnd = 1e6; Lighting.FogStart = 0
        notify("World", "Fog removed", 2)
    end)
    spacer(visPage, 2)
    header(visPage, "Camera")
    slider(visPage, "Field of View", 30, 120, 70, 0, function(v) Camera.FieldOfView = v end)
    slider(visPage, "Max Zoom", 50, 2000, 128, 0, function(v) pcall(function() LP.CameraMaxZoomDistance = v end) end)
end)

-- tracer + distance hud loop
task.spawn(function()
    while not Okaz.Unloaded do
        task.wait(1 / 40)
        if cfg.tracers or cfg.distHud then
            local vp = Camera.ViewportSize
            for _, plr in ipairs(Players:GetPlayers()) do
                if plr ~= LP and plr.Character and plr.Character:FindFirstChild("Head") then
                    local sp, on = Camera:WorldToViewportPoint(plr.Character.Head.Position)
                    if cfg.tracers then
                        local line = tracerMap[plr]
                        if not line or not line.Parent then
                            line = new("Frame", {
                                AnchorPoint = Vector2.new(0.5, 0.5), BackgroundColor3 = Theme.accent,
                                BorderSizePixel = 0, ZIndex = 400,
                            }, tracerHolder)
                            table.insert(retinters, function() line.BackgroundColor3 = Theme.accent end)
                            tracerMap[plr] = line
                        end
                        if on and sp.Z > 0 then
                            local a = Vector2.new(vp.X / 2, vp.Y)
                            local b = Vector2.new(sp.X, sp.Y)
                            local mid = (a + b) / 2
                            line.Visible = true
                            line.Position = UDim2.fromOffset(mid.X, mid.Y)
                            line.Size = UDim2.fromOffset((b - a).Magnitude, cfg.tracerThickness)
                            line.Rotation = math.deg(math.atan2(b.Y - a.Y, b.X - a.X))
                        else
                            line.Visible = false
                        end
                    end
                end
            end
            if cfg.distHud then
                local near = nearestPlayer()
                local hrp = getHRP()
                if near and near.Character and near.Character:FindFirstChild("HumanoidRootPart") and hrp then
                    distHud.Text = ("%s  %dm"):format(near.Name,
                        math.floor((near.Character.HumanoidRootPart.Position - hrp.Position).Magnitude))
                else
                    distHud.Text = "￢ﾀﾔ"
                end
            end
        end
    end
end)

--=====================================================================
-- TELEPORT
--=====================================================================
local tpPage = makeTab("￢ﾜﾈ", "Teleport", 8)
local waypoints = {}
local tpLoop = false
local rebuildWaypoints
build("Teleport", function()
    header(tpPage, "Players")
    local tpDrop = dropdown(tpPage, "Target", {}, function() end)
    local function refreshTP()
        local list = {}
        for _, p in ipairs(Players:GetPlayers()) do
            if p ~= LP then table.insert(list, p.Name) end
        end
        tpDrop.SetOptions(list)
    end
    refreshTP()
    conn(Players.PlayerAdded, refreshTP)
    conn(Players.PlayerRemoving, refreshTP)
    button(tpPage, "Teleport to Player", function()
        local plr = Players:FindFirstChild(tpDrop.Get())
        local hrp = getHRP()
        if plr and plr.Character and plr.Character:FindFirstChild("HumanoidRootPart") and hrp then
            hrp.CFrame = plr.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, 4)
            notify("Teleport", "Moved", 2)
        else notify("Teleport", "Target not found", 2) end
    end)
    toggle(tpPage, "Loop Teleport", "Follow target continuously", false, function(v)
        tpLoop = v
        if v then
            task.spawn(function()
                while tpLoop do
                    local plr = Players:FindFirstChild(tpDrop.Get())
                    local hrp = getHRP()
                    if plr and plr.Character and plr.Character:FindFirstChild("HumanoidRootPart") and hrp then
                        hrp.CFrame = plr.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, 4)
                    end
                    task.wait(0.15)
                end
            end)
        end
    end)

    spacer(tpPage, 2)
    header(tpPage, "Waypoints")
    local wpName = textbox(tpPage, "Name", "base, shop, etc", "", function() end)
    button(tpPage, "Save Waypoint Here", function()
        local hrp = getHRP()
        if hrp and wpName.Text ~= "" then
            waypoints[wpName.Text] = hrp.CFrame
            notify("Waypoint", "Saved " .. wpName.Text, 2)
            if rebuildWaypoints then rebuildWaypoints() end
        end
    end)
    local wpHolder = new("Frame", {
        Size = UDim2.new(1, 0, 0, 0), BackgroundTransparency = 1,
        AutomaticSize = Enum.AutomaticSize.Y, ZIndex = 8,
    }, tpPage)
    new("UIListLayout", { Padding = UDim.new(0, 5), SortOrder = Enum.SortOrder.LayoutOrder }, wpHolder)
    rebuildWaypoints = function()
        for _, ch in ipairs(wpHolder:GetChildren()) do
            if ch:IsA("Frame") then ch:Destroy() end
        end
        local i = 0
        for name in pairs(waypoints) do
            i += 1
            local r = new("Frame", {
                Size = UDim2.new(1, 0, 0, 32), BackgroundColor3 = C.panel,
                BackgroundTransparency = 0.35, BorderSizePixel = 0, LayoutOrder = i, ZIndex = 8,
            }, wpHolder)
            corner(r, 8)
            stroke(r, C.stroke, 1, 0.55)
            local b = new("TextButton", { Size = UDim2.new(1, -36, 1, 0), BackgroundTransparency = 1, Text = "", ZIndex = 9 }, r)
            new("TextLabel", {
                Size = UDim2.new(1, -12, 1, 0), Position = UDim2.fromOffset(10, 0),
                BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 11,
                TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text, Text = name, ZIndex = 9,
            }, r)
            b.MouseButton1Click:Connect(function()
                local hrp = getHRP()
                if hrp and waypoints[name] then hrp.CFrame = waypoints[name] + Vector3.new(0, 3, 0) end
            end)
            local x = new("TextButton", {
                AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, -6, 0.5, 0),
                Size = UDim2.fromOffset(24, 22), BackgroundColor3 = C.panel2,
                Font = Enum.Font.GothamBold, TextSize = 11, TextColor3 = C.dim,
                Text = "￢ﾜﾕ", AutoButtonColor = false, ZIndex = 10,
            }, r)
            corner(x, 6)
            x.MouseButton1Click:Connect(function() waypoints[name] = nil; rebuildWaypoints() end)
        end
    end

    spacer(tpPage, 2)
    header(tpPage, "Click TP")
    local clickTP = false
    toggle(tpPage, "Click to Teleport", "Click anywhere in the world", false, function(v) clickTP = v end)
    conn(UserInputService.InputBegan, function(i, gp)
        if gp or not clickTP or i.UserInputType ~= Enum.UserInputType.MouseButton1 then return end
        local ray = Camera:ScreenPointToRay(Mouse.X, Mouse.Y)
        local params = RaycastParams.new()
        params.FilterDescendantsInstances = { LP.Character }
        local res = Workspace:Raycast(ray.Origin, ray.Direction * 2000, params)
        local hrp = getHRP()
        if res and hrp then hrp.CFrame = CFrame.new(res.Position + Vector3.new(0, 4, 0)) end
    end)
end)

--=====================================================================
-- AUDIO
--=====================================================================
local Music = { queue = {}, index = 0, loopOne = false, autoplay = true, vol = 0.5, pitch = 1 }
local nowTitle, nowSub, progressFill, progressBar, timeLabel, refreshPlaylist

local function ensureSound()
    if Music.sound and Music.sound.Parent then return Music.sound end
    local s = Instance.new("Sound")
    s.Name = "okazMusic"; s.Volume = Music.vol; s.PlaybackSpeed = Music.pitch; s.Looped = Music.loopOne
    s.Parent = SoundService
    Music.eq = Instance.new("EqualizerSoundEffect"); Music.eq.LowGain = 0; Music.eq.Parent = s
    Music.rev = Instance.new("ReverbSoundEffect"); Music.rev.Enabled = false; Music.rev.Parent = s
    Music.dist = Instance.new("DistortionSoundEffect"); Music.dist.Enabled = false; Music.dist.Level = 0.2; Music.dist.Parent = s
    Music.shift = Instance.new("PitchShiftSoundEffect"); Music.shift.Octave = 1; Music.shift.Parent = s
    Music.sound = s
    s.Ended:Connect(function()
        if Music.loopOne then return end
        if Music.index < #Music.queue then playIndex(Music.index + 1)
        elseif Music.autoplay and #Music.queue > 0 then playIndex(1) end
    end)
    return s
end
local function fmtTime(t)
    t = math.max(0, math.floor(t or 0))
    return ("%d:%02d"):format(t // 60, t % 60)
end
playIndex = function(i)
    if #Music.queue == 0 then return end
    Music.index = math.clamp(i, 1, #Music.queue)
    local entry = Music.queue[Music.index]
    local s = ensureSound()
    s.SoundId = entry.id; s.TimePosition = 0; s.Looped = Music.loopOne; s:Play()
    if nowTitle then nowTitle.Text = entry.name end
    if nowSub then nowSub.Text = entry.id end
    if refreshPlaylist then refreshPlaylist() end
end
musicPlayPause = function()
    local s = Music.sound
    if not s or s.SoundId == "" then return end
    if s.IsPlaying then s:Pause() else s:Resume() end
end

local audioPage = makeTab("￢ﾙﾫ", "Audio", 9)
build("Audio", function()
    header(audioPage, "Now Playing")
    local nowCard = new("Frame", {
        Size = UDim2.new(1, 0, 0, 86), BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.25, BorderSizePixel = 0, ZIndex = 8,
    }, audioPage)
    corner(nowCard, 12)
    bindGradient(new("UIGradient", { Rotation = 20 }, nowCard))
    nowTitle = new("TextLabel", {
        Size = UDim2.new(1, -24, 0, 18), Position = UDim2.fromOffset(14, 12),
        BackgroundTransparency = 1, Font = Enum.Font.GothamBold, TextSize = 13,
        TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text,
        Text = "nothing loaded", ZIndex = 9, TextTruncate = Enum.TextTruncate.AtEnd,
    }, nowCard)
    nowSub = new("TextLabel", {
        Size = UDim2.new(1, -24, 0, 14), Position = UDim2.fromOffset(14, 30),
        BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 10,
        TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim, Text = "￢ﾀﾔ", ZIndex = 9,
    }, nowCard)
    progressBar = new("Frame", {
        AnchorPoint = Vector2.new(0, 1), Position = UDim2.new(0, 14, 1, -22),
        Size = UDim2.new(1, -28, 0, 4), BackgroundColor3 = Color3.fromRGB(40, 40, 52),
        BorderSizePixel = 0, ZIndex = 9,
    }, nowCard)
    corner(progressBar, 99)
    progressFill = new("Frame", {
        Size = UDim2.fromScale(0, 1), BackgroundColor3 = Theme.accent, BorderSizePixel = 0, ZIndex = 10,
    }, progressBar)
    corner(progressFill, 99)
    bindGradient(new("UIGradient", {}, progressFill))
    local progHit = new("TextButton", {
        Size = UDim2.new(1, 0, 3, 0), Position = UDim2.new(0, 0, -1, 0),
        BackgroundTransparency = 1, Text = "", ZIndex = 11,
    }, progressBar)
    progHit.MouseButton1Down:Connect(function()
        local s = Music.sound
        if not s or s.TimeLength <= 0 then return end
        local rel = math.clamp((Mouse.X - progressBar.AbsolutePosition.X) / math.max(progressBar.AbsoluteSize.X, 1), 0, 1)
        s.TimePosition = rel * s.TimeLength
    end)
    timeLabel = new("TextLabel", {
        Size = UDim2.new(1, -28, 0, 12), Position = UDim2.new(0, 14, 1, -16),
        BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 9,
        TextXAlignment = Enum.TextXAlignment.Right, TextColor3 = C.dim, Text = "0:00 / 0:00", ZIndex = 9,
    }, nowCard)

    local transport = new("Frame", { Size = UDim2.new(1, 0, 0, 38), BackgroundTransparency = 1, ZIndex = 8 }, audioPage)
    new("UIListLayout", { FillDirection = Enum.FillDirection.Horizontal, Padding = UDim.new(0, 6) }, transport)
    local function tBtn(glyph, cb)
        local b = new("TextButton", {
            Size = UDim2.new(0.25, -5, 1, 0), BackgroundColor3 = C.panel2,
            Font = Enum.Font.GothamBold, TextSize = 14, TextColor3 = C.text,
            Text = glyph, AutoButtonColor = false, ZIndex = 9,
        }, transport)
        corner(b, 9)
        stroke(b, C.stroke, 1, 0.5)
        b.MouseEnter:Connect(function() tween(b, 0.15, { BackgroundColor3 = Theme.accent, TextColor3 = C.bg }) end)
        b.MouseLeave:Connect(function() tween(b, 0.15, { BackgroundColor3 = C.panel2, TextColor3 = C.text }) end)
        b.MouseButton1Click:Connect(function() click(); task.spawn(cb) end)
        return b
    end
    tBtn("￢ﾏﾮ", function() playIndex(Music.index - 1) end)
    tBtn("￢ﾖﾶ", function() musicPlayPause() end)
    tBtn("￢ﾏﾭ", function() playIndex(Music.index + 1) end)
    tBtn("￢ﾏﾹ", function() if Music.sound then Music.sound:Stop() end end)

    spacer(audioPage, 2)
    header(audioPage, "Load")
    local idBox = textbox(audioPage, "Asset ID", "numeric id", "", function() end)
    button(audioPage, "Load & Play", function()
        local raw = idBox.Text:gsub("%s", "")
        local id = raw:match("^rbxassetid://(%d+)") or raw:match("^(%d+)$")
        if not id then notify("Audio", "Invalid id", 2); return end
        table.insert(Music.queue, { id = "rbxassetid://" .. id, name = "asset " .. id })
        playIndex(#Music.queue)
    end)
    local pathBox = textbox(audioPage, "Local File", "C:/Music/song.mp3", "", function() end)
    button(audioPage, "Load Local File", function()
        local path = pathBox.Text
        if path == "" then return end
        local asset
        if getcustomasset then
            local ok, res = pcall(getcustomasset, path); if ok then asset = res end
        elseif getsynasset then
            local ok, res = pcall(getsynasset, path); if ok then asset = res end
        end
        if asset then
            table.insert(Music.queue, { id = asset, name = path:match("[^/\\]+$") or path })
            playIndex(#Music.queue)
        else notify("Audio", "Executor can't load files", 3) end
    end)

    spacer(audioPage, 2)
    header(audioPage, "Mix")
    slider(audioPage, "Volume", 0, 1, 0.5, 2, function(v) Music.vol = v; if Music.sound then Music.sound.Volume = v end end)
    slider(audioPage, "Speed", 0.5, 2, 1, 2, function(v) Music.pitch = v; if Music.sound then Music.sound.PlaybackSpeed = v end end)
    toggle(audioPage, "Loop Track", "Repeat current song", false, function(v)
        Music.loopOne = v
        if Music.sound then Music.sound.Looped = v end
    end)

    spacer(audioPage, 2)
    header(audioPage, "Effects")
    toggle(audioPage, "Bass Boost", "Push low frequencies", false, function(v)
        ensureSound(); Music.eq.LowGain = v and 18 or 0
    end)
    toggle(audioPage, "Reverb", "Cavernous tail", false, function(v)
        ensureSound(); Music.rev.Enabled = v
        Music.rev.DecayTime = 3; Music.rev.Density = 1; Music.rev.Diffusion = 1
    end)
    toggle(audioPage, "Distortion", "Crunch", false, function(v)
        ensureSound(); Music.dist.Enabled = v
    end)
    slider(audioPage, "Pitch Shift", 0.5, 2, 1, 2, function(v) ensureSound(); Music.shift.Octave = v end)

    spacer(audioPage, 2)
    header(audioPage, "Visualizer")
    local viz = new("Frame", {
        Size = UDim2.new(1, 0, 0, 56), BackgroundColor3 = C.panel,
        BackgroundTransparency = 0.5, BorderSizePixel = 0, ZIndex = 8,
    }, audioPage)
    corner(viz, 10)
    new("UIListLayout", { FillDirection = Enum.FillDirection.Horizontal, Padding = UDim.new(0, 3),
        SortOrder = Enum.SortOrder.LayoutOrder, VerticalAlignment = Enum.VerticalAlignment.Bottom }, viz)
    pad(viz, 8, 8, 8, 8)
    local vizBars = {}
    for i = 1, 20 do
        local b = new("Frame", {
            Size = UDim2.new(1 / 20, -3, 0, 4), BackgroundColor3 = Theme.accent,
            BorderSizePixel = 0, LayoutOrder = i, ZIndex = 9,
        }, viz)
        corner(b, 3)
        bindGradient(new("UIGradient", { Rotation = 90 }, b))
        vizBars[i] = b
    end
    task.spawn(function()
        while not Okaz.Unloaded do
            local s = Music.sound
            local loud = (s and s.IsPlaying) and s.PlaybackLoudness or 0
            for i, b in ipairs(vizBars) do
                local f = 0.1 + (math.sin(os.clock() * 3 + i) * 0.5 + 0.5) * 0.4
                tween(b, 0.09, { Size = UDim2.new(1 / 20, -3, 0, math.clamp((loud / 1000) * 44 * f * 2.2, 3, 44)) })
            end
            task.wait(0.09)
        end
    end)
    task.spawn(function()
        while not Okaz.Unloaded do
            task.wait(0.15)
            local s = Music.sound
            if s then
                local len, pos = s.TimeLength, s.TimePosition
                progressFill.Size = UDim2.fromScale(len > 0 and math.clamp(pos / len, 0, 1) or 0, 1)
                timeLabel.Text = fmtTime(pos) .. " / " .. fmtTime(len)
            end
        end
    end)

    spacer(audioPage, 2)
    header(audioPage, "Playlist")
    local playlistHolder = new("Frame", {
        Size = UDim2.new(1, 0, 0, 0), BackgroundTransparency = 1,
        AutomaticSize = Enum.AutomaticSize.Y, ZIndex = 8,
    }, audioPage)
    new("UIListLayout", { Padding = UDim.new(0, 4), SortOrder = Enum.SortOrder.LayoutOrder }, playlistHolder)
    refreshPlaylist = function()
        for _, ch in ipairs(playlistHolder:GetChildren()) do
            if ch:IsA("Frame") then ch:Destroy() end
        end
        if #Music.queue == 0 then
            local e = new("Frame", { Size = UDim2.new(1, 0, 0, 26), BackgroundTransparency = 1 }, playlistHolder)
            new("TextLabel", { Size = UDim2.fromScale(1, 1), BackgroundTransparency = 1, Font = Enum.Font.Gotham,
                TextSize = 10, TextColor3 = C.dim, TextXAlignment = Enum.TextXAlignment.Left, Text = "queue empty" }, e)
            return
        end
        for i, entry in ipairs(Music.queue) do
            local r = new("Frame", {
                Size = UDim2.new(1, 0, 0, 30), BackgroundColor3 = C.panel,
                BackgroundTransparency = i == Music.index and 0.15 or 0.4,
                BorderSizePixel = 0, LayoutOrder = i, ZIndex = 8,
            }, playlistHolder)
            corner(r, 8)
            if i == Music.index then stroke(r, Theme.accent, 1, 0.3) end
            local b = new("TextButton", { Size = UDim2.new(1, -34, 1, 0), BackgroundTransparency = 1, Text = "", ZIndex = 9 }, r)
            new("TextLabel", {
                Size = UDim2.new(1, -12, 1, 0), Position = UDim2.fromOffset(10, 0),
                BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 11,
                TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.text,
                Text = ("%d. %s"):format(i, entry.name), TextTruncate = Enum.TextTruncate.AtEnd, ZIndex = 9,
            }, r)
            b.MouseButton1Click:Connect(function() playIndex(i) end)
            local x = new("TextButton", {
                AnchorPoint = Vector2.new(1, 0.5), Position = UDim2.new(1, -6, 0.5, 0),
                Size = UDim2.fromOffset(22, 22), BackgroundColor3 = C.panel2,
                Font = Enum.Font.GothamBold, TextSize = 11, TextColor3 = C.dim,
                Text = "￢ﾜﾕ", AutoButtonColor = false, ZIndex = 10,
            }, r)
            corner(x, 6)
            x.MouseButton1Click:Connect(function()
                table.remove(Music.queue, i)
                if Music.index >= i and Music.index > 1 then Music.index -= 1 end
                refreshPlaylist()
            end)
        end
    end
    refreshPlaylist()
    button(audioPage, "Clear Queue", function()
        Music.queue = {}; Music.index = 0
        if Music.sound then Music.sound:Stop() end
        refreshPlaylist(); nowTitle.Text = "nothing loaded"; nowSub.Text = "￢ﾀﾔ"
    end)
end)

--=====================================================================
-- CHAT LOG
--=====================================================================
local chatLogPage = makeTab("￢ﾜﾎ", "Chat Log", 10)
local chatLabels = {}
build("Chat Log", function()
    header(chatLogPage, "Captured")
    local chatHolder = new("Frame", {
        Size = UDim2.new(1, 0, 0, 0), BackgroundTransparency = 1,
        AutomaticSize = Enum.AutomaticSize.Y, ZIndex = 8,
    }, chatLogPage)
    new("UIListLayout", { Padding = UDim.new(0, 3), SortOrder = Enum.SortOrder.LayoutOrder }, chatHolder)
    local count = 0

    local function logChat(who, msg, col)
        count += 1
        local l = new("TextLabel", {
            Size = UDim2.new(1, 0, 0, 16), BackgroundTransparency = 1,
            Font = Enum.Font.Gotham, TextSize = 11,
            TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = col or C.text,
            Text = ("%s: %s"):format(who, msg), LayoutOrder = count, ZIndex = 9,
            TextTruncate = Enum.TextTruncate.AtEnd,
        }, chatHolder)
        table.insert(chatLabels, l)
        if #chatLabels > 120 then
            local old = table.remove(chatLabels, 1)
            if old then old:Destroy() end
        end
    end

    conn(Players.PlayerAdded, function(p)
        p.Chatted:Connect(function(m) logChat(p.Name, m, C.text) end)
    end)
    for _, p in ipairs(Players:GetPlayers()) do
        p.Chatted:Connect(function(m) logChat(p.Name, m, C.text) end)
    end
    conn(LP.Chatted, function(m) logChat(LP.Name, m, Theme.accent) end)
    button(chatLogPage, "Clear Log", function()
        for _, c in ipairs(chatLabels) do c:Destroy() end
        chatLabels = {}
    end)
end)

--=====================================================================
-- COMMANDS
--=====================================================================
local commands, commandOrder = {}, {}
local function cmd(name, usage, desc, fn)
    commands[name] = { usage = usage, desc = desc, fn = fn }
    table.insert(commandOrder, name)
end

cmd("cmds", ";cmds", "list every command", function() selectTab(tabs[11].button, tabs[11].page) end)
cmd("hide", ";hide", "hide the menu", function() setOpen(false) end)
cmd("show", ";show", "show the menu", function() setOpen(true) end)
cmd("speed", ";speed <n>", "set walkspeed", function(a)
    local n = tonumber(a[1]); if not n then return end
    cfg.speed = n
    local h = getHum(); if h then h.WalkSpeed = n end
end)
cmd("jump", ";jump <n>", "set jumppower", function(a)
    local n = tonumber(a[1]); if not n then return end
    cfg.jump = n
    local h = getHum(); if h then h.UseJumpPower = true; h.JumpPower = n end
end)
cmd("fly", ";fly [mode]", "toggle fly", function(a)
    if a[1] then cfg.flyMode = a[1]:gsub("^%l", string.upper) end
    if flyToggle then flyToggle.Set(not flyToggle.Get()) end
end)
cmd("noclip", ";noclip", "toggle noclip", function()
    noclip = not noclip
    if not noclip then setCollisions(true); recover(4) end
    notify("Command", "Noclip " .. (noclip and "on" or "off"), 2)
end)
cmd("infjump", ";infjump", "toggle infinite jump", function()
    infJump = not infJump
    notify("Command", "Inf jump " .. (infJump and "on" or "off"), 2)
end)
cmd("freeze", ";freeze", "toggle freeze self", function()
    frozen = not frozen
    local hrp = getHRP(); if hrp then hrp.Anchored = frozen end
end)
cmd("tp", ";tp <player>", "teleport to player", function(a)
    local p = resolvePlayer(a[1]); local hrp = getHRP()
    if p and p.Character and p.Character:FindFirstChild("HumanoidRootPart") and hrp then
        hrp.CFrame = p.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, 4)
    else notify("Command", "Player not found", 2) end
end)
cmd("tpr", ";tpr", "teleport to random player", function()
    local list = {}
    for _, p in ipairs(Players:GetPlayers()) do if p ~= LP then table.insert(list, p) end end
    if #list == 0 then return end
    local p = list[math.random(#list)]
    local hrp = getHRP()
    if p and p.Character and p.Character:FindFirstChild("HumanoidRootPart") and hrp then
        hrp.CFrame = p.Character.HumanoidRootPart.CFrame * CFrame.new(0, 0, 4)
    end
end)
cmd("fling", ";fling [player|all]", "fling target", function(a)
    local arg = (a[1] or ""):lower()
    if arg == "all" then
        for _, p in ipairs(Players:GetPlayers()) do
            if p.Character and p ~= LP then pcall(flingChar, p.Character, "spin", cfg.flingPower) end
        end
        return
    end
    local p = arg ~= "" and resolvePlayer(arg) or nearestPlayer()
    if p and p.Character then pcall(flingChar, p.Character, "spin", cfg.flingPower) end
end)
cmd("copy", ";copy <player>", "set copycat target", function(a)
    local p = resolvePlayer(a[1])
    if p and copyDrop then copyDrop.Set(p.Name); notify("Command", "Target " .. p.Name, 2) end
end)
cmd("esp", ";esp", "toggle player esp", function()
    cfg.espEnabled = not cfg.espEnabled
    notify("Command", "ESP " .. (cfg.espEnabled and "on" or "off"), 2)
end)
cmd("tracers", ";tracers", "toggle tracers", function()
    cfg.tracers = not cfg.tracers
    notify("Command", "Tracers " .. (cfg.tracers and "on" or "off"), 2)
end)
cmd("music", ";music <id>", "play an audio id", function(a)
    local id = (a[1] or ""):match("(%d+)")
    if not id then return end
    table.insert(Music.queue, { id = "rbxassetid://" .. id, name = "asset " .. id })
    playIndex(#Music.queue)
end)
cmd("play", ";play", "resume audio", function() musicPlayPause() end)
cmd("pause", ";pause", "pause audio", function() musicPlayPause() end)
cmd("next", ";next", "next track", function() playIndex(Music.index + 1) end)
cmd("stop", ";stop", "stop audio", function() if Music.sound then Music.sound:Stop() end end)
cmd("vol", ";vol <0-1>", "set volume", function(a)
    local n = tonumber(a[1]); if not n then return end
    Music.vol = math.clamp(n, 0, 1)
    if Music.sound then Music.sound.Volume = Music.vol end
end)
cmd("theme", ";theme <name>", "switch theme", function(a)
    local map = {
        pink = { Color3.fromRGB(255, 46, 122), Color3.fromRGB(158, 74, 255) },
        violet = { Color3.fromRGB(150, 80, 255), Color3.fromRGB(90, 120, 255) },
        cyan = { Color3.fromRGB(40, 210, 240), Color3.fromRGB(70, 140, 255) },
        lime = { Color3.fromRGB(140, 235, 80), Color3.fromRGB(40, 200, 140) },
        amber = { Color3.fromRGB(255, 165, 60), Color3.fromRGB(255, 90, 90) },
        mono = { Color3.fromRGB(225, 225, 235), Color3.fromRGB(150, 150, 165) },
    }
    local t = map[(a[1] or ""):lower()]
    if t then Theme.accent = t[1]; Theme.accent2 = t[2]; retint(); notify("Theme", a[1], 2) end
end)
cmd("stuck", ";stuck", "unstick yourself", function() recover(6) end)
cmd("reset", ";reset", "reset character", function()
    local h = getHum(); if h then h.Health = 0 end
end)
cmd("rejoin", ";rejoin", "rejoin server", function() TeleportService:Teleport(game.PlaceId, LP) end)
cmd("wp", ";wp add|go <name>", "waypoints", function(a)
    local mode, name = a[1], a[2]
    if not mode or not name then return end
    if mode == "add" then
        local hrp = getHRP()
        if hrp then
            waypoints[name] = hrp.CFrame
            if rebuildWaypoints then rebuildWaypoints() end
            notify("Waypoint", "Saved", 2)
        end
    elseif mode == "go" and waypoints[name] then
        local hrp = getHRP(); if hrp then hrp.CFrame = waypoints[name] + Vector3.new(0, 3, 0) end
    end
end)
cmd("look", ";look <player>", "face a player", function(a)
    local p = resolvePlayer(a[1]); local hrp = getHRP()
    if p and p.Character and p.Character:FindFirstChild("HumanoidRootPart") and hrp then
        hrp.CFrame = CFrame.lookAt(hrp.Position, p.Character.HumanoidRootPart.Position)
    end
end)
cmd("size", ";size <n>", "body scale", function(a)
    local n = tonumber(a[1]); local h = getHum()
    if n and h then
        for _, prop in ipairs({ "BodyDepthScale", "BodyWidthScale", "BodyHeightScale", "HeadScale" }) do
            pcall(function() h[prop] = n end)
        end
    end
end)
cmd("ping", ";ping", "report your ping", function()
    local p = 0
    pcall(function() p = math.floor(Stats.Network.ServerStatsItem["Data Ping"]:GetValue()) end)
    notify("Ping", p .. " ms", 2)
end)
cmd("pos", ";pos", "copy your position", function()
    local hrp = getHRP()
    if hrp and setclipboard then
        setclipboard(("%d, %d, %d"):format(hrp.Position.X, hrp.Position.Y, hrp.Position.Z))
        notify("Position", "Copied", 2)
    end
end)
cmd("panic", ";panic", "disable everything", function() panic() end)
cmd("unload", ";unload", "unload okaz", function()
    Okaz.Unloaded = true
    for _, c in ipairs(Okaz.Connections) do pcall(function() c:Disconnect() end) end
    pcall(stopFly); pcall(stopCopy)
    if Music.sound then pcall(function() Music.sound:Destroy() end) end
    gui:Destroy(); overlay:Destroy()
end)

conn(LP.Chatted, function(msg)
    local prefix = cfg.cmdPrefix
    if msg:sub(1, #prefix) ~= prefix then return end
    local parts = {}
    for w in msg:sub(#prefix + 1):gmatch("%S+") do table.insert(parts, w) end
    local name = (parts[1] or ""):lower()
    local entry = commands[name]
    if not entry then return end
    table.remove(parts, 1)
    local ok, err = pcall(entry.fn, parts)
    if not ok then notify("Command", tostring(err), 3) end
end)

local cmdPage = makeTab("ￂﾻ", "Commands", 11)
build("Commands", function()
    header(cmdPage, "All Commands ￢ﾀﾔ prefix " .. cfg.cmdPrefix)
    for _, name in ipairs(commandOrder) do
        local e = commands[name]
        local r = new("Frame", {
            Size = UDim2.new(1, 0, 0, 38), BackgroundColor3 = C.panel,
            BackgroundTransparency = 0.4, BorderSizePixel = 0, ZIndex = 8,
        }, cmdPage)
        corner(r, 9)
        stroke(r, C.stroke, 1, 0.6)
        new("TextLabel", {
            Size = UDim2.new(1, -16, 0, 15), Position = UDim2.fromOffset(11, 6),
            BackgroundTransparency = 1, Font = Enum.Font.Code, TextSize = 11,
            TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = Theme.accent,
            Text = e.usage, ZIndex = 9,
        }, r)
        new("TextLabel", {
            Size = UDim2.new(1, -16, 0, 12), Position = UDim2.fromOffset(11, 21),
            BackgroundTransparency = 1, Font = Enum.Font.Gotham, TextSize = 10,
            TextXAlignment = Enum.TextXAlignment.Left, TextColor3 = C.dim,
            Text = e.desc, ZIndex = 9,
        }, r)
    end
end)

--=====================================================================
-- SETTINGS
--=====================================================================
local setPage = makeTab("￢ﾚﾙ", "Settings", 12)
local menuKeys = {
    ["K"] = Enum.KeyCode.K, ["Right Shift"] = Enum.KeyCode.RightShift,
    ["Insert"] = Enum.KeyCode.Insert, ["Right Ctrl"] = Enum.KeyCode.RightControl,
}
build("Settings", function()
    header(setPage, "Theme")
    local themePresets = {
        { "Neon Pink", Color3.fromRGB(255, 46, 122), Color3.fromRGB(158, 74, 255) },
        { "Violet", Color3.fromRGB(150, 80, 255), Color3.fromRGB(90, 120, 255) },
        { "Cyan", Color3.fromRGB(40, 210, 240), Color3.fromRGB(70, 140, 255) },
        { "Lime", Color3.fromRGB(140, 235, 80), Color3.fromRGB(40, 200, 140) },
        { "Amber", Color3.fromRGB(255, 165, 60), Color3.fromRGB(255, 90, 90) },
        { "Mono", Color3.fromRGB(225, 225, 235), Color3.fromRGB(150, 150, 165) },
    }
    local grid = new("Frame", { Size = UDim2.new(1, 0, 0, 34), BackgroundTransparency = 1 }, setPage)
    new("UIListLayout", { FillDirection = Enum.FillDirection.Horizontal, Padding = UDim.new(0, 6) }, grid)
    for i, pre in ipairs(themePresets) do
        local b = new("TextButton", {
            Size = UDim2.new(1 / 6, -5, 1, 0), BackgroundColor3 = pre[2],
            Text = "", AutoButtonColor = false, LayoutOrder = i, ZIndex = 9,
        }, grid)
        corner(b, 8)
        new("UIGradient", { Color = ColorSequence.new({
            ColorSequenceKeypoint.new(0, pre[2]),
            ColorSequenceKeypoint.new(1, pre[3]),
        }) }, b)
        b.MouseButton1Click:Connect(function()
            Theme.accent = pre[2]; Theme.accent2 = pre[3]; retint(); click(); notify("Theme", pre[1], 2)
        end)
        b.MouseEnter:Connect(function() tween(b, 0.15, { Size = UDim2.new(1 / 6, -2, 1, 4) }) end)
        b.MouseLeave:Connect(function() tween(b, 0.15, { Size = UDim2.new(1 / 6, -5, 1, 0) }) end)
    end

    spacer(setPage, 2)
    header(setPage, "Custom Color")
    slider(setPage, "Red", 0, 255, 255, 0, function(v)
        Theme.accent = Color3.fromRGB(v, Theme.accent.G * 255, Theme.accent.B * 255); retint()
    end)
    slider(setPage, "Green", 0, 255, 46, 0, function(v)
        Theme.accent = Color3.fromRGB(Theme.accent.R * 255, v, Theme.accent.B * 255); retint()
    end)
    slider(setPage, "Blue", 0, 255, 122, 0, function(v)
        Theme.accent = Color3.fromRGB(Theme.accent.R * 255, Theme.accent.G * 255, v); retint()
    end)

    spacer(setPage, 2)
    header(setPage, "Interface")
    slider(setPage, "Opacity", 0, 0.6, 0, 2, function(v)
        cfg.opacity = v
        win.BackgroundTransparency = v
    end)
    slider(setPage, "UI Scale", 0.7, 1.4, 1, 2, function(v)
        cfg.scale = v
        win.Size = UDim2.fromOffset(W * v, H * v)
        shadow.Size = UDim2.fromOffset(W * v + 34, H * v + 34)
    end)
    toggle(setPage, "Click Sounds", "Audio feedback on the UI", true, function(v) sfxOn = v end)
    toggle(setPage, "Lock Window", "Prevent dragging", false, function(v) dragLocked = v end)
    dropdown(setPage, "Menu Key", { "K", "Right Shift", "Insert", "Right Ctrl" }, function(v)
        cfg.menuKey = menuKeys[v]
    end)
end)

--=====================================================================
-- MISC
--=====================================================================
local miscPage = makeTab("￢ﾜﾜ", "Misc", 13)
local spamOn = false
build("Misc", function()
    header(miscPage, "Chat")
    local spamText = textbox(miscPage, "Message", "text to spam", "okaz on top", function(v) cfg.spamMsg = v end)
    toggle(miscPage, "Chat Spam", "Send on a timer", false, function(v)
        spamOn = v
        if v then
            task.spawn(function()
                while spamOn do say(cfg.spamMsg); task.wait(cfg.spamRate) end
            end)
        end
    end)
    slider(miscPage, "Spam Rate", 1, 20, 2, 1, function(v) cfg.spamRate = v end)
    button(miscPage, "Send Once", function() say(spamText.Text) end)

    spacer(miscPage, 2)
    header(miscPage, "Server")
    button(miscPage, "Rejoin", function()
        notify("Server", "Rejoining...", 2); task.wait(0.6)
        TeleportService:Teleport(game.PlaceId, LP)
    end)
    button(miscPage, "Server Hop", function()
        notify("Server", "Searching...", 2)
        local ok, res = pcall(function()
            return HttpService:JSONDecode(game:HttpGet(
                ("https://games.roblox.com/v1/games/%d/servers/Public?sortOrder=Asc&limit=100"):format(game.PlaceId)))
        end)
        if ok and res and res.data then
            for _, s in ipairs(res.data) do
                if s.playing < s.maxPlayers and s.id ~= game.JobId then
                    TeleportService:TeleportToPlaceInstance(game.PlaceId, s.id, LP); return
                end
            end
            notify("Server", "No free servers", 2)
        else notify("Server", "Hop failed", 2) end
    end)
    button(miscPage, "Copy Job ID", function()
        if setclipboard then setclipboard(game.JobId); notify("Clipboard", "Copied", 2) end
    end)
    toggle(miscPage, "Auto Rejoin", "Reconnect if you drop", false, function(v) cfg.autoRejoin = v end)
    conn(Players.PlayerRemoving, function(p)
        if p == LP and cfg.autoRejoin and not Okaz.Unloaded then
            task.wait(2)
            pcall(function() TeleportService:Teleport(game.PlaceId, LP) end)
        end
    end)

    spacer(miscPage, 2)
    header(miscPage, "Config")
    button(miscPage, "Save Config", function()
        if not writefile then return end
        local data = {}
        for k, v in pairs(cfg) do
            if type(v) == "number" or type(v) == "boolean" or type(v) == "string" then data[k] = v end
        end
        data.aimInputName = cfg.aimInput and cfg.aimInput.Name
        data.menuKeyName = cfg.menuKey and cfg.menuKey.Name
        data.accent = { Theme.accent.R, Theme.accent.G, Theme.accent.B }
        data.accent2 = { Theme.accent2.R, Theme.accent2.G, Theme.accent2.B }
        pcall(writefile, "okaz_v18_config.json", HttpService:JSONEncode(data))
        notify("Config", "Saved", 2)
    end)
    button(miscPage, "Load Config", function()
        if not readfile or not isfile or not isfile("okaz_v18_config.json") then
            notify("Config", "No saved config", 2); return
        end
        local ok, data = pcall(function() return HttpService:JSONDecode(readfile("okaz_v18_config.json")) end)
        if not ok or not data then return end
        for k, v in pairs(data) do
            if k ~= "aimInputName" and k ~= "menuKeyName" and k ~= "accent" and k ~= "accent2" then cfg[k] = v end
        end
        local km = _G.okazKeyMap
        if data.aimInputName and km and km[data.aimInputName] then
            local m = km[data.aimInputName]
            cfg.aimIsMouse = typeof(m) == "EnumItem" and m.EnumType == Enum.UserInputType
            cfg.aimInput = m
        end
        if data.menuKeyName and menuKeys[data.menuKeyName] then cfg.menuKey = menuKeys[data.menuKeyName] end
        if data.accent then Theme.accent = Color3.fromRGB(data.accent[1], data.accent[2], data.accent[3]) end
        if data.accent2 then Theme.accent2 = Color3.fromRGB(data.accent2[1], data.accent2[2], data.accent2[3]) end
        retint()
        notify("Config", "Loaded", 3)
    end)

    spacer(miscPage, 2)
    header(miscPage, "Performance")
    toggle(miscPage, "FPS Unlocker", "Remove the 60 cap", false, function(v)
        if setfpscap then setfpscap(v and 240 or 60) end
    end)
    slider(miscPage, "FPS Cap", 30, 480, 240, 0, function(v)
        if setfpscap then setfpscap(v) end
    end)
    toggle(miscPage, "Watermark", "Stats overlay", true, function(v) wm.Visible = v end)
    button(miscPage, "Unload okaz", function() commands.unload.fn({}) end)
end)

--=====================================================================
-- PANIC
--=====================================================================
panic = function()
    cfg.aimEnabled = false; fovCircle.Visible = false; targetHud.Visible = false
    cfg.espEnabled = false; cfg.autoclick = false; autoJump = false; infJump = false
    antiVoid = false; antiFling = false; autoFling = false; tpLoop = false; spamOn = false
    cfg.tracers = false; cfg.distHud = false; distHud.Visible = false
    if flying then stopFly(); recover(4) end
    if copying then stopCopy() end
    if noclip then noclip = false; setCollisions(true); recover(4) end
    if frozen then
        frozen = false
        local hrp = getHRP(); if hrp then hrp.Anchored = false end
    end
    for _, p in ipairs(Players:GetPlayers()) do
        local ch = p.Character
        if ch then
            local h = ch:FindFirstChild("okazHL"); if h then h:Destroy() end
            local b = ch:FindFirstChild("okazESP"); if b then b:Destroy() end
        end
    end
    notify("Panic", "Everything disabled", 3)
end

--=====================================================================
-- AIMBOT ￢ﾀﾔ angular
--=====================================================================
local aiming, stickyTarget = false, nil
local function isAimInput(i)
    if cfg.aimIsMouse then return i.UserInputType == cfg.aimInput end
    return i.KeyCode == cfg.aimInput
end
conn(UserInputService.InputBegan, function(i, gp)
    if not gp and isAimInput(i) then aiming = true end
end)
conn(UserInputService.InputEnded, function(i)
    if isAimInput(i) then aiming = false; stickyTarget = nil; targetHud.Visible = false end
end)

local function isVisible(part)
    local params = RaycastParams.new()
    params.FilterDescendantsInstances = { LP.Character }
    params.FilterType = Enum.RaycastFilterType.Exclude
    local res = Workspace:Raycast(Camera.CFrame.Position, part.Position - Camera.CFrame.Position, params)
    return res == nil or res.Instance:IsDescendantOf(part.Parent)
end

local function fovRadians()
    local ppRad = (Camera.ViewportSize.Y * 0.5) / math.tan(math.rad(Camera.FieldOfView) * 0.5)
    return cfg.fov / ppRad
end

local function validTarget(part)
    if not part or not part.Parent then return false end
    local hum = part.Parent:FindFirstChildOfClass("Humanoid")
    if not hum or hum.Health <= 0 then return false end
    local to = part.Position - Camera.CFrame.Position
    if to.Magnitude < 0.1 then return true end
    local ang = math.acos(math.clamp(Camera.CFrame.LookVector:Dot(to.Unit), -1, 1))
    if ang > fovRadians() then return false end
    if cfg.wallCheck and not isVisible(part) then return false end
    return true
end

local function acquire()
    local best, bestAng
    local look = Camera.CFrame.LookVector
    local limit = fovRadians()
    for _, plr in ipairs(Players:GetPlayers()) do
        if plr ~= LP and plr.Character then
            local part = plr.Character:FindFirstChild(cfg.targetPart)
            local hum = plr.Character:FindFirstChildOfClass("Humanoid")
            if part and hum and hum.Health > 0 then
                local skip = false
                if cfg.teamCheck and plr.Team and LP.Team and plr.Team == LP.Team then skip = true end
                if not skip then
                    local to = part.Position - Camera.CFrame.Position
                    if to.Magnitude > 0.1 then
                        local ang = math.acos(math.clamp(look:Dot(to.Unit), -1, 1))
                        if ang <= limit and (not bestAng or ang < bestAng) then
                            if not cfg.wallCheck or isVisible(part) then best, bestAng = part, ang end
                        end
                    end
                end
            end
        end
    end
    return best
end

RunService:BindToRenderStep("okazAim", Enum.RenderPriority.Camera.Value + 1, function(dt)
    if fovCircle.Visible then
        local m = UserInputService:GetMouseLocation()
        fovCircle.Position = UDim2.fromOffset(m.X, m.Y)
    end
    if not (cfg.aimEnabled and aiming) then
        if targetHud.Visible then targetHud.Visible = false end
        return
    end
    if not (cfg.sticky and stickyTarget and validTarget(stickyTarget)) then
        stickyTarget = acquire()
    end
    local target = stickyTarget
    if not target then
        targetHud.Visible = false
        return
    end

    local camPos = Camera.CFrame.Position
    local look = Camera.CFrame.LookVector
    local aimPos = target.Position
    if cfg.prediction > 0 then aimPos += target.AssemblyLinearVelocity * cfg.prediction end

    local to = aimPos - camPos
    if to.Magnitude < 0.1 then return end

    local flatTo = Vector3.new(to.X, 0, to.Z)
    local flatLook = Vector3.new(look.X, 0, look.Z)
    local yaw = 0
    if flatTo.Magnitude > 0.01 and flatLook.Magnitude > 0.01 then
        yaw = wrapAngle(math.atan2(flatTo.X, flatTo.Z) - math.atan2(flatLook.X, flatLook.Z))
    end
    local pitch = math.asin(math.clamp(to.Unit.Y, -1, 1)) - math.asin(math.clamp(look.Y, -1, 1))

    local ppRad = (Camera.ViewportSize.Y * 0.5) / math.tan(math.rad(Camera.FieldOfView) * 0.5)
    local dx = yaw * ppRad
    local dy = -pitch * ppRad
    if Vector2.new(dx, dy).Magnitude <= cfg.deadzone then return end

    local alpha = math.clamp(dt * (60 / math.max(cfg.smooth, 1)), 0.02, 1)
    local stepX, stepY = dx * alpha, dy * alpha
    local stepLen = Vector2.new(stepX, stepY).Magnitude
    if stepLen > 420 then
        stepX = stepX / stepLen * 420
        stepY = stepY / stepLen * 420
    end

    if cfg.aimMode == "Mouse" and mousemoverel then
        mousemoverel(stepX, stepY)
    else
        Camera.CFrame = Camera.CFrame:Lerp(CFrame.lookAt(camPos, aimPos), alpha)
    end

    if cfg.targetHud then
        local hum = target.Parent and target.Parent:FindFirstChildOfClass("Humanoid")
        local hrp = getHRP()
        targetHud.Visible = true
        thName.Text = target.Parent and target.Parent.Name or "?"
        if hum then
            local r = hum.Health / math.max(hum.MaxHealth, 1)
            thFill.Size = UDim2.fromScale(r, 1)
            thFill.BackgroundColor3 = Color3.fromRGB(255 * (1 - r), 220 * r, 90)
        end
        thInfo.Text = hrp and ("%d studs"):format((target.Position - hrp.Position).Magnitude) or ""
    end
end)

--=====================================================================
-- OPEN / CLOSE + ORB
--=====================================================================
local orb = new("TextButton", {
    Size = UDim2.fromOffset(46, 46), Position = UDim2.fromOffset(18, 18),
    BackgroundColor3 = C.bg, BackgroundTransparency = 0.1,
    Font = Enum.Font.GothamBlack, TextSize = 15, TextColor3 = Theme.accent,
    Text = "O", AutoButtonColor = false, Visible = false,
}, gui)
corner(orb, 999)
local orbStroke = stroke(orb, Theme.accent, 1.5, 0.2)
table.insert(retinters, function() orb.TextColor3 = Theme.accent; orbStroke.Color = Theme.accent end)
orb.MouseButton1Click:Connect(function()
    orb.Visible = false
    setOpen(true)
end)

local open = true
setOpen = function(v)
    open = v
    if v then
        win.Visible = true; shadow.Visible = true; orb.Visible = false
        tween(win, 0.4, { Size = UDim2.fromOffset(W * cfg.scale, H * cfg.scale) }, Enum.EasingStyle.Back)
        tween(shadow, 0.4, { Size = UDim2.fromOffset(W * cfg.scale + 34, H * cfg.scale + 34) }, Enum.EasingStyle.Back)
    else
        tween(win, 0.25, { Size = UDim2.fromOffset(0, 0) }, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
        tween(shadow, 0.25, { Size = UDim2.fromOffset(0, 0) }, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
        task.delay(0.25, function() win.Visible = false; shadow.Visible = false end)
    end
end

win.Size = UDim2.fromOffset(0, 0)
shadow.Size = UDim2.fromOffset(0, 0)
task.spawn(function()
    tween(win, 0.55, { Size = UDim2.fromOffset(W, H) }, Enum.EasingStyle.Back)
    tween(shadow, 0.55, { Size = UDim2.fromOffset(W + 34, H + 34) }, Enum.EasingStyle.Back)
end)

closeBtn.MouseButton1Click:Connect(function() setOpen(false) end)
minBtn.MouseButton1Click:Connect(function()
    tween(win, 0.3, { Size = UDim2.fromOffset(W * cfg.scale, 46) }, Enum.EasingStyle.Quad)
    task.delay(0.3, function() setOpen(false) end)
end)
orbBtn.MouseButton1Click:Connect(function()
    setOpen(false)
    task.delay(0.3, function() orb.Visible = true end)
end)
centerBtn.MouseButton1Click:Connect(function()
    win.Position = UDim2.fromScale(0.5, 0.5)
    shadow.Position = win.Position
    click()
end)
conn(UserInputService.InputBegan, function(i, gp)
    if not gp and i.KeyCode == cfg.menuKey then
        if open then setOpen(false) else setOpen(true) end
    end
end)

if _G.okazRebuildList then _G.okazRebuildList() end
selectTab(tabs[1].button, tabs[1].page)
notify("okaz reworked", "V18 ￢ﾀﾔ ;cmds for commands", 4)

if #Okaz.Errors > 0 then
    task.delay(1, function()
        notify("Build warnings", ("%d section(s) failed"):format(#Okaz.Errors), 6)
        for _, e in ipairs(Okaz.Errors) do warn("[okaz] " .. e) end
    end)
end

conn(LP.CharacterAdded, function()
    task.wait(1)
    local h = getHum()
    if h then h.WalkSpeed = cfg.speed; h.UseJumpPower = true; h.JumpPower = cfg.jump end
    if flying then stopFly() end
    if copying then stopCopy() end
    task.wait(0.5)
    if _G.okazRebuildList then _G.okazRebuildList() end
end)