Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[[Transmission]]


	Tune.TransModes		= {"Auto", "Semi", "Manual"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
	
	--Gear Ratios
	Tune.FinalDrive		= 2.74			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
-- << VARIABLES >>


local memberships = {
	nbc = Enum.MembershipType.None;
	bc = Enum.MembershipType.BuildersClub;
	tbc = Enum.MembershipType.TurboBuildersClub;
	obc = Enum.MembershipType.OutrageousBuildersClub;
	premium = Enum.MembershipType.Premium;
	prem = Enum.MembershipType.Premium;
	};
--if UIS.TouchEnabled then
--	ContextActionService:BindAction("Spell", handleAction, true, Enum.KeyCode.V) --, Enum.KeyCode.ButtonR1)
--	ContextActionService:SetPosition("Spell", UDim2.new(1, -70, 0, 10))
--	ContextActionService:SetTitle("Spell", "SPELL")
--	ContextActionService:SetImage("Spell", "rbxassetid://2022683074")
--end
--Tune


OverheatSpeed = .2 --How fast the car will overheat
CoolingEfficiency = .05 --How fast the car will cool down
RunningTemp = 85 --In degrees

Fan = true --Cooling fan
FanTemp = 100 --At what temperature the cooling fan will activate
FanSpeed = .03
FanVolume = .2

BlowupTemp = 130 --At what temperature the engine will blow up

GUI = true --GUI temperature gauge
-- Function to update frame visibility based on the settings


local function updateFrameVisibility()
	UISpeed.Visible = ClipSettings.settings.uiSpeedSetting
	Volume.Visible = ClipSettings.settings.volume
	Wallpapers.Visible = ClipSettings.settings.wallpaper
	Notifications.Visible = ClipSettings.settings.notifications
	ClipWellbeing.Visible = ClipSettings.settings.wellbeing
	-- Add more visibility settings for other frames based on your configuration
end
--[[
	
	Calculates angle of reach  distance, altitude, velocity)
	
	Functions.AngleOfReach(
		distance,				<-- |REQ| 	Distance
		altitude,				<-- |REQ| 	Altitude
		velocity,				<-- |REQ| 	Velocity
	)
		
--]]




return function(distance, altitude, velocity)
	local gravity = game.Workspace.Gravity
	
	--
	local theta = math.atan((velocity ^ 2 + math.sqrt(velocity ^ 4 -gravity * (gravity * distance ^ 2 + 2 * altitude * velocity ^ 2))) / (gravity * distance))
	
	--
	if theta ~= theta then
		theta = math.pi/4
	end
	
	--
	return(theta)
end
-----------------------------------------------------------------------------------------------



script.Parent:WaitForChild("Gear")
script.Parent:WaitForChild("Speed")
script.Parent:WaitForChild("Needle")

local player=game.Players.LocalPlayer
local mouse=player:GetMouse()

local car = script.Parent.Parent.Parent.Car.Value
car.DriveSeat.HeadsUpDisplay = false

local _Tune = require(car["A-Chassis Tune"])

local _pRPM = _Tune.PeakRPM
local _lRPM = _Tune.Redline

local currentUnits = 1
local revEnd = math.ceil(_lRPM/1000)

script.Parent.Parent.Parent.Values.Gear.Changed:connect(function()
	local gearText = script.Parent.Parent.Parent.Values.Gear.Value
	if gearText == 0 then gearText = "N"
	elseif gearText == -1 then gearText = "R"
	end
	script.Parent.Gear.Text = gearText
end)

script.Parent.Parent.Parent.Values.RPM.Changed:connect(function()
	script.Parent.Needle.Rotation = 230 * math.min(1,script.Parent.Parent.Parent.Values.RPM.Value / (revEnd*1000))
end)

script.Parent.Parent.Parent.Values.Velocity.Changed:connect(function(property)
	script.Parent.Speed.TextLabel.Text = math.floor(UNITS[currentUnits].scaling*script.Parent.Parent.Parent.Values.Velocity.Value.Magnitude)
end)

wait(.1)
--local Energia = PastaVar.Energia


local Ferido = PastasStan.Ferido
local Caido = PastasStan.Caido

local Ragdoll = require(game.ReplicatedStorage.ACS_Engine.Modulos.Ragdoll)
local configuracao = require(game.ReplicatedStorage.ACS_Engine.ServerConfigs.Config)

local debounce = false
-- Figure out the next scene to load when one finishes.


EventSequencer.onOrchestrationFinished:Connect(function(endedSceneName)	
	if endedSceneName == PSV_SCENE.Name then
		-- PreShowVenue just ended. Now load the first scene in the show.
		local scene1 = SHOW_SCENES[1]
		if scene1 then
			EventSequencer.loadScene(scene1.Name)
		else
			warn("There are no scenes in the show list to load.")
			loadPreShowVenue()
		end
	else
		-- Find the ended-scene in the show list so that we know what to load next.
		for i,scene in ipairs(SHOW_SCENES) do
			if scene.Name == endedSceneName then
				if i < #SHOW_SCENES then
					-- Load the next scene.
					EventSequencer.loadScene(SHOW_SCENES[i+1].Name)
				else
					-- Last scene in the show ended. Load the PreShowVenue.
					loadPreShowVenue()
				end
			end
		end
	end
end)
--[[game.ReplicatedStorage.Events.SafeZones.Respawn.OnServerEvent:Connect(function(plr)
	--print(plr.Name,"Received")
	plr:LoadCharacter()
end)]]



game.ReplicatedStorage.Events.SafeZones.SafeZoneEnter.OnServerEvent:Connect(function(plr,bool,isSafe)
	--[[if isSafe == nil then
		isSafe = bool
	end
	plr.PlayerData.SafeZone.inSafeZone.Value = bool
	plr.PlayerData.SafeZone.isSafe.Value = isSafe]]
	
end)
--//Configs


local REAPPEAR_TIME = 2 --//Once the part becomes invisible, after this amount of seconds it'll appear again
local FADE_TIME = 3 --//How long it takes for the part to become fully visible/invisible

local function Animate()
	if isAnimating then return end

	isAnimating = true

	local targetProperties = {}
	targetProperties.Transparency = 1

	local disappearFade = tweenService:Create(script.Parent, TweenInfo.new(FADE_TIME), targetProperties)

	disappearFade:Play()
	disappearFade.Completed:Wait()

	wait(REAPPEAR_TIME)

	targetProperties.Transparency = 0

	local appearFade = tweenService:Create(script.Parent, TweenInfo.new(FADE_TIME), targetProperties)

	appearFade:Play()
	appearFade.Completed:Wait()

	isAnimating = false
end

script.Parent.Touched:Connect(Animate)
--DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!


local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.CookieSword -- Change "Sword" to the name of your tool, make sure your tool is in ServerStorage

hitPart.Touched:Connect(function(hit)
	if debounce == true then
		if hit.Parent:FindFirstChild("Humanoid") then
			local plr = game.Players:FindFirstChild(hit.Parent.Name)
			if plr then
				debounce = false
				hitPart.BrickColor = BrickColor.new("Bright red")
				tool:Clone().Parent = plr.Backpack
				wait(3) -- Change "3" to however long you want the player to have to wait before they can get the tool again
				debounce = true
				hitPart.BrickColor = BrickColor.new("Bright green")
			end
		end
	end
end)
-- ================================================================================
-- PUBLIC FUNCTIONS
-- ================================================================================


function ArrowGuide.new(targets)
	local arrow = Instance.new("Part")
	arrow.Name = "Arrow"
	arrow.Size = Vector3.new(2, 1, 5)
	arrow.Color = Color3.new(252/255, 1/255, 7/255) -- Red
	arrow.CanCollide = false
	
	local mesh = Instance.new("SpecialMesh")
	mesh.MeshId = "http://www.roblox.com/asset/?id=14656345" -- Arrow mesh
	mesh.Scale = Vector3.new(0.2, 0.4, 0.2)
	mesh.Parent = arrow
	
	arrow.Position = character.PrimaryPart.Position + Vector3.new(0, character.PrimaryPart.Size.Y + OFFSET, 0)
	
	local arrowWeld = Instance.new("Weld")
	arrowWeld.Part0 = arrow
	arrowWeld.Part1 = character.PrimaryPart
	
	arrow.Parent = character
	
	RunService:BindToRenderStep("UpdateDirection", 1, function()
		if targets == 0 then return end
	
		local checkpoint = targets[1]:FindFirstChild("Checkpoint")
		local closestDistance = (arrow.Position - checkpoint.Position).magnitude
		local closestTarget = checkpoint
	
		-- Find nearest target
		for _, target in ipairs(targets) do
			local hit = target:FindFirstChild("Hit")
			if (not hit or hit.Value == false) then
				checkpoint = target:FindFirstChild("Checkpoint")
				local distance = (arrow.Position - checkpoint.Position).magnitude
				if distance < closestDistance then
					closestTarget = checkpoint
				end
			end
		end
	
		-- Point arrow at nearest target
		local newPos = character.PrimaryPart.Position + Vector3.new(0, character.PrimaryPart.Size.Y + OFFSET, 0)
		arrow.CFrame = CFrame.new(newPos, closestTarget.Position)
	end)
	
	return arrow
end -- ArrowGuide.new()
-- module



local INPUT	= {}

function INPUT.GetActionInput(self, action)
	local input	= "nil"
	
	if actions[action] then
		local primary, secondary	= actions[action].Primary, actions[action].Secondary
		
		if primary then
			input	= primary.Name
		elseif secondary then
			input	= secondary.Name
		end
	end
	
	if REPLACEMENTS[input] then
		input	= REPLACEMENTS[input]
	end
	
	return string.upper(input)
end

function INPUT.GetAllActionInputs(self, action)
	local inputP, inputS	= "nil", "nil"
	
	if actions[action] then
		local primary, secondary	= actions[action].Primary, actions[action].Secondary
		
		if primary then
			inputP	= primary.Name
		end
		if secondary then
			inputS	= secondary.Name
		end
	end
	
	if REPLACEMENTS[inputP] then
		inputP	= REPLACEMENTS[inputP]
	end
	if REPLACEMENTS[inputS] then
		inputS	= REPLACEMENTS[inputS]
	end
	
	return string.upper(inputP), string.upper(inputS)
end

if not initialized then
	local keybindChanged	= Instance.new("BindableEvent")
	INPUT.KeybindChanged	= keybindChanged.Event
	
	actionBegan	= Instance.new("BindableEvent")
	actionEnded	= Instance.new("BindableEvent")
	
	INPUT.ActionBegan	= actionBegan.Event
	INPUT.ActionEnded	= actionEnded.Event
	
	-- register actions
	
	local playerData	= PLAYER_DATA:WaitForChild(PLAYER.Name)
	local keybinds		= playerData:WaitForChild("Keybinds")
	
	local function Register(action, bindP, bindS)
		local primary, secondary
		if bindP then
			local A, B	= string.match(bindP, "(.-)%.(.+)")
			
			if A and B then
				primary	= Enum[A][B]
			end
		end
		if bindS then
			local A, B	= string.match(bindS, "(.-)%.(.+)")
			
			if A and B then
				secondary	= Enum[A][B]
			end
		end
		
		RegisterAction(action, primary, secondary)
		keybindChanged:Fire(action)
	end
	
	local function Handle(keybind)
		local action	= keybind.Name
		local bind		= keybind.Value
		
		if string.match(bind, ";") then
			local bindP, bindS	= string.match(bind, "(.-);(.+)")
			
			if bindP and bindS then
				Register(action, bindP, bindS)
			elseif bindP then
				Register(action, bindP)
			elseif bindS then
				Register(action, nil, bindS)
			end
		else
			Register(action, bind)
		end
	end
	
	keybinds.ChildAdded:connect(function(keybind)
		keybind.Changed:connect(function()
			Handle(keybind)
		end)
		
		RunService.Stepped:wait()
		Handle(keybind)
	end)
	
	repeat
		RunService.Stepped:wait()
	until #keybinds:GetChildren() > 0
	
	for _, keybind in pairs(keybinds:GetChildren()) do
		keybind.Changed:connect(function()
			Handle(keybind)
		end)
		
		Handle(keybind)
	end
	
	initialized			= true
end

return INPUT
--[[Transmission]]


	Tune.TransModes		= {"Auto", "Semi"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
	
	--Gear Ratios
	Tune.FinalDrive		= 3.9			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
		--[[ 7 ]]		0.50		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
-- Compiled with roblox-ts v2.1.0
--[[
	*
	* Represents a connection to a signal.
]]


local Connection
do
	Connection = setmetatable({}, {
		__tostring = function()
			return "Connection"
		end,
	})
	Connection.__index = Connection
	function Connection.new(...)
		local self = setmetatable({}, Connection)
		return self:constructor(...) or self
	end
	function Connection:constructor(signal, fn)
		self.signal = signal
		self.Connected = true
		self._fn = fn
	end
	function Connection:Disconnect()
		if not self.Connected then
			return nil
		end
		self.Connected = false
		if self.signal._handlerListHead == self then
			self.signal._handlerListHead = self._next
		else
			local prev = self.signal._handlerListHead
			while prev and prev._next ~= self do
				prev = prev._next
			end
			if prev then
				prev._next = self._next
			end
		end
	end
	function Connection:Destroy()
		self:Disconnect()
	end
end
--Don't worry about the rest of the code, except for line 25.


game.Players.PlayerAdded:connect(function(player)
local leader = Instance.new("Folder",player)
leader.Name = "leaderstats"
local Cash = Instance.new("IntValue",leader)
Cash.Name = stat
Cash.Value = ds:GetAsync(player.UserId) or startamount
ds:SetAsync(player.UserId, Cash.Value)
Cash.Changed:connect(function()
ds:SetAsync(player.UserId, Cash.Value)
end)
end)

game.Players.PlayerRemoving:connect(function(player)
ds:SetAsync(player.UserId, player.leaderstats.Money.Value) --Change "Points" to the name of your leaderstat.
end)
--/////////--
--Utilities--
--/////////--



local function isInRegion(Region, Position)
	local Extents = Region.Size /2
	
	local Offset = GetOffset(Region, Position)
	return Offset.X < Extents.X and Offset.Y < Extents.Y and Offset.Z < Extents.Z
end

local function isInRegionIgnoreY(Region, Position)
	local Extents = Region.Size /2
	
	local Offset = GetOffset(Region, Position)
	return Offset.X < Extents.X and Offset.Z < Extents.Z
end
-- Uber l33t maths to calcluate the angle needed to throw a projectile a distance, given the altitude of the end point and the projectile's velocity


function AngleOfReach(distance, altitude, velocity)
	local gravity = workspace.Gravity
	local theta = math.atan((velocity^2 + math.sqrt(velocity^4 -gravity*(gravity*distance^2 + 2*altitude*velocity^2)))/(gravity*distance))
	if theta ~= theta then
		theta = math.pi/4
	end
	return(theta)
end
--~strict
--[[
	Packages up the internals of Roact and exposes a public API for it.
]]



local GlobalConfig = require(script.GlobalConfig)
local createReconciler = require(script.createReconciler)
local createReconcilerCompat = require(script.createReconcilerCompat)
local RobloxRenderer = require(script.RobloxRenderer)
local strict = require(script.strict)
local Binding = require(script.Binding)

local robloxReconciler = createReconciler(RobloxRenderer)
local reconcilerCompat = createReconcilerCompat(robloxReconciler)

local Roact = strict({
	Component = require(script.Component),
	createElement = require(script.createElement),
	createFragment = require(script.createFragment),
	oneChild = require(script.oneChild),
	PureComponent = require(script.PureComponent),
	None = require(script.None),
	Portal = require(script.Portal),
	createRef = require(script.createRef),
	forwardRef = require(script.forwardRef),
	createBinding = Binding.create,
	joinBindings = Binding.join,
	createContext = require(script.createContext),

	Change = require(script.PropMarkers.Change),
	Children = require(script.PropMarkers.Children),
	Event = require(script.PropMarkers.Event),
	Ref = require(script.PropMarkers.Ref),

	mount = robloxReconciler.mountVirtualTree,
	unmount = robloxReconciler.unmountVirtualTree,
	update = robloxReconciler.updateVirtualTree,

	reify = reconcilerCompat.reify,
	teardown = reconcilerCompat.teardown,
	reconcile = reconcilerCompat.reconcile,

	setGlobalConfig = GlobalConfig.set,

	-- APIs that may change in the future without warning
	UNSTABLE = {},
})

return Roact
--[=[
	Observes all descendants that match a predicate as a brio

	@param parent Instance
	@param predicate ((value: Instance) -> boolean)? -- Optional filter
	@return Observable<Brio<Instance>>
]=]


function RxInstanceUtils.observeDescendantsBrio(parent, predicate)
	assert(typeof(parent) == "Instance", "Bad parent")
	assert(type(predicate) == "function" or predicate == nil, "Bad predicate")

	return Observable.new(function(sub)
		local maid = Maid.new()

		local function handleDescendant(descendant)
			if not predicate or predicate(descendant) then
				local value = Brio.new(descendant)
				maid[descendant] = value
				sub:Fire(value)
			end
		end

		maid:GiveTask(parent.DescendantAdded:Connect(handleDescendant))
		maid:GiveTask(parent.DescendantRemoving:Connect(function(descendant)
			maid[descendant] = nil
		end))

		for _, descendant in pairs(parent:GetDescendants()) do
			handleDescendant(descendant)
		end

		return maid
	end)
end
--Rescripted by Luckymaxer
--Updated for R15 avatars by StarWars



Character = script.Parent
Humanoid = Character:FindFirstChild("Humanoid")
Head = Character:FindFirstChild("Head")
Torso = Character:FindFirstChild("Torso") or Character:FindFirstChild("UpperTorso")

Players = game:GetService("Players")
Debris = game:GetService("Debris")

Player = Players:GetPlayerFromCharacter(Character)

Sounds = {
	Explosion = script:WaitForChild("Explosion"),
}

function DestroyScript()
	Debris:AddItem(script, 0.5)
	script:Destroy()
end

if not Head or not Torso or not Humanoid or Humanoid.Health == 0 or not Player then
	DestroyScript()
	return
end

Duration = 30

Humanoid.WalkSpeed = (16 * 1.6)

Sparkles = Instance.new("Sparkles")
Sparkles.SparkleColor = Color3.new(0.8, 0, 0.8)
Sparkles.Enabled = true
Debris:AddItem(Sparkles, Duration)
Sparkles.Parent = Torso

Count = script:FindFirstChild("CoffeeCount")
if not Count then
	Count = Instance.new("IntValue")
	Count.Name = "CoffeeCount"
	Count.Value = 1
	Count.Parent = script
else
	if (Count.Value > 3) then
		if (math.random() > 0.5) then

			ExplosionSound = Sounds.Explosion:Clone()
			Debris:AddItem(ExplosionSound, 5)
			ExplosionSound.Parent = Head
			ExplosionSound:Play()

			local Explosion = Instance.new("Explosion")
			Explosion.ExplosionType = Enum.ExplosionType.NoCraters
			Explosion.BlastRadius = 2
			Explosion.BlastPressure = 1000000
			Explosion.Position = Torso.Position
			Explosion.Parent = game:GetService("Workspace")
			
		end
	end
	Count.Value = (Count.Value + 1)
end

wait(Duration)

Humanoid.WalkSpeed = 16

DestroyScript()
-- Returns the Levenshtein distance between the two given strings


local utf8_len = utf8.len -- I'm not even sure if this is faster localized, thanks Luau and your massive inconsistency.
local utf8_codes = utf8.codes

local function Levenshtein(String1, String2)
	if String1 == String2 then
		return 0
	end

	local Length1 = utf8_len(String1)
	local Length2 = utf8_len(String2)

	if Length1 == 0 then
		return Length2
	elseif Length2 == 0 then
		return Length1
	end

	local Matrix = {} -- Would love to use table.create for this, but it starts at 0.
	for Index = 0, Length1 do
		Matrix[Index] = {[0] = Index}
	end

	for Index = 0, Length2 do
		Matrix[0][Index] = Index
	end

	local Index = 1
	local IndexSub1

	for _, Code1 in utf8_codes(String1) do
		local Jndex = 1
		local JndexSub1

		for _, Code2 in utf8_codes(String2) do
			local Cost = Code1 == Code2 and 0 or 1
			IndexSub1 = Index - 1
			JndexSub1 = Jndex - 1

			Matrix[Index][Jndex] = math.min(Matrix[IndexSub1][Jndex] + 1, Matrix[Index][JndexSub1] + 1, Matrix[IndexSub1][JndexSub1] + Cost)
			Jndex = Jndex + 1
		end

		Index = Index + 1
	end

	return Matrix[Length1][Length2]
end

local function SortResults(A, B)
	return A.Distance < B.Distance
end

local function FuzzySearch(String, ArrayOfStrings, MaxResults)
	local Results = table.create(#ArrayOfStrings)

	for Index, Value in ipairs(ArrayOfStrings) do
		Results[Index] = {
			String = Value;
			Distance = Levenshtein(String, Value);
		}
	end

	table.sort(Results, SortResults)
	return Results
end

return FuzzySearch
--- Runs embedded commands and replaces them


function Util.RunEmbeddedCommands(dispatcher, str)
	str = encodeCommandEscape(str)

	local results = {}
	-- We need to do this because you can't yield in the gsub function
	for text in str:gmatch("$(%b{})") do
		local doQuotes = true
		local commandString = text:sub(2, #text-1)

		if commandString:match("^{.+}$") then -- Allow double curly for literal replacement
			doQuotes = false
			commandString = commandString:sub(2, #commandString-1)
		end

		results[text] = Util.RunCommandString(dispatcher, commandString)

		if doQuotes then
			if results[text]:find("%s") or results[text] == "" then
				results[text] = string.format("%q", results[text])
			end
		end
	end

	return decodeCommandEscape(str:gsub("$(%b{})", results))
end
-- [[ Dummiez's Data Store Score Board ]]
-- This script updates the Data store with the values from the remote function.



wait(1)

local score = game:GetService("DataStoreService"):GetOrderedDataStore(script.DataStore.Value)
	
function script.UploadScore.OnServerInvoke(player)
	local inv = player:FindFirstChild(script.Original.Value)
	score:SetAsync(player.Name, inv:FindFirstChild(script.Score.Value).Value)
end
--= Variables =--



local camera = game.Workspace.CurrentCamera

local TweeningService = game:GetService("TweenService")

local UIS = game:GetService('UserInputService')

local Bar = script.Parent:WaitForChild('STMBackground'):WaitForChild('Bar')

local player = game.Players.LocalPlayer

local NormalWalkSpeed = 10
local NewWalkSpeed = 30

local power = 10

local sprinting = false

repeat wait() until game.Players.LocalPlayer.Character

local character = player.Character

local Humanoid = character.Humanoid
local runninganim = Humanoid:LoadAnimation(script.Parent.Runninganim)
--Made by Luckymaxer



Character = script.Parent
Humanoid = Character:FindFirstChild("Humanoid")

Debris = game:GetService("Debris")

if Humanoid then
	
	for i, v in pairs(Humanoid:GetChildren()) do
		if v:IsA("Animator") then
			v:Destroy()
		end
	end
	
	function SetHumanoid()
		Humanoid.AutoRotate = false
		Humanoid.PlatformStand = false
		Humanoid.WalkSpeed = 0
		Humanoid.Jump = false
		Humanoid:ChangeState(Enum.HumanoidStateType.Freefall)
	end
	
	function UnequipTools()
		Humanoid:UnequipTools()
	end	
	
	HumanoidChanged = Humanoid.Changed:connect(SetHumanoid)
	ToolEquipped = Character.ChildAdded:connect(UnequipTools)
	
	SetHumanoid()
	UnequipTools()
	
end

wait(10)

for i, v in pairs({HumanoidChanged, ToolEquipped}) do
	if v then
		v:disconnect()
	end
end

Humanoid.AutoRotate = true
Humanoid.PlatformStand = false
Humanoid.WalkSpeed = 16

script:Destroy()