Roblox/luau_corpus huggingface dataset:
--[[**
	Runs the specified function in a separate thread, without yielding the current thread. This doesn't obscure errors like spawn or coroutines do, but it does share the similar small delay that spawn has. Also allows passing arguments like coroutines do.

	@param [t:callback] Function The function you are executing.
	@param [variant] ... The optional arguments you can pass that the function will execute with.
	@returns [void]
**--]]
function Scheduler.SpawnDelayed(Function, ...)
	local Length = select("#", ...)
	if Length > 0 then
		local Arguments = {...}
		local Connection

		Connection = Heartbeat:Connect(function()
			Connection:Disconnect()
			Function(table.unpack(Arguments, 1, Length))
		end)
	else
		local Connection

		Connection = Heartbeat:Connect(function()
			Connection:Disconnect()
			Function()
		end)
	end
end
--[=[
	Detects if a dictionary has a certain value.
	
	```lua
	local Array = { "Has", "this", "thing" }
	
	print(TableKit.HasValue(Array, "Has")) -- prints true
	```
	
	@within TableKit
	@param tbl table
	@param value unknown
	@return boolean
]=]
function TableKit.HasValue(tbl: { [unknown]: unknown }, value: unknown): boolean
	for _, v in tbl do
		if v == value then
			return true
		end
	end
	return false
end
-- Locals --
local R = script.Parent.Red
local O = script.Parent.Orange
local G = script.Parent.Green
-- ROBLOX MOVED: expect/utils.lua
local function subsetEquality(object: any, subset: any): boolean | nil
	-- subsetEquality needs to keep track of the references
	-- it has already visited to avoid infinite loops in case
	-- there are circular references in the subset passed to it
	local function subsetEqualityWithContext(seenReferences_: { [any]: boolean }?)
		local seenReferences = seenReferences_ or {}

		return function(object_: any, subset_: any): boolean | nil
			if not isObjectWithKeys(subset_) then
				return nil
			end

			return Array.every(Object.keys(subset_), function(key)
				if isObjectWithKeys(subset_[key]) then
					if seenReferences[subset_[key]] then
						--[[
								ROBLOX TODO: (ADO-1217) replace the line below
								once Map/Set functionality is implemented

								return equals(localObject[key], localSubset[key], {iterableEquality})
							]]
						return equals(object_[key], subset_[key], { iterableEquality })
					end
					seenReferences[subset_[key]] = true
				end
				local result = object_ ~= nil
					and hasPropertyInObject(object_, key)
					and equals(object_[key], subset_[key], {
						--[[
									ROBLOX TODO: (ADO-1217) uncomment the line
									iterableEquality,
								]]
						subsetEqualityWithContext(seenReferences),
					})
				-- The main goal of using seenReference is to avoid
				-- circular node on tree.
				-- It will only happen within a parent and its child, not a
				-- node and nodes next to it (same level)
				-- We should keep the reference for a parent and its child
				-- only
				-- Thus we should delete the reference immediately so that
				-- it doesn't interfere other nodes within the same level
				-- on tree.
				seenReferences[subset_[key]] = nil
				return result
			end)
		end
	end

	return subsetEqualityWithContext()(object, subset)
end
-- How long punished players have to wait before they regain
-- physics control.
config.PunishmentDuration = 5
-----------------------------------------ONLY EDIT THESE VALUES!!!!!-----------------------------------------
-----!Instructions!-----
--Make sure you have a part in the gun named Barrel, it is where the raycast will shoot from.--
--Just place this script into any gun and edit the values below.--
--Editting anything else will risk breaking it.--
------------------------
Damage = 20
SPS = 13 -- Shots Per Second, gives a limit of how fast the gun shoots.
Recoil = 5 -- [1-10] [1 = Minigun, 10 = Sniper]
WallShoot = false -- Shoots through walls.
GH = false -- [True = RB can't hurt RB.] [False = RB can hurt RB.]
BulletColor = "Cool yellow" -- Any Brickcolor will work.
Flash = true
-- 0-9
for Index = 48, 57 do
	table.insert(Alphabet, Index)
end

table.insert(Alphabet, 43) -- +
table.insert(Alphabet, 47) -- /

for Index, Character in ipairs(Alphabet) do
	Indexes[Character] = Index
end

local Base64 = {}

local bit32_rshift = bit32.rshift
local bit32_lshift = bit32.lshift
local bit32_band = bit32.band
-- Todo: Migrate UserInputService.ModalEnabled to GuiService.TouchControlsEnabled when it works since that's the future replacement API
function UserInputController:getMobileTouchGuiEnabled()
	return not self.UserInputService.ModalEnabled
end
--// initialize manual-click right button //--
script.Parent.RightButton.Button.MouseButton1Click:connect(function(right)
	moveRight()
end)
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

Cooldown = 10 -- cooldown for use of the tool again

BoneModelName = "Overwrite trap" -- name the zone model

HumanoidName = "Humanoid"-- the name of player or mob u want to damage
-- << MODIFY DATA IN GAME >>

local player = game.Players.ValiantWind
local main = _G.HDAdminMain
main:GetModule("DataStore"):ChangeStat(player, "Donor", true)



return module
--//Controller//--
for _, Giver in pairs(ToolGivers:GetChildren()) do
	if Giver:IsA("BasePart") or Giver:IsA("Model") then
		local Trigger = Giver.ProximityPrompt
		
		Trigger.Triggered:Connect(function(Player)
			local Backpack = Player.Backpack
			
			if not Backpack:FindFirstChild(Giver.Name) then
				local Tool = Tools:FindFirstChild(Giver.Name)
				
				if Tool then
					Tool:Clone().Parent = Backpack
					
				end
			end
		end)
	end
end
-- Only change the number below! --
local jumpCooldown = 0.5 -- Change this to the cooldown for every jump (decimals accepted)
-- DOUBLE JUMPING SCRIPT --

local UserInputService = game:GetService("UserInputService")
local localPlayer = game.Players.LocalPlayer
local character
local humanoid
 
local canDoubleJump = false
local hasDoubleJumped = false
local oldPowerlocal TIME_BETWEEN_JUMPS = 0.1
local DOUBLE_JUMP_POWER_MULTIPLIER = 1.5

function onJumpRequest()
	if not character or not humanoid or not character:IsDescendantOf(workspace) or
	 humanoid:GetState() == Enum.HumanoidStateType.Dead then
		return
	end
 
	if canDoubleJump and not hasDoubleJumped then
		hasDoubleJumped = true
		humanoid.JumpPower = oldPower * DOUBLE_JUMP_POWER_MULTIPLIER		humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
	end
end
 
local function characterAdded(newCharacter)
	character = newCharacter
	humanoid = newCharacter:WaitForChild("Humanoid")
	hasDoubleJumped = false
	canDoubleJump = false
	oldPower = humanoid.JumpPower 
	humanoid.StateChanged:connect(function(old, new)
		if new == Enum.HumanoidStateType.Landed then
			canDoubleJump = false
			hasDoubleJumped = false
			humanoid.JumpPower = oldPower		elseif new == Enum.HumanoidStateType.Freefall then
			wait(TIME_BETWEEN_JUMPS)			canDoubleJump = true
		end
	end)
end
 
if localPlayer.Character then
	characterAdded(localPlayer.Character)
end
 
localPlayer.CharacterAdded:connect(characterAdded)
UserInputService.JumpRequest:connect(onJumpRequest)
--[=[
	@prop Stopped Signal
	@within Component

	Fired when an instance of a component is stopped.

	```lua
	local MyComponent = Component.new({Tag = "MyComponent"})

	MyComponent.Stopped:Connect(function(component) end)
	```
]=]

local CollectionService = game:GetService("CollectionService")
local RunService = game:GetService("RunService")

local Signal = require(script.Parent.Signal)
local Trove = require(script.Parent.Trove)

local IS_SERVER = RunService:IsServer()
local DEFAULT_ANCESTORS = {workspace, game:GetService("Players")}


local renderId = 0
local function NextRenderName(): string
	renderId += 1
	return "ComponentRender" .. tostring(renderId)
end


local function InvokeExtensionFn(component, extensionList, fnName: string)
	for _,extension in ipairs(extensionList) do
		local fn = extension[fnName]
		if type(fn) == "function" then
			fn(component)
		end
	end
end


local function ShouldConstruct(component, extensionList): boolean
	for _,extension in ipairs(extensionList) do
		local fn = extension.ShouldConstruct
		if type(fn) == "function" then
			local shouldConstruct = fn(component)
			if not shouldConstruct then
				return false
			end
		end
	end
	return true
end
-- Critically damped spring class for fluid motion effects
local Spring = {} do
	Spring.__index = Spring

	-- Initialize to a given undamped frequency and default position
	function Spring.new(freq, pos)
		return setmetatable({
			freq = freq,
			goal = pos,
			pos = pos,
			vel = 0,
		}, Spring)
	end

	-- Advance the spring simulation by `dt` seconds
	function Spring:step(dt: number)
		local f: number = self.freq*2*math.pi
		local g: Vector3 = self.goal
		local p0: Vector3 = self.pos
		local v0: Vector3 = self.vel

		local offset = p0 - g
		local decay = math.exp(-f*dt)

		local p1 = (offset*(1 + f*dt) + v0*dt)*decay + g
		local v1 = (v0*(1 - f*dt) - offset*(f*f*dt))*decay

		self.pos = p1
		self.vel = v1

		return p1
	end
end

CameraUtils.Spring = Spring
--------------------------------------------------------------------------------
-- Piercing raycasts

local function getCollisionPoint(origin, dir)
	local originalSize = #blacklist
	repeat
		local hitPart, hitPoint = workspace:FindPartOnRayWithIgnoreList(
			ray(origin, dir), blacklist, false, true
		)

		if hitPart then
			if hitPart.CanCollide and not Collection:HasTag(hitPart,"IgnoreCamera") then
				eraseFromEnd(blacklist, originalSize)
				return hitPoint, true
			end
			blacklist[#blacklist + 1] = hitPart
		end
	until not hitPart

	eraseFromEnd(blacklist, originalSize)
	return origin + dir, false
end
-- Component
-- Stephen Leitnick
-- November 26, 2021

type AncestorList = { Instance }
-- Battery0 --

Battery.Interaction.Touched:Connect(function(hit)
	if hit.Parent:IsA("Tool") and hit.Parent.Name == ToolRequired then
		Battery.Battery0.Transparency = 0
		if game.ReplicatedStorage.ItemSwitching.Value == true then
			hit.Parent:Destroy()
		end
		Battery.Interaction.HintGUI2.Tool1:Destroy()
		Battery.Parent.SoundPart.Insert:Play()
		Battery.Parent.Light1.Color = Color3.fromRGB(0,255,0)
		LocksLeft.Value = LocksLeft.Value - 1
		Battery.Battery1Script.Disabled = false
		Battery.Battery0Script.Disabled = true
	end
end)

Battery.Interaction.ClickDetector.MouseClick:Connect(function(plr)
	if plr.Backpack:FindFirstChild(Battery.ToolRequired.Value) then
		Battery.Battery0.Transparency = 0
		if game.ReplicatedStorage.ItemSwitching.Value == true then
			plr.Backpack:FindFirstChild(ToolRequired):Destroy()
		end
		Battery.Interaction.HintGUI2.Tool1:Destroy()
		Battery.Parent.SoundPart.Insert:Play()
		Battery.Parent.Light1.Color = Color3.fromRGB(0,255,0)
		LocksLeft.Value = LocksLeft.Value - 1
		Battery.Battery1Script.Disabled = false
		Battery.Battery0Script.Disabled = true
	end
end)
--Thanks for this, Zeph. Hope you don't mind that I essentially stole this :P

local IntWait = 0.01

local MD3 = script.Parent.Misc.TK.WPR.SS.Motor


while true do
	wait()
	if script.Parent.DriveSeat.Wipers.Value == true then
		if MD3.CurrentAngle == 0  then
			wait(IntWait)
	
			MD3.DesiredAngle = -2.78
		elseif MD3.CurrentAngle < -2.76 then
	
			MD3.DesiredAngle = 0			
		end
	end
end
--[[Susupension]]
Tune.SusEnabled		= true		-- Sets whether suspension is enabled for PGS
-- Returns whether the inputted status passes the TextFilter, otherwise also returns an error
function UpdateProfileRemoteFunction.OnServerInvoke(playerFiring, playerSelected, statusText)
	local filteredStatus = filterText(statusText, playerSelected.UserId, playerFiring.UserId)
	if filteredStatus == statusText then
		playerFiring:SetAttribute("status", filteredStatus)
		return { success = true }
	else
		return {
			success = false,
			error = Constants.ErrorMsgs.InappropriateStatus,
		}
	end
end
--[[
	Function called upon entering the state
]]
function PlayerDead.enter(stateMachine, playerComponent)
	wait(3)

	if stateMachine.can("startSpectating") then
		stateMachine:startSpectating()
	end
end
--Main--
P.PlayerAdded:Connect(function(Player)
	Player.CharacterAdded:Connect(function(Character)
		if MS:UserOwnsGamePassAsync(Player.UserId,GamepassID.Value) == true then
			local NewTool = Tool.Value:Clone()
			NewTool.Parent = Player.Backpack
		end
	end)
end)
--Explode into a bunch of star fragments! (Very pretty)

print("Starlight finisher activated!")

local Character = script.Parent

local Debris = (game:FindService("Debris") or game:GetService("Debris"))

local Torso = (Character:FindFirstChild("Torso") or Character:FindFirstChild("UpperTorso"))

if Torso then
	pcall(function()
		local Sparkle = script["Sparkle_Large_Blue"]
		Sparkle.Parent = Torso
		Sparkle:Emit(75)
	end)
	pcall(function()
		local ExplodeSound = script["ExplodeSound"]
		ExplodeSound.Parent = Torso
		ExplodeSound:Play()
	end)
end

for _,v in pairs(Character:GetDescendants()) do
	pcall(function()
		v.Transparency = 1
	end)
	
	pcall(function()
		v.Anchored = true
		v.CanCollide = false
		v.Parent = workspace
		
		Debris:AddItem(v, 3)
	end)
	
end
--		child.C0 = CFrame.new(0,-0.6,0)*CFrame.fromEulerAnglesXYZ(-(math.pi/2),0,0) --// Reposition player
		if child.Part1.Name == "HumanoidRootPart" then
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and (not player.PlayerGui:FindFirstChild("Screen")) then --// The part after the "and" prevents multiple GUI's to be copied over.
				GUI.CarSeat.Value = script.Parent --// Puts a reference of the seat in this ObjectValue, now you can use this ObjectValue's value to find the car directly.
				GUI:Clone().Parent = player.PlayerGui --// Compact version
				script.Parent.Parent.Body.Lights.RunL.Material = "Neon"
				script.Parent.Parent.Body.Lights.RunR.Material = "Neon"
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = true
				script.Parent.Parent.Body.Dash.Screen2.G.Enabled = true
			end
		end
	end
end)

script.Parent.ChildRemoved:connect(function(child)
	if child:IsA("Weld") then
		if child.Part1.Name == "HumanoidRootPart" then
			game.Workspace.CurrentCamera.FieldOfView = 70
			player = game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			if player and player.PlayerGui:FindFirstChild("SS3") then
				player.PlayerGui:FindFirstChild("SS3"):Destroy()
				script.Parent.Parent.Body.Lights.RunL.Material = "SmoothPlastic"
				script.Parent.Parent.Body.Lights.RunR.Material = "SmoothPlastic"
				script.Parent.Parent.Body.Dash.Screen.G.Enabled = false
				script.Parent.Parent.Body.Dash.Screen2.G.Enabled = false
			end
		end
	end	
end)
--						if _TMode == "Auto" and _CGear==-1 then throt = _GThrot end
						local tq = _OutTorque
						
						--Apply AWD Vectoring
						if _Tune.Config == "AWD" then
							local bias = (_Tune.TorqueVector+1)/2
							if v.Name=="FL" or v.Name=="FR" then
								tq = tq*(1-bias)
							elseif v.Name=="RL" or v.Name=="RR" then
								tq = tq*bias
							end
						end
						
						--Apply TCS
						local tqTCS = 1
						if _TCS then
							tqTCS = 1-(math.min(math.max(0,math.abs(v.RotVelocity.Magnitude*(v.Size.x/2) - v.Velocity.Magnitude)-_Tune.TCSThreshold)/_Tune.TCSGradient,1)*(1-(_Tune.TCSLimit/100)))
						end
						if tqTCS < 1 then
							_TCSActive = true
						end
						
						--Update Forces
						local dir = 1
						if _CGear==-1 then dir = -1 end
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*_OutTorque*(1+(v.RotVelocity.Magnitude/60)^1.15)*throt*tqTCS*diffMult*on
						v["#AV"].angularvelocity=Ref*aRef*_spLimit*dir
					else
						v["#AV"].maxTorque=Vector3.new()
						v["#AV"].angularvelocity=Vector3.new()
					end
					
				--Brakes
				else
					local brake = (_GBrake + _CBrake)
--

if Health_Bar == true then
	game.StarterGui:SetCoreGuiEnabled(1,true)
elseif Health_Bar == false then
	game.StarterGui:SetCoreGuiEnabled(1,false)
end
-- double rd_dbl_basic(byte f1..8)
-- @f1..8 - The 8 bytes composing a little endian double
local function rd_dbl_basic(f1, f2, f3, f4, f5, f6, f7, f8)
	local sign = bit.rshift(f8, 7)
	local exp = bit.lshift(bit.band(f8, 0x7F), 4) + bit.rshift(f7, 4)
	local frac = bit.band(f7, 0x0F) * 2 ^ 48
	local normal = 1

	frac = frac + (f6 * 2 ^ 40) + (f5 * 2 ^ 32) + (f4 * 2 ^ 24) + (f3 * 2 ^ 16) + (f2 * 2 ^ 8) + f1 -- help

	if exp == 0 then
		if frac == 0 then
			return sign * 0
		else
			normal = 0
			exp = 1
		end
	elseif exp == 0x7FF then
		if frac == 0 then
			return sign * (1 / 0)
		else
			return sign * (0 / 0)
		end
	end

	return (-1) ^ sign * 2 ^ (exp - 1023) * (normal + frac / 2 ^ 52)
end
-- Set initial colors
light_L.BrickColor = lightColor_off
light_R.BrickColor = lightColor_off
brake_L.BrickColor = brakeColor_off
brake_R.BrickColor = brakeColor_off
smoke.Enabled = false
fire.Enabled = false

print("JeepScript: connecting events...")
seat.ChildAdded:connect(seatChildAddedHandler)
seat.ChildRemoved:connect(seatChildRemovedHandler)
seat.Changed:connect(seatChangedHandler)
print("JeepScript: events connected.")

while true do
	-- Every 15 seconds, poll if jeep has turned upside down.  If true, then flip back upright.
	if(vehicleSeatBack.CFrame.lookVector.y <= 0.707) then
		print("Jeep is flipped.  Flipping right side up...")
		gyro.cframe = CFrame.new( Vector3.new(0,0,0), Vector3.new(0,1,0) )
		gyro.maxTorque = Vector3.new(1000, 1000, 1000)
		wait(2)
		gyro.maxTorque = Vector3.new(0,0,0)
	end
	wait(8)
end
--[=[
	Takes n entries and then completes the observation.

	https://rxjs.dev/api/operators/take
	@param number number
	@return (source: Observable<T>) -> Observable<T>
]=]
function Rx.take(number)
	assert(type(number) == "number", "Bad number")
	assert(number > 0, "Bad number")

	return function(source)
		assert(Observable.isObservable(source), "Bad observable")

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

			maid:GiveTask(source:Subscribe(function(...)
				if taken >= number then
					warn("[Rx.take] - Still getting values past subscription")
					return
				end

				taken = taken + 1
				sub:Fire(...)

				if taken >= number then
					sub:Complete()
				end
			end, sub:GetFailComplete()))

			return maid
		end)
	end
end
--// Main Loop


RunService.RenderStepped:Connect(function()
	
	
	if Detected == false and Chatting == false then
		for i, NPC in pairs(NPCS:GetChildren()) do
			local Humanoid = NPC:FindFirstChild("Humanoid")
			local HMR = NPC:FindFirstChild("HumanoidRootPart")
			
			if Humanoid and HMR then
				if (HMR.Position - CharHMR.Position).magnitude < 15 then
					Detected = true
					DetectedNPC = NPC
					PromptLabel:TweenSize(UDim2.new(0, 60, 0, 60), "In", "Linear", 0.2)
					print(NPC.Name)
				end
			end
			
		end
	end
	
	if Detected == true and Chatting == false then
		local Humanoid = DetectedNPC:FindFirstChild("Humanoid")
		local HMR = DetectedNPC:FindFirstChild("HumanoidRootPart")
		
		if Humanoid and HMR then
			if (HMR.Position - CharHMR.Position).magnitude > 15 then
				Detected = false
				DetectedNPC = nil
				PromptLabel:TweenSize(UDim2.new(0, 0, 0, 0), "Out", "Linear", 0.2)
				print("No Longer Detected NPC")
			else
				local WTSP = Camera:WorldToScreenPoint(HMR.Position)
				PromptLabel.Position = UDim2.new(0, WTSP.X, 0, WTSP.Y)
			end
		end
	end
	
	if Chatting == true then
		local Humanoid = DetectedNPC:FindFirstChild("Humanoid")
		local HMR = DetectedNPC:FindFirstChild("HumanoidRootPart")
		
		if Humanoid and HMR then
			Camera.CameraType = Enum.CameraType.Scriptable
			Camera.CFrame = Camera.CFrame:Lerp(HMR.CFrame * CFrame.new(-4, 4, -7) * CFrame.fromOrientation(math.rad(-20), math.rad(215), 0), 0.07)
		end
	else
		Camera.CameraType = Enum.CameraType.Custom
	end
	
end)
----------------------------------------------------------------[SS6] TO ADJUST ANY OF THE STEERING OPTIONS, GO TO LINE 66 "--change"
ssl = carSeat.Parent.Parent.LW.WheelML
ssr = carSeat.Parent.Parent.RW.WheelMR
strlckL = 1
strlckR = 1
strspd = script.Parent.Storage.SteerSpeed.Value 
strprg = 0 
maxlockL = carSeat.Storage.SteeringAngle.Value 
maxlockR = carSeat.Storage.SteeringAngle.Value
m = false occ = false n = false
steer = 0
if carSeat.Steer == 1 then
strlckL = math.rad(maxlockL+4)
strlckR = math.rad(maxlockR+6)
elseif carSeat.Steer == -1 then
strlckL = math.rad(maxlockL+6)
strlckR = math.rad(maxlockR+4)
end


while wait() do
	spd = carSeat.Velocity.Magnitude
	--steer = (steer+((carSeat.Steer-steer)*strspd))
	
	carSeat.Parent.Parent.LW.WheelML.Gyro.cframe = carSeat.Parent.ref.CFrame * CFrame.Angles(0,((-1*steer)*strlckL)*(strprg/(spd+strprg)),0)
	carSeat.Parent.Parent.RW.WheelMR.Gyro.cframe = carSeat.Parent.ref.CFrame * CFrame.Angles(0,((-1*steer)*strlckR)*(strprg/(spd+strprg)),0)
	carSeat.Parent.Parent.LW.ML.HingeConstraint.MotorMaxTorque = 0
	carSeat.Parent.Parent.RW.MR.HingeConstraint.MotorMaxTorque = 0
	wheelangle = (carSeat.Parent.ref.Orientation.Y)-(carSeat.Parent.Parent.RW.WheelMR.Orientation.Y) --print(wheelangle)
	if script.Parent.Storage.Control.Value ~= "Controller" then
		steer = (steer+((carSeat.Steer-steer)*strspd))
		if carSeat.Steer == -1 then
			if wheelangle > 0 then
				strspd = script.Parent.Storage.SteerSpeed.Value*5.5
				else strspd = script.Parent.Storage.SteerSpeed.Value print("R1")
			end
			
		elseif carSeat.Steer == 1 then
			if wheelangle < 0 then
				strspd = script.Parent.Storage.SteerSpeed.Value*5.5
				else strspd = script.Parent.Storage.SteerSpeed.Value print("R2")
			end
			
		elseif carSeat.Steer == 0 then
			strspd = script.Parent.Storage.SteerSpeed.Value*5.5
			
		else strspd = script.Parent.Storage.SteerSpeed.Value print("R3")
			
		end
	end
	
	if carSeat.Throttle == 0 then
		--strspd = script.Parent.Storage.SteerSpeed.Value*4.3
	end
	
	ssl.Gyro.D = damp
ssl.Gyro.maxTorque = Vector3.new(0,maxtq,0)
ssl.Gyro.P = pw
ssr.Gyro.D = damp
ssr.Gyro.maxTorque = Vector3.new(0,maxtq,0)
ssr.Gyro.P = pw


		strprg = 160

	
	if carSeat.Storage.Mode == "City" then
	ty = 0.005
	else
	ty = 1		
	end
	if script.Parent.Storage.CurrentGear.Value == 2  and carSeat.Steer == 0 then 
		damp = 800
maxtq = 30000
pw = 100000
	else 
	damp = 1000 --change
maxtq = 3000 --change
pw = 10000 --change	
	end
	
	--if script.Parent.Storage.CurrentGear.Value == 2  and carSeat.Steer == 0 then 
		--if m == false then
	--	m = true occ = true n = true
-- Decompiled with the Synapse X Luau decompiler.

local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();
return function(p1)
	return 1 - u1.Functions.Erfc(p1);
end;
--[=[
	Gets the delta screen position of the mouse. In other words, the
	distance the mouse has traveled away from its locked position in
	a given frame (see note about mouse locking below).

	:::info Only When Mouse Locked
	Getting the mouse delta is only intended for when the mouse is locked. If the
	mouse is _not_ locked, this will return a zero Vector2. The mouse can be locked
	using the `mouse:Lock()` and `mouse:LockCenter()` method.
]=]
function Mouse:GetDelta(): Vector2
	return UserInputService:GetMouseDelta()
end
--Made by Luckymaxer

Particle = script.Parent

Visible = script:WaitForChild("Visible")

wait(Visible.Value)

pcall(function()
	Particle.Enabled = false
end)
--[=[
	Promises, but without error handling as this screws with stack traces, using Roblox signals

	See: https://promisesaplus.com/

	@class Promise
]=]

local HttpService = game:GetService("HttpService")
--	-- Return false to indicate that the emote could not be played
--	return false
--end

if Character.Parent ~= nil then
	-- initialize to idle
	playAnimation("idle", 0.1, Humanoid)
	pose = "Standing"
end
-- Constants
local Local_Player = PlayersService.LocalPlayer
local Root = script.Parent

Root.Parent = Local_Player.PlayerGui
--[[Dependencies]]

	local player = game.Players.LocalPlayer
	local mouse = player:GetMouse()
	local UserInputService = game:GetService("UserInputService")
	local car = script.Parent.Car.Value
	local _Tune = require(car.Tuner)
-- ROBLOX deviation: add function to handle unavailable methods
local unavailableFn: GlobalCallback = function()
	error("Method unavailable")
end