local xscr = nil

local f = false

xscr = [[
local last = game
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Camera = Workspace.CurrentCamera
local LocalPlayer = Players.LocalPlayer

local success, message = pcall(function()

return readfile('/CS/')
end)

if not success then

warn('CONE InsH // '..message)
end

local file = success and message or 'false-false-true-false-true'

local splits = string.split(file, '-')

local function stb(str)

return str == 'true'
end

local t = tostring

local spamActivate = stb(splits[1])--false

local silentAimActive = stb(splits[2])
local espActive = stb(splits[3])
local reload = stb(splits[4])
local glass = stb(splits[5])

local function write()

writefile('/CS/',
t(spamActive)..'-'..t(silentAimActive)..'-'..t(espActive)..'-'..t(reload)..'-'..t(g
lass))
end

local espList = {}

local glassRevertList = {}
local keybinds = {'F', 'G'}
local ac = {}
local noPlayers = ac
local plrToBox = {}

local vms = Workspace:WaitForChild('ViewModels'):WaitForChild('FirstPerson')

local sound = Instance.new('Sound')

sound.Volume = 1
sound.SoundId = 'rbxassetid://6895079853'

local knifeSound = Instance.new('Sound')

knifeSound.Volume = 1
knifeSound.SoundId = 'rbxassetid://17599589028'
 local s2 = Instance.new('Sound')
s2.Volume = 1
s2.SoundId = 'rbxassetid://2865228021'

local function playSound(sp, rep)

local new = (rep or sound):Clone()
new.Parent = workspace
new.PlaybackSpeed = sp or 1
new:Play()

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

if LocalPlayer:GetAttribute('OriginalPosition') then
LocalPlayer:SetAttribute('OriginalPosition', nil)
end

LocalPlayer:SetAttribute('OriginalPosition', true)

local initConnections = {}
local on = true

table.insert(initConnections,
LocalPlayer:GetAttributeChangedSignal('OriginalPosition'):Connect(function()
for _, v in pairs(initConnections) do
v:Disconnect()
end

on = false

for _, v in pairs(espList) do
v.Visible = false
v:Remove()
end

playSound(1.5, knifeSound)
return
end))

playSound(f and .2 or 1.5)

f = true

local prms = RaycastParams.new()

prms.RespectCanCollide = true

local plr = Players.LocalPlayer

local m = plr:GetMouse()

-- // AutoReload

local _main = plr.PlayerGui:WaitForChild('MainGui').MainFrame

local _items =
_main.FighterInterfaces:WaitForChild(plr.Name).Items:WaitForChild('Container')
local _connis = {}

if not on then return end

 local NOAUTORELOAD = {'Molotov', 'Grenade', 'Bow', 'Daggers'}
local ACCEPTEDCOOLDOWN = 'rbxassetid://17156089790'

local function _reloadAuto(itemSlot)

if itemSlot:IsA('Frame') and itemSlot.Name ~= 'AmmoContainers' and not
table.find(NOAUTORELOAD, itemSlot.Name) then
local i = itemSlot.Name

local con = _connis[i]

if con then con:Disconnect() end

local conni = nil

conni = itemSlot.Cooldowns.ChildAdded:Connect(function(v)
if v:IsA('Frame') and v.Icon.Image == ACCEPTEDCOOLDOWN and
reload then
conni:Disconnect()
task.delay(.1, function()
for i = 1, 4 do
mousescroll(2345)
RunService.RenderStepped:Wait()
end
end)
elseif v:IsA('Frame') then
table.insert(NOAUTORELOAD, v.Name)
conni:Disconnect()
end
end)

table.insert(initConnections, conni)

_connis[i] = conni
end
end

for _, v in pairs(_items:GetChildren()) do
_reloadAuto(v)
end

table.insert(initConnections, _items.ChildAdded:Connect(_reloadAuto))

-- // Rest

local function getWeapon()

for _, v in pairs(vms:GetChildren()) do
if string.find(v.Name, plr.Name) then
local rest = string.split(v.Name, ' - ')
return rest[2]
end
end
end

local cw = nil
local handToo = {'Handgun', 'Fists'}

local function gt()

local v = cw
for _, v in pairs((table.find(handToo, getWeapon()) and v or
v.ItemVisual):GetDescendants()) do
 if v:IsA('BasePart') and v.Transparency ~= 1 then
if not glassRevertList[v] then
glassRevertList[v] = {
texture = v:IsA'MeshPart' and v.TextureID or
'',
color = v.Color,
trans = v.Transparency,
mterial = v.Material
}
end

if not glass and glassRevertList[v] then

local list = glassRevertList[v]
if v:IsA('MeshPart') then
v.TextureID = list.texture
end

v.Color = list.color
v.Transparency = list.trans
v.Material = list.mterial
elseif glass then
if v:IsA('MeshPart') then
v.TextureID = ''
end

local il = string.find(v.Name, 'Light') or

string.find(v.Parent.Name, 'Light')

v.Color = Color3.fromRGB(255, 255, 255)

v.Transparency = il and 0 or .5

if not il then
v.Material = Enum.Material.Glass
end

local con
local con2
local con3

local function fix()

if not glass then
con:Disconnect()
con2:Disconnect()
con3:Disconnect()
else
v.Material = il and Enum.Material.Neon or
Enum.Material.Glass
v.Color = Color3.fromRGB(255, 255, 255)
v.Transparency = il and 0 or .5
end
end

v:GetPropertyChangedSignal('Parent'):Once(function()
con:Disconnect()
con2:Disconnect()
con3:Disconnect()
end)

con =
v:GetPropertyChangedSignal('Color'):Connect(fix)
con2 =
v:GetPropertyChangedSignal('Material'):Connect(fix)
con3 =
v:GetPropertyChangedSignal('Transparency'):Connect(fix)
end
elseif v:IsA('Texture') then
if not glassRevertList[v] then
glassRevertList[v] = v.Transparency
end

v.Transparency = not glass and glassRevertList[v] or 1

end
end
end

table.insert(initConnections, vms.ChildAdded:Connect(function(v)
if string.find(v.Name, plr.Name) then
local rest = string.split(v.Name, ' - ')

cw = v
gt()
end
end))

local function getNearestHead()

local closestPlayer = nil
local shortestDistance = math.huge
local shortestDistance2 = math.huge

for _, player in pairs(Players:GetPlayers()) do

if player ~= LocalPlayer and not table.find(noPlayers,
player.UserId) and player.Character and player.Character:FindFirstChild("Head")
then
local char = player.Character
local hum = char and char:FindFirstChild('Humanoid')
local head = char.Head
local headPos, headVisible =
Camera:WorldToViewportPoint(head.Position + Vector3.new(0, 0.5, 0))
local distance = (head.Position -
LocalPlayer.Character.HumanoidRootPart.Position).Magnitude
local distance2 = (Vector2.new(m.X, m.Y)-
Vector2.new(headPos.X, headPos.Y)).Magnitude/2

if distance2 < shortestDistance2 and hum.Health > 0 then

shortestDistance2 = distance2
shortestDistance = distance
closestPlayer = player
end
end
end

if closestPlayer and closestPlayer.Character and

closestPlayer.Character:FindFirstChild("Head") then
return closestPlayer.Character.Head
end

return nil
end
 local cons = {}
local noAuto = {'Medkit', 'Smoke Grenade', 'Flashbang'}
local autoRight = {'Knife'}

local f = nil
local lelCam = nil

local function char()

return plr.Character, plr.Character.HumanoidRootPart
end

local function auto(right)

local weapon = getWeapon()
if silentAimActive and weapon and not table.find(noAuto, weapon) and
(not right or table.find(autoRight, weapon)) then
local targetHead = f or getNearestHead()
if targetHead then
f = nil

local aimPosition =
targetHead.Position+Vector3.new(Random.new(.3, -.3), Random.new(-.2, -2),
Random.new(.3, -.3))
local l = Camera.CFrame

if right and weapon == 'Knife' then

f = targetHead
playSound(nil, knifeSound)
end

if weapon == 'Daggers' or weapon == 'Bow' then

aimPosition += Vector3.new(0, 2, 0)
end

local x, y, z = targetHead.CFrame:ToOrientation()
local cf = lelCam or right and weapon == 'Knife' and
CFrame.new(Camera.Position)*CFrame.Angles(x,y,z) or
CFrame.new(Camera.CFrame.Position, aimPosition)
Camera.CFrame = cf
lelCam = nil
if right and weapon == 'Knife' then lelCam = cf end
ReplicatedStorage.Remotes.Attack:FireServer(targetHead)
end
end
end

table.insert(initConnections, m.Button1Down:Connect(function()
if spamActivate then
local a = RunService.RenderStepped:Connect(auto)
table.insert(cons, a)
end
end))

table.insert(initConnections, m.Button1Up:Connect(function()
for _, v in pairs(cons) do
v:Disconnect()
end
end))
 local last = true
table.insert(initConnections,
UserInputService.InputBegan:Connect(function(input, processed)
local b = table.find(keybinds, input.KeyCode.Name)
if input.UserInputType == Enum.UserInputType.MouseButton1 or b then
auto(b)
elseif input.UserInputType == Enum.UserInputType.MouseButton2 then
auto(1)
elseif input.KeyCode == Enum.KeyCode.Y and not processed then
espActive = last and true or not espActive
silentAimActive = espActive
last = false
write()
playSound(espActive and 1 or .8)
elseif input.KeyCode == Enum.KeyCode.H and not processed then
last = true
silentAimActive = not espActive
write()
playSound(.8)
elseif input.KeyCode == Enum.KeyCode.U and not processed then
--spamActivate = not spamActivate
espActive = not espActive
write()
playSound(espActive and 1 or .8)
elseif input.KeyCode.Name == 'Z' and not processed then
glass = not glass
write()
playSound(glass and 1 or .8)
gt()
elseif input.KeyCode.Name == 'X' and not processed then
reload = not reload
write()
playSound(reload and 1 or .8)
elseif input.KeyCode == Enum.KeyCode.J and not processed then
if #noPlayers == 0 then
noPlayers = ac
else
noPlayers = {}
end
end
end))

local function updAc()

if #noPlayers > 0 then
noPlayers = ac
end
end

local c = 4
local function createESP(player)
if player ~= LocalPlayer then
local espBox = Drawing.new("Quad")
espBox.Thickness = 2
espBox.Transparency = 1
espBox.Visible = true

local function col()

espBox.Color = silentAimActive and (table.find(ac,
player.UserId) and Color3.fromRGB(0, 255, 255) or Color3.fromRGB(0, 0, 255)) or
Color3.fromRGB(150, 100, 100)
end

col()

espList[player.Name] = espBox

local added = false

local func = nil

local function x(char)

local root = char:WaitForChild('HumanoidRootPart')

local function check()

local l = root:FindFirstChild('TeammateLabel')
if l and l.Enabled then
if not added then
added = true
table.insert(ac, player.UserId)
updAc()
end
elseif added then
added = false
table.remove(ac, table.find(ac, player.UserId))
updAc()
end

col()
end

func = check

check()

table.insert(initConnections,
root.ChildAdded:Connect(check))
end

table.insert(initConnections, player.CharacterAdded:Connect(x))
if player.Character then
x(player.Character)
end

local function invis()

espBox.PointA = Vector2.new(-math.huge, -math.huge)
espBox.PointB = Vector2.new(-math.huge, -math.huge)
espBox.PointC = Vector2.new(-math.huge, -math.huge)
espBox.PointD = Vector2.new(-math.huge, -math.huge)
end

table.insert(initConnections,
RunService.RenderStepped:Connect(function()
local char = player.Character
local hum = char and char:FindFirstChild('Humanoid')
local root = char and
char:FindFirstChild('HumanoidRootPart')
if espActive and not table.find(noPlayers, player.UserId)
and root and hum and hum.Health > 0 and
player.Character:FindFirstChild("HumanoidRootPart") and getWeapon() then
 local rootPart = player.Character.HumanoidRootPart
local head = player.Character:FindFirstChild("Head")

if rootPart and head then

local rootPos, rootVisible =
Camera:WorldToViewportPoint(rootPart.Position)
local headPos, headVisible =
Camera:WorldToViewportPoint(head.Position + Vector3.new(0, 0.5, 0))

if rootVisible and headVisible then

espBox.PointA = Vector2.new(rootPos.X -
15, rootPos.Y + 30)
espBox.PointB = Vector2.new(rootPos.X +
15, rootPos.Y + 30)
espBox.PointC = Vector2.new(headPos.X +
15, headPos.Y)
espBox.PointD = Vector2.new(headPos.X -
15, headPos.Y)
espBox.Transparency = 0
espBox.Visible = true
else
invis()
espBox.Transparency = 1
espBox.Visible = false
end
else
invis()
espBox.Transparency = 1
espBox.Visible = false
end
else
invis()
espBox.Transparency = 1
espBox.Visible = false
end

if func then
func()
end
end))
end
end

for _, player in pairs(Players:GetPlayers()) do

createESP(player)
end

table.insert(initConnections, Players.PlayerAdded:Connect(function(player)
createESP(player)
end))

table.insert(initConnections, Players.PlayerRemoving:Connect(function(player)
if espList[player.Name] then
espList[player.Name]:Remove()
espList[player.Name] = nil
end
end))

game:GetService("Players").LocalPlayer.OnTeleport:Once(function(State)
((syn and syn.queue_on_teleport) or queue_on_teleport or (fluxus and
fluxus.queue_on_teleport))(xscr)
end)
]]

repeat
task.wait()
until xscr

game:GetService("Players").LocalPlayer.OnTeleport:Connect(function(State)
((syn and syn.queue_on_teleport) or queue_on_teleport or (fluxus and
fluxus.queue_on_teleport))(xscr)
end)

loadstring(xscr)()