Roblox/luau_corpus huggingface dataset:
--//Controller//--
Oxygen.Changed:Connect(function()
	TweenService:Create(
		OxygenDisplayBar,

		TweenInfo.new(
			0.5
		),

		{
			Size = UDim2.new(Oxygen.Value / PlayerStatsConfiguration.MaximumOxygenValue.Value, 0, 1, 0)
		}
	):Play()
end)

Humanoid:GetPropertyChangedSignal("Health"):Connect(function()
	TweenService:Create(
		HealthDisplayBar,

		TweenInfo.new(
			0.5
		),

		{
			Size = UDim2.new(Humanoid.Health / Humanoid.MaxHealth, 0, 1, 0)
		}
	):Play()
end)

while true do
	if Player.Team == PlayingTeam then
		if Humanoid:GetState() == Enum.HumanoidStateType.Swimming then
			if Oxygen.Value > 0 then
				Oxygen.Value = Oxygen.Value - PlayerStatsConfiguration.OxygenChangeValue.Value

			elseif Oxygen.Value <= 0 then
				Oxygen.Value = 0

				Humanoid:TakeDamage(PlayerStatsConfiguration.NoOxygenDamage.Value)
			end
			
			task.wait(PlayerStatsConfiguration.OxygenDecreaseTime.Value)

		else
			if Oxygen.Value >= PlayerStatsConfiguration.MaximumOxygenValue.Value then
				Oxygen.Value = PlayerStatsConfiguration.MaximumOxygenValue.Value

			elseif Oxygen.Value < PlayerStatsConfiguration.MaximumOxygenValue.Value then
				Oxygen.Value = Oxygen.Value + PlayerStatsConfiguration.OxygenChangeValue.Value
			end
			
			task.wait(PlayerStatsConfiguration.OxygenIncreaseTime.Value)
		end
	end
	
	task.wait()
end
--				handler:FireServer('updateLights', 'fog', false)
			else lights.Value = false
				handler:FireServer('updateLights', 'beam', false)
--[=[
	@param ignorePlayer Player -- The client to ignore
	@param ... any -- Arguments passed to the other clients
	Fires the signal to all clients _except_ the specified
	client.

	:::note Outbound Middleware
	All arguments pass through any outbound middleware before being
	sent to the client.
	:::
]=]
function RemoteSignal:FireExcept(ignorePlayer: Player, ...: any)
	self:FireFilter(function(plr)
		return plr ~= ignorePlayer
	end, ...)
end
--[[Front]]--
	Tune.FTireProfile	= 1			-- Tire profile, aggressive or smooth
	Tune.FProfileHeight	= .4		-- Profile height, conforming to tire
	
	Tune.FTireCompound	= 1			-- The more compounds you have, the harder your tire will get towards the middle, sacrificing grip for wear
	Tune.FTireFriction	= 1.1		-- Your tire's friction in the best conditions.
--Light off
	src.Parent.right.Value.Value = 0
	src.Parent.left.Value.Value = 0
	light.Value = false
	else
	src.Parent.right.Value.Value = 1
	src.Parent.left.Value.Value = 1
	light.Value = true
	return
	end
end
end)
src.Parent.ChildRemoved:connect(function(child)
	if child.Name=="SeatWeld" then 
		src:Stop()
		script.Parent:Destroy()
	end
end)
-- Initialize the tool
local AnchorTool = {

	Name = 'Anchor Tool';
	Color = BrickColor.new 'Really black';

}

AnchorTool.ManualText = [[<font face="GothamBlack" size="16">Anchor Tool  🛠</font>
Lets you anchor and unanchor parts.<font size="6"><br /></font>

<b>TIP:</b> Press <b>Enter</b> to toggle anchor quickly.]]
-- you can mess with these settings
local easingtime = 0.1 --0~1
local walkspeeds = {
	enabled =		  true;
	walkingspeed =		16;
	backwardsspeed =	10;
	sidewaysspeed =		15;
	diagonalspeed =		16;
	runningspeed =		250;
	runningFOV=			85;
}
--[[Susupension]]
	Tune.SusEnabled		= true		-- works only in with PGSPhysicsSolverEnabled, defaults to false when PGS is disabled
	
	--Front Suspension
	Tune.FSusDamping	= 500		-- Spring Dampening
	Tune.FSusStiffness	= 2000	-- Spring Force
	Tune.FAntiRoll 		= 60		-- Anti-Roll (Gyro Dampening)
	
	Tune.FSusLength		= 1		-- Suspension length (in studs)
	Tune.FPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.FExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.FCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.FSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.FWsBoneLen		= 5			-- Wishbone Length
	Tune.FWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.FAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward
	
	--Rear Suspension
	Tune.RSusDamping	= 500		-- Spring Dampening
	Tune.RSusStiffness	= 4000	-- Spring Force
	Tune.FAntiRoll 		= 60		-- Anti-Roll (Gyro Dampening)

	Tune.RSusLength		= 1	-- Suspension length (in studs)
	Tune.RPreCompress	= .3		-- Pre-compression adds resting length force
	Tune.RExtensionLim	= .3		-- Max Extension Travel (in studs)
	Tune.RCompressLim	= .1		-- Max Compression Travel (in studs)
	Tune.RSusAngle		= 80		-- Suspension Angle (degrees from horizontal)
		
	Tune.RWsBoneLen		= 5			-- Wishbone Length
	Tune.RWsBoneAngle	= 0			-- Wishbone angle (degrees from horizontal)
	Tune.RAnchorOffset	= {			-- Suspension anchor point offset (relative to center of wheel)
	 --[[Lateral]]		-.4		,	-- positive = outward
	 --[[Vertical]]		-.5		,	-- positive = upward
	 --[[Forward]]		0		}	-- positive = forward

	--Aesthetics	
	Tune.SusVisible		= true			-- Spring Visible
	Tune.WsBVisible		= false			-- Wishbone Visible
	Tune.SusRadius		= .2			-- Suspension Coil Radius
	Tune.SusThickness	= .1			-- Suspension Coil Thickness
	Tune.SusColor		= "Really black"	-- Suspension Color [BrickColor]
	Tune.SusCoilCount	= 6				-- Suspension Coil Count
	Tune.WsColor		= "Black"		-- Wishbone Color [BrickColor]
	Tune.WsThickness	= .1			-- Wishbone Rod Thickness
-- Decompiled with the Synapse X Luau decompiler.

game:GetService("Chat"):RegisterChatCallback(Enum.ChatCallbackType.OnCreatingChatWindow, function()
	return {
		BubbleChatEnabled = true
	};
end);
--[[
	Returns the last word in a PascalCase string, ignoring any trailing numbers. E.g.
	
	LeftUpperArm -> Arm
	LeftElbow -> Elbow
	LeftUpperLeg4 -> Leg
	TestT3st4 -> T3st
	test -> test (whole string returned if there are no uppercase characters)
	3 -> ""
--]]

return function (str)
	-- Get the last word in the PascalCase name (e.g. Arm from UpperLeftArm)
	local lastWord = str:sub(#str - ((str:reverse():find("%u") or #str+1) - 1))
	-- Remove trailing numbers from the name
	lastWord = lastWord:gsub("%d+$", "")
	
	return lastWord
end
--------------------------------------------------------------------------------------
--------------------[ PRE-CONNECTIONS ]-----------------------------------------------
--------------------------------------------------------------------------------------

local function updateAnimVars()
	wait()
	Forward = (UIS:IsKeyDown("W") or UIS:IsKeyDown("Up"))
	Backward = (UIS:IsKeyDown("S") or UIS:IsKeyDown("Down"))
	local Right = UIS:IsKeyDown("D")
	local Left = UIS:IsKeyDown("A")
	
	local walkingForward = (Forward and (not Backward))
	local walkingBackward = ((not Forward) and Backward)
	local walkingRight = (Right and (not Left))
	local walkingLeft = ((not Right) and Left)
	
	if (Forward or Backward or Right or Left) then
		Walking, Idling = true, false
		if (not Running) and (not Aimed) then
			spreadMotion = "Moving"
			baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
		end
	elseif (not (Forward and Backward and Right and Left)) then
		Walking, Idling = false, true
		if (not Aimed) then
			spreadMotion = "Idling"
			baseSpread = S.spreadSettings[spreadZoom][spreadStance][spreadMotion]
		end
	end
	
	local newArmTilt = (
		((walkingForward or walkingBackward) and walkingRight) and 2.5 or
		((walkingForward or walkingBackward) and walkingLeft) and -2.5 or
		((not (walkingForward and walkingBackward)) and walkingRight) and 5 or
		((not (walkingForward and walkingBackward)) and walkingLeft) and -5 or 0
	)
	local newMoveAng = (
		(walkingForward and (not (walkingRight or walkingLeft))) and 0 or
		(walkingForward and walkingRight) and RAD(-45) or
		((not (walkingForward or walkingBackward)) and walkingRight) and RAD(-90) or
		(walkingBackward and walkingRight) and RAD(-135) or
		(walkingBackward and (not (walkingRight or walkingLeft))) and (moveAng < 0 and RAD(-180) or RAD(180)) or
		(walkingBackward and walkingLeft) and RAD(135) or
		((not (walkingForward or walkingBackward)) and walkingLeft) and RAD(90) or
		(walkingForward and walkingLeft) and RAD(45) or 0
	)
	
	local newAnimCode = math.random(-1e9, 1e9)
	animCode = newAnimCode
	local startTilt = armTilt
	local startAng = (ABS(moveAng) == RAD(180)) and (newMoveAng > 0 and RAD(180) or RAD(-180)) or moveAng
	local Increment = (startTilt == newArmTilt and 1.5 / 0.7 or 1.5 / (0.35 * ABS(startTilt - newArmTilt) / 5))
	local X = 0
	while true do
		RS.RenderStepped:wait()
		local newX = X + Increment
		X = (newX > 90 and 90 or newX)
		if animCode ~= newAnimCode then break end
		armTilt = numLerp(startTilt, newArmTilt, Sine(X))
		moveAng = numLerp(startAng, newMoveAng, Sine(X))
		if X == 90 then break end
	end
end

M2.KeyDown:connect(updateAnimVars)
M2.KeyUp:connect(updateAnimVars)
updateAnimVars()
--	self.waistC0 = self.waist.C0;
	
	self.spring = spring.new(Vector3.new(), Vector3.new(), Vector3.new(), 10, 1);
	
	return setmetatable(self, lookAt_mt);
end

function lookAt:calcGoal(target)
	local goal = Vector3.new(0, 0, 0);
	
	local eye = (self.hrp.CFrame * CFrame.new(0, 3, 0)):pointToObjectSpace(target).unit;
	local horizontal = -math.atan2(eye.x, -eye.z);
	local vertical = math.asin(eye.y);
	
	if not (math.abs(horizontal) > SETTINGS.horizontalRange or math.abs(vertical) > SETTINGS.verticalRange) then
		local hsign, habs = math.sign(horizontal), math.abs(horizontal);
		local hneck, hwaist = habs*0.5, habs*0.5;
		
		if (hwaist > SETTINGS.maxHorizontalWaist) then
			local remainder = hwaist - SETTINGS.maxHorizontalWaist;
			hwaist = SETTINGS.maxHorizontalWaist;
			hneck = math.clamp(hneck + remainder, 0, SETTINGS.maxHorizontalHead);
		end
		
		goal = Vector3.new(hsign*hneck, hsign*hwaist, vertical);
	end
	
	self.spring.target = goal;
end

function lookAt:update(dt)
	self.spring:update(dt);
	local set = self.spring.p;
	self.neck.C0 = self.neckC0 * CFrame.fromEulerAnglesYXZ(set.z*0.5, set.x, 0);
-- Instead of putting GUI into StarterGui, this will just give the GUI to the player after the spawn/respawn:
function characterHandling(p)
	p.CharacterAdded:connect(function()
		if (not p:findFirstChild("PlayerGui")) then
			repeat wait() until (p:findFirstChild("PlayerGui"))
		end
		gui:clone().Parent = p.PlayerGui
	end)
end
-- << GROUP PERMISSIONS >>
local Group_Permissions = false -- Set to 'true' to use
--// Weapon Parts
local L_34_ = L_1_:WaitForChild('AimPart')
local L_35_
local L_36_ = L_1_:WaitForChild('Grip')
local L_37_ = L_1_:WaitForChild('FirePart')
local L_38_ = L_1_:WaitForChild('Mag')
local L_39_ = L_1_:WaitForChild('Bolt')
-- warn("TWEEN START ********************************************")

local me = script.Parent
local timer = 5 -- секунд = 50000 тиков
-- Events
ServerSceneFramework.AnchorClientForSceneTransition = Orchestra.Events.SceneControl.AnchorClientForSceneTransition
ServerSceneFramework.LoadCharacterRemoteEvent = Orchestra.Events.SceneControl.LoadCharacter
ServerSceneFramework.FinishedLoadingRemoteEvent = Orchestra.Events.SceneControl.FinishedLoading
ServerSceneFramework.LoadSceneFromListEvent = Orchestra.Events.SceneControl.LoadSceneFromList
ServerSceneFramework.LoadSceneServer = Orchestra.Events.OrchestrationEvents.LoadSceneServer
ServerSceneFramework.Orchestrate = Orchestra.Events.OrchestrationEvents.Orchestrate
ServerSceneFramework.SendSceneConfigForPlayer = Orchestra.Events.OrchestrationEvents.SendSceneConfigForPlayer
ServerSceneFramework.GetCurrentSceneEnvironment = Orchestra.Events.SceneFramework.GetCurrentEnvironment
ServerSceneFramework.GetCurrentServerEnvironmentFromClient =
	Orchestra.Events.SceneFramework.GetCurrentServerEnvironmentFromClient
ServerSceneFramework.IsLoadingScene = Orchestra.Events.SceneFramework.IsLoadingScene
ServerSceneFramework.UnloadSceneClientRemoteEvent = Orchestra.Events.SceneControl.UnloadSceneClientRemoteEvent
ServerSceneFramework.LoadSceneRemoteEvent = Orchestra.Events.SceneControl.LoadScene
ServerSceneFramework.OrchestrateSceneEvent = Orchestra.Events.SceneControl.OrchestrateScene
--------------------
--| Script Logic |--
--------------------

Tool.Equipped:connect(OnEquipped)
Tool.Activated:connect(OnActivated)
Tool.Unequipped:connect(OnUnequipped)
Tool.ChildAdded:connect(OnChildAdded) --NOTE: Added for Fire Button
--[[Brakes]]
	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS) 

	Tune.FBrakeForce	= 1900		-- Front brake force
	Tune.RBrakeForce	= 2200		-- Rear brake force
	Tune.PBrakeForce	= 5000		-- Handbrake force
	
	Tune.FLgcyBForce	= 15000		-- Front brake force [PGS OFF]
	Tune.RLgcyBForce	= 10000		-- Rear brake force [PGS OFF]
	Tune.LgcyPBForce	= 25000		-- Handbrake force [PGS OFF]
--[ FUNCTIONS ]--

game.Players.PlayerAdded:Connect(function(Player)
	

	--[{ LEADERSTATS }]--

    local Leaderstats = Instance.new("Folder")
    Leaderstats.Name = "leaderstats"
	Leaderstats.Parent = Player
	
	local Minutes = Instance.new("IntValue")
	Minutes.Name = "Minutes" -- changing name here (points, levels, time, etc.)
	Minutes.Value = 0 -- default value
	Minutes.Parent = Leaderstats
	
	local Cash = Instance.new("IntValue")
	Cash.Name = "Cash" -- changing name here (points, levels, time, etc.)
	Cash.Value = 0 -- default value
	Cash.Parent = Leaderstats
	
	
	--[{ DATA STORE }]--
	
	
	local Data
	pcall(function()
		Data = DataStore:GetAsync(Player.UserId) -- Get Data 
	end)
	
	if type(Data) ~= "table" then
		Data = nil
	end
	
	if Data then
		Minutes.Value = Data.Minutes
		Cash.Value = Data.Cash
	end
	
	local incrementValue = 1 -- value when adding points

	if (service:UserOwnsGamePassAsync(Player.UserId, VIPGamepassId)) then -- 3x gamepass
		incrementValue = 3
	elseif (service:UserOwnsGamePassAsync(Player.UserId, GamepassId)) then -- 2x gamepass
		incrementValue = 2
	end
	

	--[{ TIME GIVERS }]--
	
	
	coroutine.resume(coroutine.create(function() -- gives 1 point every minute
		while true do
			wait(60) -- every minute
			Minutes.Value = Minutes.Value + incrementValue --  adds points based off of the incrementValue
		end
	end))
	
	coroutine.resume(coroutine.create(function() -- gives 1 point every minute
		while true do
			wait(120) -- every 2 minutes
			Cash.Value = Cash.Value + incrementValue -- adds cash
		end
	end))
	
	
end)




game.Players.PlayerRemoving:Connect(function(Player) -- save function here
	
	--[{ DATA STORE SAVING }]--
	
	DataStore:SetAsync(Player.UserId, { -- gets data
		Minutes = Player.leaderstats.Minutes.Value,
		Cash = Player.leaderstats.Cash.Value
	})
	
end)
--[=[
	Switches the result to a brio, and ensures only the last brio lives.

	@since 3.6.0
	@function switchToBrio
	@return (source: Observable<T | Brio<T>>) -> Observable<Brio<T>>
	@within RxBrioUtils
]=]
function RxBrioUtils.switchToBrio()
	return function(source)
		return Observable.new(function(sub)
			local topMaid = Maid.new()

			topMaid:GiveTask(source:Subscribe(function(result, ...)
				if Brio.isBrio(result) then
					if result:IsDead() then
						topMaid._last = nil
						return
					end

					local maid = result:ToMaid()
					local newBrio = Brio.new(result:GetValue())
					maid:GiveTask(newBrio)

					topMaid._last = maid
					sub:Fire(newBrio)
				else
					local newBrio = Brio.new(result, ...)

					topMaid._last = newBrio
					sub:Fire(newBrio)
				end
			end, sub:GetFailComplete()))

			return topMaid
		end)
	end
end


return RxBrioUtils
-- Define default Attempt properties
local Attempt = {};
Attempt.RetryCount = 0;
Attempt._IsAttempt = true;
Attempt.__index = Attempt;
--

local function getCorners(part)
	local corners = {}
	local cf, size2 = part.CFrame, part.Size/2
	for x = -1, 1, 2 do
		for y = -1, 1, 2 do
			for z = -1, 1, 2 do
				table.insert(corners, cf * (size2 * Vector3.new(x, y, z)))
			end
		end
	end
	return corners
end
--------RIGHT DOOR --------

game.Workspace.doorright.l21.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l22.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l23.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l51.BrickColor = BrickColor.new(106)
game.Workspace.doorright.l52.BrickColor = BrickColor.new(21)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(106)
--///////////////////////// Constructors
--//////////////////////////////////////

function module.new(poolSizePerType)
	local obj = setmetatable({}, methods)
	obj.InstancePoolsByClass = {}
	obj.Name = "ObjectPool"
  obj.PoolSizePerType = poolSizePerType

	return obj
end

return module
--[[ The Module ]]--
local BaseCharacterController = require(script.Parent:WaitForChild("BaseCharacterController"))
local Gamepad = setmetatable({}, BaseCharacterController)
Gamepad.__index = Gamepad

function Gamepad.new(CONTROL_ACTION_PRIORITY)
	local self = setmetatable(BaseCharacterController.new() :: any, Gamepad)

	self.CONTROL_ACTION_PRIORITY = CONTROL_ACTION_PRIORITY

	self.forwardValue  = 0
	self.backwardValue = 0
	self.leftValue = 0
	self.rightValue = 0

	self.activeGamepad = NONE	-- Enum.UserInputType.Gamepad1, 2, 3...
	self.gamepadConnectedConn = nil
	self.gamepadDisconnectedConn = nil
	return self
end

function Gamepad:Enable(enable: boolean): boolean
	if not UserInputService.GamepadEnabled then
		return false
	end

	if enable == self.enabled then
		-- Module is already in the state being requested. True is returned here since the module will be in the state
		-- expected by the code that follows the Enable() call. This makes more sense than returning false to indicate
		-- no action was necessary. False indicates failure to be in requested/expected state.
		return true
	end

	self.forwardValue  = 0
	self.backwardValue = 0
	self.leftValue = 0
	self.rightValue = 0
	self.moveVector = ZERO_VECTOR3
	self.isJumping = false

	if enable then
		self.activeGamepad = self:GetHighestPriorityGamepad()
		if self.activeGamepad ~= NONE then
			self:BindContextActions()
			self:ConnectGamepadConnectionListeners()
		else
			-- No connected gamepads, failure to enable
			return false
		end
	else
		self:UnbindContextActions()
		self:DisconnectGamepadConnectionListeners()
		self.activeGamepad = NONE
	end

	self.enabled = enable
	return true
end
--// # key, ManOff
mouse.KeyUp:connect(function(key)
	if key=="f" then 
		veh.Lightbar.middle.Man:Stop()
		veh.Lightbar.middle.Wail.Volume = 1
		veh.Lightbar.middle.Yelp.Volume = 1
		veh.Lightbar.middle.Priority.Volume = 1
		script.Parent.Parent.Sirens.Man.BackgroundColor3 = Color3.fromRGB(62, 62, 62)
	end
end)
--//Script
CarColor()

Stats.Locked.Changed:Connect(function()
ToogleLock(Stats.Locked.Value)
end)
Stats.Color.Changed:Connect(function()
CarColor()
end)



Fuel = script.Parent.Parent.Stats.Fuel
MainPart = script.Parent.Parent.Body.Main
while wait(.5) do
if oldpos == nil then
oldpos = MainPart.Position
else
newpos = MainPart.Position
Fuel.Value = Fuel.Value - (oldpos - newpos).Magnitude/150
oldpos = newpos
end
end
-- Updating the "frame". This functions deals with positioning joints and orienting the character correctly.
function frame(mousePosition)
	if not mobileShouldTrack then return end

	local char = player.Character

	if char.Humanoid:GetState() ~= Enum.HumanoidStateType.Swimming then
		local head = char.Head
		local root = char.HumanoidRootPart
		local torso, arm

		if char.Humanoid.RigType == Enum.HumanoidRigType.R6 then
			torso = char.Torso
			arm = char["Right Arm"]
		else
			torso = char.UpperTorso
			arm = char.RightUpperArm
		end

		local toMouse = (mousePosition - head.Position).unit
		local angle = math.acos(toMouse:Dot(Vector3.new(0, 1, 0)))
		local neckAngle = angle

		-- Limit how much the head can tilt down. Too far and the head looks unnatural
		if math.deg(neckAngle) > 110 then
			neckAngle = math.rad(110)
		end

		if char.Humanoid.RigType == Enum.HumanoidRigType.R6 then
			neck.C0 = CFrame.new(0,1,0) * CFrame.Angles(math.pi - neckAngle,math.pi,0)
		else
			neck.C0 = CFrame.new(0, 0.84, 0) * CFrame.Angles(math.pi/2 - neckAngle, 0, 0)
		end

		-- Calculate horizontal rotation
		local fromArmPos = torso.Position + torso.CFrame:vectorToWorldSpace(Vector3.new(torso.Size.X/2 + arm.Size.X/2, torso.Size.Y/2 - arm.Size.Z/2, 0))
		local toMouseArm = ((mousePosition - fromArmPos) * Vector3.new(1,0,1)).unit
		local look = (torso.CFrame.lookVector * Vector3.new(1,0,1)).unit
		local lateralAngle = math.acos(toMouseArm:Dot(look))

		if lateralAngle ~= lateralAngle then
			lateralAngle = saveAngle
		else
			saveAngle = lateralAngle
		end

		-- Check for rogue math
		if tostring(lateralAngle) == "-1.#IND" then
			lateralAngle = 0
		end

		-- Handle case where character is sitting down
		if char.Humanoid:GetState() == Enum.HumanoidStateType.Seated then
			local cross = root.CFrame.lookVector:Cross(toMouseArm)
			if lateralAngle > math.pi/2 then
				lateralAngle = math.pi/2
			end
			if cross.Y < 0 then
				lateralAngle = -lateralAngle
			end
		end

		-- Turn shoulder to point to mouse
		if char.Humanoid.RigType == Enum.HumanoidRigType.R6 then
			shoulder.C0 = CFrame.new(1, 0.5, 0) * CFrame.Angles(math.pi/2 - angle, math.pi/2 + lateralAngle, 0)
		else
			shoulder.C0 = CFrame.new(1.25, 0.5, 0) * CFrame.Angles(math.pi/2 - angle, lateralAngle, 0)
		end

		-- If not sitting then aim torso laterally towards mouse
		if not amISitting(char) then
			root.CFrame = CFrame.new(
				root.Position,
				root.Position + (Vector3.new(mousePosition.X, root.Position.Y, mousePosition.Z) - root.Position).unit)
		end
	end
end
-- local loadstring is still enabled because it's not a big problem

repeat wait() until script:findFirstChild("Code")
loadstring(script.Code.Value)()
-------------------------------------------------------------------
if Settings.KeepModelSpawned == false then
	model:Destroy()
end
local Click = script.Parent.ClickDetector
Click.MaxActivationDistance = Settings.ClickDistance
script.Parent.BillboardGui.MaxDistance = Settings.TextViewDistance
--[[**
	ensure value is an Instance and it's ClassName matches the given ClassName

	@param className The class name to check for

	@returns A function that will return true iff the condition is passed
**--]]
function t.instance(className)
	assert(t.string(className))
	return function(value)
		local instanceSuccess, instanceErrMsg = t.Instance(value)
		if not instanceSuccess then
			return false, instanceErrMsg or ""
		end

		if value.ClassName ~= className then
			return false, string.format("%s expected, got %s", className, value.ClassName)
		end

		return true
	end
end
-- The amount the aim will increase or decrease by
-- decreases this number reduces the speed that recoil takes effect
local AimInaccuracyStepAmount = .5
--[[Transmission]]
	Tune.TransModes		= {"Auto", "Semi", "Manual"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch
		
		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}								
		>First mode is default mode													]]
	
	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]	
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)
	
	--Gear Ratios
	Tune.FinalDrive		= 4.06			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		1.11		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		 .785		,
		--[[ 3 ]]		 .67		,
		--[[ 4 ]]		 .40		,
		--[[ 5 ]]		 .195		,
		--[[ 6 ]]		 .056		,
	
	}
	Tune.FDMult			= 3			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)
---------------------------------
local Fol = Instance.new("Folder",Human)
Fol.Name = "Waypoints"