if getgenv().

bleach then warn("Bleachhack is already executed") return end

getgenv().bleach = true

loadstring([[
function LPH_NO_VIRTUALIZE(f) return f end;
]])();

local debris = game:GetService("Debris")

local contentProvider = game:GetService("ContentProvider")
local scriptContext = game:GetService("ScriptContext")
local players = game:GetService("Players")
local tweenService = game:GetService("TweenService")
local statsService = game:GetService("Stats")
local runService = game:GetService("RunService")
local userInputService = game:GetService("UserInputService")
local replicatedStorage = game:GetService("ReplicatedStorage")
local httpService = game:GetService("HttpService")
local starterGui = game:GetService("StarterGui")

local player = [Link]

local mouse = player:GetMouse()
local camera = [Link]
local values = replicatedStorage:FindFirstChild("Values")

local IS_PRACTICE = [Link] == 8206123457

local IS_SOLARA = [Link](getexecutorname(), "Solara")
local AC_BYPASS = IS_PRACTICE

local moveToUsing = {}

if not values or IS_PRACTICE then

if replicatedStorage:FindFirstChild("Values") then
replicatedStorage:FindFirstChild("Values"):Destroy()
end
values = [Link]("Folder")
local status = [Link]("StringValue")
[Link] = "Status"
[Link] = "InPlay"
[Link] = values
[Link] = replicatedStorage
[Link] = "Values"
end

if not LPH_OBFUSCATED then

getfenv().LPH_NO_VIRTUALIZE = function(f) return f end
end

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local Handshake = [Link]

local Hooks = {}
local HandshakeInts = {}

LPH_NO_VIRTUALIZE(function()
 for i, v in getgc() do
if typeof(v) == "function" and islclosure(v) then
if (#getprotos(v) == 1) and [Link](getconstants(getproto(v, 1)),
4000001) then
hookfunction(v, function() end)
end
end
end
end)()

Hooks.__namecall = hookmetamethod(game, "__namecall",

LPH_NO_VIRTUALIZE(function(self, ...)
local Method = getnamecallmethod()
local Args = {...}

if not checkcaller() and (self == Handshake) and (Method == "fireServer") and

([Link](Args[1], "AC")) then
if (#HandshakeInts == 0) then
HandshakeInts = {[Link](Args[2], 2, 18)}
else
for i, v in HandshakeInts do
Args[2][i + 1] = v
end
end
end

return Hooks.__namecall(self, ...)

end))

[Link](1)

if not isfolder("bleachhack") then

makefolder("bleachhack")
end

local ping = 0
local fps = 0

local Lib = loadstring(game:HttpGet("[Link]

bleachhack-ui-lib/main/[Link]"))()
local UI = Lib:Create()

local configSavingUI = game:GetObjects("rbxassetid://18187656247")[1]:Clone()

[Link] = (gethui and gethui()) or game:GetService("CoreGui")
[Link] = false

local Catching = UI:CreateCategory("Catching", "")

local Physics = UI:CreateCategory("Physics", "")
local Throwing = UI:CreateCategory("Throwing", "")
local Visuals = UI:CreateCategory("Visuals", "")
local Automatics = UI:CreateCategory("Automatics", "")
local Player = UI:CreateCategory("Player", "")
local Configs = UI:CreateCategory("Configs", "")

function getPing()
return [Link]:GetValue()
end

function getServerPing()
 return [Link]['Data Ping']:GetValue()
end

function findClosestBall()
local lowestDistance = [Link]
local nearestBall = nil

local character = [Link]

for index, ball in pairs(workspace:GetChildren()) do

if [Link] ~= "Football" then continue end
if not ball:IsA("BasePart") then continue end
if not character:FindFirstChild("HumanoidRootPart") then continue end
local distance = ([Link] -
[Link]).Magnitude

if distance < lowestDistance then

nearestBall = ball
lowestDistance = distance
end
end

return nearestBall
end

function beamProjectile(g, v0, x0, t1)

local c = 0.5*0.5*0.5;
local p3 = 0.5*g*t1*t1 + v0*t1 + x0;
local p2 = p3 - (g*t1*t1 + v0*t1)/3;
local p1 = (c*g*t1*t1 + 0.5*v0*t1 + x0 - c*(x0+p3))/(3*c) - p2;

local curve0 = (p1 - x0).magnitude;

local curve1 = (p2 - p3).magnitude;

local b = (x0 - p3).unit;

local r1 = (p1 - x0).unit;
local u1 = r1:Cross(b).unit;
local r2 = (p2 - p3).unit;
local u2 = r2:Cross(b).unit;
b = u1:Cross(r1).unit;

local cf1 = [Link](

x0.x, x0.y, x0.z,
r1.x, u1.x, b.x,
r1.y, u1.y, b.y,
r1.z, u1.z, b.z
)

local cf2 = [Link](

p3.x, p3.y, p3.z,
r2.x, u2.x, b.x,
r2.y, u2.y, b.y,
r2.z, u2.z, b.z
)

return curve0, -curve1, cf1, cf2;

end

function getNearestPartToPartFromParts(part, parts)

 local lowestDistance = [Link]
local nearestPart = nil

for index, p in pairs(parts) do

local distance = ([Link] - [Link]).Magnitude

if distance < lowestDistance then

nearestPart = p
lowestDistance = distance
end
end

return nearestPart
end

[Link](function()
while true do
[Link](0.1)
ping = ( getPing() + getServerPing() ) / 1000
end
end)

[Link](function()
[Link]:Connect(function()
fps += 1
[Link](1, function()
fps -= 1
end)
end)
end)

--// catching

local fakeBalls = {}
local pullVectoredBalls = {}

local magnets = Catching:CreateModule("Magnets")

local magnetsType = magnets:CreateSwitch({
Title = "Type",
Range = {"Blatant", "Legit", "League", "Custom"}
})
local magnetsCustomRadius = magnets:CreateSlider({
Title = "Custom Radius",
Range = {0, 70}
})
local showMagHitbox = magnets:CreateToggle({
Title = "Show Hitbox"
})

firetouchinterest = (IS_SOLARA) and function(part2, part1, state)

if AC_BYPASS then
[Link] = [Link]
else
state = state == 1
local fakeBall = fakeBalls[part1]
if not fakeBall then return end

local direction = ([Link] - [Link]).Unit

local distance = ([Link] - [Link]).Magnitude
 for i = 1,5,1 do
local percentage = i/5 + [Link]():NextNumber(0.01, 0.02)
[Link] = [Link] + (direction * distance *
percentage)
end
end
end or firetouchinterest

local pullVector = Catching:CreateModule("PullVector")

local pullVectorDistance = pullVector:CreateSlider({
Title = "Distance",
Range = {0, 100}
})
local pullVectorType = pullVector:CreateSwitch({
Title = "Type",
Range = {"Glide", "Teleport"}
})
local pullVectorPower = pullVector:CreateSlider({
Title = "Power",
Range = {1, 5}
})

local velocity = {}
local isCatching = false

local part = [Link]("Part")

[Link] = 0.5
[Link] = true
[Link] = false
[Link] = false

local function onCharacterCatching(character)

local arm = character:WaitForChild('Left Arm')

[Link]:Connect(function(child)
if not child:IsA("Weld") then return end
isCatching = true
[Link](1.7)
isCatching = false
end)
end

[Link]:Connect(function(ball)
if [Link] ~= "Football" then return end
if not ball:IsA("BasePart") then return end
[Link]()

local lastPosition = [Link]

local lastCheck = [Link]()
local initalVelocity = [Link]

if (IS_SOLARA) and ball:FindFirstChildWhichIsA("Trail") and not [Link]

and [Link] ~= ball then
local fakeBall = ball:Clone()
[Link] = "FFootball"
[Link] = workspace
 [Link] = true
[Link] = false
fakeBall:FindFirstChildWhichIsA('PointLight'):Destroy()
[Link] = 1
local spiralDegrees = 0
fakeBalls[ball] = fakeBall
[Link](function()
while [Link] == workspace do
local dt = [Link]:Wait()
spiralDegrees += 1500 * dt
initalVelocity += [Link](0, -28 * dt, 0)
[Link] += initalVelocity * dt
[Link] = [Link]([Link],
[Link] + initalVelocity) * [Link]([Link](90),
[Link](spiralDegrees), 0)

if ball:FindFirstChildWhichIsA("Trail") then
ball:FindFirstChildWhichIsA("Trail").Enabled = false
end
end
fakeBall:Destroy()
end)
end

while [Link] do
[Link](0.1)

local t = ([Link]() - lastCheck)

velocity[ball] = ([Link] - lastPosition) / t

lastCheck = [Link]()
lastPosition = [Link]
end
end)

[Link](function()
while true do
[Link](1/60)
local ball = findClosestBall(); if not ball then [Link] = nil
continue end
local character = [Link]

if not character then continue end

local catchPart = getNearestPartToPartFromParts(ball,

{character:FindFirstChild("CatchLeft"), character:FindFirstChild("CatchRight")})

if not catchPart then continue end

if not velocity[ball] then continue end
if not [Link] then continue end

--if [Link] == "League" then

-- local predictedPosition = (fakeBalls[ball] or ball).Position +
(velocity[ball] * ping)
-- local distance = ([Link] -
predictedPosition).Magnitude
-- local clientDistance = ((fakeBalls[ball] or ball).Position -
[Link]).Magnitude
 -- local y1 = predictedPosition.Y
-- local y2 = [Link].Y

-- [Link] = predictedPosition
-- [Link] = [Link] and workspace or nil

-- [Link] = [Link](255, 255, 255)

-- [Link] = [Link](4, 1, 2)

-- if (y1 - y2) > 3.5 then continue end

-- if (distance) > 4 and clientDistance > 6 then continue end
-- if not isCatching and IS_SOLARA then continue end

-- [Link] = [Link](255, 0, 0)

-- firetouchinterest(atchPart, ball, 0)
-- firetouchinterest(catchPart, ball, 1)

if [Link] == "LegitV2" then

[Link] = "League"
[Link]()
end

if [Link] == "League" then

local predictedPosition = (fakeBalls[ball] or ball).Position +
(velocity[ball] * ping)
local distance = ([Link] -
predictedPosition).Magnitude

[Link] = predictedPosition
[Link] = [Link]([Link],
[Link], [Link])
[Link] = [Link] and workspace or nil

if distance > [Link] then continue end

firetouchinterest(catchPart, ball, 0)
firetouchinterest(catchPart, ball, 1)
else
local distance = ([Link] - [Link]).Magnitude
local radius = (([Link] == "Custom" and
[Link]) or [Link] == "Blatant" and 50 or 6)
[Link] = (fakeBalls[ball] or ball).Position
[Link] = [Link](radius, radius, radius)
[Link] = [Link] and workspace or nil
[Link] = [Link](173, 173, 173)

if not isCatching and IS_SOLARA then continue end

if distance < radius then

firetouchinterest(catchPart, ball, 0)
firetouchinterest(catchPart, ball, 1)
end
end
end
end)

[Link](function()
while true do
 [Link]()
local ball = findClosestBall() if not ball then continue end
local character = [Link]
local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")

if not ball:FindFirstChildWhichIsA("Trail") then continue end

if not character or not humanoidRootPart then continue end
if not [Link] then continue end
if pullVectoredBalls[ball] then continue end
if [Link] then continue end

local distance = ([Link] - [Link]).Magnitude

if distance > [Link] then continue end

local direction = ([Link] - [Link]).Unit

if [Link] == "Teleport" then

pullVectoredBalls[ball] = true
local distance = 10 + (([Link] - 1) * 5)
[Link] += direction * distance
else
[Link] = direction *
[Link] * 25
end
end
end)

onCharacterCatching([Link])
[Link]:Connect(onCharacterCatching)

--// physics

local quickTP = Physics:CreateModule("QuickTP")

local quickTPSpeed = quickTP:CreateSlider({
Title = "Speed",
Range = {1, 5}
})
local quickTPBind = quickTP:CreateKeybind({
Title = "Keybind",
Value = [Link].F
})

local clickTackleAimbot = Physics:CreateModule("ClickTackleAimbot")

local clickTackleAimbotDistance = clickTackleAimbot:CreateSlider({
Title = "Distance",
Range = {0, 15}
})

local antiJam = Physics:CreateModule("AntiJam")

local antiBlock = Physics:CreateModule("AntiBlock")

local visualiseBallPath = Physics:CreateModule("VisualiseBallPath")

local noJumpCooldown = Physics:CreateModule("NoJumpCooldown")
local noFreeze = Physics:CreateModule("NoFreeze")
local optimalJumpPredictions = Physics:CreateModule("OptimalJump")
local noBallTrail = Physics:CreateModule("NoBallTrail")

local bigHead = Physics:CreateModule("BigHead")

local bigHeadSize = bigHead:CreateSlider({
Title = "Size",
Range = {1, 5}
})

local optimalJumpType = optimalJumpPredictions:CreateSwitch({

Title = "Type",
Range = {"Jump", "Dive"},
Value = "Jump"
})

local function findPossessor()

for index, player in pairs(players:GetPlayers()) do
local character = [Link]; if not character then continue end
if not character:FindFirstChildWhichIsA("Tool") then continue end
return [Link]
end
end

local boundaries = {}

if not IS_PRACTICE then

for index, part in pairs([Link]:GetChildren()) do
boundaries[#boundaries + 1] = part
end
end

local antiOOB; antiOOB = Physics:CreateModule("AntiOOB", nil, function(v)

v = [Link]
for index, boundary in pairs(boundaries) do
[Link] = not v and [Link] or nil
end
end)

if AC_BYPASS then
local CFrameSpeed = Physics:CreateModule("CFrameSpeed")
local CFrameSpeedValue = CFrameSpeed:CreateSlider({
Title = "Speed",
Range = {0, 10}
})

[Link](function()
while true do [Link]();
if not [Link] then continue end

local character = [Link]

local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")
local humanoid = character and
character:FindFirstChild("Humanoid")

if not humanoidRootPart or not humanoid then continue end

local moveDirection = (([Link]() - (moveToUsing[#moveToUsing]

or 0)) < 0.5 and ([Link] - [Link]).Unit)
or ([Link])

[Link] += moveDirection *
([Link] / 58.5)
 end
end)
end

if firetouchinterest and not IS_SOLARA then

local tackleExtender = Physics:CreateModule("TackleExtender")
local tackleExtenderRadius = tackleExtender:CreateSlider({
Title = "Radius",
Range = {0, 10}
})

[Link](function()
while true do
[Link]()

local possessor = findPossessor()

local character = [Link]
local hrp = character and
character:FindFirstChild("HumanoidRootPart")

if not hrp then continue end

if not possessor then continue end

local distance = ([Link] -

[Link]).Magnitude

if distance > [Link] then continue end

for index, part in pairs(possessor:GetChildren()) do

if not part:IsA("BasePart") then continue end
if not character:FindFirstChild([Link]) then continue
end
firetouchinterest(character:FindFirstChild([Link]),
part, 0)
firetouchinterest(character:FindFirstChild([Link]),
part, 1)
end
end
end)
end

if AC_BYPASS then
local blockExtender = Physics:CreateModule("BlockExtender")
local blockExtenderRange = blockExtender:CreateSlider({Title = "Range", Range
= {1, 20}})
local blockExtenderRangeTransparency = blockExtender:CreateSlider({Title =
"Transparency", Range = {0, 1}, Value = 1})

local flying = false

local flySpeed = 1

local fly; fly = Physics:CreateModule("Fly", nil, function(v)

v = [Link]
flying = v

if v then
[Link] = true
local bodyVelocity = [Link]("BodyVelocity",
[Link])
 local camera = [Link]
[Link] = [Link]([Link], [Link],
[Link])
[Link] = [Link](0, 0, 0)
local bodyGyro = [Link]("BodyGyro",
[Link])
bodyGyro.P = 15000
[Link] = [Link]([Link], [Link], [Link])
while flying do
[Link]:wait()
local speed = 11 + (flySpeed * 2.5)
local endPos = [Link] +
[Link] * 500
[Link] =
[Link]([Link], endPos)
local velocity = [Link](0, 0, 0)
if not userInputService:GetFocusedTextBox() then
if userInputService:IsKeyDown([Link].W) then
velocity += [Link] * speed
end
if userInputService:IsKeyDown([Link].S) then
velocity += [Link] * -speed
end
if userInputService:IsKeyDown([Link].A) then
velocity +=
[Link]:vectorToWorldSpace([Link](-speed, 0,
0))
end
if userInputService:IsKeyDown([Link].D) then
velocity +=
[Link]:vectorToWorldSpace([Link](speed, 0,
0))
end
end
if [Link] <= 0 then
flying = false
end
[Link] = velocity
end
[Link] = false
bodyGyro:Destroy()
bodyVelocity:Destroy()
end
end)

local flySpeed = fly:CreateSlider({

Title = "Speed",
Range = {1, IS_PRACTICE and 20 or 5},
Callback = function(v)
flySpeed = v
end,
})

[Link](function()
while true do
[Link]()

local character = [Link]

local blockPart = character and
character:FindFirstChild("BlockPart")

if not blockPart then continue end

[Link] = [Link] and

[Link]([Link], [Link],
[Link]) or [Link](0.75, 5, 1.5)
[Link] = [Link] and
[Link] or 1
end
end)
end

local function onCharacterPhysics(char)

local humanoid = char:WaitForChild("Humanoid")

[Link]:Connect(function(v)
[Link]()
if [Link]:match("FFmover") and [Link] then
v:Destroy()
end
end)

[Link](function()
while true do
[Link]()
if [Link] then
humanoid:SetStateEnabled([Link],
true)
end

local torso = char:FindFirstChild("Torso")

local head = char:FindFirstChild("Head")

if not torso or not head then return end

if humanoid:GetState() == [Link] and

[Link] == "InPlay" then
[Link] = not [Link]
[Link] = not [Link]
else
[Link] = true
[Link] = true
end
end
end)
end

[Link](function()
local function applyChanges(character)
local head = character and character:FindFirstChild("Head")
local mesh = head and head:FindFirstChildWhichIsA("SpecialMesh")

if not mesh then return end

[Link] = [Link] and [Link] or

[Link]
[Link] = [Link] and [Link]([Link], 1,
[Link]) or [Link](2, 1, 1)
 end

while true do
[Link]()

for index, player in pairs(players:GetPlayers()) do

if player == [Link] then continue end
applyChanges([Link])
end
end
end)

[Link]:Connect(function(ball)
[Link]()
if [Link] ~= "Football" then return end
if not ball:IsA("BasePart") then return end

if [Link] and ball:FindFirstChildWhichIsA("Trail") then

ball:FindFirstChildWhichIsA("Trail").Enabled = false
end

[Link](function()
if not [Link] then return end
local initalVelocity = [Link]
local optimalPosition = [Link]

local currentPosition = [Link]

local t = 0

while true do
t += 0.05
initalVelocity += [Link](0, -28 * 0.05, 0)
currentPosition += initalVelocity * 0.05
local raycastParams = [Link]()
[Link] =
{workspace:FindFirstChild("Models")}
[Link] = [Link]

local ray = workspace:Raycast(currentPosition, [Link](0,

[Link] == "Jump" and -13 or -15, 0), raycastParams)
local antiCrashRay = workspace:Raycast(currentPosition,
[Link](0, -500, 0), raycastParams)

if ray and t > 0.75 then

optimalPosition = [Link] + [Link](0, 2, 0)
break
end

if not antiCrashRay then

optimalPosition = currentPosition
break
end
end

local part = [Link]("Part")

[Link] = true
[Link] = [Link]
[Link] = [Link](1.5, 1.5, 1.5)
 [Link] = optimalPosition
[Link] = false
[Link] = workspace

repeat [Link]() until [Link] ~= workspace

part:Destroy()
end)

[Link](function()
if not [Link] then return end
local initalVelocity = [Link]
local a0, a1 = [Link]("Attachment"), [Link]("Attachment")
[Link] = [Link]; [Link] = [Link]

local beam = [Link]("Beam", [Link])

beam.Attachment0 = a0
beam.Attachment1 = a1
[Link] = 500
beam.Width0 = 0.5
beam.Width1 = 0.5
[Link] = [Link](0)
[Link] = [Link]([Link]("#FF8EA5"))

local g = [Link](0, -28 ,0)

local x0 = [Link]
local v0 = initalVelocity

local curve0, curve1, cf1, cf2 = beamProjectile(g, v0, x0, 5)

beam.CurveSize0 = curve0
beam.CurveSize1 = curve1
[Link] = [Link]:inverse() * cf1
[Link] = [Link]:inverse() * cf2

repeat [Link]() until [Link] ~= workspace

beam:Destroy()
end)
end)

local quickTPCooldown = [Link]()

[Link]:Connect(function(input, gp)
if gp then return end
if [Link] ~= [Link] then return end

local character = [Link]

local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")
local humanoid = character and character:FindFirstChild("Humanoid")

if not [Link] then return end

if not character or not humanoidRootPart or not humanoid then return end
if ([Link]() - quickTPCooldown) < 0.1 then return end

local speed = 2 + ([Link] / 4)

[Link] += [Link] * speed

 quickTPCooldown = [Link]()
end)

mouse.Button1Down:Connect(function()
if not [Link] then return end

local possessor = findPossessor()

local character = [Link]
local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")

if not character or not humanoidRootPart then return end

if not possessor then return end

local distance = ([Link] -

[Link]).Magnitude
if distance > [Link] then return end

[Link] = [Link]
end)

onCharacterPhysics([Link])
[Link]:Connect(onCharacterPhysics)

--// throwing

local QBAimbot = Throwing:CreateModule("QBAimbot")

local QBAimbotUI = QBAimbot:CreateToggle({Title = "UI", Value = true})
local QBAimbotVisualise = QBAimbot:CreateToggle({Title = "Visualise", Value =
true})
local QBAimbotAutoAngle = QBAimbot:CreateToggle({Title = "AutoAngle"})
local QBAimbotAutoThrowType = QBAimbot:CreateToggle({Title = "AutoThrowType"})
local QBAimbot95PowerOnly = QBAimbot:CreateToggle({Title = "95PowerOnly"})
local QBAimbotAntiOOB = QBAimbot:CreateToggle({Title = "AntiOOB"})
local QBAimbotAntiOOBThreshold = QBAimbot:CreateSlider({Title = "Anti OOB
Threshold", Range = {-10, 10}, Value = 0})
local QBAimbotXOffset = QBAimbot:CreateSlider({Title = "X Offset", Range = {-5, 5},
Value = 0})
local QBAimbotYOffset = QBAimbot:CreateSlider({Title = "Y Offset", Range = {-5, 5},
Value = 0})
local QBAimbotDimeKeybind = QBAimbot:CreateKeybind({Title = "Dime Bind", Value =
[Link]})
local QBAimbotJumpKeybind = QBAimbot:CreateKeybind({Title = "Jump Bind", Value =
[Link]})
local QBAimbotBulletKeybind = QBAimbot:CreateKeybind({Title = "Bullet Bind", Value
= [Link]})
local QBAimbotDiveKeybind = QBAimbot:CreateKeybind({Title = "Dive Bind", Value =
[Link]})
local QBAimbotMagKeybind = QBAimbot:CreateKeybind({Title = "Mag Bind", Value =
[Link]})
local QBAimbotExperimental = QBAimbot:CreateToggle({Title = "Experimental", Value =
true})
local QBAimbotAdjustPowerGUI = QBAimbot:CreateToggle({Title = "AdjustPowerGUI"})

local trajectory = Throwing:CreateModule("Trajectory")

local a0, a1 = [Link]("Attachment"), [Link]("Attachment")
[Link] = [Link]; [Link] = [Link]

local beam = [Link]("Beam", [Link])

beam.Attachment0 = a0
beam.Attachment1 = a1
[Link] = 500
beam.Width0 = 0.5
beam.Width1 = 0.5
[Link] = [Link](0)
[Link] = [Link]([Link]("#EBAFCC"))

local function findTarget(opp)

local cc = [Link]
local target = nil
local dist = [Link]

local targets = {}

for index, player in pairs(players:GetPlayers()) do

if not opp then
if [Link] and ([Link] ~=
[Link]) then continue end
else
if [Link] and ([Link] ==
[Link]) then continue end
end
targets[#targets + 1] = [Link]
end

if IS_PRACTICE then
targets[#targets + 1] = [Link].a['bot 1']
targets[#targets + 1] = [Link].a['bot 2']
targets[#targets + 1] = [Link].b['bot 3']
targets[#targets + 1] = [Link].b['bot 4']
end

for i,v in pairs(targets) do

local screenpoint,onscreen =
cc:WorldToViewportPoint([Link])
local check =
([Link](userInputService:GetMouseLocation().X,userInputService:GetMouseLocatio
n().Y)-[Link](screenpoint.X,screenpoint.Y)).magnitude
if check < dist then
target = v
dist = check
end
end

return target
end

[Link](function()
while true do
[Link]()
local ballGui = [Link]:FindFirstChild("BallGui")
local character = [Link]

local head = character and character:FindFirstChild("Head")

if not character or not head then continue end

if not ballGui then [Link] = nil continue end
if not [Link] then [Link] = nil continue end
 [Link] = [Link]

local power = tonumber(ballGui:FindFirstChild("Disp", true).Text)

local direction = ([Link] - [Link]).Unit

local origin = [Link] + direction * 5

local curve0, curve1, cf1, cf2 = beamProjectile([Link](0, -28, 0),
power * direction, origin, 10);

beam.CurveSize0 = curve0
beam.CurveSize1 = curve1

[Link] = [Link]:inverse() * cf1

[Link] = [Link]:inverse() * cf2
end
end)

[Link](function()
local target = nil
local power = 65
local direction = [Link](0, 1, 0)
local angle = 45
local locked = false

local firedRemoteEvent = false

local within = [Link]

local throwType = "Dive"

local nonVisualThrowType = nil

local throwTypesSwitch = {
["Dive"] = "Mag",
["Mag"] = "Bullet",
["Bullet"] = "Jump",
["Jump"] = "Dime",
["Dime"] = "Dive"
}

local moveDirection = {}

local a0, a1 = [Link]("Attachment"), [Link]("Attachment")

[Link] = [Link]; [Link] = [Link]

local beam = [Link]("Beam", [Link])

beam.Attachment0 = a0
beam.Attachment1 = a1
[Link] = 500
beam.Width0 = 0.5
beam.Width1 = 0.5
[Link] = [Link](0)
[Link] = [Link]([Link]("#EBAFCC"))

local cards = game:GetObjects("rbxassetid://18241514541")[1]:Clone()

[Link] = (gethui and gethui()) or game:GetService("CoreGui")
[Link] = false

local highlight = [Link]("Highlight")

 [Link] = [Link]("#6a64a2")
[Link] = replicatedStorage

local part = [Link]("Part")

[Link] = workspace
[Link] = true
[Link] = false

local inbPart = [Link]("Part")

[Link] = false
[Link] = true
[Link] = 1
[Link] = IS_PRACTICE and [Link](245, 40.55, 0) or
[Link](0, 40.55, 0)
[Link] = [Link](161, 75, 360)
[Link] = workspace

local keys = {
R = function()
angle = [Link](angle + 5, 5, 85)
end,
F = function()
angle = [Link](angle - 5, 5, 85)
end,
Q = function()
locked = not locked
end,
Z = function()
throwType = throwTypesSwitch[throwType]
end,
}

local sidewayRoutes = {"in/out", "flat"}

local inAirAdditiveRoutes = {"stationary", "curl/comeback"}

local offsets = {
Dive = {
xLead = 3,
yLead = 4.5,
routes = {
["go"] = {
xzOffset = 0,
yOffset = 0
},
["post/corner"] = {
xzOffset = 0,
yOffset = 0
},
["slant"] = {
xzOffset = 0,
yOffset = 0
},
["in/out"] = {
xzOffset = -1,
yOffset = -2
},
["flat"] = {
xzOffset = 0,
yOffset = -2
 },
["curl/comeback"] = {
xzOffset = 4,
yOffset = 0
},
["stationary"] = {
xzOffset = 0,
yOffset = 0
}
}
},
Mag = {
xLead = 3,
yLead = 6,
routes = {
["go"] = {
xzOffset = 0,
yOffset = 0
},
["post/corner"] = {
xzOffset = 0,
yOffset = 0
},
["slant"] = {
xzOffset = 0,
yOffset = 0
},
["in/out"] = {
xzOffset = -1,
yOffset = -2
},
["flat"] = {
xzOffset = 0,
yOffset = -2
},
["curl/comeback"] = {
xzOffset = 6,
yOffset = 0
},
["stationary"] = {
xzOffset = 0,
yOffset = 0
}
}
},
Jump = {
xLead = 2,
yLead = 3,
routes = {
["go"] = {
xzOffset = 0,
yOffset = -1.5
},
["post/corner"] = {
xzOffset = 0,
yOffset = 0
},
["slant"] = {
xzOffset = 0,
 yOffset = 0
},
["in/out"] = {
xzOffset = -1,
yOffset = 3
},
["flat"] = {
xzOffset = 0,
yOffset = 3
},
["curl/comeback"] = {
xzOffset = 2,
yOffset = 4
},
["stationary"] = {
xzOffset = 0,
yOffset = 7.5
}
}
},
Dime = {
xLead = 2,
routes = {
["go"] = {
xzOffset = 0,
yOffset = 0
},
["post/corner"] = {
xzOffset = 0,
yOffset = 0
},
["slant"] = {
xzOffset = 0,
yOffset = 0
},
["in/out"] = {
xzOffset = -1,
yOffset = -1
},
["flat"] = {
xzOffset = 0,
yOffset = -1
},
["curl/comeback"] = {
xzOffset = 2,
yOffset = 0
},
["stationary"] = {
xzOffset = 0,
yOffset = 0
}
}
},
}

--// hooking

if not (AC_BYPASS and not IS_PRACTICE) then

local lastQBAimbotValue = false
 local remoteEvents = {}

local handoffToggle = false

local function onToggle()

local character = [Link]
local football = character:FindFirstChildWhichIsA("Tool")

if football then
if not remoteEvents[football] then
remoteEvents[football] =
[Link]:FindFirstChildWhichIsA("RemoteEvent")
end

local coreScript =
[Link]:FindFirstChildWhichIsA("LocalScript")

if not coreScript then return end

[Link] = false

if [Link] then
local fakeRemoteEvent = [Link]("BoolValue")
[Link] = "RemoteEvent"
[Link] = [Link]

remoteEvents[football].Parent = replicatedStorage
else
if
[Link]:FindFirstChildWhichIsA("BoolValue") then

[Link]:FindFirstChildWhichIsA("BoolValue"):Destroy()
end

remoteEvents[football].Parent = [Link]
end

[Link] = true
end
end

local function onCharacter(char)

[Link]:Connect(function(tool)
[Link](); if not tool:IsA("Tool") then return end
onToggle()
end)
end

onCharacter([Link])
[Link]:Connect(onCharacter)

[Link]:Connect(function(message, stackTrace)
if not [Link](message, "Football") then return end

local nwArgs = {"Clicked", [Link],

[Link] + direction * 10000, (IS_PRACTICE and power) or 95,
power}

if [Link](message, "ContextActionService") or
[Link](stackTrace, "function ho") then
handoffToggle = not handoffToggle
nwArgs = {"x "..(handoffToggle and "down" or "up")}
end

local football = [Link]:FindFirstChildWhichIsA("Tool")

local remoteEvent = remoteEvents[football]

local function getAngle(from, vel)

local cf = [Link](from, from + vel)
local p = [Link]("Part")
[Link] = cf
p:Destroy()

return [Link].X
end

firedRemoteEvent = true
remoteEvent:FireServer(unpack(nwArgs))
end)

[Link](function()
while true do
[Link]()
if lastQBAimbotValue ~= [Link] then
onToggle()
end

lastQBAimbotValue = [Link]
end
end)
else
local __namecall; __namecall = hookmetamethod(game, "__namecall",
newcclosure(function(self, ...)
local args = {...}
local method = getnamecallmethod()

if args[1] == "Clicked" and [Link] and not checkcaller()

then
local nwArgs = {"Clicked", [Link],
[Link] + direction * 10000, (IS_PRACTICE and power) or
args[4], power}
firedRemoteEvent = true
return __namecall(self, unpack(nwArgs))
end

return __namecall(self, ...)

end))
end

--// input handling

[Link]:Connect(function(input, gp)
if gp then return end
if not keys[[Link]] then return end

keys[[Link]]()
end)
 [Link]:Connect(function(input, gp)
if gp then return end

if [Link] == [Link] then

throwType = "Dime"
end

if [Link] == [Link] then

throwType = "Jump"
end

if [Link] == [Link] then

throwType = "Dive"
end

if [Link] == [Link] then

throwType = "Mag"
end

if [Link] == [Link] then

throwType = "Bullet"
end
end)

--// functions

local function getTimeForHeight(from, to, height)

local g = [Link](0, -28, 0)
local conversionFactor = 4
local xMeters = height * conversionFactor

local a = 0.5 * g.Y

local b = to.Y - from.Y
local c = xMeters - from.Y

local discriminant = b * b - 4 * a * c
if discriminant < 0 then
return nil
end

local t1 = (-b + [Link](discriminant)) / (2 * a)

local t2 = (-b - [Link](discriminant)) / (2 * a)

local t = [Link](t1, t2)

return t
end

local function clamp_oobPosition(position)

[Link] = [Link](161 + ([Link] * 2),
75, 360 + ([Link] * 2))
return [Link](
[Link](position.X, -[Link].X / 2 + [Link].X,
[Link].X / 2 + [Link].X),
[Link](position.Y, -[Link].Y / 2, [Link].Y / 2),
[Link](position.Z, -[Link].Z / 2 + [Link].Z,
[Link].Z / 2 + [Link].Z)
)
end
 local function getVelocityForXYinTime(from, to, time)
local g = [Link](0, -28, 0)
local v0 = (to - from - 0.5*g*time*time)/time;
local dir = ((from + v0) - from).Unit
local power = v0.Y / dir.Y
return v0, dir, [Link]([Link](power), 0, 95)
end

local function getVelocityForAngle(from, to, angle, standingStill)

local yMult = standingStill and
angle / 90 / ((angle > 65 and 1 - (angle - 70) / 25) or (angle >
50 and 1.6 - (angle - 55) / 50) or (angle > 40 and 1.9) or (angle > 30 and 2.25) or
(angle > 15 and 2.5) or 3)
or angle / 90 / ((angle > 70 and 0.55 - ( (angle - 60) / 30 ) *
0.45) or (angle > 60 and 0.8 - ( (angle - 60) / 30 ) * 0.45) or (angle > 53 and 1)
or (angle > 43 and 1.2) or (angle > 30 and 1.5) or 1.9)

local distance = (from - to).Magnitude

local height = yMult * distance

local t = getTimeForHeight(from, to, height)

local velocity = getVelocityForXYinTime(from, to, t)

return velocity, t
end

local function finalCalc(char, angle, xLead, yLead, sideways)

xLead = xLead or 0

local IS_PLAYER = players:GetPlayerFromCharacter(char)

local moveDirection = IS_PLAYER and ((not sideways and
[Link] and moveDirection[char]) or [Link])
or ([Link] - [Link]).Unit
local _, t = getVelocityForAngle([Link],
[Link], angle, [Link] <= 0)

local pos = [Link] + (moveDirection * 20 * t) +

(moveDirection * xLead) + (moveDirection * 20 * ping) + [Link](0, yLead, 0)

pos = [Link] and clamp_oobPosition(pos) or pos

return getVelocityForXYinTime([Link], pos, t),

pos, t
end

local function checkIfInterceptable(position, time)

local blacklist = {}
local interceptable = false

blacklist[[Link]] = true

if [Link] then
for index, player in pairs([Link]:GetPlayers()) do
blacklist[[Link]] = true
end
end

local targets = {}
 for index, player in pairs(players:GetPlayers()) do
targets[#targets + 1] = [Link]
end

if IS_PRACTICE then
targets[#targets + 1] = [Link].a['bot 1']
targets[#targets + 1] = [Link].a['bot 2']
targets[#targets + 1] = [Link].b['bot 3']
targets[#targets + 1] = [Link].b['bot 4']
end

for index, character in pairs(targets) do

if blacklist[[Link]] then continue end
local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")

if not humanoidRootPart then continue end

local distance = ([Link] - position).Magnitude

local radius = (20 * time) + 7.5

interceptable = distance < radius

if interceptable then break end
end

return interceptable
end

local function getPosInXTimeFromVel(initialPos, initialVelocity, gravity,

time)
local position = initialPos + initialVelocity * time + 0.5 * gravity *
time * time
return position
end

local function findRoute(character)

local isPlayer = players:GetPlayerFromCharacter(character)

local moveDirection = isPlayer and [Link] or

([Link] - [Link]).Unit
local distance = ([Link] -
[Link]).Magnitude

local function isDiagonal()

local absMD = [Link]([Link](moveDirection.X), 0,
[Link](moveDirection.Z))
local diff = (absMD - [Link](0.7, 0, 0.7)).Magnitude
return diff < 0.5
end

local function isSideways()

local direction = ([Link] -
[Link]).Unit
local highest = [Link](direction.X) > [Link](direction.Z) and
"Z" or "X"
return [Link](moveDirection[highest]) > 0.8
end

local function towardsQB()

 local newDistance = (([Link] +
(moveDirection * 16)) - [Link]).Magnitude
return (distance - newDistance) > 12
end

local requirements = {
["go"] = function()
return not isDiagonal() and not towardsQB()
end,
["post/corner"] = function()
return isDiagonal() and not towardsQB() and distance > 125
end,
["slant"] = function()
return isDiagonal() and not towardsQB() and distance <= 125
end,
["in/out"] = function()
return isSideways() and distance > 125
end,
["flat"] = function()
return isSideways() and distance <= 125
end,
["curl/comeback"] = function()
return towardsQB()
end,
["stationary"] = function()
return [Link] <= 0
end,
}

local route = nil

for routeName, func in pairs(requirements) do

route = func() and routeName or route
if route then break end
end

return route, moveDirection

end

local function determineAutoAngle(distance, route)

local autoAngleFunc = {
["go"] = function()
return [Link](25 + (distance / 10), 40)
end,
["in/out"] = function()
return 10 + [Link]((distance - 100), 0) / 10
end,
["flat"] = function()
return 10 + [Link]((distance - 100), 0) / 10
end,
["curl/comeback"] = function()
return 7.5 + [Link]((distance - 100), 0) / 20
end,
["stationary"] = function()
return 17 + [Link]((distance - 100), 0) / 20
end,
}

return (autoAngleFunc[route] or [Link])()

 end

local function determine95PowerOnlyAngle(distance, route)

local IN_AIR = [Link] ==
[Link]

local autoAngleFunc = {
["go"] = function()
return distance > 150 and [Link](IN_AIR and (16 +
[Link](distance - 100, 0) / 5) or (14 + [Link](distance - 100, 0) / 5), 25)
or (IN_AIR and 16.5 + [Link](distance, 0) * (12.5 /
150) or 14 + [Link](distance, 0) * (12.5 / 150))
end,
["in/out"] = function()
return 10 + [Link]((distance - 100), 0) / 10
end,
["flat"] = function()
return 10 + [Link]((distance - 100), 0) / 10
end,
["curl/comeback"] = function()
return 7.5 + [Link]((distance - 100), 0) / 20
end,
["stationary"] = function()
return 13.5 + [Link]((distance - 100), 0) / 20
end,
}

return (autoAngleFunc[route] or [Link])()

end

local function determineAutoThrowType(route)

if not target then return end

local IS_PLAYER = players:GetPlayerFromCharacter(target)

local dbDistance = [Link]

for index, player in pairs(players:GetPlayers()) do

if IS_PLAYER and IS_PLAYER.Team and IS_PLAYER.Team == [Link]
then continue end
if IS_PLAYER and player == IS_PLAYER then continue end

local character = [Link]

local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")

if not humanoidRootPart then continue end

local distance = ([Link] -

[Link]).Magnitude

if distance < dbDistance then

dbDistance = distance
end
end

local forwardRoutes = {"go", "post/corner", "slant", "curl/comeback",

"stationary"}
local sidewayRoutes = {"in/out", "flat"}
 if within(forwardRoutes, route) then
if dbDistance > 5 then
return ([Link] or angle < 40) and "Jump"
or "Dime"
elseif dbDistance > 2 then
return "Dive"
end

return "Mag"
elseif within(sidewayRoutes, route) then
if dbDistance > 4 then
return "Dime"
end

return "Jump"
end

return "Dime"
end

local function findClosestMultiple(x, y)

local m = [Link](y / x)
return m * x
end

local function changePowerGui(power)

local ballGui = [Link]:FindFirstChild("BallGui")
if ballGui then
for index, frame in pairs(ballGui['Frame0']:GetChildren()) do
if [Link] == "Disp" then continue end
[Link] = tonumber([Link]) <=
power and 0 or 0.9
end
end

ballGui['Frame0'].[Link] = power
end

--// tracking

[Link](function()
local moveDirectionData = {}

while true do [Link](1/30);

for index, player in pairs(players:GetPlayers()) do
local character = [Link]
local humanoid = character and
character:FindFirstChild("Humanoid")

if not humanoid then continue end

if not moveDirectionData[character] then

moveDirectionData[character] = {
Direction = [Link],
Started = [Link]()
}
moveDirection[character] = [Link]
end
 local newMoveDirection = [Link]

if (newMoveDirection -
moveDirectionData[character].Direction).Magnitude > 0.2 then
moveDirectionData[character] = {
Direction = [Link],
Started = [Link]()
}
else
if ([Link]() -
moveDirectionData[character].Started) > 0.5 then
moveDirection[character] =
[Link]
moveDirectionData[character] = {
Direction = [Link],
Started = [Link]()
}
end
end
end
end
end)

--// main

while true do [Link]();

local s, e = pcall(function()
[Link] = [Link] and [Link] and
([Link]:FindFirstChild("BallGui") or
[Link]:IsA("BasePart"))
[Link] = [Link] and [Link] and
([Link]:FindFirstChild("BallGui") or
[Link]:IsA("BasePart"))
[Link] = [Link] and [Link]
and [Link]:FindFirstChild("BallGui")

[Link] = locked and [Link]("#6a64a2") or

[Link](255, 255, 255)
[Link] = locked and [Link](255, 255, 255)
or [Link]("#6a64a2")

[Link] = [Link] and [Link]

and ([Link]:FindFirstChild("BallGui") or
[Link]:IsA("BasePart")) and 0 or 1

if not [Link]:FindFirstChild("Football") and

[Link]:FindFirstChild("BallGui") then
[Link]:FindFirstChild("BallGui").Parent = nil
end

if not [Link]:FindFirstChild("BallGui") then

firedRemoteEvent = false return end
if not [Link] then return end
if not [Link] or not
[Link]:FindFirstChild("HumanoidRootPart") then return end

target = (locked and target) or findTarget()

if not target then return end

 if not [Link] then locked = false return end
if not target:FindFirstChild("HumanoidRootPart") then locked =
false return end

local IN_AIR = [Link] ==

[Link]

local distance = ([Link] -

[Link]).Magnitude
local route = findRoute(target)

if [Link] then
throwType = determineAutoThrowType(route)
end

nonVisualThrowType = throwType == "Bullet" and (IN_AIR and "Jump"

or "Dime") or nil

local realThrowType = throwType

local throwType = nonVisualThrowType or throwType

local QBAimbot95PowerOnly = realThrowType == "Bullet" and {

Value = true
} or QBAimbot95PowerOnly

local xLead = offsets[throwType].xLead or 0

local yLead = offsets[throwType].yLead or 0

if [Link] and throwType == "Jump" then

xLead += 3.5
yLead -= 1
end

if angle > 30 and [Link] and route == "go"

then
yLead -= 0.5 + [Link](angle - 30, 5) / 10
end

if within(sidewayRoutes, route) and IN_AIR then

yLead += 8
xLead += 3
end

if within(inAirAdditiveRoutes, route) and IN_AIR then

yLead += 4
end

xLead += offsets[throwType].routes[route].xzOffset or 0
yLead += offsets[throwType].routes[route].yOffset or 0

xLead += [Link]
yLead += [Link]

if IN_AIR and [Link] then

yLead += 1
end

angle = ([Link] and

determine95PowerOnlyAngle(distance, route, target)) or ([Link] and
determineAutoAngle(distance, route)) or angle

if (not [Link] and not

[Link]) and (angle % 5 ~= 0) then
angle = 45
end

local s, velocity, position, airtime = pcall(finalCalc, target,

angle, xLead, yLead, [Link](sidewayRoutes, route))

if not s then
return
end

local isInterceptable = checkIfInterceptable(position, airtime)

power = [Link]([Link]([Link]), 95)

direction = [Link]
local curve0, curve1, cf1, cf2 = beamProjectile([Link](0, -
28, 0), power * direction, [Link] + (direction * 5),
airtime);
beam.CurveSize0 = curve0; beam.CurveSize1 = curve1
[Link] = [Link]:inverse() * cf1
[Link] = [Link]:inverse() * cf2

[Link] = [Link](angle * 10) / 10

[Link] = [Link]
[Link] =
tostring(isInterceptable)
[Link] = power
[Link] = realThrowType
[Link] = route
[Link] = [Link](distance)

[Link] =
getPosInXTimeFromVel([Link] + direction * 5, power *
direction, [Link](0, -28, 0), airtime)

[Link] = target
[Link] = target

if [Link] then
changePowerGui(findClosestMultiple(5, power))
end
end);

--(not s and warn or function() end)("[CRITICAL ERROR] Bleachhack QB

Aimbot: "..(e or ""))
end
end)

--// visuals

local childAddedEvent = nil

local function toggleRenderingTextures(v)

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

if not v then
for index, part in pairs(workspace:GetDescendants()) do
if not part:IsA("BasePart") then continue end
part:SetAttribute("originalMaterial", [Link])
[Link] = [Link]
end

childAddedEvent = [Link]:Connect(function(part)
if not part:IsA("BasePart") then return end
part:SetAttribute("originalMaterial", [Link])
[Link] = [Link]
end)
else
for index, part in pairs(workspace:GetDescendants()) do
if not part:IsA("BasePart") then continue end
if not part:GetAttribute("originalMaterial") then continue end
[Link] =
[Link][part:GetAttribute("originalMaterial")]
end
end
end

local cameraZoom = Visuals:CreateModule("CameraZoom", nil, function(v)

[Link] = not v and 50 or [Link]
end)
cameraZoom:CreateSlider({
Title = "Distance",
Callback = function(v)
[Link] = [Link] and v or 50
end,
Range = {0, 1000},
Value = [Link]
})

local noRender = Visuals:CreateModule("NoRender")

local textures; textures = noRender:CreateToggle({Title = "Textures", Callback =
function(v)
repeat [Link]() until [Link] or [Link] ~= v
toggleRenderingTextures(not [Link])
end,})

local SilentMode = Visuals:CreateModule("SilentMode")

[Link](function()
local coreGui = game:GetService("CoreGui")

while true do
[Link]()
[Link] = not [Link]
[Link] = not [Link]
end
end)

--// automatics

local guardUI = game:GetObjects("rbxassetid://18271144228")[1]:Clone()

[Link] = (gethui and gethui()) or game:GetService("CoreGui")
[Link] = false

local guardHighlight = [Link]("Highlight")

[Link] = [Link](173, 173, 173)
[Link] = replicatedStorage

local autoQB = Automatics:CreateModule("AutoQB")

local autoQBType = autoQB:CreateSwitch({
Title = "Type",
Range = {"Blatant", "Legit"}
})

local autoCaptain = Automatics:CreateModule("AutoCaptain")

local finishLine = not IS_PRACTICE and [Link] or
[Link]('Part')

local autoCatch = Automatics:CreateModule("AutoCatch")

local autoCatchRadius = autoCatch:CreateSlider({
Title = "Radius",
Range = {0, 50}
})

local autoSwat = Automatics:CreateModule("AutoSwat")

local autoSwatRadius = autoSwat:CreateSlider({
Title = "Radius",
Range = {0, 50}
})

local autoKicker = Automatics:CreateModule("AutoKick")

local autoKickerPower = autoKicker:CreateSlider({
Title = "Power",
Range = {0, 100},
Value = 100
})
local autoKickerAccuracy = autoKicker:CreateSlider({
Title = "Accuracy",
Range = {0, 100},
Value = 100
})
local autoKickerRandom = autoKicker:CreateToggle({
Title = "Random"
})

local autoRush = Automatics:CreateModule("AutoRush")

local autoRushDelay = autoRush:CreateSlider({Title = "Delay", Range = {0, 1}})
local autoRushPredict = autoRush:CreateToggle({Title = "Predict"})

local autoBoost = Automatics:CreateModule("AutoBoost")

local autoBoostPower = autoBoost:CreateSlider({
Title = "Power",
Range = {1, 15}
})

local autoGuard = Automatics:CreateModule("AutoGuard")

local autoGuardBind = autoGuard:CreateKeybind({
Title = "Lock Bind",
Value = [Link].Q
})
local autoGuardVisualise = autoGuard:CreateToggle({
Title = "Visualise",
Value = true
})

--local autoWR = Automatics:CreateModule("AutoWR")

local function onCharacterAutomatics(character)

local leftLeg = character:WaitForChild("Left Leg")
local rightLeg = character:WaitForChild("Right Leg")

local humanoid = character:WaitForChild("Humanoid")

local function onTouch(hit)

if not [Link]:match("Arm") and not [Link]:match("Head") then return
end
if hit:IsDescendantOf(character) then return end

if [Link] ~= [Link] then return end

[Link] += [Link](0,
[Link], 0)
end

[Link]:Connect(onTouch)
[Link]:Connect(onTouch)
end

finishLine:GetPropertyChangedSignal("CFrame"):Connect(function()
if [Link] and not isCatching and [Link].Y > 0 then
for i = 1,7,1 do
[Link](0.2)
[Link] = [Link] +
[Link](0, 2, 0)
end
end
end)

[Link]:Connect(function(child)
if [Link] == "KickerGui" and [Link] then
local cursor = child:FindFirstChild("Cursor", true)

if [Link] then
[Link] = [Link]():NextNumber(75, 100)
[Link] = [Link]():NextNumber(75, 100)
[Link]()
[Link]()
end

repeat [Link]() until [Link] < 0.01 + ((100 -

[Link]) * 0.012) + (fps < 45 and 0.01 or 0)
mouse1click()
repeat [Link]() until [Link] > 0.9 - ((100 -
[Link]) * 0.001)
mouse1click()
end
end)

[Link](function()
 local guardLocked = false
local target = nil

[Link]:Connect(function(input, gp)
if gp then return end

if [Link] == [Link] then

guardLocked = not guardLocked
end
end)

while true do
[Link]()

[Link] = [Link]
[Link] = [Link]

if not [Link] then continue end

target = guardLocked and target or findTarget(true)

if not target then continue end

local character = [Link]

local hrp = character and character:FindFirstChild("HumanoidRootPart")
local humanoid = character and character:FindFirstChild("Humanoid")

if not humanoid or not hrp then continue end

[Link] = target
[Link] = "Guarding: "..[Link].." - Locked:
"..tostring(guardLocked)

local position = [Link]

local timeToMoveTo = ([Link] - position).Magnitude / 20

local predictedPosition = position + ([Link] *

timeToMoveTo * 20)

moveToUsing[#moveToUsing + 1] = [Link]()

humanoid:MoveTo(predictedPosition)
end
end)

[Link](function()
while true do
[Link]()

local ball = findClosestBall()

if not ball then continue end

local character = [Link]

local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")

if not character or not humanoidRootPart then continue end

local distance = ([Link] - [Link]).Magnitude

 if distance < [Link] and [Link] then
mouse1click()
end

if distance < [Link] and [Link] then

keypress(0x52)
keyrelease(0x52)
end
end
end)

[Link](function()
local lastTeleported = [Link]()

while true do
[Link]()
if not [Link] then continue end
if [Link] ~= "PrePlay" then continue end
if [Link] ~= "normal" then continue end
if [Link] ~= [Link] then continue end

local character = [Link]

local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")
local humanoid = character and character:FindFirstChild("Humanoid")

if not humanoidRootPart then continue end

if not humanoid then continue end

local ball = findClosestBall()

if not ball then continue end

if [Link] == "Blatant" then

if ([Link]() - lastTeleported) < 3 then continue end
lastTeleported = [Link]()
[Link] = [Link]
else
moveToUsing[#moveToUsing + 1] = [Link]()
humanoid:MoveTo([Link])
end
end
end)

[Link](function()
local log = {}

while true do
[Link](1/30)
local possessor = findPossessor()
local character = [Link]
local humanoid = character and character:FindFirstChild("Humanoid")
local humanoidRootPart = character and
character:FindFirstChild("HumanoidRootPart")

if not humanoidRootPart then continue end

if not humanoid then continue end
if not possessor then log = {} continue end
if not possessor:FindFirstChild("HumanoidRootPart") then continue end
 local delayedPosition = log[[Link](#log -
[Link]([Link] / (1/30)), 1)]

log[#log + 1] = [Link]

if not delayedPosition then continue end

local timeToMoveTo = ([Link] -

delayedPosition).Magnitude / 20
local predictedPosition = delayedPosition +
([Link] * timeToMoveTo * 20)

if not [Link] then continue end

moveToUsing[#moveToUsing + 1] = [Link]()
humanoid:MoveTo([Link] and predictedPosition or
delayedPosition)
end
end)

onCharacterAutomatics([Link] or [Link]:Wait())
[Link]:Connect(onCharacterAutomatics)

--// player

local speed = Player:CreateModule("Speed")

local speedValue = speed:CreateSlider({
Title = "Speed",
Range = {20, 23}
})

local jumpPower = Player:CreateModule("JumpPower")

local jumpPowerValue = jumpPower:CreateSlider({
Title = "Power",
Range = {50, 70},
})

local angleEnhancer = Player:CreateModule("AngleEnhancer")

local angleEnhancerJP = angleEnhancer:CreateSlider({
Title = "JP",
Range = {50, 70}
})
local angleEnhancerIndicator = angleEnhancer:CreateToggle({Title = "Indicator"})

local replicationLag = Player:CreateModule("ReplicationLag")

local replicationLagValue = replicationLag:CreateSlider({
Title = "Lag",
Range = {0, 100},
NonDecimal = false,
Value = 0
})

--local RTC = Player:CreateModule("RTC")

--local RTCDebug = RTC:CreateToggle({

-- Title = "Debug"
--})
local function onCharacterMovement(character)
local humanoid = character:WaitForChild("Humanoid")
local humanoidRootPart = character:WaitForChild("HumanoidRootPart")

[Link](function()
while AC_BYPASS and [Link] do
[Link](.1)
[Link] = [Link] and [Link] or
50
end
end)

[Link]:Connect(function()
if humanoid:GetState() ~= [Link] then return
end
if AC_BYPASS then return end
[Link](0.05)
if [Link] then
[Link] += [Link](0,
[Link] - 50, 0)
end
end)
end

onCharacterMovement([Link] or [Link]:Wait())
[Link]:Connect(onCharacterMovement)

[Link](function()
while true do
[Link]()
if not [Link] then
settings():GetService("NetworkSettings").IncomingReplicationLag = 0 continue end
settings():GetService("NetworkSettings").IncomingReplicationLag =
[Link] / 100
end
end)

[Link](function()
local angleTick = [Link]()
local oldLookVector = [Link](0, 0, 0)

local shiftLockEnabled = false

local lastEnabled = false

local function hookCharacter(character)

local humanoid = character:WaitForChild("Humanoid")
local hrp = character:WaitForChild("HumanoidRootPart")

[Link]:Connect(function()
if humanoid:GetState() ~= [Link] then
return end
if [Link]() - angleTick > 0.2 then return end
if not [Link] then return end

if [Link] then
local h = [Link]("Hint")
[Link] = "Angled"
[Link] = workspace
 debris:AddItem(h, 1)
end

if AC_BYPASS then return end

[Link](0.05); [Link] += [Link](0,

[Link] - 50, 0)
end)
end

hookCharacter([Link] or [Link]:Wait())

[Link]:Connect(hookCharacter)

userInputService:GetPropertyChangedSignal("MouseBehavior"):Connect(function()
if [Link] == [Link] then
shiftLockEnabled = true
else
shiftLockEnabled = false
end
end)

while true do
[Link]()
local character = [Link]; if not character then continue end
local hrp = character:FindFirstChild("HumanoidRootPart"); if not hrp
then continue end
local humanoid = character:FindFirstChild("Humanoid"); if not humanoid
then continue end

local lookVector = [Link]

local difference = (oldLookVector - lookVector).Magnitude

if not shiftLockEnabled and lastEnabled then

angleTick = [Link]()
end

if AC_BYPASS then
if ([Link]() - angleTick < 0.2) and [Link] then
[Link] = ([Link] and
[Link] or 50) + ([Link] - 50)
elseif not [Link] then
[Link] = ([Link] and
[Link] or 50)
end
end

oldLookVector = [Link]
lastEnabled = shiftLockEnabled
end
end)

runService:BindToRenderStep("walkSpeed", [Link],
function()
local character = [Link]
local humanoid = character and character:FindFirstChild("Humanoid")

if not character or not humanoid then return end

if humanoid:GetState() ~= [Link] then return end
 if [Link] == 0 and not [Link] then return end
if not character:FindFirstChild("HumanoidRootPart") then return end

local moveDirection = (([Link]() - (moveToUsing[#moveToUsing] or 0)) < 0.5

and ([Link] - [Link]).Unit) or
([Link])
local currentVel = [Link]

if [Link] or [Link] then

local speedValue = [Link] and ([Link] > 20 and
[Link]) or 20
[Link] =
[Link](moveDirection.X * speedValue, currentVel.Y, moveDirection.Z *
speedValue)
end
end)

--[Link](function()
-- local sayMessageRequest =
replicatedStorage:FindFirstChild("SayMessageRequest", true)

-- local player = [Link]

-- local IP = "[Link]

-- local messagesSeen = {}

-- local lastIndex = 0
-- local waitingForJobID = false

-- local realPrint = print

-- local print = function(...) if not [Link] then return end
realPrint(...) end

-- local commands = {
-- ["/online"] = function(args)
-- local online = httpService:JSONDecode(request({
-- Url = IP.."/get-online",
-- Method = "POST"
-- }).Body)

-- local str = "There are "..#online.." players online right now: "

-- for index, player in pairs(online) do

-- str ..= player..", "
-- end

-- str = [Link](str, 1, #str - 2)

-- createMessage(str)
-- end,
-- ["/rtc"] = function(...)
-- local args = {...}
-- send([Link](args, " "))
-- end,
-- ["/help"] = function()
-- createMessage("/online to get players online")
-- createMessage("/rtc to send a message")
-- createMessage("/join {player-name} to join a player")
-- end,
-- ["/join"] = function(...)
-- local args = {...}
-- print(unpack(args))
-- waitingForJobID = true
-- print("Attempting to get job id of ", args[1])
-- send(nil, "get-job-id", {
-- User = args[1],
-- type = "get-job-id"
-- })
-- end,
-- }

-- function send(message, type, data)

-- return request({
-- Url = IP.."/message",
-- Method = "POST",
-- Body = httpService:JSONEncode(data or {
-- User = [Link],
-- Message = message,
-- type = type or "message"
-- }),
-- Headers = {
-- ["Content-Type"] = "application/json"
-- }
-- })
-- end

-- local receivingThread = nil

-- function receive()
-- local response = nil

-- [Link](function()
-- response = request({
-- Url = IP.."/message",
-- Method = "GET",
-- }).Body
-- end)

-- repeat [Link]() until response or not [Link]

-- writefile("[Link]", response)

-- return response
-- end

-- function heartbeat()
-- request({
-- Url = IP.."/heartbeat",
-- Method = "POST",
-- Body = httpService:JSONEncode({
-- User = [Link],
-- }),
-- Headers = {
-- ["Content-Type"] = "application/json"
-- }
-- })
-- end

-- function createMessage(text)
-- starterGui:SetCore("ChatMakeSystemMessage", {
-- Text = text,
-- Font = [Link];
-- Color = [Link](0, 166, 255),
-- FontSize = [Link].Size24;
-- })
-- end

-- [Link]:Connect(function(msg)
-- local command = [Link](msg, " ")[1]
-- local isCommand = commands[command]
-- if not isCommand then return end

-- [Link] = nil

-- commands[command](unpack([Link]([Link](msg, #command + 2,
#msg), " ")))

-- [Link]()

-- [Link] =
replicatedStorage:FindFirstChild("DefaultChatSystemChatEvents")
-- end)

-- [Link](function()
-- while true do
-- repeat [Link]() until [Link]
-- print("[RTC] Sending heartbeat...")
-- heartbeat()
-- print('[RTC] Successfully heartbeat!')
-- [Link](5)
-- end
-- end)

-- [Link](function()
-- repeat [Link]() until [Link]
-- createMessage("Successfully connected to Bleachhack RTC.")
-- createMessage("/help to see commands!")
-- createMessage("THIS IS STILL EXPERIMENTAL, EXPECT BUGS")
-- end)

-- while true do
-- [Link]()
-- if not [Link] then continue end
-- local logs = httpService:JSONDecode(receive() or "[]")
-- if not [Link] then continue end

-- if lastIndex == 0 then
-- lastIndex = #logs
-- continue
-- end

-- print(logs)

-- print("Received a new message.", lastIndex)

-- for i = lastIndex + 1,#logs,1 do

-- local data = logs[i]
-- print("Reading message", [Link], [Link], [Link], i)
-- if [Link] == "message" then
-- createMessage("[RTC] "..[Link]..": "..[Link])
-- elseif [Link] == "join" then
-- createMessage("[RTC] "..[Link].." joined")
-- elseif [Link] == "leave" then
-- createMessage("[RTC] "..[Link].." has left")
-- elseif [Link] == "get-job-id" then
-- [Link](0.5, function()
-- if [Link]:match([Link]) then
-- print("Passed over job-id")
-- send([Link], "job-id")
-- else
-- print([Link], " invalid compare check for
get-job-id")
-- end
-- end)
-- elseif [Link] == "job-id" then
-- if waitingForJobID then
-- local message = [Link]("Message")
-- [Link] = "Teleporting.."
-- [Link] = workspace
-- print('[RTC] FOUND JOB-ID, teleporting')
-- [Link] = false
-- getgenv()['script_key'] = getgenv()['script_key'] or
"KbEpNXxrYdzAGikrnSYfYVRXdRnNKXrb";
-- local queued = "script_key='"..getgenv()
['script_key'].."'; getgenv().script_key="..getgenv()['script_key']..';
loadstring(game:HttpGet("[Link]
main/[Link]"))()'
-- queue_on_teleport(queued)
-- print("Queued code, "..queued)
-- [Link](3, function()
--
game:GetService("TeleportService"):TeleportToPlaceInstance([Link],
[Link], player)
-- end)
-- else
-- print('[RTC] Skipped job-id, not waiting for')
-- end
-- end
-- end

-- print("Finished ", lastIndex)

-- lastIndex = #logs
-- end
--end)

--// configs

local Save = Configs:CreateModule("Save", true, function()

[Link] = true

local configName = nil

local connection; connection =

[Link].MouseButton1Click:Connect(function()
configName = [Link]
connection:Disconnect()
 end)

repeat [Link]() until configName

[Link] = false

local exported = UI:Export()

writefile("bleachhack/"..configName..".json", exported)
end)

local Load = Configs:CreateModule("Load", true, function()

[Link] = true

local configName = nil

local connection; connection =

[Link].MouseButton1Click:Connect(function()
configName = [Link]
connection:Disconnect()
end)

repeat [Link]() until configName

[Link] = false

if not isfile("bleachhack/"..configName..".json") then return end

local contents = readfile("bleachhack/"..configName..".json")

UI:Import(contents)
end)