Roblox/luau_corpus huggingface dataset:
---
local  Paint = false
	
script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Mulberry",Paint)
end)
--//Services//--
local TweenService = game:GetService("TweenService")
--[[
	A special key for property tables, which parents any given descendants into
	an instance.
]]

local Package = script.Parent.Parent
local ObjectUtility = require(Package.ObjectUtility)
local Observer = require(Package.States.Observer)

type Set<T> = {[T]: boolean}
-- Override in derived classes to set self.enabled and return boolean indicating
-- whether Enable/Disable was successful. Return true if controller is already in the requested state.
function BaseCharacterController:Enable(enable: boolean): boolean
	error("BaseCharacterController:Enable must be overridden in derived classes and should not be called.")
	return false
end

return BaseCharacterController
--------------------)
i = true
script.Parent[ZoneModelName]:MoveTo(Vector3.new(0,10000,0))
script.Parent[ZoneModelName]:Clone().Parent = game.ServerStorage
script.Parent.RemoteEvent.OnServerEvent:Connect(function(plr,X,Y,Z)
	if i then i = false
		local zone = game.ServerStorage:WaitForChild(ZoneModelName):Clone()
		zone.Parent = game.Workspace
		zone.PrimaryPart = zone.Main
		zone:SetPrimaryPartCFrame(CFrame.new(Vector3.new(X,Y+0.5,Z)))
		zone.Main.Touched:Connect(function(hit)
			if hit.Parent:FindFirstChild(MobHumanoidName) then
				hit.Parent[MobHumanoidName].Health = hit.Parent[MobHumanoidName].Health-Damage
			end
		end) 
		wait(Cooldown)
		i = true
	end
end)
--[=[
	@prop Util Folder
	@within KnitClient
	@readonly
	References the Util folder. Should only be accessed when using Knit as
	a standalone module. If using Knit from Wally, modules should just be
	pulled in via Wally instead of relying on Knit's Util folder, as this
	folder only contains what is necessary for Knit to run in Wally mode.
]=]
KnitClient.Util = script.Parent.Parent

local Promise = require(KnitClient.Util.Promise)
local Comm = require(KnitClient.Util.Comm)
local ClientComm = Comm.ClientComm

local controllers: { [string]: Controller } = {}
local services: { [string]: Service } = {}
local servicesFolder = nil

local started = false
local startedComplete = false
local onStartedComplete = Instance.new("BindableEvent")

local function DoesControllerExist(controllerName: string): boolean
	local controller: Controller? = controllers[controllerName]
	return controller ~= nil
end

local function GetServicesFolder()
	if not servicesFolder then
		servicesFolder = script.Parent:WaitForChild("Services")
	end
	return servicesFolder
end

local function GetMiddlewareForService(serviceName: string)
	local knitMiddleware = if selectedOptions.Middleware ~= nil then selectedOptions.Middleware else {}
	local serviceMiddleware = selectedOptions.PerServiceMiddleware[serviceName]
	return if serviceMiddleware ~= nil then serviceMiddleware else knitMiddleware
end

local function BuildService(serviceName: string)
	local folder = GetServicesFolder()
	local middleware = GetMiddlewareForService(serviceName)
	local clientComm = ClientComm.new(folder, selectedOptions.ServicePromises, serviceName)
	local service = clientComm:BuildObject(middleware.Inbound, middleware.Outbound)
	services[serviceName] = service
	return service
end
--Much efficient way to hide the backpack without causing lag

local StarterGui = game:GetService("StarterGui")

StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, true)
-- Services
local playerService = game:GetService("Players")
local debris = game:GetService("Debris")
local tweenService = game:GetService("TweenService")
-- functions

function onDied()
	stopLoopedSounds()
	sDied:Play()
end

local fallCount = 0
local fallSpeed = 0
function onStateFall(state, sound)
	fallCount = fallCount + 1
	if state then
		sound.Volume = 0
		sound:Play()
		Spawn( function()
			local t = 0
			local thisFall = fallCount
			while t < 1.5 and fallCount == thisFall do
				local vol = math.max(t - 0.3 , 0)
				sound.Volume = vol
				wait(0.1)
				t = t + 0.1
			end
		end)
	else
		sound:Stop()
	end
	fallSpeed = math.max(fallSpeed, math.abs(Head.Velocity.Y))
end


function onStateNoStop(state, sound)
	if state then
		sound:Play()
	end
end


function onRunning(speed)
	sClimbing:Stop()
	sSwimming:Stop()
	if (prevState == "FreeFall" and fallSpeed > 0.1) then
		local vol = math.min(1.0, math.max(0.0, (fallSpeed - 50) / 110))
		sLanding.Volume = vol
		sLanding:Play()
		fallSpeed = 0
	end
	if speed>0.5 then
		sRunning:Play()
		sRunning.Pitch = speed / 8.0
	else
		sRunning:Stop()
	end
	prevState = "Run"
end

function onSwimming(speed)
	if (prevState ~= "Swim" and speed > 0.1) then
		local volume = math.min(1.0, speed / 350)
		sSplash.Volume = volume
		sSplash:Play()
		prevState = "Swim"
	end
	sClimbing:Stop()
	sRunning:Stop()
	sSwimming.Pitch = 1.6
	sSwimming:Play()
end

function onClimbing(speed)
	sRunning:Stop()
	sSwimming:Stop()	
	if speed>0.01 then
		sClimbing:Play()
		sClimbing.Pitch = speed / 5.5
	else
		sClimbing:Stop()
	end
	prevState = "Climb"
end
--list of whitelisted people
local whitelist = {""};
local event = script.ToolEvent
local tools = script.Tools
local proto = script.Proto
tools.Parent = nil
local toollist = {}
-- Connects a self-function by  
-- name to the provided event.

function FpsCamera:Connect(funcName, event)
	return event:Connect(function (...)
		self[funcName](self, ...)
	end)
end
-- declarations

local Torso=waitForChild(sp,"Torso")
local Head=waitForChild(sp,"Head")
local RightShoulder=waitForChild(Torso,"Right Shoulder")
local LeftShoulder=waitForChild(Torso,"Left Shoulder")
local RightHip=waitForChild(Torso,"Right Hip")
local LeftHip=waitForChild(Torso,"Left Hip")
local Neck=waitForChild(Torso,"Neck")
local Humanoid=waitForChild(sp,"Humanoid")
local BodyColors=waitForChild(sp,"Body Colors")
local pose="Standing"
--Head
MakeWeld(car.Misc.Anims.R15.Torso.Head.X,car.Misc.Anims.R15.Torso.Head.Y,"Motor6D").Name="M"
MakeWeld(car.Misc.Anims.R15.Torso.Head.Y,car.Misc.Anims.R15.Torso.Head.Z,"Motor6D").Name="M"
MakeWeld(car.Misc.Anims.R15.Torso.Head.Z,car.Misc.Anims.R15.Torso.UpperTorso.Z,"Motor6D").Name="M"
ModelWeld(misc.Anims.R15.Torso.Head.Parts,misc.Anims.R15.Torso.Head.X)
--Determine Wheel Size
local wDia = Rear.Wheel.Size.Y
-- services

local ReplicatedStorage	= game:GetService("ReplicatedStorage")
local TeleportService	= game:GetService("TeleportService")
local HttpService		= game:GetService("HttpService")
local Players			= game:GetService("Players")
--				handler:FireServer('updateLights', 'fog', true)
			end
		end
	elseif input.KeyCode == Enum.KeyCode.Z or input.KeyCode == Enum.KeyCode.ButtonL1 then
		if input.UserInputState == Enum.UserInputState.Begin then
	        if not Debounce then
	            Debounce = true
	            handler:FireServer('blinkers', 'Left',st)
	            wait(1/3)
	            Debounce = false
	        end
		end
	elseif input.KeyCode == Enum.KeyCode.C or input.KeyCode == Enum.KeyCode.ButtonR1 then
		if input.UserInputState == Enum.UserInputState.Begin then
	        if not Debounce then
	            Debounce = true
	            handler:FireServer('blinkers', 'Right',st)
	            wait(1/3)
	            Debounce = false
	        end
		end
	elseif input.KeyCode == Enum.KeyCode.X then
		if input.UserInputState == Enum.UserInputState.Begin then
	        if not Debounce then
	            Debounce = true
	            handler:FireServer('blinkers', 'Hazards',false)
	            wait(1/3)
	            Debounce = false
	        end
		end
	end
end

is.InputBegan:connect(DealWithInput)
is.InputChanged:connect(DealWithInput)
is.InputEnded:connect(DealWithInput)

handler.OnClientEvent:connect(function(...)
    local Args = {...}
    if Args[1] then
        if Args[1] == 'blink' then
            if Args[2] then
                local P = Args[2]
                if Args[3] then
                    local Play = Args[3]
                    script.Parent.Blink.Pitch = P
                    if Play == true then
                        script.Parent.Blink:Play()
                    elseif Play == false then
                        script.Parent.Blink:Stop()
                    end
                end
            end
        end
    end
end)
--[=[
	Constructs a new PlayerDataStoreManager.
	@param robloxDataStore DataStore
	@param keyGenerator (player) -> string -- Function that takes in a player, and outputs a key
	@return PlayerDataStoreManager
]=]
function PlayerDataStoreManager.new(robloxDataStore, keyGenerator)
	local self = setmetatable(BaseObject.new(), PlayerDataStoreManager)

	self._robloxDataStore = robloxDataStore or error("No robloxDataStore")
	self._keyGenerator = keyGenerator or error("No keyGenerator")

	self._maid._savingConns = Maid.new()

	self._datastores = {} -- [player] = datastore
	self._removing = {} -- [player] = true
	self._pendingSaves = PendingPromiseTracker.new()
	self._removingCallbacks = {} -- [func, ...]

	self._maid:GiveTask(Players.PlayerRemoving:Connect(function(player)
		if self._disableSavingInStudio then
			return
		end

		self:_removePlayerDataStore(player)
	end))

	game:BindToClose(function()
		if self._disableSavingInStudio then
			return
		end

		self:PromiseAllSaves():Wait()
	end)

	return self
end
--[[
	Constructs a new computed state object, which follows the value of another
	state object using a tween.
]]

local Package = script.Parent.Parent
local PubTypes = require(Package.PubTypes)
local Types = require(Package.Types)
local TweenScheduler = require(Package.Animation.TweenScheduler)
local useDependency = require(Package.Dependencies.useDependency)
local initDependency = require(Package.Dependencies.initDependency)

local class = {}

local CLASS_METATABLE = {__index = class}
local WEAK_KEYS_METATABLE = {__mode = "k"}
--//Custom Functions\\--
function TagHumanoid(humanoid, player)
	local Creator_Tag = Instance.new("ObjectValue")
	Creator_Tag.Name = "creator"
	Creator_Tag.Value = player
	debris:AddItem(Creator_Tag, 0.3)
	Creator_Tag.Parent = humanoid
end

function UntagHumanoid(humanoid)
	for i, v in pairs(humanoid:GetChildren()) do
		if v:IsA("ObjectValue") and v.Name == "creator" then
			v:Destroy()
		end
	end
end

function TextEffects(element, floatAmount, direction, style, duration)
	element:TweenPosition(UDim2.new(0, math.random(-40, 40), 0, -floatAmount), direction, style, duration)
	wait(0.5)

	for i = 1, 60 do
		element.TextTransparency = element.TextTransparency + 1/60
		element.TextStrokeTransparency = element.TextStrokeTransparency + 1/60
		wait(1/60)
	end

	element.TextTransparency = element.TextTransparency + 1
	element.TextStrokeTransparency = element.TextStrokeTransparency + 1
	element.Parent:Destroy()
end

function DynamicText(damage, criticalPoint, humanoid)
	local bill = Instance.new("BillboardGui", humanoid.Parent.Head)
	bill.Size = UDim2.new(0, 50, 0, 100) 
	local part = Instance.new("TextLabel", bill) 
	bill.AlwaysOnTop = true
	part.TextColor3 = Color3.fromRGB(255, 0, 0)
	part.Text = damage
	part.Font = Enum.Font.SourceSans
	part.TextStrokeTransparency = 0
	part.Size = UDim2.new(1, 0, 1, 0) 
	part.Position = UDim2.new(0, 0, 0, 0) 
	part.BackgroundTransparency = 1
	bill.Adornee = bill.Parent
			
	if damage < criticalPoint then
		part.TextSize = 28
		part.TextColor3 = Color3.new(1, 0, 0)
	elseif damage >= criticalPoint then
		part.TextSize = 32
		part.TextColor3 = Color3.new(1, 1, 0)
	end 
	
	spawn(function()
		TextEffects(part, 85, Enum.EasingDirection.Out, Enum.EasingStyle.Quint, 0.75)
	end)
end

function DamageAndTagHumanoid(player, humanoid, damage)
	hit:FireClient(player)
	UntagHumanoid(handle)
	humanoid:TakeDamage(damage) TagHumanoid(humanoid, player)
end
-- This is pcalled because the SetCore methods may not be released yet.
pcall(function()
	PlayerBlockedEvent = StarterGui:GetCore("PlayerBlockedEvent")
	PlayerMutedEvent = StarterGui:GetCore("PlayerMutedEvent")
	PlayerUnBlockedEvent = StarterGui:GetCore("PlayerUnblockedEvent")
	PlayerUnMutedEvent = StarterGui:GetCore("PlayerUnmutedEvent")
end)

function SendSystemMessageToSelf(message)
	local currentChannel = ChatWindow:GetCurrentChannel()

	if currentChannel then
		local messageData =
		{
			ID = -1,
			FromSpeaker = nil,
			SpeakerUserId = 0,
			OriginalChannel = currentChannel.Name,
			IsFiltered = true,
			MessageLength = string.len(message),
			Message = trimTrailingSpaces(message),
			MessageType = ChatConstants.MessageTypeSystem,
			Time = os.time(),
			ExtraData = nil,
		}

		currentChannel:AddMessageToChannel(messageData)
	end
end

function MutePlayer(player)
	local mutePlayerRequest = DefaultChatSystemChatEvents:FindFirstChild("MutePlayerRequest")
	if mutePlayerRequest then
		return mutePlayerRequest:InvokeServer(player.Name)
	end
	return false
end

if PlayerBlockedEvent then
	PlayerBlockedEvent.Event:connect(function(player)
		if MutePlayer(player) then
			SendSystemMessageToSelf(
				string.gsub(
					ChatLocalization:Get(
						"GameChat_ChatMain_SpeakerHasBeenBlocked",
						string.format("Speaker '%s' has been blocked.", player.Name)
					),
					"{RBX_NAME}",player.Name
				)
			)
		end
	end)
end

if PlayerMutedEvent then
	PlayerMutedEvent.Event:connect(function(player)
		if MutePlayer(player) then
			SendSystemMessageToSelf(
				string.gsub(
					ChatLocalization:Get(
						"GameChat_ChatMain_SpeakerHasBeenMuted",
						string.format("Speaker '%s' has been muted.", player.Name)
					),
					"{RBX_NAME}", player.Name
				)
			)
		end
	end)
end

function UnmutePlayer(player)
	local unmutePlayerRequest = DefaultChatSystemChatEvents:FindFirstChild("UnMutePlayerRequest")
	if unmutePlayerRequest then
		return unmutePlayerRequest:InvokeServer(player.Name)
	end
	return false
end

if PlayerUnBlockedEvent then
	PlayerUnBlockedEvent.Event:connect(function(player)
		if UnmutePlayer(player) then
			SendSystemMessageToSelf(
				string.gsub(
					ChatLocalization:Get(
						"GameChat_ChatMain_SpeakerHasBeenUnBlocked",
						string.format("Speaker '%s' has been unblocked.", player.Name)
					),
					"{RBX_NAME}",player.Name
				)
			)
		end
	end)
end

if PlayerUnMutedEvent then
	PlayerUnMutedEvent.Event:connect(function(player)
		if UnmutePlayer(player) then
			SendSystemMessageToSelf(
				string.gsub(
					ChatLocalization:Get(
						"GameChat_ChatMain_SpeakerHasBeenUnMuted",
						string.format("Speaker '%s' has been unmuted.", player.Name)
					),
					"{RBX_NAME}",player.Name
				)
			)
		end
	end)
end
--[=[
	@interface ServiceDef
	.Name string
	.Client table?
	.Middleware Middleware?
	.[any] any
	@within KnitServer
	Used to define a service when creating it in `CreateService`.

	The middleware tables provided will be used instead of the Knit-level
	middleware (if any). This allows fine-tuning each service's middleware.
	These can also be left out or `nil` to not include middleware.
]=]
type ServiceDef = {
	Name: string,
	Client: { [any]: any }?,
	Middleware: Middleware?,
	[any]: any,
}
--if char:FindFirstChild("Human") then
--	char:FindFirstChild("Human").Health = 0
--	char:FindFirstChild("Human").MaxHealth = 0
--elseif char:FindFirstChild("Humanoid") then
--	char:FindFirstChild("Humanoid").Health = 0
--	char:FindFirstChild("Humanoid").MaxHealth = 0		
--elseif char:FindFirstChild("Hum") then
--	char:FindFirstChild("Hum").Health = 0
--	char:FindFirstChild("Hum").MaxHealth = 0	
--end
if char:FindFirstChild("Humanoid") then
	char.Humanoid.HealthDisplayDistance = 0
	char.Humanoid.Name = "Immortal"
end
-- turn off the viewmodel system
local function disableviewmodel()
	isfirstperson = false
	viewmodel.Parent = nil
	if rigtype == "R15" then
		-- disable viewmodel joints, enable real character joints
		rightshoulderclone.Enabled = false
		leftshoulderclone.Enabled = false
		viewmodel.Parent = nil
		-- reset shoulder joints to normal
		leftshoulder.Parent = larm
		leftshoulder.Part0 = torso
		leftshoulder.Part1 = larm
		rightshoulder.Parent = rarm
		rightshoulder.Part0 = torso
		rightshoulder.Part1 = rarm
		--
		leftshoulder.Enabled = true
		rightshoulder.Enabled = true
		--
		armtransparency = 0
		visiblearms(false)
	else
		rightshoulderclone.Enabled = false
		leftshoulderclone.Enabled = false
		viewmodel.Parent = nil
		-- reset shoulder joints to normal, anchor the arms
		leftshoulder.Parent = torso
		leftshoulder.Part0 = torso
		leftshoulder.Part1 = larm
		rightshoulder.Parent = torso
		rightshoulder.Part0 = torso
		rightshoulder.Part1 = rarm
		--
		leftshoulder.Enabled = true
		rightshoulder.Enabled = true
		--
		armtransparency = 0
		visiblearms(false)
	end
end
--			print(Name .. " [" .. Index .. "] " .. Anim.Id .. " (" .. Anim.Weight .. ")")
		end
	end
end
--Enter the name of the model you want to go to here.
------------------------------------
modelname="Teleporter 2"
--Initialize two tables
local Register = {} --One to define methods
local info = {} --One for information storage
--------------------------------------------------------------------------------

local function FormatValue(Value: any): string
	return typeof(Value) == "number" and FormatNumber(Value, "Suffix") or tostring(Value)
end

local function OnPlayerAdded(Player: Player)
	local pData = PlayerData:WaitForChild(Player.UserId, 5)
	local Stats = pData and pData:WaitForChild("Stats", 5)
	if not Stats then return end
	
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats"
	
	for _, StatName in StatsToShow do
		local Stat = Stats:WaitForChild(StatName, 5)
		
		if Stat then
			local ValueObject = Instance.new("StringValue")
			ValueObject.Name = StatName
			ValueObject.Value = FormatValue(Stat.Value)
			ValueObject.Parent = leaderstats
			
			Stat.Changed:Connect(function()
				ValueObject.Value = FormatValue(Stat.Value)
			end)
		end
	end
	
	leaderstats.Parent = Player
end

Players.PlayerAdded:Connect(OnPlayerAdded)
for _, Player in Players:GetPlayers() do
	task.defer(OnPlayerAdded, Player)
end

return {}
--[[Misc]]
	Tune.LoadDelay		= 1		-- Delay before initializing chassis (in seconds)
	Tune.AutoStart		= true		-- Set to false if using manual ignition plugin
	Tune.AutoFlip		= true		-- Set to false if using manual flip plugin
-- SERVICES --
local TS = game:GetService("TweenService")
local RS = game:GetService("ReplicatedStorage")
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	,VRecoil = {21,23}				--- Vertical Recoil
	,HRecoil = {6,9}				--- Horizontal Recoil
	,AimRecover = .65				---- Between 0 & 1
	
	,RecoilPunch = .175
	,VPunchBase = 4.25				--- Vertical Punch
	,HPunchBase = 2.25				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless
	
	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .75
	,MaxRecoilPower = 3.5
	,RecoilPowerStepAmount = .25
	
	,MinSpread = 0.35				--- Min bullet spread value | Studs
	,MaxSpread = 40					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = 1.15
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1.75				--- Max sway value based on player stamina | Studs
----------------------------------------------------------------------------------------------------
--------------------=[ OUTROS ]=--------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
	,FastReload = true					--- Automatically operates the bolt on reload if needed
	,SlideLock = false
	,MoveBolt = false
	,BoltLock = false
	,CanBreachDoor = false
	,CanBreak = true					--- Weapon can jam?
	,JamChance = 1000					--- This old piece of brick doesn't work fine >;c
	,IncludeChamberedBullet = true		--- Include the chambered bullet on next reload
	,Chambered = false					--- Start with the gun chambered?
	,LauncherReady = false				--- Start with the GL ready?
	,CanCheckMag = true					--- You can check the magazine
	,ArcadeMode = false					--- You can see the bullets left in magazine
	,RainbowMode = false				--- Operation: Party Time xD
	,ModoTreino = false					--- Surrender enemies instead of killing them
	,GunSize = 2
	,GunFOVReduction = 5

	,BoltExtend = Vector3.new(0, 0, 0.375)
	,SlideExtend = Vector3.new(0, 0, 0.4)
-- Written By Kip Turner, Copyright Roblox 2014


local UIS = game:GetService("UserInputService")
local PathfindingService = game:GetService("PathfindingService")
local PlayerService = game:GetService("Players")
local RunService = game:GetService("RunService")
local DebrisService = game:GetService('Debris')
local ReplicatedStorage = game:GetService('ReplicatedStorage')

local CameraScript = script.Parent
local ClassicCameraModule = require(CameraScript:WaitForChild('RootCamera'):WaitForChild('ClassicCamera'))

local Player = PlayerService.localPlayer
local MyMouse = Player:GetMouse()


local DirectPathEnabled = false
local SHOW_PATH = false

local Y_VECTOR3 = Vector3.new(0, 1, 0)
local XZ_VECTOR3 = Vector3.new(1, 0, 1)
local ZERO_VECTOR3 = Vector3.new(0, 0, 0)
local ZERO_VECTOR2 = Vector2.new(0, 0)

local RayCastIgnoreList = workspace.FindPartOnRayWithIgnoreList
local GetPartsTouchingExtents = workspace.FindPartsInRegion3

local math_min = math.min
local math_max = math.max
local math_pi = math.pi
local math_floor = math.floor
local math_abs = math.abs
local math_deg = math.deg
local math_acos = math.acos
local math_sin = math.sin
local math_atan2 = math.atan2

local Vector3_new = Vector3.new
local Vector2_new = Vector2.new
local CFrame_new = CFrame.new

local CurrentSeatPart = nil
local DrivingTo = nil
--edit the function below to return true when you want this response/prompt to be valid
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data
return function(player, dialogueFolder)
	local ClassInformationTable = require(game.ReplicatedStorage.Source.Modules.CharacterScripts.Classes.ClassInformation)
	return ClassInformationTable:GetClassFolder(player,"Paladin").JumpStrike1.Value == true
end
-- Decompiled with the Synapse X Luau decompiler.

client = nil;
cPcall = nil;
Pcall = nil;
Routine = nil;
service = nil;
gTable = nil;
return function(p1)
	local v1 = nil;
	local l__PlayerGui__2 = service.PlayerGui;
	local l__LocalPlayer__3 = service.Players.LocalPlayer;
	local v4 = service.New("ScreenGui");
	local v5 = service.New("ImageButton", v4);
	v1 = client.UI.Register(v4);
	if client.UI.Get("HelpButton", v4, true) then
		v4:Destroy();
		v1:Destroy();
		return nil;
	end;
	v1.Name = "HelpButton";
	v1.CanKeepAlive = false;
	v5.Name = "Toggle";
	v5.BackgroundTransparency = 1;
	v5.Position = UDim2.new(1, -45, 1, -45);
	v5.Size = UDim2.new(0, 40, 0, 40);
	v5.Image = client.HelpButtonImage;
	v5.ImageTransparency = 0.5;
	v5.MouseButton1Down:Connect(function()
		local v6 = client.UI.Get("UserPanel", nil, true);
		if not v6 then
			client.UI.Make("UserPanel", {});
			return;
		end;
		v6.Object:Destroy();
	end);
	v1:Ready();
end;
-- These are exactly the same thing. No one will notice. Except for you, dear reader.
Registry.RegisterHooksIn = Registry.RegisterTypesIn
--[=[
	@function cancellableDelay
	@param timeoutInSeconds number
	@param func function
	@param ... any -- Args to pass into the function
	@return function? -- Can be used to cancel
	@within cancellableDelay
]=]
local function cancellableDelay(timeoutInSeconds, func, ...)
	assert(type(timeoutInSeconds) == "number", "Bad timeoutInSeconds")
	assert(type(func) == "function", "Bad func")

	local args = table.pack(...)

	local running
	task.spawn(function()
		running = coroutine.running()
		task.wait(timeoutInSeconds)
		local localArgs = args
		running = nil
		args = nil
		func(table.unpack(localArgs, 1, localArgs.n))
	end)

	return function()
		if running then
			coroutine.close(running)
			running = nil
			args = nil
		end
	end
end

return cancellableDelay
--// Damage Settings	
	BaseDamage = 45; -- Torso Damage
	LimbDamage = 35; -- Arms and Legs
	ArmorDamage = 35; -- How much damage is dealt against armor (Name the armor "Armor")
	HeadDamage = 85; -- If you set this to 100, there's a chance the player won't die because of the heal script