Pinkstack/roblox-luau-corpus-text huggingface dataset:
--[[
    Returns a HumanoidDescription representing the outfit that "player" is
    currently wearing, with the addition of one extra item given by "assetId".

    The "assetType" parameter represents which kind of accessories the new one
    belongs to. It must be the name of a property under HumanoidDescription. If
    the user is already wearing items of that type, those are removed first.

    In case of a failure to retrieve "player"'s current outfit, a generic
    character look is generated.
]]



local MerchBooth = script:FindFirstAncestor("MerchBooth")

local Cryo = require(MerchBooth.Packages.Cryo)
local matchAssetTypeToAccessoryType = require(MerchBooth.Modules.matchAssetTypeToAccessoryType)
local isAccessory = require(MerchBooth.Modules.isAccessory)
local isClassicClothing = require(MerchBooth.Modules.isClassicClothing)

local DEFAULT_BODY_COLOR = Color3.fromRGB(122, 122, 122)

local function generateDescriptionWithItem(player: Player, assetId: number, assetType: Enum.AssetType)
	local character = player and player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	local description = humanoid and humanoid:GetAppliedDescription()

	-- We could run into the "no description" case if, for instance, the game
	-- has characters disabled. In which case, we want a new description with
	-- character colors set to grey (default is black and isn't very visible in
	-- the default dark theme).
	if not description then
		description = Instance.new("HumanoidDescription")
		description.HeadColor = DEFAULT_BODY_COLOR
		description.TorsoColor = DEFAULT_BODY_COLOR
		description.LeftArmColor = DEFAULT_BODY_COLOR
		description.RightArmColor = DEFAULT_BODY_COLOR
		description.LeftLegColor = DEFAULT_BODY_COLOR
		description.RightLegColor = DEFAULT_BODY_COLOR
	end

	if isAccessory(assetType) then
		local accessoryTypeEnum = matchAssetTypeToAccessoryType(assetType)
		local accessories = Cryo.List.filter(description:GetAccessories(true), function(accessory)
			return accessory.AccessoryType ~= accessoryTypeEnum
		end)
		table.insert(accessories, {
			Order = 1,
			AssetId = assetId,
			AccessoryType = accessoryTypeEnum,
		})
		description:SetAccessories(accessories, true)
	elseif isClassicClothing(assetType) then
		if assetType == Enum.AssetType.TShirt then
			description.GraphicTShirt = assetId
		elseif assetType == Enum.AssetType.Shirt then
			description.Shirt = assetId
		elseif assetType == Enum.AssetType.Pants then
			description.Pants = assetId
		end
	end

	return description
end

return generateDescriptionWithItem
--[[Rear]]

--
	Tune.RSusDamping	= 120 		-- Dampening
	Tune.RSusStiffness	= 4000		-- Stiffness
	
	Tune.RSusLength		= 1.85 		-- Suspension length (in studs)
	Tune.RPreComp		= -0.1 		-- Vehicle height, relative to your suspension settings
	Tune.RExtLimit		= .2 		-- Max Extension Travel (in studs)
	Tune.RCompLimit		= .8 		-- Max Compression Travel (in studs)
	
	Tune.RBaseOffset	= {				-- Suspension base point
		 --[[Lateral]]		0		,	-- positive = outward
		 --[[Vertical]]		1.7		,	-- positive = upward
		 --[[Forward]]		-.5		}	-- positive = forward
	
	Tune.RBricksVisible	= false 	-- Makes the front suspension bricks visible (Debug)
	Tune.RConstsVisible	= false 	-- Makes the front suspension constraints visible (Debug)
--!strict


local BloxbizSDK = script.Parent.Parent.Parent.Parent

local UtilsStorage = BloxbizSDK:FindFirstChild("Utils")
local Fusion = require(UtilsStorage:WaitForChild("Fusion"))

export type States = {
	Enabled: Fusion.Value<boolean>,
	Hovering: Fusion.Value<boolean>,
	HeldDown: Fusion.Value<boolean>,
	Selected: Fusion.Value<boolean>,
}

export type Values<T> = {
	MouseDown: T?,
	Selected: T?,
	Hover: T?,
	Disabled: T?,
	Default: T,
}

return function(states: States, values: Values<any>, speed: number?, damping: number?): Fusion.Spring<any>
	return Fusion.Spring(
		Fusion.Computed(function()
			if states.Enabled:get() then
				if states.Selected:get() then
					return values.Selected or values.Default
				elseif states.HeldDown:get() then
					return values.MouseDown or values.Default
				elseif states.Hovering:get() then
					return values.Hover or values.Default
				else
					return values.Default
				end
			else
				return values.Disabled or values.Default
			end
		end),
		speed or 20,
		damping or 1
	)
end
-- NOTE: To hide this from the games folder structure use the command bar and type >hide
-- To Show it again type >show



local SETTINGS = {
	--The thing you need to use before typing the macro 
	PREFIX = "!",
	--The splitter character for between the (). Note: This has to be 1 character	
	ARGUMENT_SPLITTER = ",",
	--The default is tab, and this is the key you must press after typing out the macro
	ACTIVATION_KEY = "	",
	--Used for >MS(). If this is on and it requires a service to be added to the file it will also add that chunk of code. (Note: With this off it wont work as intended if it doesnt have the service already in file declared as a varable)
	AUTO_IMPORT = true,
	--turn this off to allow any sort of casing like: >gS(Players), 
	CASE_SENSATIVE_COMMANDS = false,
	--Used for >MS() so it knows what paths its allowed to look into (Note: this has to be a top level path)
	SEARCH_LOCATIONS = {"Workspace", "Players", "MaterialService", "ReplicatedFirst", "ReplicatedStorage", "ServerScriptService", "ServerStorage", "StarterGui", "StarterPack", "StarterPlayer", "Teams", "Chat", "TextChatService", "LocalizationService", "TestService"},
	--NOT WORKING RIGHT, ONLY TURN ON IF YOU WANT TO SEE WHAT IT DOES. 
	--What its supposed to do is if it sees that a required service is lower than the line you are adding it to then it will move the service up to the current line
	REORGANISE_IMPORTS = false,
}

return SETTINGS
--------------------------------------------------------------------


	if smoke == true then
		mouse.KeyDown:connect(function(key)
		if key == camkey and enabled == false then
		
		local children = car.Wheels:GetChildren()

		for index, child in pairs(children) do
				if child:IsA("Part") then
						local effect = script.soundeffect:Clone()
						effect.Name = "soundeffectCop"
				effect.Parent = child.SQ
			end
		end
		elseif key == camkey and enabled == true then
			local children = car.Wheels:GetChildren()

			for index, child in pairs(children) do
				if child:IsA("Part") then
					child.SQ.soundeffectCop:Destroy()
				end
			end
		end
		car.DriveSeat.ChildRemoved:Connect(function(child)

			if child.Name == "SeatWeld" then
				local children = car.Wheels:GetChildren()

				for index, child in pairs(children) do
					if child:IsA("Part") then
						child.SQ.soundeffectCop:Destroy()
					end
				end
			end
		end)
	end)
end
--[=[
	Gets the service by name. Throws an error if the service is not found.
]=]


function KnitServer.GetService(serviceName: string): Service
	assert(started, "Cannot call GetService until Knit has been started")
	assert(type(serviceName) == "string", `ServiceName must be a string; got {type(serviceName)}`)
	return assert(services[serviceName], `Could not find service "{serviceName}"`) :: Service
end
--[=[
	Creates a new controller.

	:::caution
	Controllers must be created _before_ calling `Knit.Start()`.
	:::
	```lua
	-- Create a controller
	local MyController = Knit.CreateController {
		Name = "MyController",
	}

	function MyController:KnitStart()
		print("MyController started")
	end

	function MyController:KnitInit()
		print("MyController initialized")
	end
	```
]=]


function KnitClient.CreateController(controllerDef: ControllerDef): Controller
	assert(type(controllerDef) == "table", "Controller must be a table; got " .. type(controllerDef))
	assert(type(controllerDef.Name) == "string", "Controller.Name must be a string; got " .. type(controllerDef.Name))
	assert(#controllerDef.Name > 0, "Controller.Name must be a non-empty string")
	assert(not DoesControllerExist(controllerDef.Name), "Controller \"" .. controllerDef.Name .. "\" already exists")
	local controller = controllerDef :: Controller
	controllers[controller.Name] = controller
	return controller
end
-- NOTE, on the first, and last numbers, the ones that make your hat go left/right/ahead/back shouldn't be changed by whole numbers
-- to make your hat giver perfect, if you have to use those two numbers, move it slowly by ".1's"
-- This can also go for the middle number. If your hat is slightly higher than its supposed to be, than edit the number slightly. 
-- Do not change the numbers by whole numbers, or else it will go really far off.  Change the numbers by ".1's" and ".2's"
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]


local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local handler = car:WaitForChild("AC6_FE_Sounds")
local _Tune = require(car["A-Chassis Tune"])
local on = 0
local throt=0
local redline=0


for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

while wait() do
	local _RPM = script.Parent.Values.RPM.Value
	
	if script.Parent.Values.Throttle.Value <= _Tune.IdleThrottle/100 then
		throt = math.max(.3,throt-.2)	
	else
		throt = math.min(1,throt+.1)	
	end	
	if script.Parent.Values.RPM.Value > _Tune.Redline-_Tune.RevBounce/4 and script.Parent.Values.Throttle.Value > _Tune.IdleThrottle/100 then
		redline=.5
	else
		redline=1
	end
	if not script.Parent.IsOn.Value then on=math.max(on-.015,0) else on=1 end
	local Pitch = math.max((((script.SetPitch.Value + script.SetRev.Value*_RPM/_Tune.Redline))*on^2),script.SetPitch.Value)
	if FE then
		handler:FireServer("updateSound",Pitch)
	else
		car.DriveSeat.Rev.Pitch = Pitch
	end
end
--[=[
	Takes a result and converts it to a brio if it is not one.

	@return (source: Observable<Brio<T> | T>) -> Observable<Brio<T>>
]=]


function RxBrioUtils.toBrio()
	return Rx.map(function(result)
		if Brio.isBrio(result) then
			return result
		end

		return Brio.new(result)
	end)
end
-- This is not ideal in a server script.
-- CFraming should be done on the client for a less choppy experience.



local base = script.Parent:WaitForChild('Base')

local startCF = base.CFrame
local startTime = os.clock()
local tau = math.pi*2


local VERTICAL_SWING_AMOUNT = 90
local VERTICAL_SWING_TIME = 19

local HORIZONTAL_SWING_AMOUNT = 0
local HORIZONTAL_SWING_TIME = 6

while base and base.Parent do
	wait()
	local d = os.clock() - startTime
	base.CFrame = startCF * CFrame.Angles(0, math.sin(d*tau/HORIZONTAL_SWING_TIME)*math.rad(HORIZONTAL_SWING_AMOUNT)*.5, math.sin(d*tau/VERTICAL_SWING_TIME)*math.rad(VERTICAL_SWING_AMOUNT)*.5)
end
--		print("Keyframe : ".. frameName)	


		playToolAnimation(toolAnimName, 0.0, Humanoid)
	end
end


function playToolAnimation(animName, transitionTime, humanoid, priority)	 
		
		local roll = math.random(1, animTable[animName].totalWeight) 
		local origRoll = roll
		local idx = 1
		while (roll > animTable[animName][idx].weight) do
			roll = roll - animTable[animName][idx].weight
			idx = idx + 1
		end
----				if EntityData.All[newAnimal.Name].dangerZoneDamage then
----					saddledCritters[newAnimal].lastAttack = Rep.Constants.RelativeTime.Value
----					newAnimal:WaitForChild("DangerZone").Touched:connect(function(hit)
----						if (Rep.Constants.RelativeTime.Value - saddledCritters[newAnimal].lastAttack) >= EntityData.All[newAnimal.Name].dangerZoneSpeed then
----							local munched
----
----							if hit.Parent:FindFirstChild("Health") and (not hit:IsDescendantOf(newAnimal.DangerZone.Parent)) and EntityData.All[hit.Parent.Name] and EntityData.All[hit.Parent.Name].health then
------hit.Parent.Health.Value = hit.Parent.Health.Value - EntityData.All[newAnimal.Name].dangerZoneDamage
----								munched = true
----
----								local canDamage = false
----								for  damageType, damageAmount  in next, EntityData.All[newAnimal.Name].damages  do
----									if EntityData.All[hit.Parent.Name].susceptions[damageType] then
----										canDamage = damageAmount
----									end
----								end 
----
----								if canDamage then 
----									DamageResource(hit.Parent, canDamage, player) 
----								end
----
----							elseif hit.Parent:FindFirstChild("Humanoid") then
----								local otherPlayer = game.Players:GetPlayerFromCharacter(hit.Parent)
----								if otherPlayer and not AreAllies(saddledCritters[newAnimal].owner, otherPlayer) then
------ do damage to the player
----									munched = true
----									DamagePlayer(otherPlayer, CalculateToolDamageToPlayers(newAnimal.Name, otherPlayer))
----
----								end
----							end
----
------ if an attack went through
----							if munched then
----								saddledCritters[newAnimal].lastAttack = Rep.Constants.RelativeTime.Value
----								PlaySoundInObject(Rep.Sounds.Bank:FindFirstChild(EntityData.All[newAnimal.name].damageSound), newAnimal.Head)
----								local emitter = game.ReplicatedStorage.Particles.Teeth:Clone()
----								emitter.Parent = newAnimal.Head
----								emitter.EmissionDirection = Enum.NormalId.Top
----								wait()
----								emitter:Emit(1)
----							end
----
----						end
----
----					end)
----				end
-- Model Position Tweening --


function Functions.CreateModelTween(Model, TweenInformation, Goal)
	local CFrameValue = Instance.new("CFrameValue")
	CFrameValue.Value = Model.PrimaryPart.CFrame
	
	CFrameValue.Changed:Connect(function(Value)
		Model:SetPrimaryPartCFrame(Value)
	end)
	
	local Tween = TweenService:Create(CFrameValue, TweenInformation, Goal)
	Tween:Play()
	Tween.Completed:Wait()
end
--[[Transmission]]


	Tune.TransModes		= {"Auto"}								--[[
	[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	= "RPM"												--[[
	[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		= 1.6		 --	[TRANSMISSION CALCULATIONS FOR NERDS]
	Tune.Ratios			= {			 --		SPEED [SPS]	 = (Wheel diameter(studs) * pi(3.14) * RPM) / (60 * Gear Ratio * Final Drive * Multiplier)
		--[[Reverse]]	3.40		,--		WHEEL TORQUE = Engine Torque * Gear Ratio * Final Drive * Multiplier
		--[[Neutral]]	0			,
		--[[ 1 ]]		3.77      	,
		--[[ 2 ]]		2.34		,
		--[[ 3 ]]		1.52		,
		--[[ 4 ]]		1.14		,
		--[[ 5 ]]		0.86		,
		--[[ 6 ]]		0.69   	,
	}
	Tune.FDMult			= 5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
--End of Editable Values



local car = script.Parent.Car.Value
local hb = game:GetService('RunService').Heartbeat
local sound = car.Body.Drag.Wind
local sound2 = car.Body.Drag.Body
sound:Play()
sound2:Play()

local function update()
	sound.Volume=Vol*(car.DriveSeat.Velocity.Magnitude/500)
	sound2.Volume=Vol*(car.DriveSeat.Velocity.Magnitude/500)
	car.Body.DownforceF.T.Force = Vector3.new(0,(car.DriveSeat.Velocity.Magnitude/-300)*F,0)
	car.Body.DownforceR.T.Force = Vector3.new(0,(car.DriveSeat.Velocity.Magnitude/-300)*R,0)
	car.Body.Drag.T.Force = Vector3.new(0,0,(car.DriveSeat.Velocity.magnitude^2*(Drag/30)))
end

hb:Connect(update)
--------------------------------------------------------------------------------
-- Popper.lua
-- Prevents your camera from clipping through walls.
--------------------------------------------------------------------------------



local Players = game:GetService('Players')

local FFlagUserPoppercamLooseOpacityThreshold do
	local success, enabled = pcall(function()
		return UserSettings():IsUserFeatureEnabled("UserPoppercamLooseOpacityThreshold")
	end)
	FFlagUserPoppercamLooseOpacityThreshold = success and enabled
end

local camera = game.Workspace.CurrentCamera

local min = math.min
local tan = math.tan
local rad = math.rad
local inf = math.huge
local ray = Ray.new

local function eraseFromEnd(t, toSize)
	for i = #t, toSize + 1, -1 do
		t[i] = nil
	end
end

local nearPlaneZ, projX, projY do
	local function updateProjection()
		local fov = rad(camera.FieldOfView)
		local view = camera.ViewportSize
		local ar = view.X/view.Y

		projY = 2*tan(fov/2)
		projX = ar*projY
	end

	camera:GetPropertyChangedSignal('FieldOfView'):Connect(updateProjection)
	camera:GetPropertyChangedSignal('ViewportSize'):Connect(updateProjection)

	updateProjection()

	nearPlaneZ = camera.NearPlaneZ
	camera:GetPropertyChangedSignal('NearPlaneZ'):Connect(function()
		nearPlaneZ = camera.NearPlaneZ
	end)
end

local blacklist = {} do
	local charMap = {}

	local function refreshIgnoreList()
		local n = 1
		blacklist = {}
		for _, character in pairs(charMap) do
			blacklist[n] = character
			n = n + 1
		end
	end

	local function playerAdded(player)
		local function characterAdded(character)
			charMap[player] = character
			refreshIgnoreList()
		end
		local function characterRemoving()
			charMap[player] = nil
			refreshIgnoreList()
		end

		player.CharacterAdded:Connect(characterAdded)
		player.CharacterRemoving:Connect(characterRemoving)
		if player.Character then
			characterAdded(player.Character)
		end
	end

	local function playerRemoving(player)
		charMap[player] = nil
		refreshIgnoreList()
	end

	Players.PlayerAdded:Connect(playerAdded)
	Players.PlayerRemoving:Connect(playerRemoving)

	for _, player in ipairs(Players:GetPlayers()) do
		playerAdded(player)
	end
	refreshIgnoreList()
end
--// Return values: bool filterSuccess, bool resultIsFilterObject, variant result


function methods:InternalApplyRobloxFilterNewAPI(speakerName, message, textFilterContext) --// USES FFLAG
	local alwaysRunFilter = false
	local runFilter = RunService:IsServer() and not RunService:IsStudio()
	if (alwaysRunFilter or runFilter) then

		local fromSpeaker = self:GetSpeaker(speakerName)
		if fromSpeaker == nil then
			return false, nil, nil
		end

		local fromPlayerObj = fromSpeaker:GetPlayer()
		if fromPlayerObj == nil then
			return true, false, message
		end

		if allSpaces(message) then
			return true, false, message
		end

		local success, filterResult = pcall(function()
			local ts = game:GetService("TextService")
			local result = ts:FilterStringAsync(message, fromPlayerObj.UserId, textFilterContext)
			return result
		end)
		if (success) then
			return true, true, filterResult
		else
			warn("Error filtering message:", message, filterResult)
			self:InternalNotifyFilterIssue()
			return false, nil, nil
		end
	end

	--// Simulate filtering latency.
	wait()
	return true, false, message
end

function methods:InternalDoMessageFilter(speakerName, messageObj, channel)
	local filtersIterator = self.FilterMessageFunctions:GetIterator()

	for funcId, func, priority in filtersIterator do
		local success, errorMessage = pcall(function()
			func(speakerName, messageObj, channel)
		end)

		if not success then
			warn(string.format("DoMessageFilter Function '%s' failed for reason: %s", funcId, errorMessage))
		end
	end
end

function methods:InternalDoProcessCommands(speakerName, message, channel)
	local commandsIterator = self.ProcessCommandsFunctions:GetIterator()

	for funcId, func, priority in commandsIterator do
		local success, returnValue = pcall(function()
			local ret = func(speakerName, message, channel)
			if type(ret) ~= "boolean" then
				error("Process command functions must return a bool")
			end
			return ret
		end)

		if not success then
			warn(string.format("DoProcessCommands Function '%s' failed for reason: %s", funcId, returnValue))
		elseif returnValue then
			return true
		end
	end

	return false
end

function methods:InternalGetUniqueMessageId()
	local id = self.MessageIdCounter
	self.MessageIdCounter = id + 1
	return id
end

function methods:InternalAddSpeakerWithPlayerObject(speakerName, playerObj, fireSpeakerAdded)
	if (self.Speakers[speakerName:lower()]) then
		error("Speaker \"" .. speakerName .. "\" already exists!")
	end

	local speaker = Speaker.new(self, speakerName)
	speaker:InternalAssignPlayerObject(playerObj)
	self.Speakers[speakerName:lower()] = speaker

	if fireSpeakerAdded then
		local success, err = pcall(function() self.eSpeakerAdded:Fire(speakerName) end)
		if not success and err then
			print("Error adding speaker: " ..err)
		end
	end

	return speaker
end

function methods:InternalFireSpeakerAdded(speakerName)
	local success, err = pcall(function() self.eSpeakerAdded:Fire(speakerName) end)
	if not success and err then
		print("Error firing speaker added: " ..err)
	end
end
--create tables:


for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "e" then
		table.insert(e, 1, part)
	end
end
for i,part in pairs(model:GetChildren()) do
	if string.sub(part.Name, 1,1) == "f" then
		table.insert(f, 1, part)
	end
end

function lightOn(T)
	for i, part in pairs (T) do
		if part:FindFirstChild("On") then
			part.On.Value  = true
		end
	end
end

function lightOff(T)
	for i, part in pairs (T) do
		if part:FindFirstChild("On") then
			part.On.Value = false
		end
	end
end

while true do

	lightOn(e)
	wait(0.25)

	lightOff(e)
	wait(0.25)

	lightOn(f)
	wait(0.25)

	lightOff(f)
	wait(0.25)
	
end
-------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------



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
-- helper functions


local function removePlayerNameFromStack(stack)
	-- in order to generalize the data so that errors are properly grouped,
	--  we must strip out any personal information from the callstack.
	if not type(stack) == "string" then
		warn(string.format("Expected stack to be a string, received : %s", type(stack)))
		return tostring(stack)
	end

	local sanitizedStack = string.gsub(stack, "Players%.[^.]+%.", "Players.<Player>.")
	return sanitizedStack
end



local ErrorReporter = {}
ErrorReporter.__index = ErrorReporter

function ErrorReporter.new(networkingImpl)
	if not networkingImpl then
		networkingImpl = Networking.new()
	end

	local er = {
		-- reporter implementations
		_googleAnalyticsReporter = ReporterGoogleAnalytics.new({
			networking = networkingImpl,
		}),
		_playFabReporter = ReporterPlayFab.new(),
	}
	setmetatable(er, ErrorReporter)

	return er
end
--Workspace.CurrentCamera.CameraSubject=game.Players.LocalPlayer.Character.Humanoid
--Workspace.CurrentCamera.CameraType="Custom"


bin.Name = "Vehicle"
end)

game.Players.LocalPlayer.Character.Humanoid.Changed:connect(function()
	if game.Players.LocalPlayer.Character.Humanoid.Jump then
		script.Parent:remove()
	end
end)