Roblox/luau_corpus huggingface dataset:
--[[if (script.Parent.Active) then
	script.Parent.Name = "RESELECT"
	while (script.Parent.Active) do wait() end
end
script.Parent.Name = "Plane"]]

function changeGear()
	gear = (not gear)
	for _,v in pairs(gearParts) do
		v.Transparency,v.Reflectance,v.CanCollide = (gear and v.Trans.Value or 1),(gear and v.Ref.Value or 0),(gear and v.Collide.Value or false)	-- Learning how to code like this is extremely useful
	end
end

function updateGui(taxiing,stalling)
	panel.Off.Visible = (not on)
	panel.Taxi.Visible,panel.Stall.Visible = taxiing,(not taxiing and stalling)
	if ((realSpeed > -10000) and (realSpeed < 10000)) then
		panel.Speed.Value.Text = tostring(math.floor(realSpeed+0.5))
	end
	panel.Altitude.Value.Text = tostring(math.floor(main.Position.y+0.5)) - 8
	panel.Throttle.Bar.Amount.Size = UDim2.new(throttle,0,1,0)
end

function taxi()	-- Check to see if the plane is on the ground or not
	return (currentSpeed <= stallSpeed and game.Workspace:findPartOnRay(Ray.new(main.Position,Vector3.new(0,-lowestPoint,0)),plane))	-- Make sure plane is on a surface
end

function stall()	-- Originally set as a giant ternary operation, but got WAY too complex, so I decided to break it down for my own sanity
	if ((altRestrict) and (main.Position.y > altMax)) then return true end
	local diff = ((realSpeed-stallSpeed)/200)
	diff = (diff > 0.9 and 0.9 or diff)
	local check = {	-- Table placed here so I could easily add new 'checks' at ease. If anything in this table is 'true,' then the plane will be considered to be taxiing
		(currentSpeed <= stallSpeed);
		(main.CFrame.lookVector.y > (realSpeed < stallSpeed and -1 or -diff));
	}
	for _,c in pairs(check) do
		if (not c) then return false end
	end
	return true
end

function fly(m)	-- Main function that controls all of the flying stuff. Very messy.
	flying = true
	local pos,t = main.Position,time()
	local lastStall = false
	while ((flying) and (not dead)) do
		--realSpeed = ((pos-main.Position).magnitude/(time()-t))	-- Calculate "real" speed
		realSpeed = main.Velocity.Magnitude
		pos,t = main.Position,time()
		local max = (maxSpeed+(-main.CFrame.lookVector.y*speedVary))	-- Speed variety based on the pitch of the aircraft
		desiredSpeed = (max*(on and throttle or 0))	-- Find speed based on throttle
		local change = (desiredSpeed > currentSpeed and 1 or -1)	-- Decide between accelerating or decelerating
		currentSpeed = (currentSpeed+(accel*change))	-- Calculate new speed
--[[Engine]]

	--		[TORQUE CURVE VISUAL]
	--		https://www.desmos.com/calculator/nap6stpjqf
	--		Use sliders to manipulate values
	--		Edit everything as if your car is NATURALLY aspirated, or as if it lacks a turbo.
	
	Tune.Horsepower		= 165
	Tune.IdleRPM		= 800
	Tune.PeakRPM		= 5500
	Tune.Redline		= 6000
	Tune.EqPoint		= 5252
	Tune.PeakSharpness	= 6.0
	Tune.CurveMult		= 0.2
	
	Tune.InclineComp	= 1.5		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Turbo Settings
	Tune.Aspiration		= "Natural"												--[[
	[Aspiration]
		"Natural"		: N/A, Naturally aspirated engine
		"Single"		: Single turbocharger
		"Double"		: Twin turbocharger											]]
	
	Tune.Boost			= 15		--Max PSI per turbo (If you have two turbos and this is 15, the PSI will be 30)
	Tune.TurboSize		= 80		--Turbo size; the bigger it is, the more lag it has.
	Tune.CompressRatio	= 9			--The compression ratio (look it up)
	
	--Misc
	Tune.RevAccel		= 125		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 25		-- RPM decay when clutch is off
	Tune.RevBounce		= 0		-- RPM kickback from redline
	Tune.IdleThrottle	= 5			-- Percent throttle at idle
	Tune.ClutchTol		= 250		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)
-- Decompiled with the Synapse X Luau decompiler.

module = {};
function module.sanitize(p1)
	return p1:gsub("%c", "");
end;
return module;
-----------------------------------------------------------------------------------------------

script.Parent:WaitForChild("Speedo")
script.Parent:WaitForChild("Tach")
script.Parent:WaitForChild("ln")
script.Parent:WaitForChild("Gear")
script.Parent:WaitForChild("Speed")

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

local car = script.Parent.Parent.Car.Value
car.Body.RSPD2.VehicleSeat.HeadsUpDisplay = false

local _Tune = require(car["A-Chassis Tune"])

local _pRPM = _Tune.PeakRPM
local _lRPM = _Tune.Redline

local currentUnits = 1
local revEnd = math.ceil(_lRPM/1000)
---Register User Input---
--Listen for keyboard and gamepad input
local function seatingAction(actionName, inputState, inputObj)
	if inputState == Enum.UserInputState.Begin then
		if AdornedSeat then
			if isFlipped(AdornedSeat) then
				flipSeat()
			else
				EnterKeyDown = true
				enterStart()
			end
			return Enum.ContextActionResult.Sink
		end
	elseif EnterKeyDown then
		EnterKeyDown = false
		return Enum.ContextActionResult.Sink
	end
	return Enum.ContextActionResult.Pass
end
--// [ key, ally
mouse.KeyDown:connect(function(key)
	if key=="m" then 
		veh.Lightbar.middle.Beep:Play()
		veh.Lightbar.Remotes.AllyEvent:FireServer(true)
	end
end)
--Tune

local WheelieButton = "T"
local DeadZone = 90
--[=[
	Use  to test that the left padding between the given GuiObject or Rect and
	the other GuiObject or Rect.

	The last argument is optional. If nil, the matcher will pass only if the
	difference **left** edge of the given GuiObject or Rect and the **left**
	edge of the other GuiObject or Rect is zero or positive.

	```lua
	-- Jest
	expect(instanceA).toBeInsideRightOf(instanceB)
	expect(instanceA).toBeInsideRightOf(instanceB, 10)
	expect(instanceA).toBeInsideRightOf(instanceB, NumberRange.new(0, 10))
	```

	```lua
	-- TestEZ
	expect(instanceA).to.be.insideRightOf(instanceB)
	expect(instanceA).to.be.insideRightOf(instanceB, 10)
	expect(instanceA).to.be.insideRightOf(instanceB, NumberRange.new(0, 10))
	```

	@tag inside
	@within CollisionMatchers2D
]=]
local function insideRightOf(a: GuiObject | Rect, b: GuiObject | Rect, distance: number | NumberRange)
	local aRect = toRect(a)
	local bRect = toRect(b)

	local distanceFromSide = (aRect.Min - bRect.Min)
	if distance then
		if typeof(distance) == "number" then
			distance = NumberRange.new(distance)
		end

		return returnValue(
			distance.Min <= distanceFromSide.X and distance.Max >= distanceFromSide.X,
			"Was within range",
			"Was not within range ( " .. tostring(distance) .. ")"
		)
	else
		return returnValue(distanceFromSide.X >= 0, "Was not left of the element", "Was too far left of the element")
	end
end

return insideRightOf
-- list of account names allowed to go through the door. 
permission = {"YOURNAMEHERE"}--Put your friends name's here. You can add more.

function checkOkToLetIn(name) 
	for i = 1,#permission do 
		
		if (string.upper(name) == string.upper(permission[i])) then return true end 
	end 
	return false 
end 

local Door = script.Parent

function onTouched(hit) 
	print("Door Hit") 
	local human = hit.Parent:findFirstChild("Humanoid") 
	if (human ~= nil ) then 
		-- a human has touched this door! 
		print("Human touched door") 
		-- test the human's name against the permission list 
		if (checkOkToLetIn(human.Parent.Name)) then 
			print("Human passed test") 
			Door.Transparency = 0.7 
			Door.CanCollide = false 
			wait(1) -- this is how long the door is open 
			Door.CanCollide = true 
			Door.Transparency = 0 
		else human.Health= 0 -- delete this line of you want a non-killing VIP door 
		end 
	end 
end 

script.Parent.Touched:connect(onTouched)
--[[
	Provides an interface to quickly run and report tests from a given object.
]]

local TestPlanner = require(script.Parent.TestPlanner)
local TestRunner = require(script.Parent.TestRunner)
local TextReporter = require(script.Parent.Reporters.TextReporter)

local TestBootstrap = {}

local function stripSpecSuffix(name)
	return (name:gsub("%.spec$", ""))
end
local function isSpecScript(aScript)
	return aScript:IsA("ModuleScript") and aScript.Name:match("%.spec$")
end

local function getPath(module, root)
	root = root or game

	local path = {}
	local last = module

	if last.Name == "init.spec" then
		-- Use the directory's node for init.spec files.
		last = last.Parent
	end

	while last ~= nil and last ~= root do
		table.insert(path, stripSpecSuffix(last.Name))
		last = last.Parent
	end
	table.insert(path, stripSpecSuffix(root.Name))

	return path
end

local function toStringPath(tablePath)
	local stringPath = ""
	local first = true
	for _, element in ipairs(tablePath) do
		if first then
			stringPath = element
			first = false
		else
			stringPath = element .. " " .. stringPath
		end
	end
	return stringPath
end

function TestBootstrap:getModulesImpl(root, modules, current)
	modules = modules or {}
	current = current or root

	if isSpecScript(current) then
		local method = require(current)
		local path = getPath(current, root)
		local pathString = toStringPath(path)

		table.insert(modules, {
			method = method,
			path = path,
			pathStringForSorting = pathString:lower()
		})
	end
end
--//Controller//--
Tool.Activated:Connect(function()
	if Configuration.OnCD.Value == false then
		ToolEvent:FireServer()
		
	end
end)
-- Await initialization
repeat wait() until _G[Tool];
Plugin = _G[Tool].Plugin;
--[[
		___      _______                _     
	   / _ |____/ ___/ /  ___ ____ ___ (_)__ 
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						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 mult=0
local det=0
local trm=0
local trmmult=0
local trmon=0
local throt=0
local redline=0
local shift=0

script:WaitForChild("Rev")

script.Parent.Values.Gear.Changed:connect(function()
	mult=1
	if script.Parent.Values.RPM.Value>5000 then
		shift=.2
	end
end)

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

handler:FireServer("newSound","Rev",car.DriveSeat,script.Rev.SoundId,0,script.Rev.Volume,true)
handler:FireServer("playSound","Rev")
car.DriveSeat:WaitForChild("Rev")

while wait() do
	mult=math.max(0,mult-.1)
	local _RPM = script.Parent.Values.RPM.Value
	
	if script.Parent.Values.Throttle.Value <= _Tune.IdleThrottle/100 then
		throt = math.max(.3,throt-.2)
		trmmult = math.max(0,trmmult-.05)
		trmon = 1		
	else
		throt = math.min(1,throt+.1)
		trmmult = 1
		trmon = 0		
	end	
	shift = math.min(1,shift+.2)	
	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 Volume = (3*throt*shift*redline)+(trm*trmon*trmmult*(3-throt)*math.sin(tick()*50))
	local Pitch = math.max((((script.Rev.SetPitch.Value + script.Rev.SetRev.Value*_RPM/_Tune.Redline))*on^2)+(det*mult*math.sin(80*tick())),script.Rev.SetPitch.Value)
	if FE then
		handler:FireServer("updateSound","Rev",script.Rev.SoundId,Pitch,Volume)
	else
		car.DriveSeat.Rev.Volume = Volume
		car.DriveSeat.Rev.Pitch = Pitch
	end
end
--Put in ServerScriptService

game.Players.PlayerAdded:connect(function(player)
	player.CharacterAdded:connect(function(character)
		--script.ToggleRagdoll:Clone().Parent = character
		script.RagdollRig:Clone().Parent = character
		script.Physics:Clone().Parent = character
		script.WindSetting:Clone().Parent = character
		script.RagdollConnect:Clone().Parent = character
		character:WaitForChild("Humanoid").Died:connect(function()
			character.UpperTorso:SetNetworkOwner(player)
		end)
	end)
end)
--//Setup//--
local JarBody = script.Parent

local Jar = JarBody.Parent
-- Make a base cosmetic bullet object. This will be cloned every time we fire off a ray.
local CosmeticBullet = Instance.new("Part")
CosmeticBullet.Material = Enum.Material.Neon
CosmeticBullet.Color = Color3.fromRGB(0, 196, 255)
CosmeticBullet.CanCollide = false
CosmeticBullet.Anchored = true
CosmeticBullet.Size = Vector3.new(0.75, 0.75, 2.4)
--Editable Values
local Drag = .14  	--Drag Coefficient
local F = 125		--Downforce at 300 SPS
local R = 150		--Downforce at 300 SPS
local Vol = 2.5
-- ROBLOX NOTE upstream: Added some utilities to support keeping the upstream code consistent
type unknown = any

local CurrentModule = script.Parent
local Packages = CurrentModule.Parent

local LuauPolyfill = require(Packages.LuauPolyfill)
local inspect = LuauPolyfill.util.inspect
type Array<T> = LuauPolyfill.Array<T>

local typesModule = require(CurrentModule.types)
type InspectOptions = typesModule.InspectOptions

function concatRestArgs(restArgs: Array<unknown>)
	local restStr = ""
	if #restArgs > 0 then
		restStr = " " .. table.concat(restArgs, " ")
	end
	return restStr
end

function getFormattedValue(value: unknown, inspectOptions: InspectOptions?)
	return if type(value) == "string" then value else inspect(value, inspectOptions)
end

function format(...)
	return formatter(nil, ...)
end

function formatWithOptions(inspectOptions: InspectOptions, fmt: unknown, ...)
	return formatter(inspectOptions, fmt, ...)
end

function formatter(inspectOptions: InspectOptions?, fmt: unknown, ...)
	local args = { ... }

	local fmtArgs = {}
	local extraArgs = {}

	if type(fmt) == "string" then
		local _, c = fmt:gsub("%%[sdj%%]", "")

		for key, value in pairs(args) do
			local formattedValue = getFormattedValue(value, inspectOptions)
			if key <= c then
				table.insert(fmtArgs, formattedValue)
			else
				table.insert(extraArgs, formattedValue)
			end
		end
	else
		fmt = inspect(fmt, inspectOptions)
		for _, value in pairs(args) do
			table.insert(extraArgs, getFormattedValue(value, inspectOptions))
		end
	end

	return string.format(fmt, table.unpack(fmtArgs)) .. concatRestArgs(extraArgs)
end

return {
	format = format,
	formatWithOptions = formatWithOptions,
	concatRestArgs = concatRestArgs,
}
--------------------------------------------------
script.Parent.Values.RPM.Changed:connect(function()
	intach.Rotation = -120 + script.Parent.Values.RPM.Value * 250 / 10500
end)

script.Parent.Values.Velocity.Changed:connect(function(property)
end)


script.Parent.Values.PBrake.Changed:connect(function()
end)
--Unlock or Lock AR/AF timer if enclosure is locked

function LockButtons()
	ButtonAlert.ProximityPrompt.Enabled = false
	ButtonAttack.ProximityPrompt.Enabled = false
	ButtonCancel.ProximityPrompt.Enabled = false
	ButtonTest.ProximityPrompt.Enabled = false
	ButtonFire.ProximityPrompt.Enabled = false
end

function UnlockButtons()
	ButtonAlert.ProximityPrompt.Enabled = true
	ButtonAttack.ProximityPrompt.Enabled = true
	ButtonCancel.ProximityPrompt.Enabled = true
	ButtonTest.ProximityPrompt.Enabled = true
	ButtonFire.ProximityPrompt.Enabled = true
end

function Check()
	if script.Parent.Locked.Value == true then
		LockButtons()
	else
		UnlockButtons()
	end
end

Check()

script.Parent.Locked.Changed:Connect(function()
	Check()
end)
--[[Front]]--
	Tune.FSusDamping	= 85 		-- Dampening
	Tune.FSusStiffness	= 2000 		-- Stiffness
	
	Tune.FSusLength		= 1 		-- Suspension length (in studs)
	Tune.FPreComp		= .25 		-- Vehicle height, relative to your suspension settings
	Tune.FExtLimit		= .8 		-- Max Extension Travel (in studs)
	Tune.FCompLimit		= .4 		-- Max Compression Travel (in studs)
	
	Tune.FBaseOffset	= {			-- Suspension (steering point) base
		 --[[Lateral]]		0		,	-- positive = outward
		 --[[Vertical]]		0		,	-- positive = upward
		 --[[Forward]]		0.256		}	-- positive = forward
	Tune.FAxleOffset	= {			-- Suspension (axle point) base
		 --[[Lateral]]		0		,	-- positive = outward
		 --[[Vertical]]		0		,	-- positive = upward
		 --[[Forward]]		0		}	-- positive = forward
	
	Tune.FBricksVisible	= false 	-- Makes the front suspension bricks visible (Debug)
	Tune.FConstsVisible	= false 	-- Makes the front suspension constraints visible (Debug)
--[[
	@class MarketPlaceManager
	
	Library of utility functions that handle the MarketPlace.
]]

local Products = require(script.Products)

local module = {}


module.Products = Products

return module
--\\Main//--
for Number, Instance in pairs(game.Workspace:GetChildren()) do
	if Instance:IsA("Part") and Instance.Name == "Base" then
		Instance.Touched:Connect(function(Hit)
			local Player = PlayerService:GetPlayerFromCharacter(Hit.Parent)
			if not Player then return end
			Player.Character:FindFirstChild("Humanoid").Sit = true
		end)
	end
end
--[[
	Given a `tweenInfo` and `currentTime`, returns a ratio which can be used to
	tween between two values over time.
]]

local TweenService = game:GetService("TweenService")

local function getTweenRatio(tweenInfo: TweenInfo, currentTime: number): number
	local delay = tweenInfo.DelayTime
	local duration = tweenInfo.Time
	local reverses = tweenInfo.Reverses
	local numCycles = 1 + tweenInfo.RepeatCount
	local easeStyle = tweenInfo.EasingStyle
	local easeDirection = tweenInfo.EasingDirection

	local cycleDuration = delay + duration
	if reverses then
		cycleDuration += duration
	end

	if currentTime >= cycleDuration * numCycles then
		return 1
	end

	local cycleTime = currentTime % cycleDuration

	if cycleTime <= delay then
		return 0
	end

	local tweenProgress = (cycleTime - delay) / duration
	if tweenProgress > 1 then
		tweenProgress = 2 - tweenProgress
	end

	local ratio = TweenService:GetValue(tweenProgress, easeStyle, easeDirection)
	return ratio
end

return getTweenRatio
--[[
	Retrieves at most one child from the children passed to a component.

	If passed nil or an empty table, will return nil.

	Throws an error if passed more than one child.
]]
local function oneChild(children)
	if not children then
		return nil
	end

	local key, child = next(children)

	if not child then
		return nil
	end

	local after = next(children, key)

	if after then
		error("Expected at most child, had more than one child.", 2)
	end

	return child
end

return oneChild
-- (Hat Giver Script - 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 = "Top Hat"
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle" 
		p.formFactor = 0
		p.Size = Vector3.new(2, 1, 1) 
		p.BottomSurface = 0 
		p.TopSurface = 0 
		p.Locked = true 
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentPos = Vector3.new(0,1,-1)
		wait(5)
		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)
--[[
    Module for obtaining the input state for the vehicle, using UserInputService
]]
local UserInputService = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local ClientVehicleBoosts = require(ReplicatedStorage.Source.ClientVehicleBoosts)
local Flags = require(ReplicatedStorage.Source.Common.Flags)

local FlagEnableBoosts = Flags.EnableBoosts

local UserInput = {}

local throttle = 0
local steer = 0

local actions = {
	Forwards = {Enum.KeyCode.W, Enum.KeyCode.Up},
	Backwards = {Enum.KeyCode.S, Enum.KeyCode.Down},
	Left = {Enum.KeyCode.A, Enum.KeyCode.Left},
	Right = {Enum.KeyCode.D, Enum.KeyCode.Right},
	Boost = {Enum.KeyCode.Space}
}

local function getActionFromInput(inputObject)
	for action, bindings in pairs(actions) do
		for _, keyCode in pairs(bindings) do
			if keyCode == inputObject.KeyCode then
				return action
			end
		end
	end
end

local function isActionHeld(action)
	local bindings = actions[action]
	for _, keyCode in pairs(bindings) do
		if UserInputService:IsKeyDown(keyCode) then
			return true
		end
	end
	return false
end
-------------------------------------
equiped=false
sp=script.Parent
RayLength=10000
Spread=0
enabled=true
reloading=false
down=false
r=game:service("RunService")
last=0
last2=0
last3=0
last4=0
last5=0
last6=0

Bullet=Instance.new("Part")
Bullet.Name="Bullet"
Bullet.BrickColor=BrickColor.new("New Yeller")
Bullet.Anchored=true
Bullet.CanCollide=false
Bullet.Locked=true
Bullet.Size=Vector3.new(1,1,1)
--[=[
	@tag Component Class
	`Start` is called when the component is started. At this point in time, it
	is safe to grab other components also bound to the same instance.

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

	function MyComponent:Start()
		-- e.g., grab another component:
		local another = self:GetComponent(AnotherComponent)
	end
	```
]=]
function Component:Start()
end
--Functions
local function onTouched(hit)
	local Humanoid = hit.Parent:FindFirstChild("Humanoid")
	local player = game.Players:GetPlayerFromCharacter(hit.Parent)

	if Humanoid and Debounce == false then
		local leaderstats = player:FindFirstChild("leaderstats")
		Debounce = true

		if Debounce == true and leaderstats then
			local sound = script.Parent["Game Sound Correct"]

			if not sound.IsPlaying then
				sound:Play()
	
			leaderstats.Guesses.Value = leaderstats.Guesses.Value + AMOUNT_GIVEN
				wait(10)
				
			Debounce = false
		end
	end
end
end
--------------------) Settings
Damage = 0 -- the ammout of health the player or mob will take

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

BoneModelName = "OWO zone" -- name the zone model

HumanoidName = "Humanoid"-- the name of player or mob u want to damage
--[[Run]]

	--Print Version
	local ver=require(car["A-Chassis Tune"].README)
	print("//INSPARE: AC6 Loaded - Build "..ver)
	
	--Runtime Loops
	
	-- ~60 c/s
	game["Run Service"].Stepped:connect(function()
		--Steering
		Steering()
		
		--RPM
		RPM()
		
		--Update External Values
		_IsOn = script.Parent.IsOn.Value
		_InControls = script.Parent.ControlsOpen.Value
		script.Parent.Values.Gear.Value = _CGear
		script.Parent.Values.RPM.Value = _RPM
		script.Parent.Values.Horsepower.Value = _HP
		script.Parent.Values.Torque.Value = _HP * _Tune.EqPoint / _RPM
		script.Parent.Values.TransmissionMode.Value = _TMode
		script.Parent.Values.Throttle.Value = _GThrot
		script.Parent.Values.Brake.Value = _GBrake
		script.Parent.Values.SteerC.Value = _GSteerC*(1-math.min(car.DriveSeat.Velocity.Magnitude/_Tune.SteerDecay,1-(_Tune.MinSteer/100)))
		script.Parent.Values.SteerT.Value = _GSteerT
		script.Parent.Values.PBrake.Value = _PBrake
		script.Parent.Values.TCS.Value = _TCS
		script.Parent.Values.TCSActive.Value = _TCSActive
		script.Parent.Values.ABS.Value = _ABS
		script.Parent.Values.ABSActive.Value = _ABSActive
		script.Parent.Values.MouseSteerOn.Value = _MSteer
		script.Parent.Values.Velocity.Value = car.DriveSeat.Velocity
	end)
	
	-- ~15 c/s
	while wait(.0667) do
		--Power
		Engine()
		
		--Flip
		if _Tune.AutoFlip then Flip() end
		if Stats.Fuel == 0 then _IsOn = false end
		
	end
-- Helper function for Determinant of 3x3, not in CameraUtils for performance reasons
local function Det3x3(a: number,b: number,c: number,d: number,e: number,f: number,g: number,h: number,i: number): number
	return (a*(e*i-f*h)-b*(d*i-f*g)+c*(d*h-e*g))
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
		playAnimation("sit", 0.5, Humanoid)
		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