Roblox/luau_corpus huggingface dataset:
-- Bind function to update event. Used to update player's orientation if FilteringEnabled
-- is true (otherwise the rotation would not replicate from the rotating player)
updateEvent.OnServerEvent:Connect(function(player, neckC0, shoulderC0)
	local character = player.Character
	if character.Humanoid.RigType == Enum.HumanoidRigType.R6 then
		character.Torso.Neck.C0 = neckC0
		character.Torso:FindFirstChild("Right Shoulder").C0 = shoulderC0
	else
		character.Head.Neck.C0 = neckC0
		character.RightUpperArm:FindFirstChild("RightShoulder").C0 = shoulderC0
	end
end)
--[[
	Creates a new promise that receives the result of this promise.

	The given callbacks are invoked depending on that result.
]]
function Promise.prototype:_andThen(traceback, successHandler, failureHandler)
	self._unhandledRejection = false

	-- If we are already cancelled, we return a cancelled Promise
	if self._status == Promise.Status.Cancelled then
		local promise = Promise.new(function() end)
		promise:cancel()

		return promise
	end

	-- Create a new promise to follow this part of the chain
	return Promise._new(traceback, function(resolve, reject, onCancel)
		-- Our default callbacks just pass values onto the next promise.
		-- This lets success and failure cascade correctly!

		local successCallback = resolve
		if successHandler then
			successCallback = createAdvancer(traceback, successHandler, resolve, reject)
		end

		local failureCallback = reject
		if failureHandler then
			failureCallback = createAdvancer(traceback, failureHandler, resolve, reject)
		end

		if self._status == Promise.Status.Started then
			-- If we haven't resolved yet, put ourselves into the queue
			table.insert(self._queuedResolve, successCallback)
			table.insert(self._queuedReject, failureCallback)

			onCancel(function()
				-- These are guaranteed to exist because the cancellation handler is guaranteed to only
				-- be called at most once
				if self._status == Promise.Status.Started then
					table.remove(self._queuedResolve, table.find(self._queuedResolve, successCallback))
					table.remove(self._queuedReject, table.find(self._queuedReject, failureCallback))
				end
			end)
		elseif self._status == Promise.Status.Resolved then
			-- This promise has already resolved! Trigger success immediately.
			successCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Rejected then
			-- This promise died a terrible death! Trigger failure immediately.
			failureCallback(unpack(self._values, 1, self._valuesLength))
		end
	end, self)
end
-- Services
local lighting = game:GetService("Lighting")
local tweenService = game:GetService("TweenService")
--[[
	Gets a list of all nodes in the tree for which the given callback returns
	true.
]]
function TestPlan:findNodes(callback)
	local results = {}
	self:visitAllNodes(function(node)
		if callback(node) then
			table.insert(results, node)
		end
	end)
	return results
end

return TestPlan
--After the coin is collected it won't emit particles when touched
part.Touched:Connect(function(hit)
	if hit.Parent:FindFirstChild("Humanoid") then
		local emitter = part.ParticleEmitter
		emitter.Enabled = false
	end
end)script.Parent.Transparency = 0
-- Sub to me! https://www.youtube.com/channel/UCrG4Cnjcz1mkDopaqPGaW3A
-- My discord! https://discord.gg/6x56rTZ5c8
-- Good luck!

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

function Light()
	local player = game.Players.LocalPlayer
	local playerChar = player.Character
	local playerLight = playerChar.Head:FindFirstChild("Light")

	if playerLight then
		playerLight:Destroy()
	else
		local light = Instance.new("SurfaceLight",playerChar:FindFirstChild("Head"))
		light.Name = "Light"
		light.Range = 60 -- Change lighting range / Изменение диапозона освещения
		light.Angle = 50 -- Change lighting angle / Изменение угла освещения
		light.Shadows = true
		light.Brigtness = 3 -- Change lighting brigtness / Изменение яркости освещения
	end
end

mouse.KeyDown:connect(function(key)

	key = key:lower()
	if key == "f" then
		script.FlashLightSound:Play()
		Light()
	end
end)
--// SHITTY CODE \/\/\/

wait(0.3)

local car = script.Parent.Car.Value
local values = script.Parent.Values
local bodmain = car.Body.MainDiff

local rpm = values.RPM

function update()
	local actrpm = rpm.Value/rpmdiv
	car.drivetrain:FireServer(actrpm,bodmain)
end

while wait(waittime) do
	update()
end
--------------| MODIFY COMMANDS |--------------
SetCommandRankByName = {
	--["jump"] = "VIP";
};	
SetCommandRankByTag = {
	["abusive"] = "Admin";
};








};
--[[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	= "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.7				-- Gearing determines top speed and wheel torque
Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
	--[[Reverse]]	3			,	-- Copy and paste a ratio to add a gear
	--[[Neutral]]	0			,	-- Ratios can also be deleted
	--[[ 1 ]]		2.6			,	-- Reverse, Neutral, and 1st gear are required
	--[[ 2 ]]		0.8			,		
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
--// Module LoadOrder List; Core modules need to be loaded in a specific order; If you create new "Core" modules make sure you add them here or they won't load
local LoadingOrder = {
	--// Nearly all modules rely on these to function
	"Logs";
	"Variables";
	"Functions";

	--// Core functionality
	"Core";
	"Remote";
	"Process";

	--// Misc
	"Admin";
	"HTTP";
	"Anti";
	"Commands";
}
--Classes
export type SoundState = {
    Save: (SoundState) -> nil,
    Play: (SoundState) -> nil,
    Resume: (SoundState) -> nil,
    Pause: (SoundState) -> nil,
    Stop: (SoundState) -> nil,
    SetEffects: (SoundState, {[string]: {[string]: any}}) -> nil,
    StateValue: StringValue,
}

export type ClientSound = {
    Update: (ClientSound) -> nil,
}



return {}
-- Sounds
local Soundscape = game.Soundscape
local ExitSound = Soundscape:FindFirstChild("ExitSound")
-- Listeners for inputs
IsOn.Changed:connect(ConfigWater)
ShouldEmitSound.Changed:connect(ConfigWater)
MaxVolume.Changed:connect(ConfigWater)
-- add the arms
table.insert(ArmPartsTable, Character:WaitForChild("Right Arm"))
table.insert(ArmPartsTable, Character:WaitForChild("Left Arm"))
--Tune
OverheatSpeed = .125 --How fast the car will overheat
CoolingEfficiency = .075 --How fast the car will cool down
RunningTemp = 85 --In degrees

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

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

User = nil
Connector = game.Workspace:FindFirstChild("GlobalPianoConnector")
if not Connector or not Connector:IsA("RemoteEvent") then
	error("The piano requires a RemoteEvent named GlobalPianoConnector to be in Workspace.")
end
-- (EarthHelm Giver - Loaded.)

debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "EarthHelm"
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle" 
		p.formFactor = 0
		p.Size = Vector3.new(1, 0.4, 1) 
		p.BottomSurface = 0 
		p.TopSurface = 0 
		p.Locked = true 
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentForward = Vector3.new (-0, -0, -1)
		h.AttachmentPos = Vector3.new(0, -0.2, 0)
		h.AttachmentRight = Vector3.new (1, 0, 0)
		h.AttachmentUp = Vector3.new (0, 1, 0)
		wait(5)
		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)
-- Services
local ContextActionService = game:GetService("ContextActionService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
-- ROBLOX deviation start: predefine functions
local comparePrimitive
local compareObjects
local getFormatOptions
local getObjectsDifference
--None of this is mine...
script.Parent.Equipped:Connect(function()
	script.Parent.WAP.act:FireServer()
end)

script.Parent.Unequipped:Connect(function()
	script.Parent.WAP.dct:FireServer()
end)
--[=[
	Chains onto an existing Promise and returns a new Promise.

	:::warning
	Within the failure handler, you should never assume that the rejection value is a string. Some rejections within the Promise library are represented by [[Error]] objects. If you want to treat it as a string for debugging, you should call `tostring` on it first.
	:::

	You can return a Promise from the success or failure handler and it will be chained onto.

	Calling `andThen` on a cancelled Promise returns a cancelled Promise.

	:::tip
	If the Promise returned by `andThen` is cancelled, `successHandler` and `failureHandler` will not run.

	To run code no matter what, use [Promise:finally].
	:::

	@param successHandler (...: any) -> ...any
	@param failureHandler? (...: any) -> ...any
	@return Promise<...any>
]=]
function Promise.prototype:andThen(successHandler, failureHandler)
	assert(successHandler == nil or isCallable(successHandler), string.format(ERROR_NON_FUNCTION, "Promise:andThen"))
	assert(failureHandler == nil or isCallable(failureHandler), string.format(ERROR_NON_FUNCTION, "Promise:andThen"))

	return self:_andThen(debug.traceback(nil, 2), successHandler, failureHandler)
end
--I M P O R T A N T--
------------------------------------------------------------------------
--Don't change any of this unless you know what you are doing.
--This script is the blur affect but also the exit button script.
------------------------------------------------------------------------

local blur = game.Lighting.Blur
local frame = script.Parent
local close = script.Parent:WaitForChild("CloseButton")

if 
	frame.Visible == true
then
	blur.Enabled = true
end

close.MouseButton1Click:Connect(function()
	frame.Visible = false
	blur.Enabled = false
end)
--The "Creative" option makes it so you can jump infinitly (True if yes, False if no)

repeat wait() until Game:GetService("Players")
local Player = Game.Players.LocalPlayer

repeat wait() until Player

local FirstJump = false
local MidJump = false
local Mouse = Player:GetMouse()
TING = false
function onKeyDown(key)
if string.byte(key) == 32 and FirstJump == true and not TING and (MidJump == false or script.Creative.Value == true) then
TING = true
MidJump = true
Player.Character.Torso.Velocity = Vector3.new(0,85,0) --How high Player jumps
Player.Character.Humanoid.WalkSpeed = 36 -- This change the walkspeed
script.Jump1:Play()
wait(1.1) --Double Jump cooldown (Not normal jump)
TING = false
end
end
---------------------------
--[[
	--Main anchor point is the DriveSeat <car.DriveSeat>	
	
	Usage:
		MakeWeld(Part1,Part2,WeldType*,MotorVelocity**) *default is "Weld"  **Applies to Motor welds only
		ModelWeld(Model,MainPart)
	Example:
		MakeWeld(car.DriveSeat,misc.PassengerSeat)
		MakeWeld(car.DriveSeat,misc.SteeringWheel,"Motor",.2)
		ModelWeld(car.DriveSeat,misc.Door)
]]
--Weld stuff here

MakeWeld(misc.Popups.Hinge,car.DriveSeat,"Motor",.1)
ModelWeld(misc.Popups.Parts,misc.Popups.Hinge)
--[[Drivetrain]]	
	Tune.Config			= "RWD"		--"FWD" , "RWD" , "AWD"
	
	--Differential Settings	
	Tune.FDiffSlipThres	= 80		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 20		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 75		-- 1 - 100%
	Tune.RDiffLockThres	= 25		-- 0 - 100%
	Tune.CDiffSlipThres	= 80		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 20		-- 0 - 100%				[AWD Only]
	
	--Traction Control Settings
	Tune.TCSEnabled		= true		-- Implements TCS
	Tune.TCSThreshold	= 0		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 15	-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 6		-- Minimum amount of torque at max reduction (in percent)
--[=[
	Initializes a new promise with the given function in a delay wrapper.

	@param seconds number
	@param func (resolve: (...) -> (), reject: (...) -> ()) -> ()?
	@return Promise<T>
]=]
function Promise.delay(seconds, func)
	assert(type(seconds) == "number", "Bad seconds")
	assert(type(func) == "function", "Bad func")

	local self = Promise.new()

	task.delay(seconds, func, self:_getResolveReject())

	return self
end
-- Decompiled with the Synapse X Luau decompiler.

local v1 = {
	Name = "runif", 
	Aliases = {}, 
	Description = "Runs a given command string if a certain condition is met.", 
	Group = "DefaultUtil", 
	Args = { {
			Type = "conditionFunction", 
			Name = "Condition", 
			Description = "The condition function"
		}, {
			Type = "string", 
			Name = "Argument", 
			Description = "The argument to the condition function"
		}, {
			Type = "string", 
			Name = "Test against", 
			Description = "The text to test against."
		}, {
			Type = "string", 
			Name = "Command", 
			Description = "The command string to run if requirements are met. If omitted, return value from condition function is used.", 
			Optional = true
		} }
};
local u1 = {
	startsWith = function(p1, p2)
		if p1:sub(1, #p2) ~= p2 then
			return;
		end;
		return p1:sub(#p2 + 1);
	end
};
function v1.Run(p3, p4, p5, p6, p7)
	local v2 = u1[p4];
	if not v2 then
		return ("Condition %q is not valid."):format(p4);
	end;
	local v3 = v2(p6, p5);
	if not v3 then
		return "";
	end;
	return p3.Dispatcher:EvaluateAndRun(p3.Cmdr.Util.RunEmbeddedCommands(p3.Dispatcher, p7 and v3));
end;
return v1;
-- This loads from, or lazily creates, NumberValue objects for exposed parameters
function OrbitalCamera:LoadNumberValueParameters()
	-- These initial values do not require change listeners since they are read only once
	self:LoadOrCreateNumberValueParameter("InitialElevation", "NumberValue", nil)
	self:LoadOrCreateNumberValueParameter("InitialDistance", "NumberValue", nil)
	
	-- Note: ReferenceAzimuth is also used as an initial value, but needs a change listener because it is used in the calculation of the limits
	self:LoadOrCreateNumberValueParameter("ReferenceAzimuth", "NumberValue", self.SetAndBoundsCheckAzimuthValue)
	self:LoadOrCreateNumberValueParameter("CWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
	self:LoadOrCreateNumberValueParameter("CCWAzimuthTravel", "NumberValue", self.SetAndBoundsCheckAzimuthValues)
	self:LoadOrCreateNumberValueParameter("MinElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
	self:LoadOrCreateNumberValueParameter("MaxElevation", "NumberValue", self.SetAndBoundsCheckElevationValues)
	self:LoadOrCreateNumberValueParameter("MinDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
	self:LoadOrCreateNumberValueParameter("MaxDistance", "NumberValue", self.SetAndBoundsCheckDistanceValues)
	self:LoadOrCreateNumberValueParameter("UseAzimuthLimits", "BoolValue", self.SetAndBoundsCheckAzimuthValues)
	
	-- Internal values set (in radians, from degrees), plus sanitization
	self.curAzimuthRad = math.rad(self.externalProperties["ReferenceAzimuth"])
	self.curElevationRad = math.rad(self.externalProperties["InitialElevation"])
	self.curDistance = self.externalProperties["InitialDistance"]
	
	self:SetAndBoundsCheckAzimuthValues()
	self:SetAndBoundsCheckElevationValues()
	self:SetAndBoundsCheckDistanceValues()
end

function OrbitalCamera:GetModuleName()
	return "OrbitalCamera"
end

function OrbitalCamera:SetInitialOrientation(humanoid)
	if not humanoid or not humanoid.RootPart then
		warn("OrbitalCamera could not set initial orientation due to missing humanoid")
		return
	end
	local newDesiredLook = (humanoid.RootPart.CFrame.lookVector - Vector3.new(0,0.23,0)).unit
	local horizontalShift = Util.GetAngleBetweenXZVectors(newDesiredLook, self:GetCameraLookVector())
	local vertShift = math.asin(self:GetCameraLookVector().y) - math.asin(newDesiredLook.y)
	if not Util.IsFinite(horizontalShift) then
		horizontalShift = 0
	end
	if not Util.IsFinite(vertShift) then
		vertShift = 0
	end
	self.rotateInput = Vector2.new(horizontalShift, vertShift)
end
-- Connect mobile sprint button state change to update walk speed
if UserInputService.TouchEnabled then
	while task.wait(0.1) do
		updateWalkSpeed()
	end
end
--solves the problem of tools falling thru houses

local connectedtools = {}

function GetConnection(tool)
	for _,v in pairs(connectedtools) do
		if v == tool then
			return true
		end
	end
	return false
end

game.Players.PlayerAdded:connect(function(plr)
	plr.CharacterAdded:connect(function(char)
		char.ChildAdded:connect(function(child)
			if child:IsA("Tool") and not GetConnection(child) then
				child.Changed:connect(function(property)
					if child and child.Parent ~= nil and property == "Parent" then
						wait(1/30)
						local handle = child:FindFirstChild("Handle")
						if child.Parent == workspace then
							if handle and handle:CanSetNetworkOwnership() and plr then
								handle:SetNetworkOwner(plr)
							end
						else
							if handle and handle:CanSetNetworkOwnership() and plr then
								handle:SetNetworkOwnershipAuto()
							end
						end
					end
				end)
				table.insert(connectedtools,child)
			end
		end)
	end)
end)

while true do --clean table
	wait(1)
	for i,v in pairs(connectedtools) do
		if v.Parent == nil then
			connectedtools[i] = nil
		end
	end
end
------------------------------------------Gun info
wait(1)
ToolName="M4"
ClipSize=30
ReloadTime=0
Firerate= 0
MinSpread=0.001
MaxSpread=0.0015
SpreadRate=0
Bulletdrop = 0.00001
automatic = false
burst = false
shot = true
Tool = script.Parent
enabled = true
local skateboardId = 65068906 
local arms = nil
local torso = nil
local weld33 = nil -- right arm
local weld55 = nil -- left arm
local welds = {}

BarrlePos=Vector3.new(0,0,0)Cursors={"http://www.roblox.com/asset/?id=47894837"}
ReloadCursor="rbxasset://textures\\GunWaitCursor.png"

barrel_1  = script.Parent:findFirstChild("barrelpos1") or script.Parent.Handle
barrel_2 = script.Parent:findFirstChild("barrelpos2") or script.Parent.Handle

double = false	--Double Wielded 
doublemode = 1 -- 1 is alternating, 2 is both
-- Decompiled with the Synapse X Luau decompiler.

local u1 = Random.new();
return function(...)
	local v14
	local v1 = { ... };
	if #v1 < 2 then
		return v1[1] and v1[1][1];
	end;
	local v2 = u1:NextNumber();
	(function()
		local v3 = 0;

			for v4, v5 in ipairs(v1) do
			if not v4 then
				break;
			end;
			v3 = v3 + v5[2];		
		end;

			for v7, v8 in ipairs(v1) do
			if not v7 then
				break;
			end;
			v8[2] = v8[2] / v3;		
		end;
	end)();
	local v10 = 0;
		for v11, v12 in ipairs(v1) do
		if not v11 then
			 v14 = nil;
			break;
		end;
		v10 = v10 + v12[2];
		if v2 <= v10 then
			v14 = v12;
			break;
		end;	
	end;
	return v14[1], v2;
end;
--[[
	Main RenderStep Update. The camera controller and occlusion module both have opportunities
	to set and modify (respectively) the CFrame and Focus before it is set once on CurrentCamera.
	The camera and occlusion modules should only return CFrames, not set the CFrame property of
	CurrentCamera directly.
--]]
local last=CFrame.new()
function CameraModule:Update(dt)
	--local Framerate = dt / (1/60)
	if self.activeCameraController then
		if FFlagUserCameraToggle then
			self.activeCameraController:UpdateMouseBehavior()
		end

		local newCameraCFrame, newCameraFocus = self.activeCameraController:Update(dt)
		self.activeCameraController:ApplyVRTransform()
		if self.activeOcclusionModule then
			newCameraCFrame, newCameraFocus = self.activeOcclusionModule:Update(dt, newCameraCFrame, newCameraFocus)
		end
		
		Players.LocalPlayer.CAM.Value=newCameraCFrame
		
		local new=newCameraCFrame

		-- Here is where the new CFrame and Focus are set for this render frame
		if _G.COFF then
			local off=_G.COFF or CFrame.new()
			game.Workspace.CurrentCamera.CFrame = last:lerp(new*off,0.4)--newCameraCFrame
		else
			workspace.CurrentCamera.CFrame = newCameraCFrame
		end
		game.Workspace.CurrentCamera.Focus = newCameraFocus
		
		last=new

		-- Update to character local transparency as needed based on camera-to-subject distance
		if self.activeTransparencyController then
			self.activeTransparencyController:Update()
		end
	end
end
--// All global vars will be wiped/replaced except script

return function(data, env)
	if env then
		setfenv(1, env)
	end

	local playergui = service.PlayerGui
	local localplayer = service.Players.LocalPlayer
	local gui = service.New("ScreenGui")
	local toggle = service.New("ImageButton", gui)
	local gTable = client.UI.Register(gui)

	local clickSound = service.New("Sound")
	clickSound.Parent = toggle
	clickSound.Volume = 0.25
	clickSound.SoundId = "rbxassetid://156286438"

	if client.UI.Get("HelpButton", gui, true) then
		gui:Destroy()
		gTable:Destroy()
		return nil
	end

	gTable.Name = "HelpButton"
	gTable.CanKeepAlive = false

	toggle.Name = "Toggle"
	toggle.BackgroundTransparency = 1
	toggle.Position = UDim2.new(1, -45, 1, -45)
	toggle.Size = UDim2.new(0, 40, 0, 40)
	toggle.Image = client.HelpButtonImage
	toggle.ImageTransparency = 0.35
	toggle.Modal = client.Variables.ModalMode
	toggle.ClipsDescendants = true

	--if client.UI.Get("Chat") then
	--	toggle.Position = UDim2.new(1, -(45+40),1, -45)
	--end

	toggle.MouseButton1Down:Connect(function()
		spawn(function()
			local effect = Instance.new("ImageLabel", toggle)
			effect.AnchorPoint = Vector2.new(0.5, 0.5)
			effect.BorderSizePixel = 0
			effect.ZIndex = toggle.ZIndex + 1
			effect.BackgroundTransparency = 1
			effect.ImageTransparency = 0.8
			effect.Image = "rbxasset://textures/whiteCircle.png"
			effect.Position = UDim2.new(0.5, 0, 0.5, 0)
			effect:TweenSize(UDim2.new(0, toggle.AbsoluteSize.X * 2.5, 0, toggle.AbsoluteSize.X * 2.5), Enum.EasingDirection.Out, Enum.EasingStyle.Linear, 0.2)
			wait(0.2)
			effect:Destroy()
		end)
		local found = client.UI.Get("UserPanel",nil,true)
		if found then
			found.Object:Destroy()
		else
			clickSound:Play()
			client.UI.Make("UserPanel",{})
		end
	end)

	gTable:Ready()
end
-- When player joins, have them spawn at the lobby
local function onPlayerJoin(player)
	LeaderboardManager.new(player)
end
--Torso
MakeWeld(car.Misc.Anims.R15.Torso.LowerTorso.X,car.DriveSeat,"Motor6D").Name="M"
MakeWeld(car.Misc.Anims.R15.Torso.LowerTorso.Z,car.Misc.Anims.R15.Torso.LowerTorso.X,"Motor6D").Name="M"
MakeWeld(car.Misc.Anims.R15.Torso.LowerTorso.Y,car.Misc.Anims.R15.Torso.LowerTorso.Z,"Motor6D").Name="M"
ModelWeld(car.Misc.Anims.R15.Torso.LowerTorso.Parts,car.Misc.Anims.R15.Torso.LowerTorso.Y)

MakeWeld(car.Misc.Anims.R15.Torso.UpperTorso.Z,car.Misc.Anims.R15.Torso.LowerTorso.Y,"Motor6D").Name="M"
ModelWeld(car.Misc.Anims.R15.Torso.UpperTorso.Parts,car.Misc.Anims.R15.Torso.UpperTorso.Z)