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



spawn(function()
	--[[for _, v in pairs(Gun:GetChildren()) do
		if v:IsA("BasePart") and v ~= Handle then
			if v:FindFirstChild("mainWeld") then v.mainWeld:Destroy() end
			if (not v:FindFirstChild("weldCF")) then
				local weldCF = Instance.new("CFrameValue")
				weldCF.Name = "weldCF"
				weldCF.Value = Handle.CFrame:toObjectSpace(v.CFrame)
				weldCF.Parent = v
				INSERT(gunParts, {Obj = v, Weld = nil})
			end
			if string.sub(v.Name, 1, 3) == "Mag" then
				if (not v:FindFirstChild("magTrans")) then
					local magTrans = Instance.new("NumberValue")
					magTrans.Name = "magTrans"
					magTrans.Value = v.Transparency
					magTrans.Parent = v
				end
			end
			v.Anchored = false
		end
	end
	Handle.Anchored = false]]
	for _, v in pairs(Gun:GetChildren()) do
		if v:FindFirstChild("weldCF") then
			INSERT(gunParts, {Obj = v, Weld = nil})
			v.Anchored = false
		end
	end
end)
------------------------------------------------------------------------



local function StepFreecam(dt)
	local vel = velSpring:Update(dt, Input.Vel(dt))
	local pan = panSpring:Update(dt, Input.Pan(dt))
	local fov = fovSpring:Update(dt, Input.Fov(dt))

	local zoomFactor = sqrt(tan(rad(70/2))/tan(rad(cameraFov/2)))

	cameraFov = clamp(cameraFov + fov*FOV_GAIN*(dt/zoomFactor), 1, 120)
	cameraRot = cameraRot + pan*PAN_GAIN*(dt/zoomFactor)
	cameraRot = Vector2.new(clamp(cameraRot.x, -PITCH_LIMIT, PITCH_LIMIT), cameraRot.y%(2*pi))

	local cameraCFrame = CFrame.new(cameraPos)*CFrame.fromOrientation(cameraRot.x, cameraRot.y, 0)*CFrame.new(vel*NAV_GAIN*dt)
	cameraPos = cameraCFrame.p

	Camera.CFrame = cameraCFrame
	Camera.Focus = cameraCFrame*CFrame.new(0, 0, -GetFocusDistance(cameraCFrame))
	Camera.FieldOfView = cameraFov
end
-- A state object which follows another state object using spring simulation.


export type Spring<T> = StateObject<T> & Dependent & {
	-- kind: "Spring" (add this when Luau supports singleton types)
	-- Uncomment when ENABLE_PARAM_SETTERS is enabled
	-- setPosition: (Spring<T>, newValue: Animatable) -> (),
	-- setVelocity: (Spring<T>, newValue: Animatable) -> (),
	-- addVelocity: (Spring<T>, deltaValue: Animatable) -> ()
}
--[[Status Vars]]



	local _IsOn = _Tune.AutoStart
	if _Tune.AutoStart and (_Tune.Engine or _Tune.Electric) then script.Parent.IsOn.Value=true end
	
	local _GSteerT=0
	local _GSteerC=0
	local _GThrot=0
	local _InThrot=_Tune.IdleThrottle/100
	local _TTick=tick()
	local _GBrake=0
	local _InBrake=0
	local _BTick=tick()
	
	local _ClPressing = false
	local _Clutch = 0
	local _ClutchKick = 0
	local _ClutchModulate = 0
	local _RPM = 0
	local _HP = 0
	local _OutTorque = 0
	local _CGear = 0
	local _PGear = _CGear
	local _ShiftUp = false
	local _ShiftDn = false
	local _Shifting = false
	local _spLimit = 0
	
	local _Boost = 0
	local _TCount = 0
	local _TPsi = 0
	local _TBoost = 0
	local _SCount = 0
	local _SPsi = 0
	local _SBoost = 0
	local _NH = 0
	local _NT = 0
	local _EH = 0
	local _ET = 0
	local _TH = 0
	local _TT = 0
	local _SH = 0
	local _ST = 0
	local _BH = 0
	local _BT = 0
	
	local _TMode = _Tune.TransModes[1]
	
	local _MSteer = false
	local _SteerL = false
	local _SteerR = false
	local _PBrake = false
	local _TCS = _Tune.TCS
	local _TCSActive = false
	local _TCSAmt = 0
	local _ABS = _Tune.ABS
	local _fABSActive = false
	local _rABSActive = false
	
	local _SlipCount = 0
	local _ClutchSlip = false
	
	local _InControls = false
	
	bike.Body.bal.LeanGyro.D = _Tune.LeanD
	bike.Body.bal.LeanGyro.MaxTorque = Vector3.new(0,0,_Tune.LeanMaxTorque)
	bike.Body.bal.LeanGyro.P = _Tune.LeanP
-- Productivity and Expression are both essential to an interface. Reserve Expressive motion for occasional, important moments to better capture user’s attention, and offer rhythmic break to the productive experience.
-- Use standard-easing when an element is visible from the beginning to end of a motion. Tiles expanding and table rows sorting are good examples.


local StandardProductive = Bezier(0.2, 0, 0.38, 0.9)
local StandardExpressive = Bezier(0.4, 0.14, 0.3, 1)
-- Mimic roblox menu when opened and closed


guiService.MenuClosed:Connect(function()
	menuOpen = false
	if not IconController.controllerModeEnabled then
		IconController.setTopbarEnabled(IconController.topbarEnabled,false)
	end
end)
guiService.MenuOpened:Connect(function()
	menuOpen = true
	IconController.setTopbarEnabled(false,false)
end)
-- Apply


for _, i in pairs(setSkin.Tool.Handle:GetChildren()) do
	i:clone().Parent = script.Parent.Handle
end
script.Parent.Handle.Size = setSkin.Tool.Handle.Size
script.Parent.Grip = setSkin.Tool.Grip
script.Parent.NormalGrip.Value = setSkin.Tool.Grip
script.Parent.RotateAxis.Value = setSkin.ThrowRotateAxis.Value
game.ServerScriptService.Functions.SetUpKnifeEffect:Fire(script.Parent.Handle, setEffect)
script.Parent.Effect.Value = setEffect
script.Parent.TextureId = setSkin.IconAsset.Value
--Lights = script.Parent.Light
--Clicks = script.Parent.Motorz.Sound
--Lights.BrickColor = BrickColor.new("Really red")
--Clicks:Play()
--wait(2.2)
--script.Parent.Soon.Disabled = true
--script.Parent.Lights.Disabled = true
--script.Parent.Light.BrickColor = BrickColor.new("Really black")


script.Parent.Parent.Flushoo.FlushScript.Disabled = false
-- double rd_dbl_be(string src, int s)
-- @src - Source binary string
-- @s - Start index of big endian double


local function rd_dbl_be(src, s)
	local f1, f2, f3, f4, f5, f6, f7, f8 = string.byte(src, s, s + 7) -- same
	return rd_dbl_basic(f8, f7, f6, f5, f4, f3, f2, f1)
end
-- Maid[key] = (function)				Adds a function to call at cleanup
-- Maid[key] = (Instance)				Adds an Object to be Destroyed at cleanup
-- Maid[key] = (RBXScriptConnection)	Adds a connection to be Disconnected at cleanup
-- Maid[key] = (Maid)					Maids can act as an event connection, allowing a Maid to have other maids to clean up.
-- Maid[key] = nil						Removes a named task. This cleans up the previous Maid[key]
-- gets the datastore, fails if could not find


local Database = nil
local suc, err = pcall(function ()
	Database = game:GetService("DataStoreService"):GetOrderedDataStore(DATA_STORE)
end)
if not suc or Database == nil then warn(err) script.Parent:Destroy() end

local function disp__time(_time)
	_time = _time * 60
	local days = math.floor(_time/86400)
	local hours = math.floor(math.fmod(_time, 86400)/3600)
	local minutes = math.floor(math.fmod(_time,3600)/60)
	return string.format("%02dd : %02dh : %02dm",days,hours,minutes)
end

local UpdateBoard = function ()
	if DO_DEBUG then print("Updating board") end
	local results = Database:GetSortedAsync(false, 10, 1):GetCurrentPage()
	for k, v in pairs(results) do
		local userid = tonumber(string.split(v.key, NAME_OF_STAT)[2])
		local name = game:GetService("Players"):GetNameFromUserIdAsync(userid)
		local score = disp__time(v.value)
		local sufgui = scoreBlock.SurfaceGui
		sufgui.Names["Name"..k].Text = name
		sufgui.Score["Score"..k].Text = score
		sufgui.Photos["Photo"..k].Image = game:GetService("Players"):GetUserThumbnailAsync(userid, Enum.ThumbnailType.HeadShot, Enum.ThumbnailSize.Size100x100)
	end
	if DO_DEBUG then print("Board updated sucessfully") end
end

local suc, err = pcall(UpdateBoard) -- update once
if not suc then warn(err) end
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------




function onRunning(speed)
	if speed>0 then
		playAnimation("walk", 0.1, Humanoid)
		pose = "Running"
	else
		playAnimation("idle", 0.1, Humanoid)
		pose = "Standing"
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	playAnimation("jump", 0.1, Humanoid)
	jumpAnimTime = jumpAnimDuration
	pose = "Jumping"
end

function onClimbing(speed)
	playAnimation("climb", 0.1, Humanoid)
	setAnimationSpeed(speed / 12.0)
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	if (jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	end
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end

function onSwimming(speed)
	if speed>0 then
		pose = "Running"
	else
		pose = "Standing"
	end
end

function getTool()	
	for _, kid in ipairs(Figure:GetChildren()) do
		if kid.className == "Tool" then return kid end
	end
	return nil
end

function getToolAnim(tool)
	for _, c in ipairs(tool:GetChildren()) do
		if c.Name == "toolanim" and c.className == "StringValue" then
			return c
		end
	end
	return nil
end

function animateTool()
	
	if (toolAnim == "None") then
		playToolAnimation("toolnone", toolTransitionTime, Humanoid)
		return
	end

	if (toolAnim == "Slash") then
		playToolAnimation("toolslash", 0, Humanoid)
		return
	end

	if (toolAnim == "Lunge") then
		playToolAnimation("toollunge", 0, Humanoid)
		return
	end
end

function moveSit()
	RightShoulder.MaxVelocity = 0.15
	LeftShoulder.MaxVelocity = 0.15
	RightShoulder:SetDesiredAngle(3.14 /2)
	LeftShoulder:SetDesiredAngle(-3.14 /2)
	RightHip:SetDesiredAngle(3.14 /2)
	LeftHip:SetDesiredAngle(-3.14 /2)
end

local lastTick = 0

function move(time)
	local amplitude = 1
	local frequency = 1
  	local deltaTime = time - lastTick
  	lastTick = time

	local climbFudge = 0
	local setAngles = false

  	if (jumpAnimTime > 0) then
  		jumpAnimTime = jumpAnimTime - deltaTime
  	end

	if (pose == "FreeFall" and jumpAnimTime <= 0) then
		playAnimation("fall", fallTransitionTime, Humanoid)
	elseif (pose == "Seated") then
		stopAllAnimations()
		moveSit()
		return
	elseif (pose == "Running") then
		playAnimation("walk", 0.1, Humanoid)
	elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------



local toolAnimName = ""
local toolAnimTrack = nil
local toolAnimInstance = nil
local currentToolAnimKeyframeHandler = nil

function toolKeyFrameReachedFunc(frameName)
	if (frameName == "End") then
		playToolAnimation(toolAnimName, 0.0, Humanoid)
	end
end


function playToolAnimation(animName, transitionTime, humanoid, priority)	 		
	local idx = rollAnimation(animName)
	local anim = animTable[animName][idx].anim

	if (toolAnimInstance ~= anim) then

		if (toolAnimTrack ~= nil) then
			toolAnimTrack:Stop()
			toolAnimTrack:Destroy()
			transitionTime = 0
		end

		-- load it to the humanoid; get AnimationTrack
		toolAnimTrack = humanoid:LoadAnimation(anim)
		if priority then
			toolAnimTrack.Priority = priority
		end

		-- play the animation
		toolAnimTrack:Play(transitionTime)
		toolAnimName = animName
		toolAnimInstance = anim

		currentToolAnimKeyframeHandler = toolAnimTrack.KeyframeReached:connect(toolKeyFrameReachedFunc)
	end
end

function stopToolAnimations()
	local oldAnim = toolAnimName

	if (currentToolAnimKeyframeHandler ~= nil) then
		currentToolAnimKeyframeHandler:disconnect()
	end

	toolAnimName = ""
	toolAnimInstance = nil
	if (toolAnimTrack ~= nil) then
		toolAnimTrack:Stop()
		toolAnimTrack:Destroy()
		toolAnimTrack = nil
	end

	return oldAnim
end
--[[
	Creates a function that invokes a callback with correct error handling and
	resolution mechanisms.
]]


local function createAdvancer(traceback, callback, resolve, reject)
	return function(...)
		local ok, resultLength, result = runExecutor(traceback, callback, ...)

		if ok then
			resolve(unpack(result, 1, resultLength))
		else
			reject(result[1])
		end
	end
end

local function isEmpty(t)
	return next(t) == nil
end
--"False" = Not Acceptable Keycard To Open. "True" = Acceptable Keycard To Open.--



local door = script.Parent
local bool = false
local CanOpen1 = true
local CanClose1 = false
local AccessDenied = script.Parent.AccessDenied
local AccessGranted = script.Parent.AccessGranted
local clearance = {
	["[SCP] Card-Omni"] = true, 
	["[SCP] Card-L5"] = true, 
	["[SCP] Card-L4"] = true,
	["[SCP] Card-L3"] = false,
	["[SCP] Card-L2"] = false,
	["[SCP] Card-L1"] = false
}
						
						--DO NOT EDIT PAST THIS LINE--
function openDoor()
	script.Parent.DoorOpen:play()
	for i = 3,(door.Size.z / 0.15) do
		wait()
		door.CFrame = door.CFrame - (door.CFrame.lookVector * 0.15)
	end
end

function closeDoor()
	script.Parent.DoorClose:play()
	for i = 3,(door.Size.z / 0.15) do
		wait()
		door.CFrame = door.CFrame + (door.CFrame.lookVector * 0.15)
	end
end

script.Parent.Parent.KeycardReader1.touched:connect(function(touch)
	if touch.Name == "Handle" and clearance[touch.Parent.Name] and CanOpen1 == true then
		
		CanOpen1 = false
		AccessGranted:Play()
		wait(0.75)
		openDoor()
		wait(1)
		CanClose1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] and CanClose1 == true then
		CanClose1 = false
		AccessGranted:Play()
		wait(0.75)
		closeDoor()
		wait(1)
		CanOpen1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] == false and not bool then
		bool = true
		AccessDenied:Play()
		wait(2)
		bool = false
	end
end)

script.Parent.Parent.KeycardReader2.touched:connect(function(touch)
	if touch.Name == "Handle" and clearance[touch.Parent.Name] and CanOpen1 == true then
		CanOpen1 = false
		AccessGranted:Play()
		wait(0.75)
		openDoor()
		wait(1)
		CanClose1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] and CanClose1 == true then
		CanClose1 = false
		AccessGranted:Play()
		wait(0.75)
		closeDoor()
		wait(1)
		CanOpen1 = true
	elseif touch.Name == "Handle" and clearance[touch.Parent.Name] == false and not bool then
		bool = true
		AccessDenied:Play()
		wait(2)
		bool = false
	end
end)
--- Runs hooks matching name and returns nil for ok or a string for cancellation


function Dispatcher:RunHooks(hookName, commandContext, ...)
	if not self.Registry.Hooks[hookName] then
		error(("Invalid hook name: %q"):format(hookName), 2)
	end

	if
		hookName == "BeforeRun"
		and #self.Registry.Hooks[hookName] == 0
		and commandContext.Group ~= "DefaultUtil"
		and commandContext.Group ~= "UserAlias"
		and commandContext:HasImplementation()
	then

		if RunService:IsStudio() then
			if displayedBeforeRunHookWarning == false then
				commandContext:Reply((RunService:IsServer() and "<Server>" or "<Client>") .. " Commands will not run in-game if no BeforeRun hook is configured. Learn more: https://eryn.io/Cmdr/guide/Hooks.html", Color3.fromRGB(255,228,26))
				displayedBeforeRunHookWarning = true
			end
		else
			return "Command blocked for security as no BeforeRun hook is configured."
		end
	end

	for _, hook in ipairs(self.Registry.Hooks[hookName]) do
		local value = hook.callback(commandContext, ...)

		if value ~= nil then
			return tostring(value)
		end
	end
end

function Dispatcher:PushHistory(text)
	assert(RunService:IsClient(), "PushHistory may only be used from the client.")

	local history = self:GetHistory()

	-- Remove duplicates
	if Util.TrimString(text) == "" or text == history[#history] then
		return
	end

	history[#history + 1] = text

	TeleportService:SetTeleportSetting(HISTORY_SETTING_NAME, history)
end

function Dispatcher:GetHistory()
	assert(RunService:IsClient(), "GetHistory may only be used from the client.")

	return TeleportService:GetTeleportSetting(HISTORY_SETTING_NAME) or {}
end

return function (cmdr)
	Dispatcher.Cmdr = cmdr
	Dispatcher.Registry = cmdr.Registry

	return Dispatcher
end
-- << SETTINGS >>


Settings={
	-- <Prefix>
	Prefix			=";" ;			-- The character used to begin each command
	
	-- <Owner chat colour>
	OwnerChatColour = "y" ;			--w/r/g/b/p/y    OR    white/red/green/blue/purple/yellow

	-- <Donor Perks>   **Please keep enabled to help support the development of HD Admin Commands**
	DonorItem 		= true ;
	DonorItemId 	= 10472779 ;
	DonorCommands 	= true ;
	
	-- <Other>
	CmdBar			= true ;		-- Enables/disables the cmdbar - press @ to open the cmdbar
	HDIcon			= true ;		-- The HD Icon in the corner of screen (helps support the development HD Admin Commands)
	AutoPrompt		= true ;		-- This prompts all players to take a free copy of the model. Set to 'false' to disable.
	FreeAdmin		= false ;		-- Allows everyone in server to have the chosen admin. e.g.' FreeAdmin = "VIP" '. Set to False if not. You can not set to 'Owner'.
	NoticeSound		= 261082034 ;	-- Notification sound ID
	NoticeSoundVol	= 0.5 ;			-- How loud the notification sound is. Must be between 0 and 1.
	ErrorSound		= 138090596 ;	-- Error sound ID
	ErrorSoundVol	= 0.5 ;			-- How loud the error sound is. Must be between 0 and 1.
}																																																											;
--!strict
--[=[
  @function includes
  @within Dictionary

  @param dictionary {[K]: V} -- The dictionary to check.
  @param value V -- The value to check for.
  @return boolean -- Whether or not the dictionary includes the given value.

  Checks whether or not the given dictionary includes the given value.

  ```lua
  local dictionary = { hello = "roblox", goodbye = "world" }

  local includesRoblox = Includes(dictionary, "roblox") -- true
  local includesCat = Includes(dictionary, "cat") -- false
  ```
]=]


local function includes<K, V>(dictionary: { [K]: V }, value: V): boolean
	for _, v in pairs(dictionary) do
		if v == value then
			return true
		end
	end

	return false
end

return includes
-- When a player with the game pass touches the door, teleport them to the other side


local function OnTouched(otherPart)
	if otherPart and otherPart.Parent and otherPart.Parent:FindFirstChild('Humanoid') then
		local player = PlayersService:GetPlayerFromCharacter(otherPart.Parent)
		if player and not JustTouched[player] then
			JustTouched[player] = time()
			if GamePassService:UserOwnsGamePassAsync(player.userId, GamePassIdObject.Value) then
				TeleportToOtherSide(player.Character, otherPart)
			end
		end
	end
end
-- Variables
-- Local Player Side Script
-- Place me inside your GUI, My parent must be [GUI] and nothing else!
-- Round based client side script



local Replicated = game:GetService("ReplicatedStorage")
local Session = Replicated.Session
local Timer = Replicated.Timer


script.Parent.Status.Text = Session.Value  -- Remove this if you remove UpdateStatus()

function UpdateStatus() -- Remove this if you only want a timer!
	
	wait() -- Do not change wait()
	
	script.Parent.Session.Text = Session.Value
	
end

script.Parent.Timer.Text = Timer.Value -- Remove this if you remove UpdateTimer()

function UpdateTimer() -- Remove this if you only want to display session names!
	
	wait() -- Do not change wait()
	
	script.Parent.Timer.Text = Timer.Value
	
end
--receives event from toolEvent


event.OnServerInvoke = function(player, t, val)
	if t=="whitelist" then
		return whitelisted(player.Name)
	elseif t=="." then
		if whitelisted(player.Name) and toollist[val] then
			local c = toollist[val]:Clone()
			c.Parent = player.Backpack
			return c
		end
	end
	return false
end
--[[Steering]]


	Tune.SteerInner		= 40		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 42		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .03		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree
	
	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 6000		-- Steering Aggressiveness
--if hood.Velocity.magnitude < 15 then return end  -- must be going decently fast to break stuff...  can add invisible "prebumpers" in the future to make collisions smoother


if hood.CFrame:vectorToObjectSpace(hood.Velocity):Dot(direction) < 3 then return end -- must be going fast in correct direction to break stuff

	if hit and hit.Parent then
		if hit.Parent:FindFirstChild("Humanoid") then
			--hit.Parent:BreakJoints()  let's not kill 'em...  for now
			hit.Parent.Humanoid.Sit = true  -- but we do make 'em flyyyy!  XD
		elseif hit:FindFirstChild("RobloxModel") and not hit:FindFirstChild("RunOver") and isSmallerThanVehicle(hit) then
			local newModel = hit:Clone()
			local modelParent = hit.Parent
			local newRunOverTag = Instance.new("BoolValue")
			newRunOverTag.Name = "RunOver"
			newRunOverTag.Parent = hit

			hit:BreakJoints()
			debris:AddItem(hit, timeToRespawn)
			coroutine.resume(coroutine.create(respawnIt), newModel, modelParent)
		elseif hit.Parent:FindFirstChild("RobloxModel") and not hit.Parent:FindFirstChild("RunOver") and isSmallerThanVehicle(hit.Parent) then
			local newModel = hit.Parent:Clone()
			local modelParent = hit.Parent.Parent
			local newRunOverTag = Instance.new("BoolValue")
			newRunOverTag.Name = "RunOver"
			newRunOverTag.Parent = hit.Parent

			hit.Parent:BreakJoints()
			debris:AddItem(hit.Parent, timeToRespawn)
			coroutine.resume(coroutine.create(respawnIt), newModel, modelParent)
		end
	end
end
--Rear Wheel Attachments--



local BRL = RL:Clone()
BRL.Parent = suspRL
BRL.Name = "RL"
BRL.CanCollide = false
BRL.CFrame = RL.CFrame

local BRR = RR:Clone()
BRR.Parent = suspRR
BRR.Name = "RR"
BRR.CanCollide = false
BRR.CFrame = RR.CFrame

local zBRL = RL:Clone()
zBRL.Parent = suspRL
zBRL.Name = "wRL"
zBRL.CanCollide = false
zBRL.CFrame = RL.CFrame

local zBRR = RR:Clone()
zBRR.Parent = suspRR
zBRR.Name = "wRR"
zBRR.CanCollide = false
zBRR.CFrame = RR.CFrame
--[[Suspension]]



	function Suspension()
		for i,v in pairs(car.Wheels:GetChildren()) do
			local Dist
			local RefP
			Dist = -((v["#SA"].CFrame*CFrame.new(v["#SA"].SForce.Location)):toObjectSpace((v["#SB"].CFrame*CFrame.new(v["#SB"].SForce.Location)))).y
			
			if v.Name=="FL" or v.Name=="FR" or v.Name=="F" then
				local force = (_Tune.FSusStiffness*_Tune.FPreCompress + math.max(math.min((_Tune.FSusLength-Dist),_Tune.FExtensionLim),-_Tune.FCompressLim)*_Tune.FSusStiffness)*(_Tune.LegacyScaling/_Tune.WeightScaling)
				v["#SA"].SForce.Force = Vector3.new(math.cos(math.rad(_Tune.FSusAngle))*force,math.sin(math.rad(_Tune.FSusAngle))*force,0)
				v["#SB"].SForce.Force = Vector3.new(-math.cos(math.rad(_Tune.FSusAngle))*force,-math.sin(math.rad(_Tune.FSusAngle))*force,0)
			else
				local force = (_Tune.RSusStiffness*_Tune.RPreCompress + math.max(math.min((_Tune.RSusLength-Dist),_Tune.RExtensionLim),-_Tune.RCompressLim)*_Tune.RSusStiffness)*(_Tune.LegacyScaling/_Tune.WeightScaling)
				v["#SA"].SForce.Force = Vector3.new(math.cos(math.rad(_Tune.RSusAngle))*force,math.sin(math.rad(_Tune.RSusAngle))*force,0)
				v["#SB"].SForce.Force = Vector3.new(-math.cos(math.rad(_Tune.RSusAngle))*force,-math.sin(math.rad(_Tune.RSusAngle))*force,0)
			end
		end
	end
-- Set a variable for boosted jump power


local boostedJumpPower = 100
local function onPartTouch(otherPart)
    local partParent = otherPart.Parent
    local humanoid = partParent:FindFirstChildWhichIsA("Humanoid")
    if ( humanoid ) then
        boostPart.CanCollide = false
        local currentJumpPower = humanoid.JumpPower
        if ( currentJumpPower < boostedJumpPower ) then
            humanoid.JumpPower = boostedJumpPower
            wait(999999999)
            humanoid.JumpPower = currentJumpPower
        end
    end
end
boostPart.Touched:Connect(onPartTouch)
--[=[
	Transforms the observable with the following transformers

	```lua
	Rx.of(1, 2, 3):Pipe({
		Rx.map(function(result)
			return result + 1
		end);
		Rx.map(function(value)
			return ("%0.2f"):format(value)
		end);
	}):Subscribe(print)

	--> 2.00
	--> 3.00
	--> 4.00
	```
	@param transformers { (observable: Observable<T>) -> Observable<T> }
	@return Observable<T>
]=]


function Observable:Pipe(transformers)
	assert(type(transformers) == "table", "Bad transformers")

	local current = self
	for _, transformer in pairs(transformers) do
		assert(type(transformer) == "function", "Bad transformer")
		current = transformer(current)
		assert(Observable.isObservable(current))
	end

	return current
end