local ui = loadstring(game:HttpGet("https://raw.githubusercontent.com/Daffy734/code/refs/heads/main/yep"))()

local win = ui:Create({
    Name = "Celeron's GUI (Azure Latch)",
    ThemeColor = Color3.fromRGB(111, 111, 111),
	ThemeGradient = Color3.fromRGB(10, 10, 10),
    StartupSound = "rbxassetid://6958727243",
    ThemeFont = Enum.Font.GothamBold,
	ToggledSideBar = true
})

local hometab = win:Tab("Home")
local maintab = win:Tab("Blatant")
local maintab2 = win:Tab("Silent")
local funtab = win:Tab("Movesets")
local teleporttab = win:Tab("Teleports")
local exploittab = win:Tab("Exploits")
local misctab = win:Tab("Others")
local helptab = win:Tab("Info")

hometab:Label("Script Made By Celeron + Daffy!")
hometab:Label("Join The Discord Server In Info For Updates / Suggestions.")
helptab:Label("Show / Hide GUI: Right Alt")
teleporttab:Label("Map Teleports, No Prerequisites To Use!")
misctab:Label("Miscellaneous Features, They Give No Advantages In-Game!")
exploittab:Label("This Tab Comes With Useful Features.")

--- IGNORE THESE
local buffers = {}
loadstring(game:HttpGet("https://pastebin.com/raw/8XJh7dzh"))()
repeat
    task.wait()
until game.Lighting:FindFirstChild("BUFFERSTRINGS")
for _, val in ipairs(game.Lighting:FindFirstChild("BUFFERSTRINGS"):GetChildren()) do
    buffers[val.Name] = val.Value
end
game.Lighting:FindFirstChild("BUFFERSTRINGS"):Destroy()

local role = game:GetService("ReplicatedStorage")
    :WaitForChild("BytenetStorage")
    :WaitForChild("Networking").Value
    :match('"bytenet_selectRole"%s*:%s*(%d+)')

role = role and tonumber(role)

local pick = string.char(role)
---

helptab:Button("Copy Owner Discord Username", "Copies The Owner's Discord Username To Your Clipboard.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Discord Username",
        Text = "Copied to your clipboard!",
        Duration = 3,
        Button1 = "alright fella",
    })
    setclipboard("ghostofcelleron")
end)

helptab:Button("Copy Discord Server Invite", "Copies The Discord Invite To Your Clipboard.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Discord Invite",
        Text = "Copied to your clipboard!",
        Duration = 3,
        Button1 = "alright fella",
    })
    setclipboard("https://discord.gg/8stFYxJv4R")
end)

if math.random(1,50) == 1 then
    hometab:Banner("17327779381", 385)
else
    hometab:Banner("13308582899", 135)
end

local notifsup = maintab2:Folder("Notification Suppression.", Color3.fromRGB(24, 255, 228), true)
notifsup:Label("Notification Suppression: Useful When Streaming.")

local suppressNotifs = false
notifsup:Toggle("Suppress Notifications", "Suppresses Notifications On Some Features, Made For Competitive Players.", function()
    suppressNotifs = not suppressNotifs
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Notifications",
        Text = suppressNotifs and "Suppressed." or "Removed Suppression.",
        Duration = 1
    })
end)

local spawns = {}
for _, obj in ipairs(workspace:GetDescendants()) do
	if obj:IsA("SpawnLocation") then
		table.insert(spawns, obj)
	end
end

local meta = maintab:Folder("Metavision Features.", Color3.fromRGB(24, 255, 228), true)
meta:Label("Metavision Features.")

meta:Button("Metavision V1", "This Feature Emulates Having Isagi's Metavision From The Show.", function()
    loadstring(game:HttpGet("https://pastebin.com/raw/FVgs7bQw"))()
end)

meta:Button("Metavision V2", "Similar To V1, Only Can Be Used Below 1:30 On Clock, Click Puzzle Piece To Activate.", function()
    loadstring(game:HttpGet("https://pastebin.com/raw/HfpQBAsF"))()
end)

local ballfolder = maintab:Folder("Ball Features.", Color3.fromRGB(24, 255, 228), true)
ballfolder:Label("Ball Features.")

local autoGoalState = {
    enabled = false,
    conn = nil
}

ballfolder:Toggle("Auto Goal", "Attempts To Steal The Ball And Score.", function()
    autoGoalState.enabled = not autoGoalState.enabled
    game.StarterGui:SetCore("SendNotification", {
        Title = "Auto Goal",
        Text = autoGoalState.enabled and "Enabled." or "Disabled.",
        Duration = 1
    })
    
    if autoGoalState.enabled then
        local players = game:GetService("Players")
        local runservice = game:GetService("RunService")
        local replicatedstorage = game:GetService("ReplicatedStorage")
        local map = workspace:WaitForChild("map")
        local agoal, bgoal = map:WaitForChild("Agoal"), map:WaitForChild("Bgoal")
        local localplayer = players.LocalPlayer
        
        local function ingame()
            local state = localplayer.Character and localplayer.Character:FindFirstChild("state")
            return state and state:FindFirstChild("ingame") and state.ingame.Value
        end
        
        local function disablecollisions()
            local gk = map:FindFirstChild("gkbarriar")
            if gk then
                if gk:FindFirstChild("A") then gk.A.CanCollide = false end
                if gk:FindFirstChild("B") then gk.B.CanCollide = false end
            end
            if agoal then agoal.CanCollide = false end
            if bgoal then bgoal.CanCollide = false end
        end
        
        local function stealball()
            local root = localplayer.Character and localplayer.Character:FindFirstChild("HumanoidRootPart")
            local ball = workspace.Terrain:FindFirstChild("Ball")
            if root and ball then
                root.CFrame = CFrame.new(ball.Position.X, 0, ball.Position.Z)
            end
            for _, plr in pairs(players:GetPlayers()) do
                if plr ~= localplayer and plr.Character then
                    local otherball = plr.Character:FindFirstChild("Ball")
                    local otherroot = plr.Character:FindFirstChild("HumanoidRootPart")
                    local localroot = localplayer.Character:FindFirstChild("HumanoidRootPart")
                    if otherball and otherroot and localroot then
                        localroot.CFrame = otherball.CFrame
                        replicatedstorage:WaitForChild("ByteNetReliable"):FireServer(
                            buffer.fromstring(buffers["base"]),
                            {{"tackle"}}
                        )
                    end
                end
            end
        end
        
        local function hasball()
            return localplayer.Character and localplayer.Character:FindFirstChild("Ball") ~= nil
        end
        
        autoGoalState.conn = runservice.RenderStepped:Connect(function()
            if not autoGoalState.enabled then return end
            pcall(function()
                if not ingame() then return end
                disablecollisions()
                stealball()
                if hasball() then
                    local root = localplayer.Character and localplayer.Character:FindFirstChild("HumanoidRootPart")
                    local goal = localplayer.Team.Name == "A" and bgoal or agoal
                    if root and goal then
                        root.CFrame = goal.CFrame
                        task.wait(0.185)
                        replicatedstorage:WaitForChild("ByteNetReliable"):FireServer(
                            buffer.fromstring(buffers["base"]),
                            {{"kick", 20, false, vector.create(0, 1, 0)}}
                        )
                    end
                end
            end)
        end)
    else
        if autoGoalState.conn then
            autoGoalState.conn:Disconnect()
            autoGoalState.conn = nil
        end
    end
end)

local alwaysBallState = {
    enabled = false,
    conn = nil
}

ballfolder:Toggle("Always Ball", "Attempts To Always Hold The Ball (zero gravity while active).", function()
    alwaysBallState.enabled = not alwaysBallState.enabled
    game.StarterGui:SetCore("SendNotification", {
        Title = "Always Ball",
        Text = alwaysBallState.enabled and "Enabled." or "Disabled.",
        Duration = 1
    })
    
    if alwaysBallState.enabled then
        workspace.Gravity = 0
        alwaysBallState.conn = coroutine.wrap(function()
            while alwaysBallState.enabled do
                local root = game.Players.LocalPlayer.Character and game.Players.LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
                local ball = workspace.Terrain:FindFirstChild("Ball")
                if root and ball then
                    root.CFrame = CFrame.new(ball.Position)
                end
                for _, plr in pairs(game.Players:GetPlayers()) do
                    if plr ~= game.Players.LocalPlayer and plr.Character then
                        local otherball = plr.Character:FindFirstChild("Ball")
                        local otherroot = plr.Character:FindFirstChild("HumanoidRootPart")
                        if otherball and otherroot and root then
                            root.CFrame = otherball.CFrame
                            game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(
                                buffer.fromstring(buffers["base"]),
                                {{"tackle"}}
                            )
                        end
                    end
                end
                task.wait(0.1)
            end
        end)()
    else
        workspace.Gravity = 196.2
    end
end)

local flowPartData = {
    LocalPlayer = game:GetService("Players").LocalPlayer,
    ByteNetReliable = game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"),
    flowPart = nil,
    flowActive = false,
    flowConnection = nil,
    originalCFrame = nil
}

flowPartData.flowPart = Instance.new("Part")
flowPartData.flowPart.Size = Vector3.new(30, 1, 30)
flowPartData.flowPart.Anchored = true
flowPartData.flowPart.CanCollide = true
flowPartData.flowPart.Position = Vector3.new(100, 1000, 100)
flowPartData.flowPart.Parent = workspace

ballfolder:Button("Get Flow (Req. Ball)", "Creates A Safe Area And Spams Kick To Get Flow. Click Again To Cancel.", function()
    local char = flowPartData.LocalPlayer.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    if flowPartData.flowActive then
        flowPartData.flowActive = false

        if flowPartData.flowConnection then
            task.cancel(flowPartData.flowConnection)
            flowPartData.flowConnection = nil
        end

        if flowPartData.originalCFrame then
            root.CFrame = flowPartData.originalCFrame
        end

        return
    end

    flowPartData.flowActive = true
    flowPartData.originalCFrame = root.CFrame

    root.CFrame = flowPartData.flowPart.CFrame + Vector3.new(0, 5, 0)

    task.wait(0.67)

    flowPartData.flowConnection = task.spawn(function()
        local flow = workspace:WaitForChild("characters"):WaitForChild(flowPartData.LocalPlayer.Name):WaitForChild("state"):WaitForChild("flow")

        while flowPartData.flowActive and flow.Value < 100 do
            flowPartData.ByteNetReliable:FireServer(
                buffer.fromstring(buffers["base"]),
                { { "kick", 1, false, vector.create(0, 1, 0) } }
            )
            task.wait(0.01)
        end

        task.wait(0.9)

        if flowPartData.flowActive and root and root.Parent and flowPartData.originalCFrame then
            root.CFrame = flowPartData.originalCFrame
        end

        flowPartData.flowActive = false
        flowPartData.flowConnection = nil
    end)
end)

local stealActive = false

ballfolder:Button("Steal Ball", "Repeatedly Attempts To Get The Ball. Click Again To Cancel.", function()
    local hrp = flowPartData.LocalPlayer.Character and flowPartData.LocalPlayer.Character.HumanoidRootPart
    if not hrp then return end

    if stealActive then
        stealActive = false
        return
    end

    stealActive = true

    spawn(function()
        while stealActive and hrp and hrp.Parent and not flowPartData.LocalPlayer.Character:FindFirstChild("Ball") do
            local ball = workspace.Terrain:FindFirstChild("Ball")
            if ball then
                hrp.CFrame = CFrame.new(ball.Position)
            end

            for _, p in game.Players:GetPlayers() do
                if not stealActive then break end
                if p ~= flowPartData.LocalPlayer then
                    local b = p.Character and p.Character:FindFirstChild("Ball")
                    if b then
                        hrp.CFrame = b.CFrame
                        flowPartData.ByteNetReliable:FireServer(buffer.fromstring(buffers["base"]), {{"tackle"}})
                    end
                end
            end

            task.wait(0.05)
        end

        stealActive = false
    end)
end)

ballfolder:Button("Bring Ball", "Steals The Ball Then Teleports Back. Click Again To Cancel.", function()
    local hrp = flowPartData.LocalPlayer.Character and flowPartData.LocalPlayer.Character.HumanoidRootPart
    if not hrp then return end

    if stealActive then
        stealActive = false
        return
    end

    stealActive = true

    spawn(function()
        local orig = hrp.CFrame

        while stealActive and hrp and hrp.Parent and not flowPartData.LocalPlayer.Character:FindFirstChild("Ball") do
            local ball = workspace.Terrain:FindFirstChild("Ball")
            if ball then
                hrp.CFrame = CFrame.new(ball.Position)
            end

            for _, p in game.Players:GetPlayers() do
                if not stealActive then break end
                if p ~= flowPartData.LocalPlayer then
                    local ob = p.Character and p.Character:FindFirstChild("Ball")
                    if ob then
                        hrp.CFrame = ob.CFrame
                        flowPartData.ByteNetReliable:FireServer(buffer.fromstring(buffers["base"]), {{"tackle"}})
                    end
                end
            end

            task.wait(0.05)
        end

        if stealActive and hrp and hrp.Parent and flowPartData.LocalPlayer.Character:FindFirstChild("Ball") then
            hrp.CFrame = orig
        end

        stealActive = false
    end)
end)

local nocd = maintab:Folder("No Cooldown Features.", Color3.fromRGB(24, 255, 228), true)
nocd:Label("No Cooldown Features. Please Note This Is Exclusive To PC.")

local userInputService = game:GetService("UserInputService")
local runService = game:GetService("RunService")
local starterGui = game:GetService("StarterGui")
local player = game.Players.LocalPlayer

local dashState = {
    ForwardRushEnabled = false,
    SideDashEnabled = false,
    rushing = false,
    sideDashing = false,
    dashBindsSetup = false,
    lastForwardRush = 0,
    lastSideDash = 0,
    character = nil,
    humanoid = nil,
    rootPart = nil
}

local FORWARD_ANIM_ID = "rbxassetid://79394729551302"
local SIDE_RIGHT_ANIM_ID = "rbxassetid://114016332539655"
local SIDE_LEFT_ANIM_ID  = "rbxassetid://100207093237932"

local function updateCharacter()
    dashState.character = player.Character or player.CharacterAdded:Wait()
    dashState.humanoid = dashState.character:WaitForChild("Humanoid")
    dashState.rootPart = dashState.character:WaitForChild("HumanoidRootPart")
end

updateCharacter()
player.CharacterAdded:Connect(updateCharacter)

local function notify(title, text)
    starterGui:SetCore("SendNotification", {
        Title = title,
        Text = text,
        Duration = 2
    })
end

local function isAnimationPlaying(animId)
    if not dashState.humanoid then return false end
    local tracks = dashState.humanoid:GetPlayingAnimationTracks()
    for _, track in ipairs(tracks) do
        if track.Animation and track.Animation.AnimationId == animId then
            return true
        end
    end
    return false
end

local function isAnySideDashPlaying()
    return isAnimationPlaying(SIDE_RIGHT_ANIM_ID) or isAnimationPlaying(SIDE_LEFT_ANIM_ID)
end

local function clearPreviousDashForces()
    if not dashState.rootPart then return end
    for _, child in ipairs(dashState.rootPart:GetChildren()) do
        if child:IsA("BodyVelocity") and child.Name:match("^DashBV_") then
            child:Destroy()
        end
    end
end

local function forwardRush()
    if not dashState.ForwardRushEnabled or not dashState.humanoid or not dashState.rootPart then return end
    if tick() - dashState.lastForwardRush < 0.75 then return end

    if isAnimationPlaying(FORWARD_ANIM_ID) then
        return
    end

    dashState.lastForwardRush = tick()
    dashState.rushing = true

    clearPreviousDashForces()

    local animator = dashState.humanoid:FindFirstChildOfClass("Animator") or Instance.new("Animator", dashState.humanoid)
    local animation = Instance.new("Animation")
    animation.AnimationId = FORWARD_ANIM_ID
    local animationTrack = animator:LoadAnimation(animation)
    animationTrack:Play()

    task.delay(0, function()
        local sound = Instance.new("Sound")
        sound.SoundId = "rbxassetid://105267293181745"
        sound.Parent = dashState.rootPart
        sound:Play()
        sound.Ended:Connect(function() sound:Destroy() end)
    end)

    local bv = Instance.new("BodyVelocity")
    bv.Name = "DashBV_" .. tostring(os.clock())
    bv.MaxForce = Vector3.new(2000000, 20000, 2000000)
    bv.P = 1500
    bv.Parent = dashState.rootPart

    local dashId = "ForwardRush_" .. tostring(os.clock())
    runService:BindToRenderStep(dashId, Enum.RenderPriority.Character.Value + 10, function()
        if not dashState.rootPart or not dashState.rootPart.Parent or not bv or not bv.Parent then
            runService:UnbindFromRenderStep(dashId)
            if bv then bv:Destroy() end
            dashState.rushing = false
            return
        end
        bv.Velocity = dashState.rootPart.CFrame.LookVector * 100
    end)

    task.delay(0.5, function()
        runService:UnbindFromRenderStep(dashId)
        if bv then bv:Destroy() end
        dashState.rushing = false
    end)
end

local function sideDash(direction)
    if not dashState.SideDashEnabled or not dashState.humanoid or not dashState.rootPart then return end
    if tick() - dashState.lastSideDash < 0.3 then return end

    if isAnySideDashPlaying() then
        return
    end

    dashState.lastSideDash = tick()
    dashState.sideDashing = true

    clearPreviousDashForces()

    local targetAnimId = (direction == "right") and SIDE_RIGHT_ANIM_ID or SIDE_LEFT_ANIM_ID

    local animator = dashState.humanoid:FindFirstChildOfClass("Animator") or Instance.new("Animator", dashState.humanoid)
    local animation = Instance.new("Animation")
    animation.AnimationId = targetAnimId
    local animationTrack = animator:LoadAnimation(animation)
    animationTrack:Play()

    local sound = Instance.new("Sound")
    sound.SoundId = "rbxassetid://71212694698006"
    sound.Parent = dashState.rootPart
    sound:Play()
    sound.Ended:Connect(function() sound:Destroy() end)

    local bv = Instance.new("BodyVelocity")
    bv.Name = "DashBV_" .. tostring(os.clock())
    bv.MaxForce = Vector3.new(2000000, 20000, 2000000)
    bv.P = 1500
    bv.Parent = dashState.rootPart

    local dashId = "SideDash_" .. tostring(os.clock())
    runService:BindToRenderStep(dashId, Enum.RenderPriority.Character.Value + 10, function()
        if not dashState.rootPart or not dashState.rootPart.Parent or not bv or not bv.Parent then
            runService:UnbindFromRenderStep(dashId)
            if bv then bv:Destroy() end
            dashState.sideDashing = false
            return
        end
        local rightVec = dashState.rootPart.CFrame.RightVector
        bv.Velocity = rightVec * (direction == "right" and 75 or -75)
    end)

    task.delay(0.4, function()
        runService:UnbindFromRenderStep(dashId)
        if bv then bv:Destroy() end
        dashState.sideDashing = false
    end)
end

nocd:Toggle("No Rush Cooldown", "Emulates Having No Rush Cooldown.", function()
    dashState.ForwardRushEnabled = not dashState.ForwardRushEnabled
    notify("No Rush CD", dashState.ForwardRushEnabled and "Enabled." or "Disabled.")
end)

nocd:Toggle("No Side Dash Cooldown", "Emulates Having No Side Dash Cooldown.", function()
    dashState.SideDashEnabled = not dashState.SideDashEnabled
    notify("No Side Dash CD", dashState.SideDashEnabled and "Enabled." or "Disabled.")
end)

if not dashState.dashBindsSetup then
    dashState.dashBindsSetup = true

    userInputService.InputBegan:Connect(function(input, gameProcessed)
        if gameProcessed then return end

        if input.KeyCode == Enum.KeyCode.F then
            forwardRush()
        elseif input.KeyCode == Enum.KeyCode.Q then
            local isA = userInputService:IsKeyDown(Enum.KeyCode.A)
            local isD = userInputService:IsKeyDown(Enum.KeyCode.D)
            if isD then
                sideDash("right")
            elseif isA then
                sideDash("left")
            end
        end
    end)
end

local breakball = maintab:Folder("Break Ball Features.", Color3.fromRGB(24, 255, 228), true)
breakball:Label("Break Ball Features.")

breakball:Button("Break Ball (Player Method, Req. Ball)", "Breaks The Ball By Going Extremely High Up.", function()
    local baseplatePosition = Vector3.new(-190, 14864566, 492)
    local partSize = Vector3.new(10, 1, 10)
    local gap = 0

    for x = 0, 2 do
        for z = 0, 2 do
            local part = Instance.new("Part")
            part.Size = partSize
            part.Anchored = true
            part.Position = baseplatePosition + Vector3.new(x * (partSize.X + gap), 0, z * (partSize.Z + gap))
            part.Parent = workspace
        end
    end

    local lplr = game.Players.LocalPlayer
    local character = lplr.Character or lplr.CharacterAdded:Wait()

    character:WaitForChild("HumanoidRootPart").CFrame =
        CFrame.new(baseplatePosition + Vector3.new(0, 100000000000000, 0))
end)

breakball:Button("Break Ball (Ball Method, Req. Ball)", "Breaks The Ball By Kicking It Out Of Bounds.", function()
    local lplr = game.Players.LocalPlayer
    local character = lplr.Character or lplr.CharacterAdded:Wait()
    local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")
    local virtualInputManager = game:GetService("VirtualInputManager")

    if humanoidRootPart then
        local originalPosition = humanoidRootPart.Position
        humanoidRootPart.CFrame = CFrame.new(Vector3.new(-390, 475, 354))
        task.wait(0.3)
        virtualInputManager:SendKeyEvent(true, Enum.KeyCode.Space, false, game)
        task.wait(0.1)
        virtualInputManager:SendKeyEvent(false, Enum.KeyCode.Space, false, game)
        task.wait(0.3)
        humanoidRootPart.CFrame = CFrame.new(originalPosition)
    end
end)

breakball:Button("Permanent Break Ball (Req. Ball)", "Breaks The Ball By Placing It In The Void.", function()
    workspace.FallenPartsDestroyHeight = -50000
    game.Players.LocalPlayer.Character:SetPrimaryPartCFrame(CFrame.new(1, -49999, 1))
end)

local ballmag = maintab2:Folder("Ball Magnet Features.", Color3.fromRGB(24, 255, 228), true)
ballmag:Label("Original Ball Magnet: Allows You To Grab The Ball From Further Away.")

local ballMagnetState = {
    active = false,
    conn = nil
}

ballmag:Toggle("Ball Magnet", "The Original Ball Magnet, Always On Max Range.", function()
    local remote = game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable")
    ballMagnetState.active = not ballMagnetState.active

    game.StarterGui:SetCore("SendNotification", {
        Title = "Ball Magnet",
        Text = ballMagnetState.active and "Enabled." or "Disabled.",
        Duration = 1
    })

    if ballMagnetState.active then
        if ballMagnetState.conn then
            ballMagnetState.conn:Disconnect()
        end

        ballMagnetState.conn = task.spawn(function()
            while ballMagnetState.active do
                pcall(function()
                    remote:FireServer(buffer.fromstring(buffers["grabball"]))
                end)
                task.wait()
            end
        end)
    else
        if ballMagnetState.conn then
            ballMagnetState.conn = nil
        end
    end
end)

local magnetHoldState = {
    enabled = false,
    holding = false,
    beganConnection = nil,
    endedConnection = nil
}

local userInputService2 = game:GetService("UserInputService")
local remote2 = game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable")

ballmag:Toggle("Ball Magnet (Bind: M2, Click / Hold.)", "Similar To The Original, But Only Activate While Right Click Is Held Down.", function()
    if not magnetHoldState.enabled then
        magnetHoldState.enabled = true

        magnetHoldState.beganConnection = userInputService2.InputBegan:Connect(function(input, gameProcessed)
            if gameProcessed then return end
            if input.UserInputType == Enum.UserInputType.MouseButton2 then
                magnetHoldState.holding = true
                task.spawn(function()
                    while magnetHoldState.holding do
                        remote2:FireServer(buffer.fromstring(buffers["grabball"]))
                        task.wait(0.05)
                    end
                end)
            end
        end)

        magnetHoldState.endedConnection = userInputService2.InputEnded:Connect(function(input, gameProcessed)
            if gameProcessed then return end
            if input.UserInputType == Enum.UserInputType.MouseButton2 then
                magnetHoldState.holding = false
            end
        end)

        starterGui:SetCore("SendNotification", {
            Title = "Ball Magnet (M2 Hold)",
            Text = "Enabled.",
            Duration = 3
        })
    else
        magnetHoldState.enabled = false
        magnetHoldState.holding = false

        if magnetHoldState.beganConnection then magnetHoldState.beganConnection:Disconnect() magnetHoldState.beganConnection = nil end
        if magnetHoldState.endedConnection then magnetHoldState.endedConnection:Disconnect() magnetHoldState.endedConnection = nil end

        starterGui:SetCore("SendNotification", {
            Title = "Ball Magnet (M2 Hold)",
            Text = "Disabled.",
            Duration = 3
        })
    end
end)

local ballHitboxState = {
    active = false,
    hitbox = nil,
    loop = nil
}

ballmag:Toggle("Ball Magnet Hitbox", "Shows The Magnet's Hitbox On The Ball.", function()
    ballHitboxState.active = not ballHitboxState.active

    game.StarterGui:SetCore("SendNotification", {
        Title = "Ball Magnet Hitbox",
        Text = ballHitboxState.active and "Enabled." or "Disabled.",
        Duration = 1
    })

    local RunService = game:GetService("RunService")

    local function removeHitbox()
        if ballHitboxState.hitbox then
            ballHitboxState.hitbox:Destroy()
            ballHitboxState.hitbox = nil
        end
    end

    local function stopLoop()
        if ballHitboxState.loop then
            ballHitboxState.loop:Disconnect()
            ballHitboxState.loop = nil
        end
    end

    if not ballHitboxState.active then
        stopLoop()
        removeHitbox()
        return
    end

    stopLoop()

    ballHitboxState.loop = RunService.Heartbeat:Connect(function()
        if not ballHitboxState.active then
            stopLoop()
            removeHitbox()
            return
        end

        local terrain = workspace:FindFirstChild("Terrain")
        local ball = terrain and terrain:FindFirstChild("Ball")

        if not ball or not ball:IsA("BasePart") then
            removeHitbox()
            return
        end

        if not ballHitboxState.hitbox then
            local hitbox = Instance.new("Part")
            hitbox.Name = "BallMagnetHitbox"
            hitbox.Shape = Enum.PartType.Ball
            hitbox.Size = Vector3.new(25, 25, 25)
            hitbox.Material = Enum.Material.Neon
            hitbox.Color = Color3.fromRGB(15, 155, 155)
            hitbox.Transparency = 0.9
            hitbox.CanCollide = false
            hitbox.CanTouch = false
            hitbox.CanQuery = false
            hitbox.Anchored = false
            hitbox.Massless = true
            hitbox.CFrame = ball.CFrame
            hitbox.Parent = ball

            local weld = Instance.new("WeldConstraint")
            weld.Part0 = ball
            weld.Part1 = hitbox
            weld.Parent = hitbox

            ballHitboxState.hitbox = hitbox
        end
    end)
end)

ballmag:Label("Ball Magnet Radius: Same As Above, But The Range Is Changeable.")

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService2 = game:GetService("RunService")

local remote3 = ReplicatedStorage:WaitForChild("ByteNetReliable")
local localPlayer = Players.LocalPlayer

local ballRadiusState = {
    radius = 1,
    conn = nil,
    lastFire = 0,
    FIRE_INTERVAL = 0.1,
    hrp = nil
}

ballmag:Slider("Ball Magnet Radius", 1, 1, 25, 0.5, function(v)
    ballRadiusState.radius = v
end)

if ballRadiusState.conn then
    ballRadiusState.conn:Disconnect()
end

local function setupCharacter(char)
    ballRadiusState.hrp = char:WaitForChild("HumanoidRootPart", 10)
end

if localPlayer.Character then
    setupCharacter(localPlayer.Character)
end

localPlayer.CharacterAdded:Connect(function(char)
    setupCharacter(char)
end)

ballRadiusState.conn = RunService2.Heartbeat:Connect(function()
    local radius = ballRadiusState.radius or 1
    if radius < 2 then return end

    local ball = Workspace.Terrain:FindFirstChild("Ball")
    if not ball then return end

    if ballRadiusState.hrp then
        local dist = (ballRadiusState.hrp.Position - ball.Position).Magnitude
        if dist <= radius and (time() - ballRadiusState.lastFire) >= ballRadiusState.FIRE_INTERVAL then
            ballRadiusState.lastFire = time()
            pcall(function()
                remote3:FireServer(buffer.fromstring(buffers["grabball"]))
            end)
        end
    end
end)

local ballRangeVizState = {
    enabled = false,
    hitbox = nil,
    loop = nil
}

ballmag:Toggle("Ball Magnet Radius Hitbox", "Shows The Magnet's Hitbox On The Ball.", function()
    ballRangeVizState.enabled = not ballRangeVizState.enabled

    game.StarterGui:SetCore("SendNotification", {
        Title = "Ball Magnet Radius Hitbox",
        Text = ballRangeVizState.enabled and "Enabled." or "Disabled.",
        Duration = 1
    })

    local RunService = game:GetService("RunService")

    local function removeHitbox()
        if ballRangeVizState.hitbox then
            ballRangeVizState.hitbox:Destroy()
            ballRangeVizState.hitbox = nil
        end
    end

    local function stopLoop()
        if ballRangeVizState.loop then
            ballRangeVizState.loop:Disconnect()
            ballRangeVizState.loop = nil
        end
    end

    if not ballRangeVizState.enabled then
        stopLoop()
        removeHitbox()
        return
    end

    stopLoop()

    ballRangeVizState.loop = RunService.Heartbeat:Connect(function()
        if not ballRangeVizState.enabled then
            stopLoop()
            removeHitbox()
            return
        end

        local terrain = workspace:FindFirstChild("Terrain")
        local ball = terrain and terrain:FindFirstChild("Ball")
        if not ball or not ball:IsA("MeshPart") then
            removeHitbox()
            return
        end

        local radius = ballRadiusState.radius or 1
        if radius < 2 then
            removeHitbox()
            return
        end

        if not ballRangeVizState.hitbox then
            local hitbox = Instance.new("Part")
            hitbox.Name = "BallMagnetRange"
            hitbox.Shape = Enum.PartType.Ball
            hitbox.Material = Enum.Material.Neon
            hitbox.Color = Color3.fromRGB(15, 155, 155)
            hitbox.Transparency = 0.9
            hitbox.CanCollide = false
            hitbox.CanTouch = false
            hitbox.CanQuery = false
            hitbox.Anchored = true
            hitbox.Massless = true
            hitbox.Parent = workspace
            ballRangeVizState.hitbox = hitbox
        end

        local d = radius * 2
        local hitbox = ballRangeVizState.hitbox
        hitbox.Size = Vector3.new(d, d, d)
        hitbox.CFrame = ball.CFrame
    end)
end)

local autodrib = maintab2:Folder("Auto Dribble / Counter Features.", Color3.fromRGB(24, 255, 228), true)
autodrib:Label("Set The Auto-Counter Number To Your Character's Counter Move.")

autodrib:Button("Show Keybinds", "Shows The Keybinds For The Toggle Keybinds Feature.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Keybinds",
        Text = "Z = Auto-Dribble\nX = Move One\nC = Move Two",
        Duration = 4
    })
    task.delay(0.5, function()
        StarterGui:SetCore("SendNotification", {
            Title = "Keybinds",
            Text = "V = Move Three\nN = Move Four\nM = Move Five.",
            Duration = 4
        })
    end)
end)

local autoSkillState = {
    suppressNotifs = false,
    autoSkills = {
        ["toggleDetection"] = "dribble",
        ["toggleCounter1"] = "skill1",
        ["toggleCounter2"] = "skill2",
        ["toggleCounter3"] = "skill3",
        ["toggleCounter4"] = "skill4",
        ["toggleCounter5"] = "skill5"
    },
    toggleDetection = false,
    toggleCounter1 = false,
    toggleCounter2 = false,
    toggleCounter3 = false,
    toggleCounter4 = false,
    toggleCounter5 = false,
    keybindsEnabled = false,
    keybindSetup = false,
    cooldowns = {}
}

buffer = buffer or {
    fromstring = function(str)
        return str
    end
}

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local StarterGui = game:GetService("StarterGui")
local UserInputService = game:GetService("UserInputService")

local player = Players.LocalPlayer
local ANIMATION_ID = "rbxassetid://109744655458082"

local function notifySkill(title, text, duration)
    if not autoSkillState.suppressNotifs then
        StarterGui:SetCore("SendNotification", {
            Title = title,
            Text = text,
            Duration = duration or 2
        })
    end
end

RunService.Stepped:Connect(function()
    local char = player.Character
    local root = char and char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    local ball = char:FindFirstChild("Ball")
    if not ball or not ball:IsA("MeshPart") then
        return
    end

    for _, target in ipairs(Players:GetPlayers()) do
        if target ~= player and target.Character and target.Team ~= player.Team then
            local targetHRP = target.Character:FindFirstChild("HumanoidRootPart")
            local targetHumanoid = target.Character:FindFirstChild("Humanoid")
            local animator = targetHumanoid and targetHumanoid:FindFirstChildOfClass("Animator")

            if targetHRP and animator then
                local distance = (root.Position - targetHRP.Position).Magnitude
                if distance <= 40 then
                    local now = tick()
                    local last = autoSkillState.cooldowns[target] or 0
                    if now - last >= 0.5 then
                        for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
                            if track.Animation.AnimationId == ANIMATION_ID then
                                autoSkillState.cooldowns[target] = now

                                for _, toggleKey in ipairs({
                                    "toggleDetection",
                                    "toggleCounter1",
                                    "toggleCounter2",
                                    "toggleCounter3",
                                    "toggleCounter4",
                                    "toggleCounter5"
                                }) do
                                    local skillName = autoSkillState.autoSkills[toggleKey]
                                    if autoSkillState[toggleKey] and skillName then
                                        local args
                                        if skillName == "dribble" then
                                            args = {
                                                buffer.fromstring(buffers["base"]),
                                                { { skillName, false } }
                                            }
                                        else
                                            args = {
                                                buffer.fromstring(buffers["base"]),
                                                { { skillName } }
                                            }
                                        end
                                        ReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(unpack(args))
                                    end
                                end
                                break
                            end
                        end
                    end
                end
            end
        end
    end
end)

local function createAutoCounter(label, toggleKey)
    autodrib:Toggle(label, function()
        autoSkillState[toggleKey] = not (autoSkillState[toggleKey] or false)
        notifySkill(label, autoSkillState[toggleKey] and "Enabled." or "Disabled.", 3)
    end)
end

autodrib:Toggle("Toggle Keybinds", "Enables Auto Dribble / Auto Counter Features Via Keybinds, Check Info For Binds.", function()
    autoSkillState.keybindsEnabled = not (autoSkillState.keybindsEnabled or false)
    notifySkill("Keybinds", autoSkillState.keybindsEnabled and "Enabled." or "Disabled.", 3)
end)

createAutoCounter("Auto Dribble", "toggleDetection")
createAutoCounter("Auto Counter (Move One)", "toggleCounter1")
createAutoCounter("Auto Counter (Move Two)", "toggleCounter2")
createAutoCounter("Auto Counter (Move Three)", "toggleCounter3")
createAutoCounter("Auto Counter (Move Four)", "toggleCounter4")
createAutoCounter("Auto Counter (Move Five)", "toggleCounter5")

if not autoSkillState.keybindSetup then
    autoSkillState.keybindSetup = true

    UserInputService.InputBegan:Connect(function(input, gameProcessed)
        if gameProcessed or not autoSkillState.keybindsEnabled then return end

        local keyMap = {
            [Enum.KeyCode.Z] = {"toggleDetection", "Auto-Dribble"},
            [Enum.KeyCode.X] = {"toggleCounter1", "Auto-Counter (Move One)"},
            [Enum.KeyCode.C] = {"toggleCounter2", "Auto-Counter (Move Two)"},
            [Enum.KeyCode.V] = {"toggleCounter3", "Auto-Counter (Move Three)"},
            [Enum.KeyCode.N] = {"toggleCounter4", "Auto-Counter (Move Four)"},
            [Enum.KeyCode.M] = {"toggleCounter5", "Auto-Counter (Move Five)"}
        }

        local mapping = keyMap[input.KeyCode]
        if mapping then
            local toggleKey, label = unpack(mapping)
            autoSkillState[toggleKey] = not (autoSkillState[toggleKey] or false)
            notifySkill(label, autoSkillState[toggleKey] and "Enabled." or "Disabled.", 3)
        end
    end)
end

local autogoal = maintab:Folder("Auto Goal Features.", Color3.fromRGB(24, 255, 228), true)
autogoal:Label("Auto Goal: Automatically Does Auto Goal Steps Instantly.")

autogoal:Button("Isagi U-20 Goal", "Attempts To Do Isagi's U-20 Auto Goal By Teleporting To The Designated Area.", function()
    local plr = game.Players.LocalPlayer
    if plr.Character and plr.Character:FindFirstChild("HumanoidRootPart") then
        local hrp = plr.Character.HumanoidRootPart
        
        if plr.Team == game.Teams:FindFirstChild("A") then
            hrp.CFrame = CFrame.new(-536, 3, 999)
        elseif plr.Team == game.Teams:FindFirstChild("B") then
            hrp.CFrame = CFrame.new(-537, 3, 1549)
        end
        task.wait(0.2)
        ReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(
            buffer.fromstring(buffers["base"]),
            { { "skill3"} }
        )
    end
end)

autogoal:Button("Barou Devour Goal", "Attempts To Do Barou's Devour Auto Goal By Teleporting Behind Two Enemy Players.", function()
    local plr = game.Players.LocalPlayer

    local function countEnemyTeamMembers()
        local op = game.Teams:FindFirstChild("A")
        if plr.Team == game.Teams:FindFirstChild("A") then
            op = game.Teams:FindFirstChild("B")
        end
        local count = 0
        for _, player in ipairs(game.Players:GetPlayers()) do
            if player.Team == op then
                count += 1
            end
        end
        return count
    end
    
    local function getTwoRandomEnemies()
        local enemies = {}
        local op = game.Teams:FindFirstChild("A")
        if plr.Team == game.Teams:FindFirstChild("A") then
            op = game.Teams:FindFirstChild("B")
        end
        
        for _, player in ipairs(game.Players:GetPlayers()) do
            if player ~= plr and player.Team == op then
                table.insert(enemies, player)
            end
        end
        
        for i = #enemies, 2, -1 do
            local j = math.random(1, i)
            enemies[i], enemies[j] = enemies[j], enemies[i]
        end

        return enemies[1], enemies[2]
    end
    
    if countEnemyTeamMembers() >= 2 then
        local p1, p2 = getTwoRandomEnemies()
        if not p1 or not p2 then return end

        local function tpToPlayer(targetPlayer)
            local char = plr.Character or plr.CharacterAdded:Wait()
            local root = char:WaitForChild("HumanoidRootPart")
            local targetRoot = targetPlayer.Character and targetPlayer.Character:FindFirstChild("HumanoidRootPart")

            if root and targetRoot then
                root.CFrame = targetRoot.CFrame
            end
        end

        tpToPlayer(p1)
        task.wait(0.3)
        tpToPlayer(p2)
        
        task.wait(0.3)
        
        if plr.Team == game.Teams:FindFirstChild("A") then
            plr.Character.HumanoidRootPart.Position = Vector3.new(-625, 3, 925)
        elseif plr.Team == game.Teams:FindFirstChild("B") then
            plr.Character.HumanoidRootPart.Position = Vector3.new(-588, 3, 1643)
        end
    end
end)

autogoal:Button("Nagi Dream Goal", "Attempts To Do Nagi's Control Move Auto Goal In Flow.", function()
    local plr = game.Players.LocalPlayer
    if plr.Character and plr.Character:FindFirstChild("HumanoidRootPart") then
        local hrp = plr.Character.HumanoidRootPart
        
        if plr.Team == game.Teams:FindFirstChild("A") then
            hrp.CFrame = CFrame.new(-459, 3, 862)
        elseif plr.Team == game.Teams:FindFirstChild("B") then
            hrp.CFrame = CFrame.new(-611, 3, 1682) * CFrame.Angles(0, math.rad(180), 0)
        end
        task.wait(0.2)
        if plr.Character and plr.Character:FindFirstChild("Humanoid") then
            plr.Character.Humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
        end
        task.wait(0.2)
        ReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(
            buffer.fromstring(buffers["base"]),
            { { "skill2", true } }
        )
    end
end)

local add = maintab:Folder("Fun Features.", Color3.fromRGB(24, 255, 228), true)
add:Label("Fun Features: Pretty Fun Features I'd Say.")

local AnimationId = "rbxassetid://113098409724280"
local safety = Vector3.new(-540, 3, 1274)

local invisState = {
    active = false,
    character = nil,
    humanoid = nil,
    animationTrack = nil
}

local function startInvisibility()
    if not invisState.humanoid then return end
    invisState.active = true

    local anim = Instance.new("Animation")
    anim.AnimationId = AnimationId
    local track = invisState.humanoid:LoadAnimation(anim)
    track.Priority = Enum.AnimationPriority.Action4
    track.Looped = false
    track:Play(0)
    track:AdjustSpeed(0)
    invisState.animationTrack = track
end

local function stopInvisibility()
    invisState.active = false
    if invisState.animationTrack then
        invisState.animationTrack:Stop()
        invisState.animationTrack:Destroy()
        invisState.animationTrack = nil
    end
    if invisState.humanoid then
        invisState.humanoid.CameraOffset = Vector3.new(0, 0, 0)
    end
end

local Workspace = game:GetService("Workspace")
local RunService3 = game:GetService("RunService")

RunService3.RenderStepped:Connect(function()
    if not invisState.active then return end
    if not invisState.humanoid or not invisState.character then return end

    invisState.humanoid.CameraOffset = Vector3.new(0, 0, 0)

    local rootPart = invisState.character:FindFirstChild("HumanoidRootPart")
    if rootPart then
        local rayOrigin = rootPart.Position
        local rayDirection = Vector3.new(0, -500, 0)
        local raycastResult = Workspace:Raycast(rayOrigin, rayDirection)

        if not raycastResult then
            rootPart.CFrame = CFrame.new(safety)
        end
    end
end)

player.CharacterAdded:Connect(function(char)
    invisState.character = char
    invisState.humanoid = char:WaitForChild("Humanoid")

    if invisState.active then
        startInvisibility()
    end
end)

if player.Character then
    invisState.character = player.Character
    invisState.humanoid = player.Character:FindFirstChildOfClass("Humanoid")
end

add:Toggle("Invisibility V1 (Method: Animation)", "Makes You Almost Fully Invisible To Other Players Using An Animation.", function(v)
    if v then
        startInvisibility()
    else
        stopInvisibility()
    end
end)

add:Button("Invisibility V2 (Method: Clone)", "Makes You Almost Fully Invisible To Other Players Using Cloning. Click Z To Disable." , function(v)
    local Players = game:GetService("Players")
    local RunService = game:GetService("RunService")
    local UserInputService = game:GetService("UserInputService")

    local player = Players.LocalPlayer
    local enabled = true

    local charactersfolder = workspace:WaitForChild("characters", 10)
    if not charactersfolder then return end

    local character = charactersfolder:WaitForChild(player.Name, 15)
    if not character then return end

    if not character:FindFirstChild("Humanoid") or not character:FindFirstChild("HumanoidRootPart") then return end

    character.Archivable = true
    local characterroot = character:WaitForChild("HumanoidRootPart")
    characterroot.Transparency = 1

    local clone = character:Clone()
    if not clone then return end

    clone.Name = player.Name .. "_Ghost"
    clone.Parent = workspace

    for _, obj in ipairs(clone:GetDescendants()) do
        if obj:IsA("BasePart") or obj:IsA("MeshPart") or obj:IsA("Part") then
            if obj.Name == "HumanoidRootPart" then
                obj.Transparency = 1
            else
                obj.Transparency = 0.4
            end
            obj.CanCollide = true
        elseif obj:IsA("Decal") or obj:IsA("Texture") or obj:IsA("ShirtGraphic") then
            obj.Transparency = 0
        end
    end

    local cloneroot = clone:WaitForChild("HumanoidRootPart", 5)
    if cloneroot then
        cloneroot.Transparency = 1
    end

    local clonehumanoid = clone:WaitForChild("Humanoid", 5)
    if not cloneroot or not clonehumanoid then
        clone:Destroy()
        return
    end

    cloneroot.CFrame = character.HumanoidRootPart.CFrame + Vector3.new(0, 5, 0)
    clonehumanoid.PlatformStand = false
    clonehumanoid.WalkSpeed = 75
    clonehumanoid.JumpPower = 50

    player.Character = clone
    workspace.CurrentCamera.CameraSubject = clonehumanoid

    local animations = {
        Run  = "rbxassetid://90801998022970",
        Jump = "rbxassetid://80330677678466"
    }

    local runanim = Instance.new("Animation")
    runanim.AnimationId = animations.Run
    local runtrack = clonehumanoid:LoadAnimation(runanim)
    runtrack.Looped = true
    runtrack.Priority = Enum.AnimationPriority.Movement

    local jumpanim = Instance.new("Animation")
    jumpanim.AnimationId = animations.Jump
    local jumptrack = clonehumanoid:LoadAnimation(jumpanim)
    jumptrack.Looped = false
    jumptrack.Priority = Enum.AnimationPriority.Action

    local isrunning = false

    local teleportconn
    local speedenforceconn

    UserInputService.InputBegan:Connect(function(input, gameprocessed)
        if gameprocessed then return end
        if input.KeyCode == Enum.KeyCode.Z and enabled then
            enabled = false
            
            if teleportconn then teleportconn:Disconnect() end
            if speedenforceconn then speedenforceconn:Disconnect() end
            teleportconn = nil
            speedenforceconn = nil
            
            player.Character = character
            workspace.CurrentCamera.CameraSubject = character:FindFirstChild("Humanoid")
            
            if clone then clone:Destroy() end
            clone = nil
            
            for _, part in ipairs(character:GetDescendants()) do
                if part:IsA("BasePart") or part:IsA("MeshPart") then
                    if part.Name == "HumanoidRootPart" then
                        part.Transparency = 1
                    else
                        part.Transparency = 0
                    end
                    part.CanCollide = true
                elseif part:IsA("Decal") or part:IsA("Texture") or part:IsA("ShirtGraphic") then
                    part.Transparency = 0
                end
            end
            
            runtrack:Stop(0.2)
            jumptrack:Stop(0.2)
            isrunning = false
        end
    end)

    teleportconn = RunService.Heartbeat:Connect(function()
        if not enabled then return end
        if not cloneroot or not cloneroot.Parent or not characterroot or not characterroot.Parent then return end
        local clonepos = cloneroot.Position
        local underpos = clonepos - Vector3.new(0, 15, 0)
        characterroot.CFrame = CFrame.new(underpos, clonepos)
        for _, part in ipairs(character:GetDescendants()) do
            if part:IsA("BasePart") or part:IsA("MeshPart") then
                part.Transparency = 1
                part.CanCollide = false
            end
        end
    end)

    speedenforceconn = RunService.RenderStepped:Connect(function()
        if not enabled then return end
        if not clonehumanoid or not clonehumanoid.Parent then return end
        clonehumanoid.WalkSpeed = 75
        clonehumanoid.JumpPower = 50
    end)

    RunService.Heartbeat:Connect(function()
        if not enabled or not clonehumanoid or not clonehumanoid.Parent then return end
        local moving = clonehumanoid.MoveDirection.Magnitude > 0.01
        local currentstate = clonehumanoid:GetState()
        if moving and currentstate ~= Enum.HumanoidStateType.Jumping then
            if not isrunning then
                runtrack:Play(0.1)
                isrunning = true
            end
        else
            if isrunning then
                runtrack:Stop(0.3)
                isrunning = false
            end
        end
        if currentstate == Enum.HumanoidStateType.Jumping or currentstate == Enum.HumanoidStateType.Freefall then
            if not jumptrack.IsPlaying then
                jumptrack:Play(0.15)
            end
        elseif jumptrack.IsPlaying then
            jumptrack:Stop(0.2)
        end
    end)

    player.CharacterRemoving:Connect(function()
        enabled = false
        if teleportconn then teleportconn:Disconnect() end
        if speedenforceconn then speedenforceconn:Disconnect() end
        runtrack:Stop(0)
        jumptrack:Stop(0)
        isrunning = false
        if clone then clone:Destroy() end
    end)
end)

local passingState = {
    InfiniteRangePassing = false,
    busy = false
}

local plr = Players.LocalPlayer
local mouse = plr:GetMouse()
local Camera = workspace.CurrentCamera
local passpass = ReplicatedStorage:WaitForChild("ByteNetReliable")

local keyToSkill = {
    [Enum.KeyCode.One]   = "skill1",
    [Enum.KeyCode.Two]   = "skill2",
    [Enum.KeyCode.Three] = "skill3",
    [Enum.KeyCode.Four]  = "skill4",
}

local function getClosestPlayerToCursor()
    local mousePos = UserInputService:GetMouseLocation()
    local closestChar, closestDist = nil, math.huge
    local char, hum, hrp, screenPos, onScreen, dist

    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= plr and p.Team == plr.Team then
            char = p.Character
            if not char then continue end
            hum = char:FindFirstChild("Humanoid")
            hrp = char:FindFirstChild("HumanoidRootPart")

            if hum and hrp and hum.Health > 0 then
                screenPos, onScreen = Camera:WorldToViewportPoint(hrp.Position)
                if onScreen then
                    dist = (Vector2.new(screenPos.X, screenPos.Y) - mousePos).Magnitude
                    if dist < closestDist then
                        closestDist = dist
                        closestChar = char
                    end
                end
            end
        end
    end

    return closestChar
end

UserInputService.InputBegan:Connect(function(input, gp)
    if gp then return end
    if not passingState.InfiniteRangePassing then return end
    if passingState.busy then return end
    if plr.Team == game.Teams.lobby then return end

    local skillName = keyToSkill[input.KeyCode]
    if not skillName then return end

    local targetChar = getClosestPlayerToCursor()
    if not targetChar then return end

    passingState.busy = true

    passpass:FireServer(
        buffer.fromstring(buffers["base"]),
        {
            {
                skillName,
                targetChar
            }
        }
    )

    task.delay(0.1, function()
        passingState.busy = false
    end)
end)

add:Toggle("Infinite Range Passing", "Pass To The Closest Teammate To Your Mouse From Anywhere.", function(v)
    passingState.InfiniteRangePassing = v
    StarterGui:SetCore("SendNotification", {
        Title = "Infinite Pass",
        Text = v and "Enabled." or "Disabled.",
        Duration = 5
    })
end)

add:Button("Steal Screen Time (funny)", "Click Z To Disable, Steals Screen Time.", function()
    local plr = game.Players.LocalPlayer
    local char = plr.Character
    local cam = workspace.CurrentCamera

    local stopped = false

    game.UserInputService.InputBegan:Connect(function(key, bg)
        if bg then return end

        if key.KeyCode == Enum.KeyCode.Z then
            stopped = true
        end
    end)

    local ogPos = plr.Character.HumanoidRootPart.Position
    local incut = false
    local anim = nil

    local con
    con = game["Run Service"].RenderStepped:Connect(function()
        if stopped then
            con:Disconnect()
            return
        end

        if char ~= plr.Character then char = plr.Character end
        local hum = char:FindFirstChild("Humanoid")
        local root = char:FindFirstChild("HumanoidRootPart")

        if cam.CameraType == Enum.CameraType.Scriptable then
            if incut == false then
                anim = hum.Animator:LoadAnimation(game:GetService("ReplicatedStorage").emoteWiki.myanimefans.Animation)
                anim.Looped = true
                anim:Play()
                anim:AdjustSpeed(4)
            end
            incut = true
            root.CFrame = cam.CFrame * CFrame.new(0, -1.3, -2.3) * CFrame.Angles(0, math.rad(180), 0)
        else
            if incut == true then
                incut = false
                if anim then
                    anim:Stop()
                end
                root.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
                root.CFrame = CFrame.new(ogPos)
                root.AssemblyLinearVelocity = Vector3.new(0, 0, 0)
            end
            ogPos = root.Position
        end
    end)
end)

add:Button("Goalkeeper Anywhere (Rejoin To Disable.) (Credit: someone cool..)", "Allows You To Do GK Side Dashes Instead!", function()
    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Goalkeeper Anywhere",
        Text = "If You Don't See GK Animations, Your Executor Doesn't Support The Required Functions.",
        Duration = 10,
        Button1 = "ok my executor is fine",
        Button2 = "aw man my executor sucks"
    })

    local module = game:GetService("ReplicatedStorage").util.actionUtil
    local env = require(module)

    local oldfunc
    oldfunc = hookfunction(env.checkGK, function (...)
        return true
    end)
end)

add:Button("Shachoko GK Catch (Req. GK Position.)", "Makes It Almost Impossible To Be Scored On As GK And Does Shachoko Kick.", function()
loadstring(game:HttpGet("https://pastebin.com/raw/Hr1HnK38"))()
end)

local oth = maintab:Folder("Other Blatant Features.", Color3.fromRGB(24, 255, 228), true)
oth:Label("Other Blatant Features: It's In The Name.")

local blatantState = {
    enabled = false,
    loopConnection = nil
}

local rs = game:GetService("RunService")
local sg = game:GetService("StarterGui")
local ws = game:GetService("Workspace")

local function setCollide(state)
    local a = ws.map.gkbarriar.Abarriar
    local b = ws.map.gkbarriar.Bbarriar
    local ag = ws.map.Agoal
    local bg = ws.map.Bgoal

    if a then a.CanCollide = state end
    if b then b.CanCollide = state end
    if ag then ag.CanCollide = state end
    if bg then bg.CanCollide = state end
end

oth:Toggle("Blatant Mode", "Removes Collisions With Goal Boxes.", function()
    blatantState.enabled = not blatantState.enabled
    if blatantState.enabled then
        blatantState.loopConnection = rs.Heartbeat:Connect(function() setCollide(false) end)
        sg:SetCore("SendNotification",{Title="Blatant Mode",Text="Enabled.",Duration=3})
    else
        if blatantState.loopConnection then blatantState.loopConnection:Disconnect() blatantState.loopConnection = nil end
        setCollide(true)
        sg:SetCore("SendNotification",{Title="Blatant Mode",Text="Disabled.",Duration=3})
    end
end)

local nostunState = {
    enabled = false
}

local nostunPlayer = game.Players.LocalPlayer

local function applyNoStun()
    if not nostunState.enabled then return end
    local c = nostunPlayer.Character
    if not c then return end
    local h = c:FindFirstChild("Humanoid")
    if h then
        h.WalkSpeed = 40
    end
end

local function setupCharacter(char)
    if nostunState.enabled then
        applyNoStun()
    end
end

nostunPlayer.CharacterAdded:Connect(setupCharacter)

if nostunPlayer.Character then
    setupCharacter(nostunPlayer.Character)
end

oth:Toggle("No Stun", "Overrides The Stunned State So You Can Move.", function(v)
    nostunState.enabled = v
    if v then
        game.StarterGui:SetCore("SendNotification", {Title="No Stun", Text="Enabled"})
        applyNoStun()
    else
        game.StarterGui:SetCore("SendNotification", {Title="No Stun", Text="Disabled"})
    end
end)

game:GetService("RunService").RenderStepped:Connect(function()
    if nostunState.enabled then
        applyNoStun()
    end
end)

local brickSpamState = {
    running = false
}

oth:Toggle("Spam Brick Sound (5v5 + GK Only.)", "This SHOULD Be Self Explanatory.", function(state)
    brickSpamState.running = state

    if brickSpamState.running then
        sg:SetCore("SendNotification", {
            Title = "Brick Spam";
            Text = "Enabled.";
            Duration = 3
        })

        task.spawn(function()
            local char = game.Players.LocalPlayer.Character
            local root = char:WaitForChild("HumanoidRootPart")

            local team = game.Players.LocalPlayer.Team and game.Players.LocalPlayer.Team.Name
            local targetPos

            if team == "A" then
                targetPos = Vector3.new(-510, 3, 1706)
            elseif team == "B" then
                targetPos = Vector3.new(-559, 3, 843)
            end

            if targetPos then
                while brickSpamState.running do
                    root.CFrame = CFrame.new(targetPos)
                    task.wait(0.1)

                    local args = {
                        buffer.fromstring(buffers["base"]),
                        {
                            {
                                "kick",
                                27,
                                false,
                                vector.create(0, 1, 0)
                            }
                        }
                    }
                    game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(unpack(args))

                    task.wait(0.05)
                end
            end
        end)
    else
        sg:SetCore("SendNotification", {
            Title = "Brick Spam";
            Text = "Disabled.";
            Duration = 3
        })
    end
end)

local th = maintab:Folder("Trap Helper.", Color3.fromRGB(24, 255, 228), true)
th:Label("Trap Helper: Automatically Moves Toward Ball During Trap Moves.")

local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local StarterGui = game:GetService("StarterGui")

local player = Players.LocalPlayer

local trapAnims = {
    "rbxassetid://73387016994281",
    "rbxassetid://101043441232233",
    "rbxassetid://96593185131882",
    "rbxassetid://116422938520670",
    "rbxassetid://90734196141468",
    "rbxassetid://85349589701503",
    "rbxassetid://120351399679118"
}

local trapState = {
    enabled = false,
    detected = false,
    armTime = 0,
    active = false,
    track = nil,
    ball = nil,
    conn = nil,
    alignOri = nil
}

local armWindow = 0.35
local trapMaxDist = 50
local trapSpeed = 50

local function findBall()
    local terrain = workspace.Terrain
    if terrain then
        local b = terrain:FindFirstChild("Ball")
        if b and b:IsA("BasePart") then return b end
    end
end

local function cleanupTrap()
    if trapState.conn then 
        trapState.conn:Disconnect() 
        trapState.conn = nil 
    end
    trapState.active = false
    trapState.track = nil
    trapState.ball = nil
    if trapState.alignOri then 
        trapState.alignOri:Destroy() 
        trapState.alignOri = nil 
    end
end

local function startLerpToBall(hrp, ball, track)
    if (ball.Position - hrp.Position).Magnitude > trapMaxDist then return end

    trapState.ball = ball
    trapState.track = track
    trapState.active = true

    if trapState.alignOri then trapState.alignOri:Destroy() end
    local ao = Instance.new("AlignOrientation")
    ao.Name = "TrapFaceAlign"
    ao.Mode = Enum.OrientationAlignmentMode.OneAttachment
    ao.Attachment0 = hrp:FindFirstChild("RootAttachment") or Instance.new("Attachment", hrp)
    ao.RigidityEnabled = false
    ao.MaxTorque = 20000
    ao.Responsiveness = 1000
    ao.Parent = hrp
    trapState.alignOri = ao

    if trapState.conn then trapState.conn:Disconnect() end

    trapState.conn = RunService.RenderStepped:Connect(function(dt)
        if not trapState.track or not trapState.track.IsPlaying then
            cleanupTrap()
            return
        end

        if not trapState.ball or not trapState.ball.Parent then
            cleanupTrap()
            return
        end

        local cur = hrp.Position
        local tgt = trapState.ball.Position - Vector3.new(0, 3, 0)
        local dir = tgt - cur
        local dist = dir.Magnitude

        if dist > trapMaxDist or dist < 0.5 then
            cleanupTrap()
            return
        end

        local move = dir.Unit * (trapSpeed * dt)
        hrp.CFrame = CFrame.new(cur + move) * hrp.CFrame.Rotation

        local ballFlat = Vector3.new(trapState.ball.Position.X, hrp.Position.Y, trapState.ball.Position.Z)
        if trapState.alignOri then
            trapState.alignOri.CFrame = CFrame.lookAt(hrp.Position, ballFlat)
        end
    end)

    track.Stopped:Connect(function()
        cleanupTrap()
    end)
end

local function hookTraps(char)
    local animator = char:WaitForChild("Humanoid"):WaitForChild("Animator")
    local hrp = char:WaitForChild("HumanoidRootPart")

    animator.AnimationPlayed:Connect(function(track)
        if not trapState.enabled then return end
        if not track.Animation then return end

        local id = track.Animation.AnimationId
        for _, animId in ipairs(trapAnims) do
            if id == animId and os.clock() >= trapState.armTime then
                trapState.detected = true

                task.delay(0.05, function()
                    if track.IsPlaying then
                        local ball = findBall()
                        if ball then
                            startLerpToBall(hrp, ball, track)
                        end
                    end
                end)

                break
            end
        end
    end)
end

local function setupCharacter(char)
    hookTraps(char)
end

if player.Character then
    setupCharacter(player.Character)
end
player.CharacterAdded:Connect(setupCharacter)

UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    if input.UserInputType ~= Enum.UserInputType.Keyboard then return end

    local code = input.KeyCode.Value
    if code < Enum.KeyCode.One.Value or code > Enum.KeyCode.Five.Value then return end

    if trapState.active then return end

    trapState.armTime = os.clock()
    trapState.detected = false

    task.delay(armWindow, function()
        if not trapState.detected then return end

        local char = player.Character
        if not char then return end

        local hrp = char:FindFirstChild("HumanoidRootPart")
        if not hrp then return end

        local ball = findBall()
        if ball then
            local tracks = char.Humanoid.Animator:GetPlayingAnimationTracks()
            for _, track in ipairs(tracks) do
                if track.Animation and table.find(trapAnims, track.Animation.AnimationId) then
                    startLerpToBall(hrp, ball, track)
                    break
                end
            end
        end
    end)
end)

th:Toggle("Trap Helper", function(state)
    trapState.enabled = state
    StarterGui:SetCore("SendNotification", {
        Title = "Trap Helper",
        Text = state and "Enabled." or "Disabled.",
        Duration = 1
    })
end)

th:Slider("Trap Helper Max Distance", 50, 50, 200, 1, function(v)
    trapMaxDist = v
end)

th:Slider("Trap Helper Speed", 50, 50, 1000, 1, function(v)
    trapSpeed = v
end)

local d = maintab:Folder("Distance Move Buffs.", Color3.fromRGB(24, 255, 228), true)
d:Label("Distance Move Buffs: Buffs Movement Based Moves.")

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer
local rs = RunService

local DashConfigs = {
    Tackle = {
        animId = "rbxassetid://109744655458082",
        sliderVar = "tackleDist",
        duration = 0.4,
        cooldown = 0.15,
        wait = 0
    },
    Rush = {
        animId = "rbxassetid://79394729551302",
        sliderVar = "rushDist",
        duration = 0.4,
        cooldown = 0.15,
        wait = 0.15
    },
    GKDash = {
        animId = "rbxassetid://90537955276413",
        sliderVar = "gkDist",
        duration = 0.55,
        cooldown = 0.15,
        wait = 0.05
    },
    Naruhaya = {
        animId = "rbxassetid://82240286756891",
        sliderVar = "naruhayaDist",
        duration = 0.45,
        cooldown = 0.15,
        wait = 0.33
    },
    Raumdeuter = {
        animIds = {["rbxassetid://81582265162782"] = true},
        sliderVar = "raumDist",
        duration = 0.55,
        cooldown = 0.15,
        wait = 0.1
    },
    DraconicRush = {
        animId = "rbxassetid://95359966795185",
        sliderVar = "dracDist",
        duration = 0.625,
        cooldown = 0.15,
        wait = 0.175
    },
    StepOvers = {
        animId = "rbxassetid://84063609284472",
        sliderVar = "stepDist",
        duration = 0.15,
        cooldown = 0.15,
        wait = 1.275
    },
    KaiserOffBall = {
        animId = "rbxassetid://110660551661470",
        sliderVar = "kaiserDist",
        duration = 0.55,
        cooldown = 0.15,
        wait = 0.15
    },
    OcclusionBreak = {
        animId = "rbxassetid://116181317759538",
        sliderVar = "occlusionDist",
        duration = 1.0,
        cooldown = 0.15,
        wait = 0.2
    },
    DivingHeader = {
        animId = "rbxassetid://91506202951715",
        sliderVar = "divingDist",
        duration = 0.35,
        cooldown = 0.15,
        wait = 0.05
    },
    ReflexTackle = {
        animId = "rbxassetid://113088324958896",
        sliderVar = "reflexDist",
        duration = 0.2,
        cooldown = 0.15,
        wait = 0
    },
    SpeedDribble = {
        animIds = {
            ["rbxassetid://70397727954557"] = true,
            ["rbxassetid://131196726012273"] = true
        },
        sliderVar = "speedDist",
        duration = 1.15,
        cooldown = 0.15,
        wait = 0.2
    },
    CutIn = {
        animIds = {
            ["rbxassetid://133384553147918"] = true,
            ["rbxassetid://128936529440509"] = true
        },
        sliderVar = "cutDist",
        duration = 1.0,
        cooldown = 0.15,
        wait = 0.2
    },
    HeroInstinct = {
        animId = "rbxassetid://82417661349987",
        sliderVar = "instinctDist",
        duration = 1.25,
        cooldown = 0.15,
        wait = 0.33
    },
    CloseQuarterDribble = {
        animId = "rbxassetid://94171465685487",
        sliderVar = "quarterDist",
        duration = 2.25,
        cooldown = 0.15,
        wait = 0.18
    },
    ZombieDribble = {
        animId = "rbxassetid://102294508090597",
        sliderVar = "zombDist",
        duration = 1.7,
        cooldown = 0.15,
        wait = 0.15
    },
    KingsPath = {
        animId = "rbxassetid://73560885704292",
        sliderVar = "kingsDist",
        duration = 1.175,
        cooldown = 0.15,
        wait = 0.4
    },
    MachCutIn = {
        animIds = {
            ["rbxassetid://133945265328817"] = true,
            ["rbxassetid://88448030655006"] = true
        },
        sliderVar = "machDist",
        duration = 0.15,
        cooldown = 0.15,
        wait = 0.625
    },
    GoldenZone = {
        animId = "rbxassetid://132426354821688",
        sliderVar = "goldenDist",
        duration = 2.0,
        cooldown = 0.15,
        requiresBall = true,
        wait = 0.15
    },
    Devour = {
        animId = "rbxassetid://117921992582675",
        sliderVar = "devourMaxDist",
        speed = 150,
        cooldown = 0.15,
        isUnlimited = true,
        wait = 0.2
    }
}

local Distances = {}
for _, cfg in pairs(DashConfigs) do
    Distances[cfg.sliderVar] = 0
end

local ActiveDashes = {}
local cachedHRP = nil
local renderConn = nil

local ZERO = Vector3.new()
local DEFAULT_DIR = Vector3.new(0,0,1)

local function updateDashes(dt)
    for i = #ActiveDashes, 1, -1 do
        local dash = ActiveDashes[i]
        local hrp = dash.hrp

        if not hrp or not hrp.Parent then
            table.remove(ActiveDashes, i)
            continue
        end

        local step = dash.cfg.isUnlimited and (dash.speed * dt) or math.min(dash.speed * dt, dash.remaining)

        local look = hrp.CFrame.LookVector
        local dir = Vector3.new(look.X, 0, look.Z).Unit
        if dir.Magnitude < 0.01 then
            dir = DEFAULT_DIR
        end

        local newPos = hrp.Position + dir * step

        hrp.CFrame = CFrame.new(newPos.X, hrp.Position.Y, newPos.Z) * CFrame.new(ZERO, dir)

        dash.remaining = dash.remaining - step

        if dash.remaining <= 0 then
            table.remove(ActiveDashes, i)
        end
    end

    if #ActiveDashes == 0 and renderConn then
        renderConn:Disconnect()
        renderConn = nil
    end
end

local function startUpdateIfNeeded()
    if not renderConn and #ActiveDashes > 0 then
        renderConn = game:GetService("RunService").RenderStepped:Connect(updateDashes)
    end
end

local function startDash(hrp, cfg, track)
    local dist = Distances[cfg.sliderVar]
    if dist <= 0 then return end

    task.delay(cfg.wait or 0, function()
        if not hrp or not hrp.Parent then return end

        local dash = {
            hrp = hrp,
            remaining = dist,
            cfg = cfg
        }

        if cfg.isUnlimited then
            dash.remaining = math.huge
            dash.speed = cfg.speed

            if track then
                local stoppedConn
                stoppedConn = track.Stopped:Connect(function()
                    dash.remaining = 0
                    if stoppedConn then
                        stoppedConn:Disconnect()
                    end
                end)
            end
        else
            dash.speed = dist / cfg.duration
        end

        table.insert(ActiveDashes, dash)
        startUpdateIfNeeded()
    end)
end

local function onAnimationPlayed(track)
    if not track.Animation then return end
    local id = track.Animation.AnimationId

    for _, cfg in pairs(DashConfigs) do
        local match = false
        if cfg.animId and id == cfg.animId then
            match = true
        elseif cfg.animIds and cfg.animIds[id] then
            match = true
        end

        if match then
            if cachedHRP and cachedHRP.Parent then
                if cfg.requiresBall then
                    local ball = cachedHRP.Parent:FindFirstChild("Ball")
                    if not ball or not ball:IsA("MeshPart") then continue end
                end
                startDash(cachedHRP, cfg, track)
            end
        end
    end
end

local function setupCharacter(char)
    local hum = char:WaitForChild("Humanoid", 5)
    if not hum then return end

    local animator = hum:WaitForChild("Animator", 5)
    if not animator then return end

    cachedHRP = char:WaitForChild("HumanoidRootPart", 5)
    if not cachedHRP then return end

    animator.AnimationPlayed:Connect(onAnimationPlayed)
end

if player.Character then
    setupCharacter(player.Character)
end
player.CharacterAdded:Connect(setupCharacter)

d:Label("Universal Movement Buffs.")
d:Slider("Tackle Distance", 0, 0, 75, 1, function(v)
    Distances.tackleDist = v
end)

d:Slider("Rush Distance", 0, 0, 75, 1, function(v)
    Distances.rushDist = v
end)

d:Slider("GK Front Dive Distance", 0, 0, 75, 1, function(v)
    Distances.gkDist = v
end)

d:Label("Isagi Movement Buffs.")
d:Slider("Naruhaya Footwork Distance", 0, 0, 200, 1, function(v)
    Distances.naruhayaDist = v
end)

d:Label("NEL Isagi Movement Buffs.")
d:Slider("Raumdeuter Distance", 0, 0, 200, 1, function(v)
    Distances.raumDist = v
end)

d:Label("Shidou Movement Buffs.")
d:Slider("Draconic Rush Distance", 0, 0, 200, 1, function(v)
    Distances.dracDist = v
end)

d:Label("Bachira Movement Buffs.")
d:Slider("Step Overs Distance", 0, 0, 200, 1, function(v)
    Distances.stepDist = v
end)

d:Label("Kaiser Movement Buffs.")
d:Slider("Off The Ball Distance", 0, 0, 200, 1, function(v)
    Distances.kaiserDist = v
end)

d:Label("Rin Movement Buffs.")
d:Slider("Occlusion Break Distance", 0, 0, 200, 1, function(v)
    Distances.occlusionDist = v
end)

d:Label("Gagamaru Movement Buffs.")
d:Slider("Diving Header Distance", 0, 0, 125, 1, function(v)
    Distances.divingDist = v
end)

d:Label("Aiku Movement Buffs.")
d:Slider("Reflex Tackle Distance", 0, 0, 125, 1, function(v)
    Distances.reflexDist = v
end)

d:Label("Yukimiya Movement Buffs.")
d:Slider("Speed Dribble Distance", 0, 0, 200, 1, function(v)
    Distances.speedDist = v
end)

d:Slider("Cut In Distance", 0, 0, 200, 1, function(v)
    Distances.cutDist = v
end)

d:Label("Kunigami Movement Buffs.")
d:Slider("Hero's Instinct Distance", 0, 0, 300, 1, function(v)
    Distances.instinctDist = v
end)

d:Label("Kurona Movement Buffs.")
d:Slider("Close Quarter Dribble Distance", 0, 0, 250, 1, function(v)
    Distances.quarterDist = v
end)

d:Label("Don Lorenzo Movement Buffs.")
d:Slider("Zombie Dribble Distance", 0, 0, 250, 1, function(v)
    Distances.zombDist = v
end)

d:Label("Barou Movement Buffs.")
d:Slider("King's Path Distance", 0, 0, 750, 1, function(v)
    Distances.kingsDist = v
end)

d:Slider("DEVOUR. Distance", 0, 0, 500, 1, function(v)
    Distances.devourMaxDist = v
end)

d:Label("Chigiri Movement Buffs.")
d:Slider("Mach Cut-In Distance", 0, 0, 200, 1, function(v)
    Distances.machDist = v
end)

d:Slider("Golden Zone Distance (Req. Ball)", 0, 0, 400, 1, function(v)
    Distances.goldenDist = v
end)

local autoact = maintab2:Folder("Auto Activate Features.", Color3.fromRGB(24, 255, 228), true)
autoact:Label("Auto Activate: Activates The Move When Ball Within Range.")

local autoActivateState = {
    distance = 10,
    toggleState = false,
    moveNumber = 1,
    db = true
}

autoact:Textbox("Auto Activate Move Number", "Example: 1, 2, 3, 4, 5.", function(v)
    local nsdv = tonumber(v)
    if nsdv and nsdv <= 5 and nsdv > 0 then
        autoActivateState.moveNumber = nsdv
    end
end)

autoact:Slider("Auto Activate Distance", 10, 3, 70, 0.5, function(v)
    autoActivateState.distance = v
end)

autoact:Toggle("Auto Activate Toggle", "Hold The Right Mouse Button To Have It On", function(v)
    autoActivateState.toggleState = not autoActivateState.toggleState
end)

game.UserInputService.InputBegan:Connect(function(input, bg)
    if bg then return end
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        autoActivateState.db = false
    end
end)

game.UserInputService.InputEnded:Connect(function(input, bg)
    if bg then return end
    if input.UserInputType == Enum.UserInputType.MouseButton2 then
        autoActivateState.db = true
    end
end)

game:GetService("RunService").RenderStepped:Connect(function()
    if not autoActivateState.toggleState then return end

    local char = game.Players.LocalPlayer.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")
    if not hrp then return end

    local playerPos = hrp.Position
    
    if game.Workspace.Terrain:FindFirstChild("Ball") then
        local ballPos = game.Workspace.Terrain:FindFirstChild("Ball").Position
        local distance = (playerPos - ballPos).Magnitude

        if distance <= autoActivateState.distance and not autoActivateState.db then
            local args = {
                buffer.fromstring(buffers["base"]),
                {
                    { "skill" .. autoActivateState.moveNumber }
                }
            }

            game.ReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(unpack(args))
        end
    end
end)

local autoline = maintab2:Folder("Auto Line Up Features.", Color3.fromRGB(24, 255, 228), true)
autoline:Label("Auto Line Ups: Helps You Aim At Certain Areas.")

local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")
local RunService = game:GetService("RunService")
local StarterGui = game:GetService("StarterGui")

local player = Players.LocalPlayer
local camera = Workspace.CurrentCamera

local character = player.Character
local hrp = character and character:FindFirstChild("HumanoidRootPart")

local padCount = 0
local targetCount = 0

local holdingRMB = false
local camLockConnection = nil
local activeTarget = nil

local function updateCharacterRefs(char)
	character = char
	hrp = character:WaitForChild("HumanoidRootPart")
end

if player.Character then
	updateCharacterRefs(player.Character)
end

player.CharacterAdded:Connect(updateCharacterRefs)

local function pad(pos, color)
	padCount += 1
	local p = Instance.new("Part")
	p.Name = "pad" .. padCount
	p.Size = Vector3.new(5, 5, 5)
	p.Position = pos
	p.Transparency = 0.65
	p.Anchored = true
	p.CanCollide = false
	p.Color = color
	p.Material = Enum.Material.SmoothPlastic
	p.Parent = Workspace
end

local function target(pos, color)
	targetCount += 1
	local t = Instance.new("Part")
	t.Name = "target" .. targetCount
	t.Shape = Enum.PartType.Ball
	t.Size = Vector3.new(6, 6, 6)
	t.Position = pos
	t.Anchored = true
	t.CanCollide = false
	t.Color = color
	t.Material = Enum.Material.Neon
	t.Parent = Workspace
end

UserInputService.InputBegan:Connect(function(input, gpe)
	if gpe then return end
	if input.UserInputType == Enum.UserInputType.MouseButton2 then
		holdingRMB = true
	end
end)

UserInputService.InputEnded:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton2 then
		holdingRMB = false
		activeTarget = nil
		if camLockConnection then
			camLockConnection:Disconnect()
			camLockConnection = nil
		end
		if hrp then
			hrp.Anchored = false
		end
	end
end)

local function getPadUnderPlayer()
	if not hrp then return end

	local params = RaycastParams.new()
	params.FilterDescendantsInstances = {character}
	params.FilterType = Enum.RaycastFilterType.Blacklist

	local result = Workspace:Raycast(hrp.Position, Vector3.new(0, -6, 0), params)
	if result and result.Instance then
		return result.Instance.Name:match("^pad(%d+)$")
	end
end

RunService.RenderStepped:Connect(function()
	if not holdingRMB or not hrp then return end

	local padIndex = getPadUnderPlayer()
	if not padIndex then return end

	local targetPart = Workspace:FindFirstChild("target" .. padIndex)
	if not targetPart then return end

	activeTarget = targetPart

	hrp.Anchored = true

	if not camLockConnection then
		camLockConnection = RunService.RenderStepped:Connect(function()
			if not holdingRMB or not activeTarget then return end
			camera.CFrame = CFrame.new(camera.CFrame.Position, activeTarget.Position)
		end)
	end
end)

autoline:Toggle("Sae Line Ups", "Sae's Drive Shot Line Ups.", function(s)
	if s then
		StarterGui:SetCore("SendNotification", {
			Title = "Sae Line Ups",
			Text = "Enabled.",
			Duration = 3
		})

		local colors = {
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(0, 255, 0),
			Color3.fromRGB(255, 255, 0),
			Color3.fromRGB(0, 0, 255),
		}

		local goalRelative = {
			{pad = Vector3.new(80, -10, -162),  target = Vector3.new(20, 44, -26)},
			{pad = Vector3.new(172, -10, -44),  target = Vector3.new(110, 13, -15)},
			{pad = Vector3.new(0, -10, -211),   target = Vector3.new(32, 85, -14)},
			{pad = Vector3.new(-78, -10, -133), target = Vector3.new(82, 41, -18)},
			{pad = Vector3.new(-130, -9, 166),  target = Vector3.new(-50, 52, 16)},
			{pad = Vector3.new(-190, -9, 66),   target = Vector3.new(-90, 30, 16)},
			{pad = Vector3.new(72, -9, 164),    target = Vector3.new(-57, 56, 16)},
			{pad = Vector3.new(-1, -9, 222),    target = Vector3.new(-6, 76, 55)},
		}

		local map = Workspace:WaitForChild("map", 8)
		if not map then return end

		local agoal = map:FindFirstChild("Agoal")
		local bgoal = map:FindFirstChild("Bgoal")

		local agoalPos = agoal.Position
		local bgoalPos = bgoal.Position

		for i = 1, 8 do
			local entry = goalRelative[i]
			if not entry then continue end

			local basePos = (i <= 4) and agoalPos or bgoalPos
			local col = colors[(i - 1) % 4 + 1]

			pad(basePos + entry.pad, col)
			target(basePos + entry.target, col)
		end

	else
		StarterGui:SetCore("SendNotification", {
			Title = "Sae Line Ups",
			Text = "Disabled.",
			Duration = 3
		})

		for i = 1, padCount do
			local p = Workspace:FindFirstChild("pad" .. i)
			if p then p:Destroy() end
		end

		for i = 1, targetCount do
			local t = Workspace:FindFirstChild("target" .. i)
			if t then t:Destroy() end
		end

		padCount = 0
		targetCount = 0
	end
end)

autoline:Toggle("Kaiser Line Ups", "Kaiser's Impact Magnus Line Ups.", function(k)
	if k then
		StarterGui:SetCore("SendNotification", {
			Title = "Kaiser Line Ups",
			Text = "Enabled.",
			Duration = 3
		})

		local colors = {
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(0, 255, 0),
			Color3.fromRGB(255, 255, 0),
			Color3.fromRGB(0, 0, 255),
			Color3.fromRGB(255, 0, 255),
			Color3.fromRGB(255, 182, 193),
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(0, 255, 0),
			Color3.fromRGB(255, 255, 0),
			Color3.fromRGB(0, 0, 255),
			Color3.fromRGB(255, 0, 255),
			Color3.fromRGB(255, 182, 193),
		}
	
	    local goalRelative = {
            {pad = Vector3.new(-3, -9, 263), target = Vector3.new(8, 112, 16)},
            {pad = Vector3.new(120, -9, 221), target = Vector3.new(49, 75, 15)},
            {pad = Vector3.new(230, -9, 68), target = Vector3.new(116, 39, 21)},
            {pad = Vector3.new(207, -9, 15), target = Vector3.new(91, 29, -11)},
            {pad = Vector3.new(39, -9, 117), target = Vector3.new(24, 10, 13)},
            {pad = Vector3.new(-134, -9, 148), target = Vector3.new(87, 57, 19)},
            {pad = Vector3.new(-1, -10, -250), target = Vector3.new(-12, 115, -13)},
            {pad = Vector3.new(-231, -10, -60), target = Vector3.new(-142, 24, -22)},
            {pad = Vector3.new(-120, -10, -215), target = Vector3.new(-53, 65, -18)},
            {pad = Vector3.new(-212, -10, -15), target = Vector3.new(-89, 33, 12)},
            {pad = Vector3.new(-48, -10, -116), target = Vector3.new(-24, 8, -13)},
            {pad = Vector3.new(126, -10, -146), target = Vector3.new(-109, 60, -14)},
        }

		local map = Workspace:WaitForChild("map", 8)
		if not map then return end

		local agoal = map:FindFirstChild("Agoal")
		local bgoal = map:FindFirstChild("Bgoal")

		local agoalPos = agoal.Position
		local bgoalPos = bgoal.Position

		for i = 1, 12 do
			local entry = goalRelative[i]
			if not entry then continue end

			local basePos = (i <= 6) and bgoalPos or agoalPos
			local col = colors[i]

			pad(basePos + entry.pad, col)
			target(basePos + entry.target, col)
		end

	else
		StarterGui:SetCore("SendNotification", {
			Title = "Kaiser Line Ups",
			Text = "Disabled.",
			Duration = 3
		})

		for i = 1, padCount do
			local p = Workspace:FindFirstChild("pad" .. i)
			if p then p:Destroy() end
		end

		for i = 1, targetCount do
			local t = Workspace:FindFirstChild("target" .. i)
			if t then t:Destroy() end
		end

		padCount = 0
		targetCount = 0
	end
end)

autoline:Toggle("Yukimiya Line Ups", "Yukimiya's Gyro Shot Line Ups.", function(y)
	if y then
		StarterGui:SetCore("SendNotification", {
			Title = "Yukimiya Line Ups",
			Text = "Enabled.",
			Duration = 3
		})

		local colors = {
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(255, 255, 0),
			Color3.fromRGB(0, 0, 255),
			Color3.fromRGB(0, 255, 0),
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(0, 255, 0),
			Color3.fromRGB(255, 255, 0),
			Color3.fromRGB(0, 0, 255),
		}

		local goalRelative = {
			{pad = Vector3.new(-1, -9, 222), target = Vector3.new(-57, 58, 13)},
			{pad = Vector3.new(-82, -9, 182), target = Vector3.new(-51, 74, 14)},
			{pad = Vector3.new(130, -9, 136), target = Vector3.new(-114, 95, 13)},
			{pad = Vector3.new(63, -9, 192), target = Vector3.new(-104, 128, 13)},
			{pad = Vector3.new(6, -10, -206), target = Vector3.new(65, 124, -12)},
			{pad = Vector3.new(-59, -10, -201), target = Vector3.new(123, 148, -12)},
			{pad = Vector3.new(68, -10, -198), target = Vector3.new(61, 105, -12)},
			{pad = Vector3.new(-134, -10, -113), target = Vector3.new(4, 55, -53)},
		}

		local map = Workspace:WaitForChild("map", 8)
		if not map then return end

		local agoal = map:FindFirstChild("Agoal")
		local bgoal = map:FindFirstChild("Bgoal")

		local agoalPos = agoal.Position
		local bgoalPos = bgoal.Position

		for i = 1, 8 do
			local entry = goalRelative[i]
			if not entry then continue end

			local basePos = (i <= 4) and bgoalPos or agoalPos
			local col = colors[i]

			pad(basePos + entry.pad, col)
			target(basePos + entry.target, col)
		end

	else
		StarterGui:SetCore("SendNotification", {
			Title = "Yukimiya Line Ups",
			Text = "Disabled.",
			Duration = 3
		})

		for i = 1, padCount do
			local p = Workspace:FindFirstChild("pad" .. i)
			if p then p:Destroy() end
		end

		for i = 1, targetCount do
			local t = Workspace:FindFirstChild("target" .. i)
			if t then t:Destroy() end
		end

		padCount = 0
		targetCount = 0
	end
end)

autoline:Toggle("Rin Line Ups", "Rin's Curve Shot Line Ups.", function(r)
	if r then
		StarterGui:SetCore("SendNotification", {
			Title = "Rin Line Ups",
			Text = "Enabled.",
			Duration = 3
		})

		local colors = {
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(0, 255, 0),
			Color3.fromRGB(255, 255, 0),
			Color3.fromRGB(0, 0, 255),
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(0, 255, 0),
			Color3.fromRGB(255, 255, 0),
			Color3.fromRGB(0, 0, 255),
		}

		local goalRelative = {
			{pad = Vector3.new(73, -9, 200), target = Vector3.new(5, 67, 54)},
			{pad = Vector3.new(-2, -9, 215), target = Vector3.new(0, 88, 54)},
			{pad = Vector3.new(-84, -9, 160), target = Vector3.new(-29, 13, 26)},
			{pad = Vector3.new(-169, -9, 105), target = Vector3.new(-29, 24, 26)},
			{pad = Vector3.new(-1, -10, -213), target = Vector3.new(-1, 77, -53)},
			{pad = Vector3.new(-70, -10, -196), target = Vector3.new(9, 71, -53)},
			{pad = Vector3.new(81, -10, -114), target = Vector3.new(30, 11, -20)},
			{pad = Vector3.new(163, -10, -91), target = Vector3.new(30, 26, -20)},
		}

		local map = Workspace:WaitForChild("map", 8)
		if not map then return end

		local agoal = map:FindFirstChild("Agoal")
		local bgoal = map:FindFirstChild("Bgoal")

		local agoalPos = agoal.Position
		local bgoalPos = bgoal.Position

		for i = 1, 8 do
			local entry = goalRelative[i]
			if not entry then continue end

			local basePos = (i <= 4) and bgoalPos or agoalPos
			local col = colors[i]

			pad(basePos + entry.pad, col)
			target(basePos + entry.target, col)
		end

	else
		StarterGui:SetCore("SendNotification", {
			Title = "Rin Line Ups",
			Text = "Disabled.",
			Duration = 3
		})

		for i = 1, padCount do
			local p = Workspace:FindFirstChild("pad" .. i)
			if p then p:Destroy() end
		end

		for i = 1, targetCount do
			local t = Workspace:FindFirstChild("target" .. i)
			if t then t:Destroy() end
		end

		padCount = 0
		targetCount = 0
	end
end)

autoline:Toggle("Rin Flow Line Ups", "Rin's Kill Shot Line Ups.", function(k)
	if k then
		StarterGui:SetCore("SendNotification", {
			Title = "Rin Flow Line Ups",
			Text = "Enabled.",
			Duration = 3
		})

		local colors = {
			Color3.fromRGB(147, 112, 219),
			Color3.fromRGB(255, 0, 0),
			Color3.fromRGB(147, 112, 219),
			Color3.fromRGB(255, 0, 0),
		}

		local goalRelative = {
			{pad = Vector3.new(158, -9, 321), target = Vector3.new(-12, 125, 54)},
			{pad = Vector3.new(-187, -9, 290), target = Vector3.new(-29, 83, 20)},
			{pad = Vector3.new(-117, -10, -320), target = Vector3.new(14, 96, -53)},
			{pad = Vector3.new(198, -10, -265), target = Vector3.new(30, 90, -13)},
		}

		local map = Workspace:WaitForChild("map", 8)
		if not map then return end

		local agoal = map:FindFirstChild("Agoal")
		local bgoal = map:FindFirstChild("Bgoal")

		local agoalPos = agoal.Position
		local bgoalPos = bgoal.Position

		for i = 1, 4 do
			local entry = goalRelative[i]
			if not entry then continue end

			local basePos = (i <= 2) and bgoalPos or agoalPos
			local col = colors[i]

			pad(basePos + entry.pad, col)
			target(basePos + entry.target, col)
		end

	else
		StarterGui:SetCore("SendNotification", {
			Title = "Rin Flow Line Ups",
			Text = "Disabled.",
			Duration = 3
		})

		for i = 1, padCount do
			local p = Workspace:FindFirstChild("pad" .. i)
			if p then p:Destroy() end
		end

		for i = 1, targetCount do
			local t = Workspace:FindFirstChild("target" .. i)
			if t then t:Destroy() end
		end

		padCount = 0
		targetCount = 0
	end
end)

local autopos = maintab2:Folder("Auto Position Features.", Color3.fromRGB(24, 255, 228), true)
autopos:Label("Auto Position: Automatically Sets Certain Positions.")

local autoPositionState = {
    CF = false,
    GK = false,
    CFConn = nil,
    GKConn = nil
}

buffer = buffer or {
    fromstring = function(str)
        return str
    end
}

local function firePacketsIfNear()
    local char = game:GetService("Players").LocalPlayer.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    if (root.Position - Vector3.new(-371, 13, -1599)).Magnitude <= 15 or
       (root.Position - Vector3.new(-196, 13, -1599)).Magnitude <= 15 then
        game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring(pick .. "\001\001\000A"))
        game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring(pick .. "\001\001\000B"))
    end
end

local function fireGKPackets()
    local char = game:GetService("Players").LocalPlayer.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart")
    if not root then return end

    game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring(pick .. "\005\001\000B"))
    game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring(pick .. "\005\001\000A"))
end

autopos:Toggle("Auto Pick CF", "Automatically Picks Center Field Position On Respawn Or Enable.", function()
    autoPositionState.CF = not autoPositionState.CF

    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Auto Pick CF",
        Text = autoPositionState.CF and "Enabled." or "Disabled.",
        Duration = 1
    })

    if autoPositionState.CF then
        autoPositionState.CFConn = game:GetService("Players").LocalPlayer.CharacterAdded:Connect(function()
            task.wait(0.3)
            firePacketsIfNear()
        end)

        task.spawn(function()
            repeat task.wait() until game:GetService("Players").LocalPlayer.Character and game:GetService("Players").LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            firePacketsIfNear()
        end)
    else
        if autoPositionState.CFConn then
            autoPositionState.CFConn:Disconnect()
            autoPositionState.CFConn = nil
        end
    end
end)

autopos:Toggle("Auto Pick GK", "Automatically Picks Goalkeeper Position On Respawn Or Enable.", function()
    autoPositionState.GK = not autoPositionState.GK

    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Auto Pick GK",
        Text = autoPositionState.GK and "Enabled." or "Disabled.",
        Duration = 1
    })

    if autoPositionState.GK then
        autoPositionState.GKConn = game:GetService("Players").LocalPlayer.CharacterAdded:Connect(function()
            task.wait(0.3)
            fireGKPackets()
        end)

        task.spawn(function()
            repeat task.wait() until game:GetService("Players").LocalPlayer.Character and game:GetService("Players").LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            fireGKPackets()
        end)
    else
        if autoPositionState.GKConn then
            autoPositionState.GKConn:Disconnect()
            autoPositionState.GKConn = nil
        end
    end
end)

local autogk = maintab2:Folder("Auto Goalkeeper Features.", Color3.fromRGB(24, 255, 228), true)
autogk:Label("Auto Goalkeeper: Automatically Plays As GK For You.")

autogk:Button("Celeron's Auto GK Enhanced", "Click V To Toggle, Reset To Disable.", function()
    task.spawn(function()
        local Players = game:GetService("Players")
        local ReplicatedStorage = game:GetService("ReplicatedStorage")
        local Workspace = game:GetService("Workspace")
        local RunService = game:GetService("RunService")
        local UserInputService = game:GetService("UserInputService")

        local plr = Players.LocalPlayer
        local char = plr.Character or plr.CharacterAdded:Wait()
        local hum = char:WaitForChild("Humanoid")
        local hrp = char:WaitForChild("HumanoidRootPart")

        local gui = Instance.new("ScreenGui")
        gui.ResetOnSpawn = false
        gui.Parent = plr.PlayerGui

        local dot = Instance.new("Frame")
        dot.Size = UDim2.new(0.012, 0, 0.025, 0)
        dot.Position = UDim2.new(0.988, 0, 0.975, 0)
        dot.BorderSizePixel = 0
        dot.Parent = gui

        local gkState = {
            enabled = true,
            pause = false,
            look = nil,
            ballHolder = ReplicatedStorage.workspace.ballHolder,
            lastHolder = nil,
            remote = ReplicatedStorage:WaitForChild("ByteNetReliable"),
            map = Workspace:WaitForChild("map"),
            GRAVITY = Vector3.new(0, -Workspace.Gravity, 0),
            velSmooth = Vector3.zero,
            lastVel = Vector3.zero,
            tackleArgs = {buffer.fromstring(buffers.base), {{"tackle"}}},
            emptyBuffer = buffer.fromstring(buffers["grabball"]),
            magnetBurstActive = false,
            tackle_radius = 50,
            terrain = Workspace.Terrain,
            cachedBall = nil,
            renderConn = nil,
            inputConn = nil,
            holderConn = nil,
            ballAdded = nil,
            ballRemoved = nil,
            diedConn = nil,
            charAddedConn = nil
        }

        gkState.look = Instance.new("AlignOrientation")
        gkState.look.Name = "AutoGKLook"
        gkState.look.Mode = Enum.OrientationAlignmentMode.OneAttachment
        gkState.look.Attachment0 = hrp:WaitForChild("RootAttachment")
        gkState.look.Responsiveness = 1200
        gkState.look.MaxTorque = math.huge
        gkState.look.Enabled = false
        gkState.look.Parent = hrp

        gkState.lastHolder = gkState.ballHolder.Value

        local function updateindicator()
            dot.BackgroundColor3 = gkState.enabled and Color3.fromRGB(0,255,0) or Color3.fromRGB(255,0,0)
        end

        local function cleanup()
            gkState.enabled = false
            if gkState.renderConn then gkState.renderConn:Disconnect() end
            if gkState.inputConn then gkState.inputConn:Disconnect() end
            if gkState.holderConn then gkState.holderConn:Disconnect() end
            if gkState.ballAdded then gkState.ballAdded:Disconnect() end
            if gkState.ballRemoved then gkState.ballRemoved:Disconnect() end
            if gkState.diedConn then gkState.diedConn:Disconnect() end
            if gkState.charAddedConn then gkState.charAddedConn:Disconnect() end
            if gkState.look then gkState.look:Destroy() end
            if gui then gui:Destroy() end
        end

        gkState.holderConn = gkState.ballHolder.Changed:Connect(function(cur)
            if gkState.lastHolder == char and cur == nil then
                gkState.pause = true
                task.delay(2.6, function() gkState.pause = false end)
            end
            gkState.lastHolder = cur
        end)

        gkState.ballAdded = gkState.terrain.ChildAdded:Connect(function(child)
            if child.Name == "Ball" then gkState.cachedBall = child end
        end)

        gkState.ballRemoved = gkState.terrain.ChildRemoved:Connect(function(child)
            if child == gkState.cachedBall then gkState.cachedBall = nil end
        end)

        local function predictgoalimpact(pos, vel, accel, goal)
            if not goal then return nil end
            local cf = goal.CFrame
            local normal = cf.LookVector
            local goalPos = cf.Position
            local rel = pos - goalPos
            local a = 0.5 * accel:Dot(normal)
            local b = vel:Dot(normal)
            local c = rel:Dot(normal)
            if math.abs(a) < 1e-6 then
                if math.abs(b) < 1e-6 then return nil end
                local t = -c / b
                return t > 0 and t
            end
            local disc = b*b - 4*a*c
            if disc < 0 then return nil end
            local sd = math.sqrt(disc)
            local t1 = (-b - sd) / (2*a)
            local t2 = (-b + sd) / (2*a)
            return (t1 > 0 and t1) or (t2 > 0 and t2)
        end

        gkState.renderConn = RunService.RenderStepped:Connect(function(dt)
            if not gkState.enabled then return end

            local ball = gkState.cachedBall
            if not ball or plr.Team == game.Teams.lobby or gkState.pause then
                gkState.look.Enabled = false
                return
            end

            local rawVel = ball.AssemblyLinearVelocity
            gkState.velSmooth = gkState.velSmooth:Lerp(rawVel, math.clamp(dt*15, 0, 1))
            local accel = (gkState.velSmooth - gkState.lastVel) / math.max(dt, 1/240)
            gkState.lastVel = gkState.velSmooth

            local goal = (plr.Team == game.Teams.B and gkState.map.Bgoal) or (plr.Team == game.Teams.A and gkState.map.Agoal)

            local tImpact = predictgoalimpact(ball.Position, gkState.velSmooth, accel, goal)

            local predicted
            if tImpact then
                predicted = ball.Position + gkState.velSmooth * tImpact + 0.5 * accel * tImpact^2
            else
                predicted = ball.Position + gkState.velSmooth * 0.25 + 0.5 * gkState.GRAVITY * 0.0625
            end

            gkState.look.Enabled = true
            gkState.look.CFrame = CFrame.lookAt(hrp.Position, Vector3.new(predicted.X, hrp.Position.Y, predicted.Z))

            local dist = (hrp.Position - ball.Position).Magnitude

            if dist > gkState.tackle_radius and dist <= 52 and ball.Position.Y > hrp.Position.Y + 4 then
                hum.Jump = true
            end

            if dist <= gkState.tackle_radius then
                gkState.remote:FireServer(unpack(gkState.tackleArgs))
                if not gkState.magnetBurstActive then
                    gkState.magnetBurstActive = true
                    task.spawn(function()
                        local start = os.clock()
                        while os.clock() - start < 0.86 and gkState.enabled do
                            gkState.remote:FireServer(gkState.emptyBuffer)
                            task.wait(0.1)
                        end
                        gkState.magnetBurstActive = false
                    end)
                end
            end
        end)

        gkState.inputConn = UserInputService.InputBegan:Connect(function(input, gameProcessed)
            if gameProcessed then return end
            if input.KeyCode == Enum.KeyCode.V then
                gkState.enabled = not gkState.enabled
                updateindicator()
                if not gkState.enabled then gkState.look.Enabled = false end
            end
        end)

        gkState.diedConn = hum.Died:Connect(cleanup)
        gkState.charAddedConn = plr.CharacterAdded:Connect(cleanup)

        updateindicator()
    end)
end)

autogk:Button("Daffy's Auto GK", "Reset Or Click F4 To Disable.", function()
    local gkPlayerState = {
        plr = Players.LocalPlayer,
        char = nil,
        cam = workspace.CurrentCamera,
        hum = nil,
        hrp = nil,
        originalCamType = nil,
        originalCamCFrame = nil,
        guii = nil,
        cambu = nil,
        gerg = nil,
        dot = nil,
        kind = "",
        align = nil,
        onn = true,
        pause = false,
        ballHolder = nil,
        lastHolder = nil,
        remote = nil,
        con = nil,
        kill = nil
    }

    gkPlayerState.char = gkPlayerState.plr.Character or gkPlayerState.plr.CharacterAdded:Wait()
    gkPlayerState.hum = gkPlayerState.char:WaitForChild("Humanoid")
    gkPlayerState.hrp = gkPlayerState.char:WaitForChild("HumanoidRootPart")

    gkPlayerState.originalCamType = gkPlayerState.cam.CameraType
    gkPlayerState.originalCamCFrame = gkPlayerState.cam.CFrame

    gkPlayerState.guii = Instance.new("ScreenGui")
    gkPlayerState.guii.Parent = gkPlayerState.plr.PlayerGui

    gkPlayerState.cambu = Instance.new("TextButton")
    gkPlayerState.cambu.Text = "Camera Mode"
    gkPlayerState.cambu.Size = UDim2.new(0.159,0,0.109,0)
    gkPlayerState.cambu.Position = UDim2.new(0.317,0,0.444,0)
    gkPlayerState.cambu.TextScaled = true
    gkPlayerState.cambu.Parent = gkPlayerState.guii

    gkPlayerState.gerg = Instance.new("TextButton")
    gkPlayerState.gerg.Text = "Body Mode"
    gkPlayerState.gerg.Size = UDim2.new(0.159,0,0.109,0)
    gkPlayerState.gerg.Position = UDim2.new(0.524,0,0.444,0)
    gkPlayerState.gerg.TextScaled = true
    gkPlayerState.gerg.Parent = gkPlayerState.guii

    gkPlayerState.dot = Instance.new("Frame")
    gkPlayerState.dot.Size = UDim2.new(0.012,0,0.025,0)
    gkPlayerState.dot.Position = UDim2.new(0.988,0,0.975,0)
    gkPlayerState.dot.BackgroundColor3 = Color3.fromRGB(0,255,0)
    gkPlayerState.dot.BorderSizePixel = 0
    gkPlayerState.dot.Parent = gkPlayerState.guii

    gkPlayerState.cambu.MouseButton1Up:Connect(function()
        gkPlayerState.kind = "cam"
    end)
    gkPlayerState.gerg.MouseButton1Up:Connect(function()
        gkPlayerState.kind = "body"
    end)

    repeat task.wait() until gkPlayerState.kind ~= ""
    gkPlayerState.cambu:Destroy()
    gkPlayerState.gerg:Destroy()

    local function getBall()
        return workspace.Terrain:FindFirstChild("Ball")
    end

    if gkPlayerState.kind == "body" then
        gkPlayerState.hum.AutoRotate = false
        gkPlayerState.align = Instance.new("AlignOrientation")
        gkPlayerState.align.Mode = Enum.OrientationAlignmentMode.OneAttachment
        gkPlayerState.align.Attachment0 = gkPlayerState.hrp:WaitForChild("RootAttachment")
        gkPlayerState.align.Responsiveness = 300
        gkPlayerState.align.MaxTorque = math.huge
        gkPlayerState.align.Enabled = false
        gkPlayerState.align.Parent = gkPlayerState.hrp
    end

    gkPlayerState.ballHolder = ReplicatedStorage.workspace.ballHolder
    gkPlayerState.lastHolder = gkPlayerState.ballHolder.Value

    gkPlayerState.ballHolder.Changed:Connect(function()
        local cur = gkPlayerState.ballHolder.Value
        if gkPlayerState.lastHolder == gkPlayerState.char and cur == nil then
            gkPlayerState.pause = true
            task.delay(0.7, function()
                gkPlayerState.pause = false
            end)
        end
        gkPlayerState.lastHolder = cur
    end)

    gkPlayerState.remote = ReplicatedStorage:WaitForChild("ByteNetReliable")

    local function cleanup()
        gkPlayerState.onn = false

        if gkPlayerState.align then
            gkPlayerState.align:Destroy()
        end

        gkPlayerState.cam.CameraType = gkPlayerState.originalCamType
        gkPlayerState.cam.CFrame = gkPlayerState.originalCamCFrame

        if gkPlayerState.guii then
            gkPlayerState.guii:Destroy()
        end
    end

    gkPlayerState.con = RunService.RenderStepped:Connect(function()
        if not gkPlayerState.onn then
            gkPlayerState.con:Disconnect()
            return
        end

        local ball = getBall()
        if not ball or gkPlayerState.plr.Team == game.Teams.lobby or gkPlayerState.pause then
            if gkPlayerState.align then gkPlayerState.align.Enabled = false end
            return
        end

        if gkPlayerState.kind == "cam" then
            gkPlayerState.cam.CameraType = Enum.CameraType.Scriptable
            gkPlayerState.cam.CFrame = CFrame.lookAt(gkPlayerState.cam.CFrame.Position, ball.Position)

        elseif gkPlayerState.kind == "body" then
            gkPlayerState.align.Enabled = true
            local dir = ball.Position - gkPlayerState.hrp.Position
            dir = Vector3.new(dir.X, 0, dir.Z)
            if dir.Magnitude > 0.01 then
                gkPlayerState.align.CFrame = CFrame.lookAt(Vector3.zero, dir)
            end
        end

        local dist = (gkPlayerState.hrp.Position - ball.Position).Magnitude
        if dist <= 60 then
            if ball.Position.Y >= gkPlayerState.hrp.Position.Y + 6 then
                gkPlayerState.hum.Jump = true
            else
                gkPlayerState.hum.Jump = false
            end

            gkPlayerState.remote:FireServer(
                buffer.fromstring(buffers.base),
                {
                    { "tackle" }
                }
            )
        end
    end)

    gkPlayerState.kill = UserInputService.InputBegan:Connect(function(input, gp)
        if gp then return end
        if input.KeyCode == Enum.KeyCode.F4 then
            cleanup()
            gkPlayerState.kill:Disconnect()
            gkPlayerState.con:Disconnect()
        end
    end)

    repeat task.wait() until gkPlayerState.hum.Health <= 0 or gkPlayerState.plr.Team == game.Teams.lobby
    cleanup()
    gkPlayerState.kill:Disconnect()
    gkPlayerState.con:Disconnect()
end)

local airdr = maintab2:Folder("Air Dribble Features.", Color3.fromRGB(24, 255, 228), true)
airdr:Label("Air Dribble: Dribbles The Ball Through The Air.")

local bindKey = Enum.KeyCode.LeftAlt

local airDribbleState = {
    enabled = false
}

local function notify(text)
    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Air Dribble",
        Text = text,
        Duration = 2
    })
end

airdr:Toggle("Air Dribble", "Kicks The Ball Forward Infront Of You And Up.", function()
    airDribbleState.enabled = not airDribbleState.enabled
    notify(airDribbleState.enabled and "Enabled." or "Disabled.")
end)

airdr:Textbox("Air Dribble Bind", "Enter Key (Example: E, Q, LeftAlt.)", function(text)
    if typeof(text) ~= "string" then
        bindKey = Enum.KeyCode.LeftAlt
        notify("Invalid Key. Bind Is Now LeftAlt.")
        return
    end

    local formatted = text:gsub("%s+", "")
    local success, key = pcall(function()
        return Enum.KeyCode[formatted]
    end)

    if success and key then
        bindKey = key
        notify("Bind Set To: " .. key.Name)
    else
        bindKey = Enum.KeyCode.LeftAlt
        notify("Invalid Key. Bind Is Now LeftAlt.")
    end
end)

game:GetService("UserInputService").InputBegan:Connect(function(input, gp)
    if gp or input.KeyCode ~= bindKey then return end
    if not airDribbleState.enabled then return end

    local char = game:GetService("Players").LocalPlayer.Character
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    local root = char and char:FindFirstChild("HumanoidRootPart")
    if not (hum and root) then return end

    local anim = Instance.new("Animation")
    anim.AnimationId = "rbxassetid://76587445975710"
    local track = hum:LoadAnimation(anim)
    track:Play()

    local dir = root.CFrame.LookVector
    local kickVec = vector.create(dir.X * 0.75, 0.65, dir.Z * 0.75)

    game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring(buffers["base"]), {
        { "kick", 28, false, kickVec }
    })
end)

local othersil = maintab2:Folder("Other Features.", Color3.fromRGB(24, 255, 228), true)
othersil:Label("Other Features: Self Explanatory, Other Silent Features.")

local qteState = {
    enabled = false
}

othersil:Toggle("Auto QuickTimeEvent", "Automatically Does QuickTimeEvents, How Else Can I Explain It?", function()
qteState.enabled = not qteState.enabled

local function sendNotification(status)
    if not autoSkillState.suppressNotifs then
        game:GetService("StarterGui"):SetCore("SendNotification", {
            Title = "QuickTimeEvent",
            Text = status,
            Duration = 1
        })
    end
end

local function convertNumberToKeyText(text)
    local numberMap = {
        ["1"] = "One", ["2"] = "Two", ["3"] = "Three", ["4"] = "Four", ["5"] = "Five",
        ["6"] = "Six", ["7"] = "Seven", ["8"] = "Eight", ["9"] = "Nine", ["0"] = "Zero"
    }
    return numberMap[text] or text
end

local function isShadeOfGreen(color)
    return color.G > color.R and color.G > color.B
end

local function checkQTE()
    local player = game:GetService("Players").LocalPlayer
    if qteState.enabled and player and player:FindFirstChild("PlayerGui") then
        local qteGui = player.PlayerGui:FindFirstChild("Qte")
        if qteGui and qteGui:FindFirstChild("QTE") then
            for _, descendant in ipairs(qteGui.QTE:GetDescendants()) do
                if descendant:IsA("Frame") or descendant:IsA("TextLabel") then
                    if isShadeOfGreen(descendant.BackgroundColor3) then
                        local textLabel = qteGui.QTE:FindFirstChild("TextLabel")
                        if textLabel then
                            local keyText = convertNumberToKeyText(textLabel.Text)
                            local keyCode = Enum.KeyCode[keyText]
                            if keyCode then
                                game:GetService("VirtualInputManager"):SendKeyEvent(true, keyCode, false, game)
                                game:GetService("VirtualInputManager"):SendKeyEvent(false, keyCode, false, game)
                            end
                        end
                        break
                    end
                end
            end
        end
    end
end

game:GetService("RunService").RenderStepped:Connect(checkQTE)

sendNotification(qteState.enabled and "Enabled." or "Disabled.")
end)

local formlessState = {
    enabled = false
}

othersil:Toggle("Auto Formless (Bind: Y)", "Shidou Only Formless Macro.", function()
    formlessState.enabled = not (formlessState.enabled or false)

    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Auto Formless",
        Text = formlessState.enabled and "Enabled." or "Disabled.",
        Duration = 2
    })

    if formlessState.inputConnection then
        formlessState.inputConnection:Disconnect()
        formlessState.inputConnection = nil
    end

    if formlessState.enabled then
        formlessState.inputConnection = game:GetService("UserInputService").InputBegan:Connect(function(input, gp)
            if gp or input.KeyCode ~= Enum.KeyCode.Y then return end
            if game:GetService("UserInputService").MouseBehavior ~= Enum.MouseBehavior.LockCenter then return end

            local LP = game:GetService("Players").LocalPlayer
            local char = LP.Character
            local hrp = char and char:FindFirstChild("HumanoidRootPart")
            local hum = char and char:FindFirstChildOfClass("Humanoid")
            if not hrp or not hum then return end

            hum.AutoRotate = false

            local Camera = workspace.CurrentCamera
            local camType = Camera.CameraType
            local camSubject = Camera.CameraSubject
            local camCF = Camera.CFrame
            local flipped = camCF * CFrame.Angles(0, math.rad(180), 0)

            Camera.CameraType = Enum.CameraType.Scriptable
            Camera.CFrame = flipped

            task.delay(0.1, function()
                if LP.Character and LP.Character:FindFirstChildOfClass("Humanoid") then
                    Camera.CameraSubject = LP.Character:FindFirstChildOfClass("Humanoid")
                    Camera.CameraType = Enum.CameraType.Custom
                else
                    Camera.CameraSubject = camSubject
                    Camera.CameraType = camType
                end
                hum.AutoRotate = true
            end)

            task.wait(0.15)

            local anim = Instance.new("Animation")
            anim.AnimationId = "rbxassetid://76587445975710"
            local track = hum:LoadAnimation(anim)
            track:Play()

            local dir = hrp.CFrame.LookVector
            local kickVec = vector.create(dir.X * 0.5, 1, dir.Z * 0.5)

            local remote = game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable")
            remote:FireServer(buffer.fromstring(buffers["base"]), { { "kick", 25, false, kickVec } })
            game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(
                buffer.fromstring(buffers["base"]), { { "skill1" } }
            )
        end)
    end
end)

local cutsceneState = {
    nocutscene = false
}

othersil:Toggle("No Cutscene", "Shitty Feature For Right Now That Disables Cutscenes.", function()
    cutsceneState.nocutscene = not cutsceneState.nocutscene
    local StarterGui = game:GetService("StarterGui")
    local SoundService = game:GetService("SoundService")
    local tempFolder = SoundService:FindFirstChild("celerontemp") or Instance.new("Folder", SoundService)
    tempFolder.Name = "celerontemp"
    local crowdSound = SoundService:FindFirstChild("football-crowd-3-69245") or tempFolder:FindFirstChild("football-crowd-3-69245")

    StarterGui:SetCore("SendNotification", {
        Title = "No Cutscene",
        Text = cutsceneState.nocutscene and "Enabled." or "Disabled.",
        Duration = 1
    })

    if cutsceneState.nocutscene then
        if crowdSound and crowdSound:IsDescendantOf(SoundService) then
            local clone = crowdSound:Clone()
            clone.Parent = tempFolder
            crowdSound:Stop()
            crowdSound:Destroy()
        end
    else
        local stored = tempFolder:FindFirstChild("football-crowd-3-69245")
        if stored then
            stored.Parent = SoundService
            stored:Play()
        end
    end
end)

local iframeState = {
    enabled = false,
    activeDots = {},
    dotSize = UDim2.new(0, 6, 0, 6),
    offset = Vector3.new(0, 3, 0),
    updateInterval = 0.2
}

othersil:Toggle("IFrame Indicator", "Shows The I-Frame Status Of All Players. (Green = Off, Red = On.)", function()
    iframeState.enabled = not iframeState.enabled

    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "IFrame Indicator",
        Text = iframeState.enabled and "Enabled." or "Disabled.",
        Duration = 3
    })

    local charactersFolder = workspace:FindFirstChild("characters")
    if not charactersFolder then return end

    local function createDot(char)
        if iframeState.activeDots[char] then return end
        local hrp = char:FindFirstChild("HumanoidRootPart")
        if not hrp then return end
        local gui = Instance.new("BillboardGui")
        gui.Name = "IframeDot"
        gui.Size = UDim2.new(0, 12, 0, 12)
        gui.StudsOffset = iframeState.offset
        gui.AlwaysOnTop = true
        gui.Adornee = hrp
        gui.Parent = hrp
        local dot = Instance.new("Frame")
        dot.Size = iframeState.dotSize
        dot.Position = UDim2.new(0.5, -3, 0.5, -3)
        dot.BackgroundColor3 = Color3.fromRGB(128, 128, 128)
        dot.BorderSizePixel = 0
        dot.BackgroundTransparency = 0
        dot.Parent = gui
        iframeState.activeDots[char] = dot
    end

    local function updateDot(char, dot)
        local state = char:FindFirstChild("state")
        local iframe = state and state:FindFirstChild("iframe")
        if iframe and iframe:IsA("BoolValue") then
            dot.BackgroundColor3 = iframe.Value and Color3.fromRGB(255, 0, 0) or Color3.fromRGB(0, 255, 0)
        else
            dot.BackgroundColor3 = Color3.fromRGB(128, 128, 128)
        end
    end

    local function clearDots()
        for char, dot in pairs(iframeState.activeDots) do
            if dot and dot.Parent then
                dot.Parent:Destroy()
            end
        end
        iframeState.activeDots = {}
    end

    if iframeState.enabled then
        for _, char in ipairs(charactersFolder:GetChildren()) do
            createDot(char)
        end
        charactersFolder.ChildAdded:Connect(function(char)
            task.wait(0.5)
            if iframeState.enabled then
                createDot(char)
            end
        end)
        task.spawn(function()
            while iframeState.enabled do
                for char, dot in pairs(iframeState.activeDots) do
                    if char and dot then
                        updateDot(char, dot)
                    end
                end
                for _, char in ipairs(charactersFolder:GetChildren()) do
                    if not iframeState.activeDots[char] then
                        createDot(char)
                    end
                end
                task.wait(iframeState.updateInterval)
            end
        end)
    else
        clearDots()
    end
end)

othersil:Button("Fix Duplicate Ball", "I Don't Know If This Is Still An Issue But Removes Duplicate Balls If Existent.", function()
    for _, obj in ipairs(workspace.Terrain:GetDescendants()) do
        if obj:IsA("MeshPart") and obj.Name == "Ball" then
            obj:Destroy()
        end
    end
end)

local mobile = maintab2:Folder("Mobile Silent Features.", Color3.fromRGB(24, 255, 228), true)
mobile:Label("Mobile Silent Features: Silent Features Ported To Mobile.")

local mobform = {
    gui = nil,
    active = false
}

local function trigger()
    if game:GetService("UserInputService").MouseBehavior ~= Enum.MouseBehavior.LockCenter then return end
    local lp = game:GetService("Players").LocalPlayer
    local char = lp.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    if not hrp or not hum then return end

    hum.AutoRotate = false
    local cam = workspace.CurrentCamera
    local camType = cam.CameraType
    local camSubject = cam.CameraSubject
    local camCF = cam.CFrame
    local flipped = camCF * CFrame.Angles(0, math.rad(180), 0)

    cam.CameraType = Enum.CameraType.Scriptable
    cam.CFrame = flipped

    task.delay(0.1, function()
        if lp.Character and lp.Character:FindFirstChildOfClass("Humanoid") then
            cam.CameraSubject = lp.Character:FindFirstChildOfClass("Humanoid")
            cam.CameraType = Enum.CameraType.Custom
        else
            cam.CameraSubject = camSubject
            cam.CameraType = camType
        end
        if hum and hum.Parent then
            hum.AutoRotate = true
        end
    end)

    task.wait(0.15)

    local anim = Instance.new("Animation")
    anim.AnimationId = "rbxassetid://76587445975710"
    local track = hum:LoadAnimation(anim)
    track:Play()

    local dir = hrp.CFrame.LookVector
    local kickVec = Vector3.new(dir.X * 0.5, 1, dir.Z * 0.5)

    game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring(buffers["base"]), { { "kick", 25, false, kickVec } })
    game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring(buffers["base"]), { { "skill1" } })
end

local function makeDraggable(frame)
    local dragging, dragInput, dragStart, startPos
    frame.InputBegan:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
            dragging = true
            dragStart = input.Position
            startPos = frame.Position
            input.Changed:Connect(function()
                if input.UserInputState == Enum.UserInputState.End then
                    dragging = false
                end
            end)
        end
    end)
    frame.InputChanged:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch then
            dragInput = input
        end
    end)
    game:GetService("UserInputService").InputChanged:Connect(function(input)
        if input == dragInput and dragging then
            local delta = input.Position - dragStart
            frame.Position = UDim2.new(
                startPos.X.Scale,
                startPos.X.Offset + delta.X,
                startPos.Y.Scale,
                startPos.Y.Offset + delta.Y
            )
        end
    end)
end

local function show()
    if mobform.gui then return end
    local pg = game:GetService("Players").LocalPlayer:WaitForChild("PlayerGui")
    local sg = Instance.new("ScreenGui")
    sg.Name = "FormlessMobile"
    sg.ResetOnSpawn = false
    sg.Parent = pg
    mobform.gui = sg

    local btn = Instance.new("TextButton")
    btn.Size = UDim2.new(0, 100, 0, 100)
    btn.Position = UDim2.new(0.5, -50, 0.5, -50)
    btn.AnchorPoint = Vector2.new(0.5, 0.5)
    btn.BackgroundColor3 = Color3.fromRGB(15, 15, 15)
    btn.BorderSizePixel = 0
    btn.Text = "Formless"
    btn.TextColor3 = Color3.fromRGB(220, 220, 220)
    btn.Font = Enum.Font.GothamSemibold
    btn.TextSize = 20
    btn.AutoButtonColor = true
    btn.Parent = sg

    local cr = Instance.new("UICorner")
    cr.CornerRadius = UDim.new(0, 8)
    cr.Parent = btn

    btn.MouseEnter:Connect(function()
        btn.BackgroundColor3 = Color3.fromRGB(35, 35, 35)
    end)

    btn.MouseLeave:Connect(function()
        btn.BackgroundColor3 = Color3.fromRGB(15, 15, 15)
    end)

    btn.Activated:Connect(trigger)

    makeDraggable(btn)
end

local function hide()
    if mobform.gui then
        mobform.gui:Destroy()
        mobform.gui = nil
    end
end

mobile:Button("Auto Formless (Mobile Button.)", "Click Again To Remove Button.", function()
    mobform.active = not mobform.active
    if mobform.active then
        show()
    else
        hide()
    end
end)

local airDribble = {
    gui = nil,
    active = false,
    enabled = true
}

local function trigger()
    if not airDribble.enabled then return end
    local char = game:GetService("Players").LocalPlayer.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")
    local hum = char and char:FindFirstChildOfClass("Humanoid")
    if not hrp or not hum then return end

    local anim = Instance.new("Animation")
    anim.AnimationId = "rbxassetid://76587445975710"
    hum:LoadAnimation(anim):Play()

    local dir = hrp.CFrame.LookVector
    local kickVec = Vector3.new(dir.X * 0.75, 0.65, dir.Z * 0.75)

    game:GetService("ReplicatedStorage"):WaitForChild("ByteNetReliable"):FireServer(
        buffer.fromstring(buffers["base"]),
        { { "kick", 28, false, kickVec } }
    )
end

local function makeDraggable(frame)
    local dragging, dragInput, dragStart, startPos
    frame.InputBegan:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
            dragging = true
            dragStart = input.Position
            startPos = frame.Position
            input.Changed:Connect(function()
                if input.UserInputState == Enum.UserInputState.End then dragging = false end
            end)
        end
    end)
    frame.InputChanged:Connect(function(input)
        if input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch then
            dragInput = input
        end
    end)
    game:GetService("UserInputService").InputChanged:Connect(function(input)
        if input == dragInput and dragging then
            local delta = input.Position - dragStart
            frame.Position = UDim2.new(
                startPos.X.Scale, startPos.X.Offset + delta.X,
                startPos.Y.Scale, startPos.Y.Offset + delta.Y
            )
        end
    end)
end

local function show()
    if airDribble.gui then return end
    local sg = Instance.new("ScreenGui")
    sg.Name = "AirDribbleMobile"
    sg.ResetOnSpawn = false
    sg.Parent = game:GetService("Players").LocalPlayer:WaitForChild("PlayerGui")
    airDribble.gui = sg

    local btn = Instance.new("TextButton")
    btn.Size = UDim2.new(0, 100, 0, 100)
    btn.Position = UDim2.new(0.5, -50, 0.5, -50)
    btn.AnchorPoint = Vector2.new(0.5, 0.5)
    btn.BackgroundColor3 = Color3.fromRGB(15, 15, 15)
    btn.BorderSizePixel = 0
    btn.Text = "Air Dribble"
    btn.TextColor3 = Color3.fromRGB(220, 220, 220)
    btn.Font = Enum.Font.GothamSemibold
    btn.TextSize = 20
    btn.AutoButtonColor = true
    btn.Parent = sg

    local cr = Instance.new("UICorner")
    cr.CornerRadius = UDim.new(0, 8)
    cr.Parent = btn

    btn.MouseEnter:Connect(function() btn.BackgroundColor3 = Color3.fromRGB(35, 35, 35) end)
    btn.MouseLeave:Connect(function() btn.BackgroundColor3 = Color3.fromRGB(15, 15, 15) end)
    btn.Activated:Connect(trigger)
    makeDraggable(btn)
end

local function hide()
    if airDribble.gui then
        airDribble.gui:Destroy()
        airDribble.gui = nil
    end
end

mobile:Button("Air Dribble (Mobile Button)", "Click Again To Remove Button.", function()
    airDribble.active = not airDribble.active
    if airDribble.active then show() else hide() end
end)

funtab:Label("Celeron's Movesets, Recommend Using In Normal Servers.")

funtab:Button("Goku Moveset (Req. Isagi)", "Click F4 To Disable.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Credits",
        Text = "brought to you by celeron!",
        Duration = 5,
        Button1 = "OK",
    })
    loadstring(game:HttpGet("https://raw.githubusercontent.com/ghostofcelleron/Celeron/refs/heads/main/goku%20moveset%20(azl)",true))()
end)

funtab:Button("Aizen Moveset (Req. Isagi)", "Click F4 To Disable.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Credits",
        Text = "brought to you by celeron!",
        Duration = 5,
        Button1 = "OK",
    })
    loadstring(game:HttpGet("https://raw.githubusercontent.com/ghostofcelleron/Celeron/refs/heads/main/aizen%20moveset",true))()
end)

funtab:Button("Loki Moveset (V2) (Req. Isagi.)", "Click F4 To Disable, Rejoin To Fix Isagi Music.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Credits",
        Text = "brought to you by celeron!",
        Duration = 5,
        Button1 = "OK",
    })
    loadstring(game:HttpGet("https://raw.githubusercontent.com/ghostofcelleron/Celeron/refs/heads/main/loki%20v2"))()
end)

funtab:Button("Ronaldo Moveset (V3) (Req. Shidou)", "Click F4 To Disable.", function()
    loadstring(game:HttpGet("https://raw.githubusercontent.com/ghostofcelleron/Celeron/refs/heads/main/ronaldov3"))()
end)

funtab:Label("Daffy's Movesets.")

funtab:Button("Gojo Moveset (Req. Isagi.)", "Click F4 To Disable.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Credits",
        Text = "brought to you by daffy!",
        Duration = 5,
        Button1 = "OK",
    })
    loadstring(game:HttpGet("https://pastebin.com/raw/TH8xDy9X"))()
end)

funtab:Button("Hugo Moveset (Early Access.) (Req. Kunigami)", "Click F4 To Disable, Rejoin To Fix Kunigami Music.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Credits",
        Text = "brought to you by daffy!",
        Duration = 5,
        Button1 = "OK",
    })
loadstring(game:HttpGet("https://pastebin.com/raw/ND6yrPyk"))()
end)

funtab:Button("Naoya Moveset (Req. Sae)", "Click F4 To Disable.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Credits",
        Text = "brought to you by daffy!",
        Duration = 5,
        Button1 = "OK",
    })
    loadstring(game:HttpGet("https://pastebin.com/raw/PDwm0ZcF"))()
end)

funtab:Button("Lore Sae Moveset (Req. Sae.)", "Rejoin To Disable.", function()
    local StarterGui = game:GetService("StarterGui")
    StarterGui:SetCore("SendNotification", {
        Title = "Credits",
        Text = "brought to you by daffy!",
        Duration = 5,
        Button1 = "OK",
    })
    loadstring(game:HttpGet("https://pastebin.com/raw/kMQ0v88u"))()
end)

misctab:Button("Infinite Yield", function()
    loadstring(game:HttpGet("https://raw.githubusercontent.com/EdgeIY/infiniteyield/master/source"))()
end)

teleporttab:Button("Spawn Area", function()
    game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame = CFrame.new(-269, 4, -1599)
end)

teleporttab:Button("Middle Field", function()
    game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame = CFrame.new(-540, 3, 1274)
end)

teleporttab:Button("Reporter Area", function()
    game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame = CFrame.new(-6, 2, 3237)
end)

teleporttab:Button("Goal Box (A)", function()
    game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame = CFrame.new(-537, 3, 1575)
end)

teleporttab:Button("Goal Box (B)", function()
    game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame = CFrame.new(-534, 3, 974)
end)

misctab:Button("Upgrade UI (very cool actually)", function()
    loadstring(game:HttpGet("https://pastebin.com/raw/QDNYsgxQ"))()
end)

misctab:Label("Emotes.")

local emoteStates = {
    toosie = false,
    sae = false,
    assumptions = false
}

misctab:Toggle("Toosie Slide", function()
    emoteStates.toosie = not emoteStates.toosie

    local animationId = "rbxassetid://95959941666543"
    local soundId = "rbxassetid://1845341094"

    local player = game.Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local animator = humanoid:FindFirstChildOfClass("Animator")

    local animation = Instance.new("Animation")
    animation.AnimationId = animationId

    local animationTrack = animator:LoadAnimation(animation)

    local sound

    if emoteStates.toosie then
        animationTrack:Play()
        sound = Instance.new("Sound")
        sound.Name = "Toosie Slide"
        sound.SoundId = soundId
        sound.Looped = true
        sound.Parent = game.SoundService
        sound:Play()
    else
        for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
            track:Stop()
        end

        local existingSound = game.SoundService:FindFirstChild("Toosie Slide")
        if existingSound then
            existingSound:Stop()
            existingSound:Destroy()
        end
    end
end)

misctab:Toggle("Sae Pose", function()
    emoteStates.sae = not emoteStates.sae

    local animationId = "rbxassetid://136812327261825"
    local soundId = "rbxassetid://1843404009"

    local player = game.Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local animator = humanoid:FindFirstChildOfClass("Animator")

    local animation = Instance.new("Animation")
    animation.AnimationId = animationId

    local animationTrack = animator:LoadAnimation(animation)

    local sound

    if emoteStates.sae then
        animationTrack:Play()
        sound = Instance.new("Sound")
        sound.Name = "Sae Pose"
        sound.SoundId = soundId
        sound.Volume = 1
        sound.Looped = true
        sound.Parent = game.SoundService
        sound:Play()
    else
        for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
            track:Stop()
        end

        local existingSound = game.SoundService:FindFirstChild("Sae Pose")
        if existingSound then
            existingSound:Stop()
            existingSound:Destroy()
        end
    end
end)

misctab:Toggle("Assumptions", function()
    emoteStates.assumptions = not emoteStates.assumptions

    local animationId = "rbxassetid://108778663919542"
    local soundId = "rbxassetid://137023124734348"

    local player = game.Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local animator = humanoid:FindFirstChildOfClass("Animator")

    local animation = Instance.new("Animation")
    animation.AnimationId = animationId

    local animationTrack = animator:LoadAnimation(animation)

    local sound

    if emoteStates.assumptions then
        animationTrack:Play()
        sound = Instance.new("Sound")
        sound.Name = "Assumptions"
        sound.SoundId = soundId
        sound.PlaybackSpeed = 0.17
        sound.Volume = 0.6
        sound.Looped = true
        sound.Parent = game.SoundService

        local eq = Instance.new("EqualizerSoundEffect")
        eq.LowGain = 10
        eq.MidGain = 0
        eq.HighGain = 4
        eq.Parent = sound

        sound:Play()
    else
        for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
            track:Stop()
        end

        local existingSound = game.SoundService:FindFirstChild("Assumptions")
        if existingSound then
            existingSound:Stop()
            existingSound:Destroy()
        end
    end
end)

misctab:Button("Akuma Taunt", function()
    local animationId = "rbxassetid://111005363990501"
    local soundId = "rbxassetid://133370927301258"

    local player = game.Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local animator = humanoid:FindFirstChildOfClass("Animator")

    local animation = Instance.new("Animation")
    animation.AnimationId = animationId

    local animationTrack = animator:LoadAnimation(animation)

    local sound = Instance.new("Sound")
    sound.Name = "Akuma Taunt"
    sound.SoundId = soundId
    sound.Volume = 10
    sound.Parent = game.SoundService

    animationTrack:Play()
    sound:Play()

    sound.Ended:Connect(function()
        sound:Destroy()
    end)

    animationTrack.Stopped:Connect(function()
        animationTrack:Stop()
    end)
end)

misctab:Button("Cartoon Fall", function()
    local animationId = "rbxassetid://98064370044269"
    local soundIds = { "rbxassetid://8663054927", "rbxassetid://4979513906" }

    local player = game.Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local animator = humanoid:FindFirstChildOfClass("Animator")

    local animation = Instance.new("Animation")
    animation.AnimationId = animationId

    local animationTrack = animator:LoadAnimation(animation)

    local sound = Instance.new("Sound")
    sound.Name = "Ragdoll"
    sound.Volume = 10
    sound.Parent = game.SoundService

    local currentIndex = 1

    local function playNextSound()
        if currentIndex <= #soundIds then
            sound.SoundId = soundIds[currentIndex]
            sound:Play()

            sound.Ended:Connect(function()
                currentIndex = currentIndex + 1
                playNextSound()
            end)
        else
            sound:Destroy()
        end
    end
    animationTrack:Play()
    playNextSound()
end)

misctab:Button("Spit", function()
    local animationId = "rbxassetid://97257010665720"
    local soundId = "rbxassetid://18111052648"

    local player = game.Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoid = character:FindFirstChildOfClass("Humanoid")
    local animator = humanoid:FindFirstChildOfClass("Animator")

    local animation = Instance.new("Animation")
    animation.AnimationId = animationId

    local animationTrack = animator:LoadAnimation(animation)

    local sound = Instance.new("Sound")
    sound.Name = "Spit"
    sound.SoundId = soundId
    sound.Volume = 2
    sound.Parent = game.SoundService

    animationTrack:Play()
    sound:Play()

    sound.Ended:Connect(function()
        sound:Destroy()
    end)
end)

exploittab:Label("Semi-Private Server: People MAY Still Join Depending On Updates.")

exploittab:Button("Semi-Private Server Info", "This Comes With Instructions On How To Use The Feature Below.", function()
    local StarterGui = game:GetService("StarterGui")

    StarterGui:SetCore("SendNotification", {
        Title = "Semi-Private Server Info",
        Text = "If you end up in a server with another player, block someone.",
        Duration = 10
    }) task.wait(0.5)
    StarterGui:SetCore("SendNotification", {
        Title = "Semi-Private Server Info",
        Text = "After blocking a player in that server, run the feature to create a server again!",
        Duration = 10
    })
end)

exploittab:Button("Semi-Private Server (Method: 11v11)", "This Feature Creates A Server Where You Can Farm Goals / Quests!", function()
    game:GetService("TeleportService"):Teleport(85946466968831, game.Players.LocalPlayer)
end)

exploittab:Label("Instant Disconnect: Automatically Disconnects If Other Players Join.")

local disconnectState = {
    limit = nil,
    enabled = false
}

exploittab:Textbox("Instant Disconnect", "If More Than The Entered Number Of Players Join, You Disconnect.", function(v)
    local n = tonumber(v)
    if n then
        disconnectState.limit = n
    else
        disconnectState.limit = nil
    end
end)

exploittab:Toggle("Enable Instant Disconnect", "Toggles The Above Feature.", function(v)
    disconnectState.enabled = v
    if v then
        game.StarterGui:SetCore("SendNotification", {Title="Instant Disconnect", Text="Enabled."})
    else
        game.StarterGui:SetCore("SendNotification", {Title="Instant Disconnect", Text="Disabled."})
    end
end)

game:GetService("RunService").RenderStepped:Connect(function()
    if disconnectState.enabled and disconnectState.limit and #game.Players:GetPlayers() > disconnectState.limit then
        game.Players.LocalPlayer:Kick("Instant Disconnect Has Been Triggered.")
    end
end)

exploittab:Label("Goal Farming: Use At Your Own Risk, I Am Not Responsible For Bans.")

local goalFarmState = {
    Enabled = false,
    CFConn = nil,
    RenderConn = nil,
    StopAt = nil,
    goal = 0,
    desc = "not-started"
}

buffer = buffer or {
    fromstring = function(str)
        return str
    end
}

local GoalPlayers = game:GetService("Players")
local GoalRunService = game:GetService("RunService")
local GoalReplicatedStorage = game:GetService("ReplicatedStorage")

local GoalMapFolder = workspace:WaitForChild("map")
local GoalAGoal = GoalMapFolder:WaitForChild("Agoal")
local GoalBGoal = GoalMapFolder:WaitForChild("Bgoal")
local GoalLocalPlayer = GoalPlayers.LocalPlayer

local function firePacketsIfNearGoal()
    local char = GoalLocalPlayer.Character
    if not char then return end
    local root = char:FindFirstChild("HumanoidRootPart")
    if not root then return end
    if (root.Position - Vector3.new(-371, 13, -1599)).Magnitude <= 15 or
       (root.Position - Vector3.new(-196, 13, -1599)).Magnitude <= 15 then
        GoalReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring("\006\001\001\000A"))
        GoalReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(buffer.fromstring("\006\001\001\000B"))
    end
end

local function IsInGame()
    local LocalCharacter = GoalLocalPlayer.Character
    if not LocalCharacter then return false end
    local StateFolder = LocalCharacter:FindFirstChild("state")
    if not StateFolder then return false end
    local InGameValue = StateFolder:FindFirstChild("ingame")
    if not InGameValue then return false end
    return InGameValue.Value
end

local function DisableCollisionBoxes()
    local MapFolder = workspace:FindFirstChild("map")
    if not MapFolder then return end
    local GkBarriar = MapFolder:FindFirstChild("gkbarriar")
    local AGoal = MapFolder:FindFirstChild("Agoal")
    local BGoal = MapFolder:FindFirstChild("Bgoal")
    if GkBarriar then
        local ABarriar = GkBarriar:FindFirstChild("A")
        local BBarriar = GkBarriar:FindFirstChild("B")
        if ABarriar then ABarriar.CanCollide = false end
        if BBarriar then BBarriar.CanCollide = false end
    end
    if AGoal then AGoal.CanCollide = false end
    if BGoal then BGoal.CanCollide = false end
end

local function StealBall()
    local LocalCharacter = GoalLocalPlayer.Character
    local LocalHumanoidRootPart = LocalCharacter and LocalCharacter:FindFirstChild("HumanoidRootPart")
    local Football = workspace.Terrain:FindFirstChild("Ball")
    if LocalHumanoidRootPart and Football then
        task.wait(0.5)
        LocalHumanoidRootPart.CFrame = CFrame.new(Football.Position.X, 0, Football.Position.Z)
    end
    for _, OtherPlayer in pairs(GoalPlayers:GetPlayers()) do
        if OtherPlayer ~= GoalLocalPlayer then
            local OtherCharacter = OtherPlayer.Character
            local OtherFootball = OtherCharacter and OtherCharacter:FindFirstChild("Ball")
            local OtherHumanoidRootPart = OtherCharacter and OtherCharacter:FindFirstChild("HumanoidRootPart")
            if OtherFootball and OtherHumanoidRootPart and LocalHumanoidRootPart then
                task.wait(0.5)
                LocalHumanoidRootPart.CFrame = OtherFootball.CFrame
                local args = {
                    buffer.fromstring(buffers["base"]),
                    {
                        {
                            "tackle"
                        }
                    }
                }
                GoalReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(unpack(args))
            end
        end
    end
end

local function HasBall()
    local LocalCharacter = GoalLocalPlayer.Character
    local Football = LocalCharacter and LocalCharacter:FindFirstChild("Ball")
    return Football ~= nil
end

local function stopGoalFarm()
    if not goalFarmState.Enabled then return end
    goalFarmState.Enabled = false

    if goalFarmState.CFConn then
        goalFarmState.CFConn:Disconnect()
        goalFarmState.CFConn = nil
    end
    if goalFarmState.RenderConn then
        goalFarmState.RenderConn:Disconnect()
        goalFarmState.RenderConn = nil
    end

    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Goal Farm",
        Text = "Target Reached! :3",
        Duration = 2
    })
end

local function trackGoalsLoop()
    task.spawn(function()
        local goals = GoalLocalPlayer:WaitForChild("leaderstats"):WaitForChild("goals")
        while goalFarmState.Enabled do
            task.wait(1)
            local count = goals.Value
            if goalFarmState.StopAt and count >= goalFarmState.StopAt then
                stopGoalFarm()
                return
            end
        end
    end)
end

exploittab:Toggle("Goal Farm", "Automatically Farms Goals For You.", function()
    goalFarmState.Enabled = not goalFarmState.Enabled
    game:GetService("StarterGui"):SetCore("SendNotification", {
        Title = "Goal Farm",
        Text = goalFarmState.Enabled and "Enabled." or "Disabled.",
        Duration = 1
    })
    if goalFarmState.Enabled then
        goalFarmState.CFConn = GoalLocalPlayer.CharacterAdded:Connect(function()
            task.wait(1)
            if goalFarmState.Enabled then
                firePacketsIfNearGoal()
            end
        end)
        task.spawn(function()
            repeat task.wait() until GoalLocalPlayer.Character and GoalLocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            if goalFarmState.Enabled then
                firePacketsIfNearGoal()
            end
        end)
        goalFarmState.RenderConn = GoalRunService.RenderStepped:Connect(function()
            if not goalFarmState.Enabled then return end
            pcall(function()
                if not IsInGame() then return end
                DisableCollisionBoxes()
                StealBall()
                if HasBall() then
                    local LocalCharacter = GoalLocalPlayer.Character
                    local LocalRootPart = LocalCharacter and LocalCharacter:FindFirstChild("HumanoidRootPart")
                    local Goal = GoalLocalPlayer.Team.Name == "A" and GoalBGoal or GoalAGoal
                    if LocalRootPart and Goal then
                        task.wait(0.5)
                        LocalRootPart.CFrame = Goal.CFrame
                        task.wait(0.185)
                        local args = {
                            buffer.fromstring(buffers["base"]),
                            {
                                {
                                    "kick",
                                    20,
                                    false,
                                    vector.create(0, 1, 0)
                                }
                            }
                        }
                        GoalReplicatedStorage:WaitForChild("ByteNetReliable"):FireServer(unpack(args))
                    end
                end
            end)
        end)
        trackGoalsLoop()
    else
        stopGoalFarm()
    end
end)

exploittab:Textbox("Goal Target", "Enter a number of goals to stop farming at.", function(v)
    local num = tonumber(v)
    if num then
        goalFarmState.StopAt = num
        game:GetService("StarterGui"):SetCore("SendNotification", {
            Title = "Goal Target",
            Text = "Goal Target: " .. num,
            Duration = 2
        })
    else
        goalFarmState.StopAt = math.huge
        game:GetService("StarterGui"):SetCore("SendNotification", {
            Title = "Goal Target",
            Text = "Invalid Target, Farm Will Be Infinite.",
            Duration = 2
        })
    end
end)

loadstring(game:HttpGet("https://raw.githubusercontent.com/ghostofcelleron/Scripts/refs/heads/main/oldthingyep",true))()
loadstring(game:HttpGet("https://pastebin.com/raw/rQMS2B9R",true))()