View difference between Paste ID: gr8xr1BL and vqF4Pxws

 --[[
 	VAPE PRIVATE - leak and I'll break ur kneecaps
 
 	Credits
 	Infinite Yield - Blink
 	DevForum - lots of rotation math because I hate it
 	Please notify me if you need credits
 ]]
 local GuiLibrary = shared.GuiLibrary
 local players = game:GetService("Players")
 local textservice = game:GetService("TextService")
 local repstorage = game:GetService("ReplicatedStorage")
 local lplr = players.LocalPlayer
 local lighting = game:GetService("Lighting")
 local cam = workspace.CurrentCamera
 workspace:GetPropertyChangedSignal("CurrentCamera"):connect(function()
 	cam = (workspace.CurrentCamera or workspace:FindFirstChild("Camera") or Instance.new("Camera"))
 end)
 local targetinfo = shared.VapeTargetInfo
 local collectionservice = game:GetService("CollectionService")
 local uis = game:GetService("UserInputService")
 local mouse = lplr:GetMouse()
 local bedwars = {}
 local bedwarsblocks = {}
 local blockraycast = RaycastParams.new()
 blockraycast.FilterType = Enum.RaycastFilterType.Whitelist
 local getfunctions
 local oldchar
 local oldcloneroot
 local matchState = 0
 local kit = ""
 local antivoidypos = 0
 local kills = 0
 local beds = 0
 local lagbacks = 0
 local reported = 0
 local vec3 = Vector3.new
 local cfnew = CFrame.new
 local currentinventory = {
 	["inventory"] = {
 		["items"] = {},
 		["armor"] = {},
 		["hand"] = nil
 	}
 }
 local disguisecheck = false
 local betterisfile = function(file)
 	local suc, res = pcall(function() return readfile(file) end)
 	return suc and res ~= nil
 end
 local requestfunc = syn and syn.request or http and http.request or http_request or fluxus and fluxus.request or request or function(tab)
 	if tab.Method == "GET" then
 		return {
 			Body = game:HttpGet(tab.Url, true),
 			Headers = {},
 			StatusCode = 200
 		}
 	else
 		return {
 			Body = "bad exploit",
 			Headers = {},
 			StatusCode = 404
 		}
 	end
 end
 local queueteleport = syn and syn.queue_on_teleport or queue_on_teleport or fluxus and fluxus.queue_on_teleport or function() end
 local teleportfunc
 local getasset = getsynasset or getcustomasset or function(location) return "rbxasset://"..location end
 local storedshahashes = {}
 local oldshoot
 local chatconnection
 local blocktable
 local inventories = {}
 local Hitboxes = {["Enabled"] = false}
 local Reach = {["Enabled"] = false}
 local Killaura = {["Enabled"] = false}
 local nobob = {["Enabled"] = false}
 local AnticheatBypass = {["Enabled"] = false}
 local AnticheatBypassCombatCheck = {["Enabled"] = false}
 local combatcheck = false
 local combatchecktick = tick()
 local disabletpcheck = false
 local queueType = "bedwars_test"
 local FastConsume = {["Enabled"] = false}
 local chatconnection2
 local oldchanneltab
 local oldchannelfunc
 local oldchanneltabs = {}
 local connectionstodisconnect = {}
 local anticheatfunny = false
 local anticheatfunnyyes = false
 local tpstring
 local networkownertick = tick()
 local networkownerfunc = isnetworkowner or function(part)
 	if gethiddenproperty(part, "NetworkOwnershipRule") == Enum.NetworkOwnership.Manual then
 		sethiddenproperty(part, "NetworkOwnershipRule", Enum.NetworkOwnership.Automatic)
 		networkownertick = tick() + 8
 	end
 	return networkownertick <= tick()
 end
 local uninjectflag = false
-local clients = {
+
-	ChatStrings1 = {
+
-		["KVOP25KYFPPP4"] = "vape",
+
-		["IO12GP56P4LGR"] = "future",
+
-		["RQYBPTYNURYZC"] = "rektsky"
+
-	},
+
-	ChatStrings2 = {
+
-		["vape"] = "KVOP25KYFPPP4",
+
-		["future"] = "IO12GP56P4LGR",
+
-		["rektsky"] = "RQYBPTYNURYZC"
+
-	},
+
-	ClientUsers = {}
+
 			RunLoops.RenderStepTable[name] = nil
-local function GetURL(scripturl)
+
-	if shared.VapeDeveloper then
+
-		return readfile("vape/"..scripturl)
+
 	function RunLoops:BindToStepped(name, num, func)
-		return game:HttpGet("https://raw.githubusercontent.com/7GrandDadPGN/VapeV4ForRoblox/main/"..scripturl, true)
+
 			RunLoops.StepTable[name] = game:GetService("RunService").Stepped:connect(func)
 		end
-local shalib = loadstring(GetURL("Libraries/sha.lua"))()
+
-local entity = shared.vapeentity
+
-local whitelisted = {
+
-	players = {
+
-		"edbf7c4bd824bb17954c0fee8f108b6263a23d58e1dc500157513409cd9c55433ad43ea5c8bb121602fcd0eb0137d64805aaa8c597521298f5b53d69fa82014b",
+
-        "94a10e281a721c62346185156c15dcc62a987aa9a73c482db4d1b0f2b4673261ec808040fb70886bf50453c7af97903ffe398199b43fccf5d8b619121493382d",
+
-        "a91361a785c34c433f33386ef224586b7076e1e10ebb8189fdc39b7e37822eb6c79a7d810e0d2d41e000db65f8c539ffe2144e70d48e6d3df7b66350d4699c36",
+
-        "cd41b8c39abf4b186f611f3afd13e5d0a2e5d65540b0dab93eed68a68f3891e0448d87dbba0937395ab1b7c3d4b6aed4025caad2b90b2cdbf4ca69441644d561",
+
-        "28f1c2514aea620a23ef6a1f084e86a993e2585110c1ddd7f98cc6b3bd331251382c0143f7520153c91a368be5683d3406e06c9e35fba61f8bd2ac811c05f46b",
+
-        "8b6c2833fa6e3a7defdeb8ffb4dcd6d4c652e6d02621c054df7c44ebaf94858ac5cbed6a6aadf0270c07d7054b7a2dd1ebf49ab20ffbc567213376c7848b8b90",
+
-        "6662a5dfbb5311ee66af25cf9b6255c8b70f977022fcaed8fa9e6bcb4fe0159c148835d7c3b599a5f92f9a67455e0158f8977f33e9306dd4cee3efceb0b75441",
+
-        "bdf4e13afb63148ad68cf75e25ec6f0cf11e0c4a597e8bdd5c93724a44bde2ce12eee46549a90ae4390bbfa36f8c662b7634600c552ca21d093004d473f9b23f",
+
-        "6f3e2567502502ac053f72a3ad27eead7aeef4f0ad7b1695150040c36de8868b045ac0ac7e75dab8b9e973fea0561ad1f9fa4ea9f57bfee6ad59ff6b440640ff",
+
-        "96fdd47dbac073243048420c583ff9ef999f5d009dcac2b40e16fb8ec08269eba30bb94c830ce82ef7711a2cd18fc43d2a495fb9ba37d42c5047fe4f1c7315a6",
+
-        "cc5ec617693d5c0b67c591adbc3560e2b4ee11ec87a625c5a026d8d1b57d82a3965ea4874a4deabee7015c9a5a1d52d0d75e2821c36a5b5ea21f0f72e100cbb7",
+
-        "a650c02f7ae2a15303926b520213a7b74382c0be925e649733ab9d2e028462af51cec91357647907a76029951910e9fcb524fdb8f78c6c2df4e6d56d3b215ddd",
+
-        "ae55a45820f801cfb2e0539c079dec830f0765b2a431eaa26957bf17054e0d93fbf28e9538c812d0b79cd20bd2862a8fd930b8d4f838c1cd135344e2d6f0e85e",
+
-        "6ff2157b9f16703f12a08980cff9f23a56e20de493b38c816dbe36f519155eb27751d1aabb10b8859850c88d8921b49fbac13d67cbfba3cca36f31afd1d4db85",
+
-        "33cc2e81258d38699b3638e9888e0263904ae3ee5ea1f14bab25c52dc1f0eb7212bb9ea3bcb2c45a1f577286a0319ac9952f4181908161276af6db22f49901a3",
+
-        "4316131222bddc978cea052e43b958c689190f7fc1308da43dccfc04f0cb0637c0cc328e130406993e83a1b2f63c4b2a5267080b6c344282a5314b0be6c6b79e",
+
-        "cf22724d1d4368338f59bab33321c1ded4fdbefc5f254d832d68db49a861e9fc546049a1e7b63076e5fef2c29faf127156396433ca3c73bb6630420d6e4e4e4f",
+
-        "75967edb96b649fdc44d81c7d1085b72cc3c638d564d7cd3cded4c1713fc7d7e8e286dcc8e2b8858634e807aa760311af077840d0a6b3a6d7a90a8d2bd3ac171",
+
-        "34664958478e9c40b1befa4a73dac9e16d8b1e3ffe2f7a0b25f2defb1b1f8a469116970b2fc720540903b240abc9b3986fe91ef9333d4fab26945535a4af1dcd",
+
-        "2892f7112427bcd09afbc6e57a8152839641ecf932134bb90eb0bdd730afdb6dc99829b78e2380977f529afc50d3cbca30d224b8f13dd60e465c120ef10ab651",
+
-        "9dc7a3fd30ef6c7d68da21b8a0c954c49c78710079118892d85aac93f12025fed982a4c2184fff001c616d8f59a034d70c3d85677be383c300ed95a6984e42ac",
+
-        "edc25420a498cac15a3c38d298765a948ddae5007c15c77fbc5aa6c65149c968ce20eb916024ddd4c6e47aeaae9b10d13e1d0b245089f04db2902b1eda643cbc",
+
-        "95520901447cb29c4a8b0c6376e5a10d8a05cc2225e0a64789ce917e27db891cd9c1aa3cd27869941ef797492fab2e3dd903db8100e57e0842577cfb35f45848",
+
-        "7141c96de6ca4e94f407b1b4803f32fe72322213d94310445b69c11be913d6ceb3777e04e19ab8ff76c12260e6705035311e673b68b0763ebff2a3d67a06f90d",
+
-        "3b84ce0a89a50a01299cf4582fd0ed164a8cb24289ac3a4afc3a652e9aacad0a9e17caa2c787cd3cd6a3e7a79a31f2f2c4f6f54a58ae1c53d03226134070f5b9"
+
-	},
+
-	owners = {
+
-		"66ed442039083616d035cd09a9701e6c225bd61278aaad11a759956172144867ed1b0dc1ecc4f779e6084d7d576e49250f8066e2f9ad86340185939a7e79b30f",
+
-        "55273f4b0931f16c1677680328f2784842114d212498a657a79bb5086b3929c173c5e3ca5b41fa3301b62cccf1b241db68a85e3cd9bbe5545b7a8c6422e7f0d2",
+
-        "389b0e57c452ceb5e7c71fa20a75fd11147cef40adef9935f10abf5982d21e2ff01b7357f22855b5ea6536d4b841a337c0e52cfb614049bf47b175addc4f905e"
+
-	},
+
-	chattags = {
+
-		["55273f4b0931f16c1677680328f2784842114d212498a657a79bb5086b3929c173c5e3ca5b41fa3301b62cccf1b241db68a85e3cd9bbe5545b7a8c6422e7f0d2"] = {
+
-			NameColor = {r = 255, g = 0, b = 0},
+
-			Tags = {
+
-				{
+
-					TagColor = {r = 255, g = 0, b = 0},
+
-					TagText = "okay"
+
-				}
+
-			}
+
 local function LaunchDirection(start, target, v, g, higherArc: boolean)
 	-- get the direction flattened:
 	local horizontal = Vector3.new(target.X - start.X, 0, target.Z - start.Z)
-pcall(function()
+
-	whitelisted = game:GetService("HttpService"):JSONDecode(game:HttpGet("https://raw.githubusercontent.com/7GrandDadPGN/whitelists/main/whitelist2.json", true))
+
 	local d = horizontal.Magnitude
 	local a = LaunchAngle(v, g, d, h, higherArc)
 
 	-- NaN ~= NaN, computation couldn't be done (e.g. because it's too far to launch)
 	if a ~= a then return nil end
 
 	-- speed if we were just launching at a flat angle:
 	local vec = horizontal.Unit * v
 
 	-- rotate around the axis perpendicular to that direction...
 	local rotAxis = Vector3.new(-horizontal.Z, 0, horizontal.X)
 
 	-- ...by the angle amount
 	return CFrame.fromAxisAngle(rotAxis, a) * vec
 end
 
 local function FindLeadShot(targetPosition: Vector3, targetVelocity: Vector3, projectileSpeed: Number, shooterPosition: Vector3, shooterVelocity: Vector3, gravity: Number)
 	local distance = (targetPosition - shooterPosition).Magnitude
 
 	local p = targetPosition - shooterPosition
 	local v = targetVelocity - shooterVelocity
 	local a = Vector3.zero
 
 	local timeTaken = (distance / projectileSpeed)
 
 	if gravity > 0 then
 		local timeTaken = projectileSpeed/gravity+math.sqrt(2*distance/gravity+projectileSpeed^2/gravity^2)
 	end
 
 	local goalX = targetPosition.X + v.X*timeTaken + 0.5 * a.X * timeTaken^2
 	local goalY = targetPosition.Y + v.Y*timeTaken + 0.5 * a.Y * timeTaken^2
 	local goalZ = targetPosition.Z + v.Z*timeTaken + 0.5 * a.Z * timeTaken^2
 
 	return Vector3.new(goalX, goalY, goalZ)
 end
 
 local function addvectortocframe(cframe, vec)
 	local x, y, z, R00, R01, R02, R10, R11, R12, R20, R21, R22 = cframe:GetComponents()
 	return CFrame.new(x + vec.X, y + vec.Y, z + vec.Z, R00, R01, R02, R10, R11, R12, R20, R21, R22)
 end
 
 local function addvectortocframe2(cframe, newylevel)
 	local x, y, z, R00, R01, R02, R10, R11, R12, R20, R21, R22 = cframe:GetComponents()
 	return CFrame.new(x, newylevel, z, R00, R01, R02, R10, R11, R12, R20, R21, R22)
 end
 
 local function runcode(func)
 	func()
 end
 
 runcode(function()
 	local textlabel = Instance.new("TextLabel")
 	textlabel.Size = UDim2.new(1, 0, 0, 36)
 	textlabel.Text = "Moderators can ban you at any time, Always use alts."
 	textlabel.BackgroundTransparency = 1
 	textlabel.ZIndex = 10
 	textlabel.TextStrokeTransparency = 0
 	textlabel.TextScaled = true
 	textlabel.Font = Enum.Font.SourceSans
 	textlabel.TextColor3 = Color3.new(1, 1, 1)
 	textlabel.Position = UDim2.new(0, 0, 0, -36)
 	textlabel.Parent = GuiLibrary["MainGui"].ScaledGui.ClickGui
 	task.spawn(function()
 		repeat task.wait() until matchState ~= 0
 		textlabel:Remove()
 	end)
 end)
 
 local cachedassets = {}
 local function getcustomassetfunc(path)
 	if not betterisfile(path) then
 		task.spawn(function()
 			local textlabel = Instance.new("TextLabel")
 			textlabel.Size = UDim2.new(1, 0, 0, 36)
 			textlabel.Text = "Downloading "..path
 			textlabel.BackgroundTransparency = 1
 			textlabel.TextStrokeTransparency = 0
 			textlabel.TextSize = 30
 			textlabel.Font = Enum.Font.SourceSans
 			textlabel.TextColor3 = Color3.new(1, 1, 1)
 			textlabel.Position = UDim2.new(0, 0, 0, -36)
 			textlabel.Parent = GuiLibrary["MainGui"]
 			repeat task.wait() until betterisfile(path)
 			textlabel:Remove()
 		end)
 		local req = requestfunc({
 			Url = "https://raw.githubusercontent.com/7GrandDadPGN/VapeV4ForRoblox/main/"..path:gsub("vape/assets", "assets"),
 			Method = "GET"
 		})
 		writefile(path, req.Body)
 	end
 	if cachedassets[path] == nil then
 		cachedassets[path] = getasset(path)
 	end
 	return cachedassets[path]
 end
 
 GuiLibrary["LoadSettingsEvent"].Event:connect(function(res)
 	for i,v in pairs(res) do
 		local obj = GuiLibrary["ObjectsThatCanBeSaved"][i]
 		if obj and v["Type"] == "ItemList" and obj.Api then
 			obj["Api"]["Hotbars"] = v["Items"]
 			obj["Api"]["CurrentlySelected"] = v["CurrentlySelected"]
 			obj["Api"]["RefreshList"]()
 		end
 	end
 end)
 
 local function createwarning(title, text, delay)
 	local suc, res = pcall(function()
 		local frame = GuiLibrary["CreateNotification"](title, text, delay, "assets/WarningNotification.png")
 		frame.Frame.Frame.ImageColor3 = Color3.fromRGB(236, 129, 44)
 		return frame
 	end)
 	return (suc and res)
 end
 
 local function getItemNear(itemName, inv)
 	for i5, v5 in pairs(inv or currentinventory.inventory.items) do
 		if v5.itemType:find(itemName) then
 			return v5, i5
 		end
 	end
 	return nil
 end
 
 local function getItem(itemName, inv)
 	for i5, v5 in pairs(inv or currentinventory.inventory.items) do
 		if v5.itemType == itemName then
 			return v5, i5
 		end
 	end
 	return nil
 end
 
 local function getHotbarSlot(itemName)
 	for i5, v5 in pairs(currentinventory.hotbar) do
 		if v5["item"] and v5["item"].itemType == itemName then
 			return i5 - 1
 		end
 	end
 	return nil
 end
 
 local function getSword()
 	local bestsword, bestswordslot, bestswordnum = nil, nil, 0
 	for i5, v5 in pairs(currentinventory.inventory.items) do
 		if bedwars["ItemTable"][v5.itemType]["sword"] then
 			local swordrank = bedwars["ItemTable"][v5.itemType]["sword"]["damage"] or 0
 			if swordrank > bestswordnum then
 				bestswordnum = swordrank
 				bestswordslot = i5
 				bestsword = v5
 			end
 		end
 	end
 	return bestsword, bestswordslot
 end
 
 local function getSlotFromItem(item)
 	for i,v in pairs(currentinventory.inventory.items) do
 		if v.itemType == item.itemType then
 			return i
 		end
 	end
 	return nil
 end
 
 local function getAxe()
 	local bestsword, bestswordslot, bestswordnum = nil, nil, 0
 	for i5, v5 in pairs(currentinventory.inventory.items) do
 		if v5.itemType:find("axe") and v5.itemType:find("pickaxe") == nil and v5.itemType:find("void") == nil then
 			bestswordnum = swordrank
 			bestswordslot = i5
 			bestsword = v5
 		end
 	end
 	return bestsword, bestswordslot
 end
 
 local function getPickaxe()
 	return getItemNear("pick")
 end
 
 local function getBaguette()
 	return getItemNear("baguette")
 end
 
 local function getwool()
 	local wool = getItemNear("wool")
 	return wool and wool.itemType, wool and wool.amount
 end
 
 local function isAliveOld(plr, alivecheck)
 	if plr then
 		return plr and plr.Character and plr.Character.Parent ~= nil and plr.Character:FindFirstChild("HumanoidRootPart") and plr.Character:FindFirstChild("Head") and plr.Character:FindFirstChild("Humanoid")
 	end
 	return entity.isAlive
 end
 
 local function isAlive(plr, alivecheck)
 	if plr then
 		local ind, tab = entity.getEntityFromPlayer(plr)
 		return ((not alivecheck) or tab and tab.Humanoid:GetState() ~= Enum.HumanoidStateType.Dead) and tab
 	end
 	return entity.isAlive
 end
 
 local function hashvec(vec)
 	return {
 		["value"] = vec
 	}
 end
 
 local function getremote(tab)
 	for i,v in pairs(tab) do
 		if v == "Client" then
 			return tab[i + 1]
 		end
 	end
 	return ""
 end
 
 local function betterfind(tab, obj)
 	for i,v in pairs(tab) do
 		if v == obj or type(v) == "table" and v.hash == obj then
 			return v
 		end
 	end
 	return nil
 end
 
 local GetNearestHumanoidToMouse = function() end
 
 local function randomString()
 	local randomlength = math.random(10,100)
 	local array = {}
 
 	for i = 1, randomlength do
 		array[i] = string.char(math.random(32, 126))
 	end
 
 	return table.concat(array)
 end
 
 local function getWhitelistedBed(bed)
 	for i,v in pairs(players:GetChildren()) do
 		if v:GetAttribute("Team") and bed and bed:GetAttribute("Team"..v:GetAttribute("Team").."NoBreak") and bedwars["CheckWhitelisted"](v) then
 			return true
 		end
 	end
 	return false
 end
 
 local OldClientGet
 local oldbreakremote
 local oldbob
 runcode(function()
     getfunctions = function()
 		local Flamework = require(repstorage["rbxts_include"]["node_modules"]["@flamework"].core.out).Flamework
 		repeat task.wait() until Flamework.isInitialized
         local KnitClient = debug.getupvalue(require(lplr.PlayerScripts.TS.knit).setup, 6)
         local Client = require(repstorage.TS.remotes).default.Client
         local InventoryUtil = require(repstorage.TS.inventory["inventory-util"]).InventoryUtil
         bedwars = {
 			["AnimationType"] = require(repstorage.TS.animation["animation-type"]).AnimationType,
 			["AnimationUtil"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["game-core"].out["shared"].util["animation-util"]).AnimationUtil,
 			["AngelUtil"] = require(repstorage.TS.games.bedwars.kit.kits.angel["angel-kit"]),
 			["AppController"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["game-core"].out.client.controllers["app-controller"]).AppController,
 			["AttackRemote"] = getremote(debug.getconstants(getmetatable(KnitClient.Controllers.SwordController)["attackEntity"])),
             ["BalloonController"] = KnitClient.Controllers.BalloonController,
             ["BlockController"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["block-engine"].out).BlockEngine,
             ["BlockController2"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["block-engine"].out.client.placement["block-placer"]).BlockPlacer,
             ["BlockEngine"] = require(lplr.PlayerScripts.TS.lib["block-engine"]["client-block-engine"]).ClientBlockEngine,
             ["BlockEngineClientEvents"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["block-engine"].out.client["block-engine-client-events"]).BlockEngineClientEvents,
 			["BlockPlacementController"] = KnitClient.Controllers.BlockPlacementController,
             ["BedwarsKits"] = require(repstorage.TS.games.bedwars.kit["bedwars-kit-shop"]).BedwarsKitShop,
 			["BedTable"] = {},
             ["BlockBreaker"] = KnitClient.Controllers.BlockBreakController.blockBreaker,
             ["BowTable"] = KnitClient.Controllers.ProjectileController,
 			["BowConstantsTable"] = debug.getupvalue(KnitClient.Controllers.ProjectileController.enableBeam, 5),
 			["CannonRemote"] = getremote(debug.getconstants(KnitClient.Controllers.CannonHandController.fireCannon)),
 			["ChestController"] = KnitClient.Controllers.ChestController,
 			["CheckWhitelisted"] = function(plr, ownercheck)
 				local plrstr = bedwars["HashFunction"](plr.Name..plr.UserId)
 				local localstr = bedwars["HashFunction"](lplr.Name..lplr.UserId)
 				return ((ownercheck == nil and (betterfind(whitelisted.players, plrstr) or betterfind(whitelisted.owners, plrstr)) or ownercheck and betterfind(whitelisted.owners, plrstr))) and betterfind(whitelisted.owners, localstr) == nil and true or false
 			end,
 			["CheckPlayerType"] = function(plr)
 				local plrstr = bedwars["HashFunction"](plr.Name..plr.UserId)
 				local playertype, playerattackable = "DEFAULT", true
 				local private = betterfind(whitelisted.players, plrstr)
 				local owner = betterfind(whitelisted.owners, plrstr)
 				if private then
 					playertype = "VAPE PRIVATE"
 					playerattackable = not (type(private) == "table" and private.invulnerable or false)
 				end
 				if owner then
 					playertype = "VAPE OWNER"
 					playerattackable = not (type(owner) == "table" and owner.invulnerable or false)
 				end
 				return playertype, playerattackable
 			end,
 			["ClickHold"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["game-core"].out.client.ui.lib.util["click-hold"]).ClickHold,
             ["ClientHandler"] = Client,
             ["ClientHandlerDamageBlock"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["block-engine"].out.remotes).BlockEngineRemotes.Client,
             ["ClientStoreHandler"] = require(lplr.PlayerScripts.TS.ui.store).ClientStore,
 			["ClientHandlerSyncEvents"] = require(lplr.PlayerScripts.TS["client-sync-events"]).ClientSyncEvents,
             ["CombatConstant"] = require(repstorage.TS.combat["combat-constant"]).CombatConstant,
 			["CombatController"] = KnitClient.Controllers.CombatController,
 			["ConsumeSoulRemote"] = getremote(debug.getconstants(KnitClient.Controllers.GrimReaperController.consumeSoul)),
 			["ConstantManager"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["game-core"].out["shared"].constant["constant-manager"]).ConstantManager,
 			["CooldownController"] = KnitClient.Controllers.CooldownController,
             ["damageTable"] = KnitClient.Controllers.DamageController,
 			["DaoRemote"] = getremote(debug.getconstants(debug.getprotos(KnitClient.Controllers.DaoController.onEnable)[4])),
 			["DamageController"] = KnitClient.Controllers.DamageController,
 			["DamageIndicator"] = KnitClient.Controllers.DamageIndicatorController.spawnDamageIndicator,
 			["DamageIndicatorController"] = KnitClient.Controllers.DamageIndicatorController,
 			["DetonateRavenRemote"] = getremote(debug.getconstants(getmetatable(KnitClient.Controllers.RavenController).detonateRaven)),
             ["DropItem"] = getmetatable(KnitClient.Controllers.ItemDropController).dropItemInHand,
             ["DropItemRemote"] = getremote(debug.getconstants(getmetatable(KnitClient.Controllers.ItemDropController).dropItemInHand)),
             ["EatRemote"] = getremote(debug.getconstants(debug.getproto(getmetatable(KnitClient.Controllers.ConsumeController).onEnable, 1))),
             ["EquipItemRemote"] = getremote(debug.getconstants(debug.getprotos(shared.oldequipitem or require(repstorage.TS.entity.entities["inventory-entity"]).InventoryEntity.equipItem)[3])),
 			["FishermanTable"] = KnitClient.Controllers.FishermanController,
 			["GameAnimationUtil"] = require(repstorage.TS.animation["animation-util"]).GameAnimationUtil,
 			["GamePlayerUtil"] = require(repstorage.TS.player["player-util"]).GamePlayerUtil,
             ["getEntityTable"] = require(repstorage.TS.entity["entity-util"]).EntityUtil,
             ["getIcon"] = function(item, showinv)
                 local itemmeta = bedwars["ItemTable"][item.itemType]
                 if itemmeta and showinv then
                     return itemmeta.image
                 end
                 return ""
             end,
             ["getInventory"] = function(plr)
                 local suc, result = pcall(function()
 					if plr == lplr then
 						return currentinventory.inventory
 					end
 					return inventories[plr]
 				end)
                 return (suc and result or {
                     ["items"] = {},
                     ["armor"] = {},
                     ["hand"] = nil
                 })
             end,
 			["getInventory2"] = function(plr)
                 local suc, result = pcall(function()
 					return InventoryUtil.getInventory(plr)
 				end)
                 return (suc and result or {
                     ["items"] = {},
                     ["armor"] = {},
                     ["hand"] = nil
                 })
             end,
             ["getItemMetadata"] = require(repstorage.TS.item["item-meta"]).getItemMeta,
 			["GrimReaperController"] = KnitClient.Controllers.GrimReaperController,
 			["GuitarHealRemote"] = getremote(debug.getconstants(KnitClient.Controllers.GuitarController.performHeal)),
 			["HashFunction"] = function(str)
 				if storedshahashes[tostring(str)] == nil then
 					storedshahashes[tostring(str)] = shalib.sha512(tostring(str).."SelfReport")
 				end
 				return storedshahashes[tostring(str)]
 			end,
 			["HighlightController"] = KnitClient.Controllers.EntityHighlightController,
             ["ItemTable"] = debug.getupvalue(require(repstorage.TS.item["item-meta"]).getItemMeta, 1),
 			["IsVapePrivateIngame"] = function()
 				for i,v in pairs(players:GetChildren()) do
 					local plrstr = bedwars["HashFunction"](v.Name..v.UserId)
 					if bedwars["CheckPlayerType"](v) ~= "DEFAULT" or whitelisted.chattags[plrstr] then
 						return true
 					end
 				end
 				return false
 			end,
 			["JuggernautRemote"] = getremote(debug.getconstants(debug.getprotos(debug.getprotos(KnitClient.Controllers.JuggernautController.KnitStart)[1])[4])),
 			["KatanaController"] = KnitClient.Controllers.DaoController,
 			["KatanaRemote"] = getremote(debug.getconstants(debug.getproto(KnitClient.Controllers.DaoController.onEnable, 4))),
             ["KnockbackTable"] = debug.getupvalue(require(repstorage.TS.damage["knockback-util"]).KnockbackUtil.calculateKnockbackVelocity, 1),
 			["KnockbackTable2"] = require(repstorage.TS.damage["knockback-util"]).KnockbackUtil,
 			["LobbyClientEvents"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"].lobby.out.client.events).LobbyClientEvents,
 			["MapMeta"] = require(repstorage.TS.game.map["map-meta"]),
 			["MissileController"] = KnitClient.Controllers.GuidedProjectileController,
 			["MinerRemote"] = getremote(debug.getconstants(debug.getprotos(debug.getproto(getmetatable(KnitClient.Controllers.MinerController).onKitEnabled, 1))[2])),
 			["MinerController"] = KnitClient.Controllers.MinerController,
 			["ProdAnimations"] = require(repstorage.TS.animation.definitions["prod-animations"]).ProdAnimations,
             ["PickupRemote"] = getremote(debug.getconstants(getmetatable(KnitClient.Controllers.ItemDropController).checkForPickup)),
             ["PlayerUtil"] = require(repstorage.TS.player["player-util"]).GamePlayerUtil,
 			["ProjectileMeta"] = require(repstorage.TS.projectile["projectile-meta"]).ProjectileMeta,
 			["QueueMeta"] = require(repstorage.TS.game["queue-meta"]).QueueMeta,
 			["QueueCard"] = require(lplr.PlayerScripts.TS.controllers.global.queue.ui["queue-card"]).QueueCard,
 			["QueryUtil"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["game-core"].out).GameQueryUtil,
 			["PaintRemote"] = getremote(debug.getconstants(KnitClient.Controllers.PaintShotgunController.fire)),
             ["prepareHashing"] = require(repstorage.TS["remote-hash"]["remote-hash-util"]).RemoteHashUtil.prepareHashVector3,
 			["ProjectileRemote"] = getremote(debug.getconstants(debug.getupvalues(getmetatable(KnitClient.Controllers.ProjectileController)["launchProjectileWithValues"])[2])),
 			["ProjectileHitRemote"] = getremote(debug.getconstants(debug.getproto(KnitClient.Controllers.ProjectileController.createLocalProjectile, 1))),
 			["PirateRemote"] = getremote(debug.getconstants(KnitClient.Controllers.PirateFlagController.checkForPickUp)),
             ["RavenTable"] = KnitClient.Controllers.RavenController,
 			["RespawnController"] = KnitClient.Controllers.BedwarsRespawnController,
 			["RespawnTimer"] = require(lplr.PlayerScripts.TS.controllers.games.bedwars.respawn.ui["respawn-timer"]).RespawnTimerWrapper,
 			["ResetRemote"] = getremote(debug.getconstants(debug.getproto(KnitClient.Controllers.ResetController.createBindable, 1))),
 			["Roact"] = require(repstorage["rbxts_include"]["node_modules"]["roact"].src),
 			["RuntimeLib"] = require(repstorage["rbxts_include"].RuntimeLib),
             ["Shop"] = require(repstorage.TS.games.bedwars.shop["bedwars-shop"]).BedwarsShop,
 			["ShopItems"] = debug.getupvalue(require(repstorage.TS.games.bedwars.shop["bedwars-shop"]).BedwarsShop.getShopItem, 2),
             ["ShopRight"] = require(lplr.PlayerScripts.TS.controllers.games.bedwars.shop.ui["item-shop"]["shop-left"]["shop-left"]).BedwarsItemShopLeft,
 			["SpawnRavenRemote"] = getremote(debug.getconstants(getmetatable(KnitClient.Controllers.RavenController).spawnRaven)),
             ["SoundManager"] = require(repstorage["rbxts_include"]["node_modules"]["@easy-games"]["game-core"].out).SoundManager,
 			["SoundList"] = require(repstorage.TS.sound["game-sound"]).GameSound,
             ["sprintTable"] = KnitClient.Controllers.SprintController,
 			["StopwatchController"] = KnitClient.Controllers.StopwatchController,
             ["SwingSword"] = getmetatable(KnitClient.Controllers.SwordController).swingSwordAtMouse,
             ["SwingSwordRegion"] = getmetatable(KnitClient.Controllers.SwordController).swingSwordInRegion,
             ["SwordController"] = KnitClient.Controllers.SwordController,
             ["TreeRemote"] = getremote(debug.getconstants(debug.getprotos(debug.getprotos(KnitClient.Controllers.BigmanController.KnitStart)[2])[1])),
 			["TrinityRemote"] = getremote(debug.getconstants(debug.getproto(getmetatable(KnitClient.Controllers.AngelController).onKitEnabled, 1))),
             ["VictoryScreen"] = require(lplr.PlayerScripts.TS.controllers["game"].match.ui["victory-section"]).VictorySection,
             ["ViewmodelController"] = KnitClient.Controllers.ViewmodelController,
 			["WeldTable"] = require(repstorage.TS.util["weld-util"]).WeldUtil,
         }
 		blocktable = bedwars["BlockController2"].new(bedwars["BlockEngine"], getwool())
 		bedwars["placeBlock"] = function(newpos, customblock)
 			if getItem(customblock) then
 				blocktable.blockType = customblock
 				return blocktable:placeBlock(Vector3.new(newpos.X / 3, newpos.Y / 3, newpos.Z / 3))
 			end
 		end
         task.spawn(function()
             repeat task.wait() until matchState ~= 0
 			if (not uninjectflag) then
 				bedwarsblocks = collectionservice:GetTagged("block")
 				connectionstodisconnect[#connectionstodisconnect + 1] = collectionservice:GetInstanceAddedSignal("block"):connect(function(v) table.insert(bedwarsblocks, v) blockraycast.FilterDescendantsInstances = bedwarsblocks end)
 				connectionstodisconnect[#connectionstodisconnect + 1] = collectionservice:GetInstanceRemovedSignal("block"):connect(function(v) local found = table.find(bedwarsblocks, v) if found then table.remove(bedwarsblocks, found) end blockraycast.FilterDescendantsInstances = bedwarsblocks end)
 				blockraycast.FilterDescendantsInstances = bedwarsblocks
 				local lowestypos = 99999
 				for i,v in pairs(bedwarsblocks) do
 					if v.Name == "bed" then
 						table.insert(bedwars["BedTable"], v)
 					end
 				end
 				for i,v in pairs(bedwarsblocks) do
 					local newray = workspace:Raycast(v.Position + Vector3.new(0, 800, 0), Vector3.new(0, -1000, 0), blockraycast)
 					if i % 100 == 0 then
 						task.wait(0.1)
 					end
 					if newray and newray.Position.Y <= lowestypos then
 						lowestypos = newray.Position.Y
 					end
 				end
 				antivoidypos = lowestypos + 9
 			end
         end)
 		connectionstodisconnect[#connectionstodisconnect + 1] = bedwars["ClientStoreHandler"].changed:connect(function(p3, p4)
 			if p3.Game ~= p4.Game then
 				matchState = p3.Game.matchState
 				queueType = p3.Game.queueType or "bedwars_test"
 			end
 			if p3.Kit ~= p4.Kit then
 				bedwars["BountyHunterTarget"] = p3.Kit.bountyHunterTarget
 			end
 			if p3.Bedwars ~= p4.Bedwars then
 				kit = p3.Bedwars.kit
 			end
 			if p3.Inventory ~= p4.Inventory then
 				currentinventory = p3.Inventory.observedInventory
 			end
         end)
 		local clientstorestate = bedwars["ClientStoreHandler"]:getState()
         matchState = clientstorestate.Game.matchState or 0
         kit = clientstorestate.Bedwars.kit or ""
 		queueType = clientstorestate.Game.queueType or "bedwars_test"
 		currentinventory = clientstorestate.Inventory.observedInventory
     end
 end)
 
 local fakeuiconnection
 GuiLibrary["SelfDestructEvent"].Event:connect(function()
 	uninjectflag = true
 	if blocktable then
 		blocktable:disable()
 	end
 	for i3,v3 in pairs(connectionstodisconnect) do
 		if v3.Disconnect then
 			pcall(function() v3:Disconnect() end)
 		end
 	end
 end)
 
 local function getblock(pos)
 	local blockpos = bedwars["BlockController"]:getBlockPosition(pos)
 	return bedwars["BlockController"]:getStore():getBlockAt(blockpos), blockpos
 end
 
 getfunctions()
 
 local function getNametagString(plr)
 	local nametag = ""
 	local hash = bedwars["HashFunction"](plr.Name..plr.UserId)
 	if bedwars["CheckPlayerType"](plr) == "VAPE PRIVATE" then
 		nametag = '<font color="rgb(127, 0, 255)">[VAPE PRIVATE] '..(plr.Name)..'</font>'
 	end
 	if bedwars["CheckPlayerType"](plr) == "VAPE OWNER" then
 		nametag = '<font color="rgb(255, 80, 80)">[VAPE OWNER] '..(plr.DisplayName or plr.Name)..'</font>'
 	end
 	if clients.ClientUsers[tostring(plr)] then
 		nametag = '<font color="rgb(255, 255, 0)">['..clients.ClientUsers[tostring(plr)]..'] '..(plr.DisplayName or plr.Name)..'</font>'
 	end
 	if whitelisted.chattags[hash] then
 		local data = whitelisted.chattags[hash]
 		local newnametag = ""
 		if data.Tags then
 			for i2,v2 in pairs(data.Tags) do
 				newnametag = newnametag..'<font color="rgb('..math.floor(v2.TagColor.r * 255)..', '..math.floor(v2.TagColor.g * 255)..', '..math.floor(v2.TagColor.b * 255)..')">['..v2.TagText..']</font> '
 			end
 		end
 		nametag = newnametag..(newnametag.NameColor and '<font color="rgb('..math.floor(newnametag.NameColor.r * 255)..', '..math.floor(newnametag.NameColor.g * 255)..', '..math.floor(newnametag.NameColor.b * 255)..')">' or '')..(plr.DisplayName or plr.Name)..(newnametag.NameColor and '</font>' or '')
 	end
 	return nametag
 end
 
 local function friendCheck(plr, recolor)
 	if GuiLibrary["ObjectsThatCanBeSaved"]["Use FriendsToggle"]["Api"]["Enabled"] then
 		local friend = (table.find(GuiLibrary["ObjectsThatCanBeSaved"]["FriendsListTextCircleList"]["Api"]["ObjectList"], plr.Name) and GuiLibrary["ObjectsThatCanBeSaved"]["FriendsListTextCircleList"]["Api"]["ObjectListEnabled"][table.find(GuiLibrary["ObjectsThatCanBeSaved"]["FriendsListTextCircleList"]["Api"]["ObjectList"], plr.Name)] and true or nil)
 		if recolor then
 			return (friend and GuiLibrary["ObjectsThatCanBeSaved"]["Recolor visualsToggle"]["Api"]["Enabled"] and true or nil)
 		else
 			return friend
 		end
 	end
 	return nil
 end
 
 local function getPlayerColor(plr)
 	return (friendCheck(plr, true) and Color3.fromHSV(GuiLibrary["ObjectsThatCanBeSaved"]["Friends ColorSliderColor"]["Api"]["Hue"], GuiLibrary["ObjectsThatCanBeSaved"]["Friends ColorSliderColor"]["Api"]["Sat"], GuiLibrary["ObjectsThatCanBeSaved"]["Friends ColorSliderColor"]["Api"]["Value"]) or tostring(plr.TeamColor) ~= "White" and plr.TeamColor.Color)
 end
 
 shared.vapeteamcheck = function(plr)
 	return (GuiLibrary["ObjectsThatCanBeSaved"]["Teams by colorToggle"]["Api"]["Enabled"] and lplr:GetAttribute("Team") ~= plr:GetAttribute("Team") or GuiLibrary["ObjectsThatCanBeSaved"]["Teams by colorToggle"]["Api"]["Enabled"] == false)
 end
 
 local function targetCheck(plr)
 	return plr and plr.Humanoid and plr.Humanoid.Health > 0 and plr.Character:FindFirstChild("ForceField") == nil
 end
 
 local function switchItem(tool, legit)
 	if legit then
 		local hotbarslot = getHotbarSlot(tool.Name)
 		if hotbarslot then
 			bedwars["ClientStoreHandler"]:dispatch({
 				type = "InventorySelectHotbarSlot",
 				slot = hotbarslot
 			})
 		end
 	end
 	pcall(function()
 		lplr.Character.HandInvItem.Value = tool
 	end)
 	bedwars["ClientHandler"]:Get(bedwars["EquipItemRemote"]):CallServerAsync({
 		hand = tool
 	})
 end
 
 local updateitem = Instance.new("BindableEvent")
 runcode(function()
 	local inputobj = nil
 	local tempconnection
 	tempconnection = uis.InputBegan:connect(function(input)
 		if input.UserInputType == Enum.UserInputType.MouseButton1 then
 			inputobj = input
 			tempconnection:Disconnect()
 		end
 	end)
 	connectionstodisconnect[#connectionstodisconnect + 1] = updateitem.Event:connect(function(inputObj)
 		if uis:IsMouseButtonPressed(0) then
 			game:GetService("ContextActionService"):CallFunction("block-break", Enum.UserInputState.Begin, inputobj)
 		end
 	end)
 end)
 
 local function getBestTool(block)
     local tool = nil
 	local blockmeta = bedwars["ItemTable"][block]
 	local blockType = blockmeta["block"] and blockmeta["block"]["breakType"]
 	if blockType then
 		for i,v in pairs(bedwars["getInventory"](lplr).items) do
 			local meta = bedwars["ItemTable"][v.itemType]
 			if meta["breakBlock"] and meta["breakBlock"][blockType] then
 				tool = v
 				break
 			end
 		end
 	end
     return tool
 end
 
 local function switchToAndUseTool(block, legit)
 	local tool = getBestTool(block.Name)
 	if tool and (entity.isAlive and lplr.Character:FindFirstChild("HandInvItem") and lplr.Character.HandInvItem.Value ~= tool["tool"]) then
 		if legit then
 			if getHotbarSlot(tool.itemType) then
 				bedwars["ClientStoreHandler"]:dispatch({
 					type = "InventorySelectHotbarSlot",
 					slot = getHotbarSlot(tool.itemType)
 				})
 				task.wait(0.1)
 				updateitem:Fire(inputobj)
 				return true
 			else
 				return false
 			end
 		end
 		switchItem(tool["tool"])
 		task.wait(0.1)
 	end
 end
 
 local normalsides = {}
 for i,v in pairs(Enum.NormalId:GetEnumItems()) do if v.Name ~= "Bottom" then table.insert(normalsides, v) end end
 
 local function isBlockCovered(pos)
 	local coveredsides = 0
 	for i, v in pairs(normalsides) do
 		local blockpos = (pos + (Vector3.FromNormalId(v) * 3))
 		local block = getblock(blockpos)
 		if block then
 			coveredsides = coveredsides + 1
 		end
 	end
 	return coveredsides == #normalsides
 end
 
 local function getallblocks(pos, normal)
 	local blocks = {}
 	local lastfound = nil
 	for i = 1, 20 do
 		local blockpos = (pos + (Vector3.FromNormalId(normal) * (i * 3)))
 		local extrablock = getblock(blockpos)
 		local covered = isBlockCovered(blockpos)
 		if extrablock and extrablock.Parent ~= nil then
 			if bedwars["BlockController"]:isBlockBreakable({blockPosition = blockpos}, lplr) then
 				table.insert(blocks, extrablock.Name)
 			else
 				table.insert(blocks, "unbreakable")
 				break
 			end
 			lastfound = extrablock
 			if covered == false then
 				break
 			end
 		else
 			break
 		end
 	end
 	return blocks
 end
 
 local function getlastblock(pos, normal)
 	local lastfound, lastpos = nil, nil
 	for i = 1, 20 do
 		local blockpos = (pos + (Vector3.FromNormalId(normal) * (i * 3)))
 		local extrablock, extrablockpos = getblock(blockpos)
 		local covered = isBlockCovered(blockpos)
 		if extrablock and extrablock.Parent ~= nil then
 			lastfound, lastpos = extrablock, extrablockpos
 			if covered == false then
 				break
 			end
 		else
 			break
 		end
 	end
 	return lastfound, lastpos
 end
 
 local healthbarblocktable = {
 	["blockHealth"] = -1,
 	["breakingBlockPosition"] = Vector3.zero
 }
 bedwars["breakBlock"] = function(pos, effects, normal, bypass)
     if lplr:GetAttribute("DenyBlockBreak") == true then
 		return nil
 	end
 	local block, blockpos = nil, nil
 	if not bypass then block, blockpos = getlastblock(pos, normal) end
 	if not block then block, blockpos = getblock(pos) end
     if blockpos then
         if bedwars["BlockEngineClientEvents"].DamageBlock:fire(block.Name, blockpos, block):isCancelled() then
             return nil
         end
         local blockhealthbarpos = {blockPosition = Vector3.zero}
         local blockdmg = 0
         if block and block.Parent ~= nil then
             switchToAndUseTool(block)
             blockhealthbarpos = {
                 blockPosition = blockpos
             }
             if healthbarblocktable.blockHealth == -1 or blockhealthbarpos.blockPosition ~= healthbarblocktable.breakingBlockPosition then
 				local blockdata = bedwars["BlockController"]:getStore():getBlockData(blockhealthbarpos.blockPosition)
 				if not blockdata then
 					return nil
 				end
 				local blockhealth = blockdata:GetAttribute(lplr.Name .. "_Health")
 				if blockhealth == nil then
 					blockhealth = block:GetAttribute("Health")
 				end
 				healthbarblocktable.blockHealth = blockhealth
 				healthbarblocktable.breakingBlockPosition = blockhealthbarpos.blockPosition
 			end
             blockdmg = bedwars["BlockController"]:calculateBlockDamage(lplr, blockhealthbarpos)
             healthbarblocktable.blockHealth = healthbarblocktable.blockHealth - blockdmg
             if healthbarblocktable.blockHealth < 0 then
                 healthbarblocktable.blockHealth = 0
             end
             bedwars["ClientHandlerDamageBlock"]:Get("DamageBlock"):CallServerAsync({
                 blockRef = blockhealthbarpos,
                 hitPosition = blockpos * 3,
                 hitNormal = Vector3.FromNormalId(normal)
             }):andThen(function(result)
 				if result == "failed" then
 					healthbarblocktable.blockHealth = healthbarblocktable.blockHealth + blockdmg
 				end
 			end)
             if effects then
 				bedwars["BlockBreaker"]:updateHealthbar(blockhealthbarpos, healthbarblocktable.blockHealth, block:GetAttribute("MaxHealth"), blockdmg)
                 if healthbarblocktable.blockHealth <= 0 then
                     bedwars["BlockBreaker"].breakEffect:playBreak(block.Name, blockhealthbarpos.blockPosition, lplr)
                     bedwars["BlockBreaker"].healthbarMaid:DoCleaning()
 					healthbarblocktable.breakingBlockPosition = Vector3.zero
                 else
                     bedwars["BlockBreaker"].breakEffect:playHit(block.Name, blockhealthbarpos.blockPosition, lplr)
                 end
             end
         end
     end
 end
 
 local function getEquipped()
 	local typetext = ""
 	local obj = currentinventory.inventory.hand
 	if obj then
 		local metatab = bedwars["ItemTable"][obj.itemType]
 		typetext = metatab.sword and "sword" or metatab.block and "block" or obj.itemType:find("bow") and "bow"
 	end
     return {["Object"] = obj and obj.tool, ["Type"] = typetext, ["Amount"] = obj and obj.amount}
 end
 
 local function GetAllNearestHumanoidToPosition(player, distance, amount, targetcheck, overridepos)
 	local returnedplayer = {}
 	local currentamount = 0
     if entity.isAlive then -- alive check
         for i, v in pairs(entity.entityList) do -- loop through players
             if (v.Targetable or targetcheck) and targetCheck(v) and currentamount < amount then -- checks
                 local mag = (entity.character.HumanoidRootPart.Position - v.RootPart.Position).magnitude
 				if overridepos and mag > distance then
 					mag = (overridepos - v.RootPart.Position).magnitude
 				end
                 if mag <= distance then -- mag check
                     table.insert(returnedplayer, v)
 					currentamount = currentamount + 1
                 end
             end
         end
 		for i2,v2 in pairs(collectionservice:GetTagged("Monster")) do -- monsters
 			if v2:FindFirstChild("HumanoidRootPart") and currentamount < amount and v2:GetAttribute("Team") ~= lplr:GetAttribute("Team") then -- no duck
 				local mag = (entity.character.HumanoidRootPart.Position - v2.HumanoidRootPart.Position).magnitude
 				if overridepos and mag > distance then
 					mag = (overridepos - v2.HumanoidRootPart.Position).magnitude
 				end
                 if mag <= distance then -- magcheck
                     table.insert(returnedplayer, {Player = {Name = (v2 and v2.Name or "Monster"), UserId = (v2 and v2.Name == "Duck" and 2020831224 or 1443379645)}, Character = v2, RootPart = v2.HumanoidRootPart}) -- monsters are npcs so I have to create a fake player for target info
 					currentamount = currentamount + 1
                 end
 			end
 		end
 		for i3,v3 in pairs(collectionservice:GetTagged("Drone")) do -- drone
 			if v3:FindFirstChild("HumanoidRootPart") and currentamount < amount then
 				if tonumber(v3:GetAttribute("PlayerUserId")) == lplr.UserId then continue end
 				local droneplr = players:GetPlayerByUserId(v3:GetAttribute("PlayerUserId"))
 				if droneplr and droneplr.Team == lplr.Team then continue end
 				local mag = (entity.character.HumanoidRootPart.Position - v3.HumanoidRootPart.Position).magnitude
 				if overridepos and mag > distance then
 					mag = (overridepos - v3.HumanoidRootPart.Position).magnitude
 				end
                 if mag <= distance then -- magcheck
                     table.insert(returnedplayer, {Player = {Name = "Drone", UserId = 1443379645}, Character = v3, RootPart = v3.HumanoidRootPart}) -- monsters are npcs so I have to create a fake player for target info
 					currentamount = currentamount + 1
                 end
 			end
 		end
 	end
 	return returnedplayer -- table of attackable entities
 end
 
 GetNearestHumanoidToMouse = function(player, distance, checkvis)
 	local closest, returnedplayer = distance, nil
 	if entity.isAlive then
 		for i, v in pairs(entity.entityList) do
 			if v.Targetable then
 				local vec, vis = cam:WorldToScreenPoint(v.RootPart.Position)
 				if vis and targetCheck(v) then
 					local mag = (uis:GetMouseLocation() - Vector2.new(vec.X, vec.Y)).magnitude
 					if mag <= closest then
 						closest = mag
 						returnedplayer = v
 					end
 				end
 			end
 		end
 	end
 	return returnedplayer, closest
 end
 
 local function GetNearestHumanoidToPosition(player, distance, overridepos)
 	local closest, returnedplayer = distance, nil
     if entity.isAlive then
         for i, v in pairs(entity.entityList) do
 			if v.Targetable and targetCheck(v) then
 				local mag = (entity.character.HumanoidRootPart.Position - v.RootPart.Position).magnitude
 				if overridepos and mag > distance then
 					mag = (overridepos - v.RootPart.Position).magnitude
 				end
 				if mag <= closest then
 					closest = mag
 					returnedplayer = v
 				end
 			end
         end
 	end
 	return returnedplayer
 end
 
 local function getBow()
 	local bestsword, bestswordslot, bestswordnum = nil, nil, 0
 	for i5, v5 in pairs(bedwars["getInventory"](lplr).items) do
 		if v5.itemType:find("bow") then
 			local tab = bedwars["ItemTable"][v5.itemType].projectileSource.ammoItemTypes
 			local tab2 = tab[#tab]
 			if bedwars["ProjectileMeta"][tab2].combat.damage > bestswordnum then
 				bestswordnum = bedwars["ProjectileMeta"][tab2].combat.damage
 				bestswordslot = i5
 				bestsword = v5
 			end
 		end
 	end
 	return bestsword, bestswordslot
 end
 
 local function getCustomItem(v2)
 	local realitem = v2.itemType
 	if realitem == "swords" then
 		realitem = getSword() and getSword().itemType or "wood_sword"
 	elseif realitem == "pickaxes" then
 		realitem = getPickaxe() and getPickaxe().itemType or "wood_pickaxe"
 	elseif realitem == "axes" then
 		realitem = getAxe() and getAxe().itemType or "wood_axe"
 	elseif realitem == "bows" then
 		realitem = getBow() and getBow().itemType or "wood_bow"
 	elseif realitem == "wool" then
 		realitem = getwool() or "wool_white"
 	end
 	return realitem
 end
 
 local function findItemInTable(tab, item)
 	for i,v in pairs(tab) do
 		if v.itemType then
 			local gottenitem, gottenitemnum = getItem(getCustomItem(v))
 			if gottenitem and gottenitem.itemType == item.itemType then
 				return i
 			end
 		end
 	end
 	return nil
 end
 
 local function getypos(pos)
 	local block = getblock(pos)
 	local lastfound = nil
 	if block and block.Parent ~= nil then
 		for i = 1, 20 do
 			local extrablock = getblock(pos + Vector3.new(0, i * 3, 0))
 			if extrablock then
 				lastfound = extrablock
 			else
 				if lastfound then
 					return lastfound.Position + Vector3.new(0, 2, 0)
 				else
 					return pos + Vector3.new(0, 2, 0)
 				end
 			end
 		end
 		return block.Position + Vector3.new(0, 2, 0)
 	end
 end
 
 runcode(function()
 	local function findplayers(arg)
 		for i,v in pairs(game:GetService("Players"):GetChildren()) do if v.Name:lower():sub(1, arg:len()) == arg:lower() then return v end end
 		return nil
 	end
 
 	local PlayerCrasher = {["Enabled"] = false}
 	local PlayerCrasherPower = {["Value"] = 2}
 	local PlayerCrasherDelay = {["Value"] = 2}
 	local PlayerCrasherBox = {["Value"] = ""}
 	local targetedplayer
 	PlayerCrasher = GuiLibrary["ObjectsThatCanBeSaved"]["UtilityWindow"]["Api"].CreateOptionsButton({
 		["Name"] = "PlayerCrasher",
 		["Function"] = function(callback)
 			if callback then
 				for i,v in pairs(game:GetService("ReplicatedStorage"):GetDescendants()) do
 					if (v.Name:find("arty") or v.Name:find("otification"))and v:IsA("RemoteEvent") then
 						for i2,v2 in pairs(getconnections(v.OnClientEvent)) do
 							v2:Disable()
 						end
 					end
 				end
 				spawn(function()
 					repeat
 						task.wait(3)
 						createwarning("PlayerCrasher", targetedplayer and "Crashing "..(targetedplayer.DisplayName or targetedplayer.Name) or "Player not found", 3)
 					until (not PlayerCrasher["Enabled"])
 				end)
 				spawn(function()
 					repeat
 						task.wait(PlayerCrasherDelay["Value"] == 0 and nil or PlayerCrasherDelay["Value"] / 10)
 						local plr = findplayers(PlayerCrasherBox["Value"])
 						targetedplayer = plr
 						if plr then
 							spawn(function()
 								for i = 1, PlayerCrasherPower["Value"] do
 									bedwars["LobbyClientEvents"].inviteToParty({
 										player = plr
 									})
 									bedwars["LobbyClientEvents"].leaveParty()
 								end
 							end)
 						end
 					until (not PlayerCrasher["Enabled"])
 				end)
 			end
 		end
 	})
 	PlayerCrasherBox = PlayerCrasher.CreateTextBox({
 		["Name"] = "Player",
 		["TempText"] = "player target",
 		["FocusLost"] = function(enter) end
 	})
 	PlayerCrasherPower = PlayerCrasher.CreateSlider({
 		["Name"] = "Requests per second",
 		["Min"] = 1,
 		["Max"] = 10,
 		["Default"] = 2,
 		["Function"] = function() end
 	})
 	PlayerCrasherDelay = PlayerCrasher.CreateSlider({
 		["Name"] = "Seconds per request",
 		["Min"] = 0,
 		["Max"] = 10,
 		["Default"] = 0,
 		["Function"] = function() end
 	})
 end)
 
 runcode(function()
 	local function getaccessories()
 		local count = 0
 		if isAlive() then
 			for i,v in pairs(lplr.Character:GetChildren()) do
 				if v:IsA("Accessory") then
 					count = count + 1
 				end
 			end
 		end
 		return count
 	end
 
 	local AntiCrash = {["Enabled"] = false}
 	AntiCrash = GuiLibrary["ObjectsThatCanBeSaved"]["UtilityWindow"]["Api"].CreateOptionsButton({
 		["Name"] = "AntiCrash",
 		["Function"] = function(callback)
 			if callback then
 				local cached = {}
 				game:GetService("CollectionService"):GetInstanceAddedSignal("inventory-entity"):connect(function(inv)
 					spawn(function()
 						local invitem = inv:WaitForChild("HandInvItem")
 						local funny
 						task.wait(0.2)
 						for i,v in pairs(getconnections(invitem.Changed)) do
 							funny = v.Function
 							v:Disable()
 						end
 						if funny then
 							invitem.Changed:connect(function(item)
 								if cached[inv] == nil then cached[inv] = 0 end
 								if cached[inv] >= 6 then return end
 								cached[inv] = cached[inv] + 1
 								task.delay(1, function() cached[inv] = cached[inv] - 1 end)
 								funny(item)
 							end)
 						end
 					end)
 				end)
 				for i2,inv in pairs(game:GetService("CollectionService"):GetTagged("inventory-entity")) do
 					spawn(function()
 						local invitem = inv:WaitForChild("HandInvItem")
 						local funny
 						task.wait(0.2)
 						for i,v in pairs(getconnections(invitem.Changed)) do
 							funny = v.Function
 							v:Disable()
 						end
 						if funny then
 							invitem.Changed:connect(function(item)
 								if cached[inv] == nil then cached[inv] = 0 end
 								if cached[inv] >= 6 then return end
 								cached[inv] = cached[inv] + 1
 								task.delay(1, function() cached[inv] = cached[inv] - 1 end)
 								funny(item)
 							end)
 						end
 					end)
 				end
 			end
 		end
 	})
 
 	local Crasher = {["Enabled"] = false}
 	local CrasherAutoEnable = {["Enabled"] = false}
 	local oldcrash
 	local oldplay
 	Crasher = GuiLibrary["ObjectsThatCanBeSaved"]["UtilityWindow"]["Api"].CreateOptionsButton({
 		["Name"] = "ClientCrasher",
 		["Function"] = function(callback)
 			if callback then
 				oldcrash = bedwars["GameAnimationUtil"].playAnimation
 				oldplay = bedwars["SoundManager"].playSound
 				bedwars["GameAnimationUtil"].playAnimation = function(lplr, anim, ...)
 					if anim == bedwars["AnimationType"].EQUIP_1 then
 						return
 					end
 					return oldcrash(lplr, anim, ...)
 				end
 				bedwars["SoundManager"].playSound = function(self, num, ...)
 					if num == bedwars["SoundList"].EQUIP_DEFAULT or num == bedwars["SoundList"].EQUIP_SWORD or num == bedwars["SoundList"].EQUIP_BOW then
 						return
 					end
 					return oldplay(self, num, ...)
 				end
 				local remote = bedwars["ClientHandler"]:Get(bedwars["EquipItemRemote"])["instance"]
 				local slowmode = false
 				local suc
 				task.spawn(function()
 					repeat
 						task.wait(slowmode and 2 or 15)
 						slowmode = not slowmode
 					until (not Crasher["Enabled"])
 				end)
 				task.spawn(function()
 					repeat
 						task.wait(0.2)
 						suc = pcall(function()
 							local inv = lplr.Character.InventoryFolder.Value:GetChildren()
 							local item = inv[1]
 							local item2 = inv[2]
 							if item then
 								task.spawn(function()
 									for i = 1, (slowmode and 0 or 35) do
 										game:GetService("RunService").Heartbeat:Wait()
 										task.spawn(function()
 											remote:InvokeServer({
 												hand = item
 											})
 										end)
 										task.spawn(function()
 											remote:InvokeServer({
 												hand = item2 or false
 											})
 										end)
 									end
 								end)
 							end
 						end)
 					until (not Crasher["Enabled"])
 				end)
 			else
 				bedwars["GameAnimationUtil"].playAnimation = oldcrash
 				bedwars["SoundManager"].playSound = oldplay
 				slowmode = false
 			end
 		end
 	})
 end)
 
 runcode(function()
 	local function getScaffold(vec, diagonaltoggle)
 		local realvec = Vector3.new(math.floor((vec.X / 3) + 0.5) * 3, math.floor((vec.Y / 3) + 0.5) * 3, math.floor((vec.Z / 3) + 0.5) * 3)
 		return realvec
 	end
 
 	local function getPirateFlag()
 		for i,v in pairs(collectionservice:GetTagged("block")) do
 			if v.Name == "pirate_flag" and v:GetAttribute("PlacedByUserId") == lplr.UserId then
 				return v.Position, v
 			end
 		end
 	end
 
 	local function delete(v, flag)
 		task.spawn(function()
 			pcall(function()
 				bedwars["ClientHandler"]:Get(bedwars["PirateRemote"]):CallServer({
 					flagPosition = bedwars["BlockController"]:getBlockPosition(flag) * 3,
 					itemDrop = v
 				})
 			end)
 		end)
 	end
 
 	local deletenearby = {["Enabled"] = false}
 	local pickupitemdrop = {["Enabled"] = false}
 	local deletenearbyblocks = {["Enabled"] = true}
 	local deletenearbyplayers = {["Enabled"] = false}
 	local deletenearbyplayershum = {["Enabled"] = false}
 	local deleteteammates = {["Enabled"] = false}
 	local certainblocks = {["ObjectList"] = {}}
 	deletenearby = GuiLibrary["ObjectsThatCanBeSaved"]["UtilityWindow"]["Api"].CreateOptionsButton({
 		["Name"] = "DeleteNearby",
 		["Function"] = function(callback)
 			if callback then
 				local flag, flagobj = getPirateFlag()
 				if getItem("pirate_flag") or flag then
 					if entity.isAlive then
 						if not flag then
 							bedwars["placeBlock"](getScaffold(entity.character.HumanoidRootPart.Position - (entity.character.HumanoidRootPart.CFrame.lookVector * 4)), "pirate_flag")
 							flag, flagobj = getPirateFlag()
 						end
 						task.delay(0.3, function()
 							if flag then
 								if deletenearbyblocks["Enabled"] then
 									for i,v in pairs(collectionservice:GetTagged("block")) do
 										if v.Name ~= "pirate_flag" and (v.Position - flag).Magnitude <= 60 then
 											if i % 100 == 0 then
 												task.wait(0.3)
 											end
 											if #certainblocks["ObjectList"] <= 0 or table.find(certainblocks["ObjectList"], v.Name) then
 												delete(v, flag)
 											end
 										end
 									end
 								end
 								for i,v in pairs(entity.entityList) do
 									if (v.RootPart.Position - flag).Magnitude <= 60 then
 										if (not deleteteammates["Enabled"]) and (not v.Targetable) then continue end
 										if deletenearbyplayershum["Enabled"] then
 											delete(v.RootPart, flag)
 										end
 										if deletenearbyplayers["Enabled"] then
 											delete(v.Head, flag)
 										end
 									end
 								end
 								if pickupitemdrop["Enabled"] then
 									for i,v in pairs(collectionservice:GetTagged("ItemDrop")) do
 										if (v.Position - flag).Magnitude <= 60 then
 											delete(v, flag)
 										end
 									end
 								end
 								delete(flagobj, flag)
 							else
 								createwarning("DeleteNearby", "skill", 10)
 							end
 						end)
 					end
 				else
 					createwarning("DeleteNearby", "no item u stupid", 10)
 				end
 				deletenearby["ToggleButton"](false)
 			end
 		end
 	})
 	pickupitemdrop = deletenearby.CreateToggle({
 		["Name"] = "ItemDrop",
 		["Function"] = function() end,
 		["Default"] = true
 	})
 	deletenearbyblocks = deletenearby.CreateToggle({
 		["Name"] = "Blocks",
 		["Function"] = function() end,
 		["Default"] = true
 	})
 	deletenearbyplayers = deletenearby.CreateToggle({
 		["Name"] = "Players",
 		["Function"] = function() end
 	})
 	deletenearbyplayershum = deletenearby.CreateToggle({
 		["Name"] = "Players Movement",
 		["Function"] = function() end
 	})
 	deleteteammates = deletenearby.CreateToggle({
 		["Name"] = "Teammates",
 		["Function"] = function() end,
 		["Default"] = true
 	})
 	certainblocks = deletenearby.CreateTextList({
 		["Name"] = "NukerList",
 		["TempText"] = "block (tesla_trap)",
 		["AddFunction"] = function() end
 	})
 end)
 
 local bypassed = false
 runcode(function()
 	local anticheatdisabler = {["Enabled"] = false}
 	local anticheatdisablerauto = {["Enabled"] = false}
 	local anticheatdisablerconnection
 	local anticheatdisablerconnection2
 	anticheatdisabler = GuiLibrary["ObjectsThatCanBeSaved"]["UtilityWindow"]["Api"].CreateOptionsButton({
 		["Name"] = "FloatDisabler",
 		["Function"] = function(callback)
 			if callback then
 				local balloonitem = getItem("balloon")
 				if balloonitem then
 					local oldfunc3 = bedwars["BalloonController"].hookBalloon
 					local oldfunc4 = bedwars["BalloonController"].enableBalloonPhysics
 					local oldfunc5 = bedwars["BalloonController"].deflateBalloon
 					bedwars["BalloonController"].inflateBalloon()
 					bedwars["BalloonController"].enableBalloonPhysics = function() end
 					bedwars["BalloonController"].deflateBalloon = function() end
 					bedwars["BalloonController"].hookBalloon = function(Self, plr, attachment, balloon)
 						if tostring(plr) == lplr.Name then
 							balloon:WaitForChild("Balloon").CFrame = CFrame.new(0, -1995, 0)
 							balloon.Balloon:ClearAllChildren()
 							local threadidentity = syn and syn.set_thread_identity or setidentity
 							threadidentity(7)
 							spawn(function()
 								wait(0.5)
 								createwarning("AnticheatDisabler", "Disabled Anticheat!", 5)
 								bypassed = true
 							end)
 							threadidentity(2)
 							bedwars["BalloonController"].hookBalloon = oldfunc3
 							bedwars["BalloonController"].enableBalloonPhysics = oldfunc4
 						end
 					end
 				end
 				anticheatdisabler["ToggleButton"](true)
 			end
 		end
 	})
 	anticheatdisablerauto = anticheatdisabler.CreateToggle({
 		["Name"] = "Auto Disable",
 		["Function"] = function(callback)
 			if callback then
 				anticheatdisablerconnection = repstorage.Inventories.DescendantAdded:connect(function(p3)
 					if p3.Parent.Name == lplr.Name then
 						if p3.Name == "balloon" then
 							repeat task.wait() until getItem("balloon")
 							anticheatdisabler["ToggleButton"](false)
 						end
 					end
 				end)
 			else
 				if anticheatdisablerconnection then
 					anticheatdisablerconnection:Disconnect()
 				end
 			end
 		end,
 	})
 end)