Roblox/luau_corpus huggingface dataset:
------------- Settings

local Lighting = game.Lighting
local TweenService = game:GetService("TweenService")

function day()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ClockTime = 12}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Brightness = 3.05}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Ambient = Color3.fromRGB(106, 130, 186)}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ColorShift_Bottom = Color3.fromRGB(0,0,0)}):Play()
end

function night()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ClockTime = 0}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Brightness = 0.4}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {Ambient = Color3.fromRGB(0,0,0)}):Play()
	TweenService:Create(Lighting, TweenInfo.new(Speed), {ColorShift_Bottom = Color3.fromRGB(0,0,0)}):Play()
end

while true do
	day()
	wait(DayDuration60)
	night()
	wait(NightDuration60)
end
-- Decompiled with the Synapse X Luau decompiler.

local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();
return function(p1)
	return "1/" .. u1.Functions.FormatAbbreviated(1 / p1);
end;
--[[Drivetrain Initialize]]

	local Drive={}
	
	--Power Front Wheels
	--if _Tune.Config == "FWD" or _Tune.Config == "AWD" then
		--for i,v in pairs(car.Wheels:GetChildren()) do
			--if v.Name=="FL" or v.Name=="FR" or v.Name=="F" then
				--table.insert(Drive,v)
			--end
		--end
	--end
	
	--Power Rear Wheels
	if _Tune.Config == "RWD" or _Tune.Config == "AWD" then
		for i,v in pairs(car.Wheels:GetChildren()) do
			if v.Name=="RL" or v.Name=="RR" or v.Name=="R" then
				table.insert(Drive,v)
			end
		end
	end
	
	--Determine Wheel Size
	local wDia = 0
	for i,v in pairs(Drive) do
		if v.Size.x>wDia then wDia = v.Size.x end
	end
	
	--Pre-Toggled PBrake
	for i,v in pairs(car.Wheels:GetChildren()) do
		if v["#AV"]:IsA("BodyAngularVelocity") then
			if math.abs(v["#AV"].maxTorque.Magnitude-PBrakeForce)<1 then
				_PBrake=true
			end
		else
			if math.abs(v["#AV"].MotorMaxTorque-PBrakeForce)<1 then
				_PBrake=true
			end
		end
	end
-- An hour in seconds
local RESHOWING_FREQUENCY = 1440*1440


function calculateShowTimes()
	local timeUntilNextShow = nil
	local timeIntoShow = nil
	local currentTime = DateTime.now().UnixTimestampMillis/1000
	local timeUntilFirstShow = FIRST_EVER_SHOW - currentTime
	if timeUntilFirstShow > 0 then
		timeUntilNextShow = timeUntilFirstShow
	else
		timeUntilNextShow = timeUntilFirstShow % RESHOWING_FREQUENCY
		timeIntoShow = RESHOWING_FREQUENCY - timeUntilNextShow
	end
	return timeUntilNextShow, timeIntoShow
end


function loadPreShowVenue()
	-- The PreShowVenue scene length needs to be adjusted to match the time until the next show.
	local timeUntilNextShow, timeIntoShow = calculateShowTimes()
	PSV_SCENE:SetAttribute("TimeLength", timeUntilNextShow)
	EventSequencer.loadScene(PSV_SCENE.Name)
end
------------------------------------------------------------------------
-- move on to next line
------------------------------------------------------------------------
function luaX:currIsNewline(ls)
  return ls.current == "\n" or ls.current == "\r"
end

function luaX:inclinenumber(ls)
  local old = ls.current
  -- lua_assert(currIsNewline(ls))
  self:nextc(ls)  -- skip '\n' or '\r'
  if self:currIsNewline(ls) and ls.current ~= old then
    self:nextc(ls)  -- skip '\n\r' or '\r\n'
  end
  ls.linenumber = ls.linenumber + 1
  if ls.linenumber >= self.MAX_INT then
    self:syntaxerror(ls, "chunk has too many lines")
  end
end
--Function For Making New Ray Bricks
function makeRay(cframe, size)
	local p						= Instance.new("Part")
	p.Name						= "RayPart"
	p.BrickColor				= BrickColor.new("Bright red")
	p.Transparency				= 0.5
	p.Anchored					= true
	p.CanCollide				= false
	p.TopSurface				= Enum.SurfaceType.Smooth
	p.BottomSurface				= Enum.SurfaceType.Smooth
	p.formFactor				= Enum.FormFactor.Custom
	p.CFrame					= cframe
	p.Size						= size
	p.Parent					= m
	ignoreList[#ignoreList+1]	= p
end

		local flash = parts.Parent.Gun.Muzzle:clone()
		
	    
		flash.Parent = game.Workspace
		
		
		flash.Anchored = true

		parts.Parent.Gun.Muzzle.Sound:Play();
		local FL				= flash.PointLight:clone()
		FL.Parent				= flash
		FL.Enabled = true
		local Flashy = flash.Flash:clone()
		Flashy.Parent = flash
		Flashy.Enabled = true
		game.Debris:AddItem(FL, .07)
		game.Debris:AddItem(Flashy, 2)
		game.Debris:AddItem(flash, .08)

round					= Instance.new("Part", user)
round.Name				= "RayPart"
round.Transparency		= 0
round.Anchored			= true
round.CanCollide		= true
round.TopSurface		= Enum.SurfaceType.Smooth
round.BottomSurface		= Enum.SurfaceType.Smooth
round.Material			= Enum.Material.Neon
round.formFactor		= Enum.FormFactor.Custom
round.BrickColor		= BrickColor.new("Daisy orange")
yOffset					= -0.2

local PL				= Instance.new("PointLight")
PL.Parent				= round
PL.Brightness			= 50
PL.Color				= Color3.new(255, 255, 0)
PL.Range				= 10
PL.Shadows				= true
-- Roact
local new = Roact.createElement
local HotkeyTooltip = require(script.Parent:WaitForChild 'HotkeyTooltip')
--[[

have all the edits only on the client until the client is done
then send fire the remote event once with all the changes
instead of per accessory.
too lazy to change. adopt me does it 1 by 1 soo...

]]

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
--// Connections
L_108_.OnClientEvent:connect(function(L_191_arg1, L_192_arg2, L_193_arg3, L_194_arg4, L_195_arg5, L_196_arg6, L_197_arg7)
	if L_191_arg1 and not L_15_ then
		MakeFakeArms()
		
		L_42_ = L_2_.PlayerGui.MainGui
		L_26_ = L_42_:WaitForChild('Others')
		L_27_ = L_26_:WaitForChild('Kill')
		L_28_ = L_42_:WaitForChild('GameGui'):WaitForChild('AmmoFrame')
		L_29_ = L_28_:WaitForChild('Ammo')
		L_30_ = L_28_:WaitForChild('AmmoBackground')
		L_31_ = L_28_:WaitForChild('MagCount')
		L_32_ = L_28_:WaitForChild('MagCountBackground')
		L_33_ = L_28_:WaitForChild('DistDisp')
		L_34_ = L_28_:WaitForChild('Title')
		L_35_ = L_28_:WaitForChild('Mode1')
		L_36_ = L_28_:WaitForChild('Mode2')
		L_37_ = L_28_:WaitForChild('Mode3')
		L_38_ = L_28_:WaitForChild('Mode4')
		L_39_ = L_28_:WaitForChild('Mode5')
		L_40_ = L_28_:WaitForChild('Stances')
		L_41_ = L_42_:WaitForChild('Shading')
		L_41_.Visible = false
		
		L_34_.Text = L_1_.Name
		UpdateAmmo()
		
		L_43_ = L_192_arg2
		L_44_ = L_193_arg3
		L_45_ = L_194_arg4
		L_46_ = L_195_arg5
		L_47_ = L_196_arg6
		L_48_ = L_197_arg7	
		L_49_ = L_62_.Bolt
		
		L_87_ = L_48_.C1
		L_88_ = L_48_.C0
		
		if L_1_:FindFirstChild('AimPart2') then
			L_57_ = L_1_:WaitForChild('AimPart2')
		end
		
		if L_1_:FindFirstChild('FirePart2') then
			L_60_ = L_1_.FirePart2
		end
		
		if L_24_.FirstPersonOnly then
			L_2_.CameraMode = Enum.CameraMode.LockFirstPerson
		end
		--uis.MouseIconEnabled = false
		L_5_.FieldOfView = 70
		L_15_ = true
	elseif L_15_ then
		if L_3_ and L_3_.Humanoid and L_3_.Humanoid.Health > 0 and L_9_ then
			Stand()
			Unlean()
		end	
		
		L_93_ = 0
		L_80_ = false
		L_81_ = false
		L_82_ = false
		L_64_ = false
		L_67_ = false
		L_66_ = false
		Shooting = false
		
		L_97_ = 70
		
		RemoveArmModel()
		
		L_42_:Destroy()	
		
		for L_198_forvar1, L_199_forvar2 in pairs(IgnoreList) do
			if L_199_forvar2 ~= L_3_ and L_199_forvar2 ~= L_5_ and L_199_forvar2 ~= L_101_ then
				table.remove(IgnoreList, L_198_forvar1)
			end
		end
		
		if L_3_:FindFirstChild('Right Arm') and L_3_:FindFirstChild('Left Arm') then
			L_3_['Right Arm'].LocalTransparencyModifier = 0
			L_3_['Left Arm'].LocalTransparencyModifier = 0
		end	

		L_78_ = false
		L_69_ = true
		
		L_2_.CameraMode = Enum.CameraMode.Classic
		L_107_.MouseIconEnabled = true		
		L_5_.FieldOfView = 70
		L_15_ = false
		L_107_.MouseDeltaSensitivity = L_52_
		L_4_.Icon = "http://www.roblox.com/asset?id=0"
		L_15_ = false
		L_4_.TargetFilter = nil
	end
end)
--Edited by Stickmasterluke
local p = game.Players.LocalPlayer
local c = game.Workspace:WaitForChild(p.Name)
local m = p:GetMouse()
Tool=script.Parent
local part = Instance.new("Part")
part.CanCollide = false
part.Transparency = 1
part.Name = "Aim"
part.Anchored = true
part.Size = Vector3.new(.1,.1,.1)
part.CFrame = c.Torso.CFrame*CFrame.new(0,0,0)
part.Parent = c.Torso
delay(0,function()
	while wait(0.1) do
		part.CFrame = c.Torso.CFrame*CFrame.new(0,0,-3)
		part.CFrame = CFrame.new(part.Position, m.Hit.p)
	end
end)

enabled = true
function onButton1Down(mouse)
	if not enabled then
		return
	end

	enabled = false
	mouse.Icon = "rbxasset://textures\\GunWaitCursor.png"

	wait(.5)
	mouse.Icon = "rbxasset://textures\\GunCursor.png"
	enabled = true

end

function onEquippedLocal(mouse)
	if mouse == nil then
		print("Mouse not found")
		return 
	end
	
	mouse.Icon = "rbxasset://textures\\GunCursor.png"
	mouse.Button1Down:connect(function() onButton1Down(mouse) end)
end


Tool.Equipped:connect(onEquippedLocal)
--///////////////// Internal-Use Methods
--//////////////////////////////////////
--DO NOT REMOVE THIS. Chat must be filtered or your game will face
--moderation.
function methods:InternalApplyRobloxFilter(speakerName, message, toSpeakerName) --// USES FFLAG
	if (RunService:IsServer() and not RunService:IsStudio()) then
		local fromSpeaker = self:GetSpeaker(speakerName)
		local toSpeaker = toSpeakerName and self:GetSpeaker(toSpeakerName)

		if fromSpeaker == nil then
			return nil
		end

		local fromPlayerObj = fromSpeaker:GetPlayer()
		local toPlayerObj = toSpeaker and toSpeaker:GetPlayer()

		if fromPlayerObj == nil then
			return message
		end

		if allSpaces(message) then
			return message
		end

		local filterStartTime = tick()
		local filterRetries = 0
		while true do
			local success, message = pcall(function()
				if toPlayerObj then
					return Chat:FilterStringAsync(message, fromPlayerObj, toPlayerObj)
				else
					return Chat:FilterStringForBroadcast(message, fromPlayerObj)
				end
			end)
			if success then
				return message
			else
				warn("Error filtering message:", message)
			end
			filterRetries = filterRetries + 1
			if filterRetries > MAX_FILTER_RETRIES or (tick() - filterStartTime) > MAX_FILTER_DURATION then
				self:InternalNotifyFilterIssue()
				return nil
			end
			local backoffInterval = FILTER_BACKOFF_INTERVALS[math.min(#FILTER_BACKOFF_INTERVALS, filterRetries)]
			-- backoffWait = backoffInterval +/- (0 -> backoffInterval)
			local backoffWait = backoffInterval + ((math.random()*2 - 1) * backoffInterval)
			wait(backoffWait)
		end
	else
		--// Simulate filtering latency.
		--// There is only latency the first time the message is filtered, all following calls will be instant.
		if not StudioMessageFilteredCache[message] then
			StudioMessageFilteredCache[message] = true
			wait()
		end
		return message
	end

	return nil
end
--[[
	Package link auto-generated by Rotriever
]]
local PackageIndex = script.Parent._Index

local Package = require(PackageIndex["mock"]["mock"])

return Package
--[[Manage Plugins]]
	
	script.Parent["A-Chassis Interface"].Car.Value=car
	for i,v in pairs(script.Parent.Plugins:GetChildren()) do
		for _,a in pairs(v:GetChildren()) do
			if a:IsA("RemoteEvent") or a:IsA("RemoteFunction") then 
				a.Parent=car
				for _,b in pairs(a:GetChildren()) do
					if b:IsA("Script") then b.Disabled=false end
				end	
			end
		end
		v.Parent = script.Parent["A-Chassis Interface"]
	end
	script.Parent.Plugins:Destroy()
-- Stop: Stops the clock
Stop.OnInvoke = function()
	Running = false
end
--[[NOTICE: This only works if you have an atmosphere in Lighting. 
If you don't, feel free to delete this script and put the {"Fog"} script in ServerScriptService.

--Put me in ServerScriptService and you're set! -ethanleung101]]

while true do
	wait(60)--wait()
	game.Lighting.Atmosphere.Density = 0.35 --makes the game foggy (must add atmosphere in Lighting to make it work)
	wait(120)
	game.Lighting.Atmosphere.Density = 0.2 --returns to normal
	wait(240)
end
--!strict
local Array = script.Parent.Parent
local LuauPolyfill = Array.Parent
local types = require(LuauPolyfill.types)
type Object = types.Object
type Array<T> = types.Array<T>
type Map<K, V> = types.Map<K, V>
type mapFn<T, U> = (element: T, index: number) -> U
type mapFnWithThisArg<T, U> = (thisArg: any, element: T, index: number) -> U

return function<T, U>(
	value: Map<any, any>,
	mapFn: (mapFn<T, U> | mapFnWithThisArg<T, U>)?,
	thisArg: Object?
	-- FIXME Luau: need overloading so the return type on this is more sane and doesn't require manual casts
): Array<U> | Array<T> | Array<string>
	local array = {}

	if mapFn then
		array = {}
		for i, v in value :: any do
			if thisArg ~= nil then
				(array :: Array<U>)[i] = (mapFn :: mapFnWithThisArg<T, U>)(thisArg, v, i)
			else
				(array :: Array<U>)[i] = (mapFn :: mapFn<T, U>)(v, i)
			end
		end
	else
		array = {}
		for i, v in value :: any do
			(array :: Array<T>)[i] = v
		end
	end

	return array
end
-- ROBLOX deviation: declare these now because of scoping differences between in
-- Lua and JS
local describeComponentFrame
local describeFunctionComponentFrame
-- Provide functionality to the local API endpoint instance
SyncAPI.OnInvoke = function (...)

	-- Route requests to server endpoint if in filter mode
	if IsFilterModeEnabled() then
		return ServerEndpoint:InvokeServer(...);

	-- Perform requests locally if working locally
	else
		SyncModule = require(SyncAPI:WaitForChild 'SyncModule');
		return SyncModule.PerformAction(Game.Players.LocalPlayer, ...);
	end;

end;
-- Implement Signal:Wait() in terms of a temporary connection using
-- a Signal:Connect() which disconnects itself.
function Signal:Wait()
	local waitingCoroutine = coroutine.running()
	local cn;
	cn = self:Connect(function(...)
		cn:Disconnect()
		task.spawn(waitingCoroutine, ...)
	end)
	return coroutine.yield()
end
--!strict
export type Error = { name: string, message: string, stack: string? }

local Error = {}

local DEFAULT_NAME = "Error"
Error.__index = Error
Error.__tostring = function(self)
	-- Luau FIXME: I can't cast to Error or Object here: Type 'Object' could not be converted into '{ @metatable *unknown*, {|  |} }'
	return getmetatable(Error :: any).__tostring(self)
end

function Error.new(message: string?): Error
	return (
		setmetatable({
			name = DEFAULT_NAME,
			message = message or "",
			stack = debug.traceback(nil, 2),
		}, Error) :: any
	) :: Error
end

return setmetatable(Error, {
	__call = function(_, ...)
		local inst = Error.new(...)
		inst.stack = debug.traceback(nil, 2)
		return inst
	end,
	__tostring = function(self)
		if self.name ~= nil then
			if self.message and self.message ~= "" then
				return string.format("%s: %s", tostring(self.name), tostring(self.message))
			end
			return tostring(self.name)
		end
		return tostring(DEFAULT_NAME)
	end,
})
--// bolekinds

local plr = script.Parent.Parent.Parent.Parent.Parent.Parent.Parent

script.Parent.MouseButton1Click:Connect(function()
	if plr.YouCash.Value >= 500 and game.ServerStorage.ServerData.CatBed.Value == false then
		script.Parent.Parent.Parent.Ching:Play()
		plr.YouCash.Value -= 500
		game.ServerStorage.ServerData.CatBed.Value = true
	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 gui = client.UI.Prepare(script.Parent.Parent)
	local label = gui.LABEL
	local str = data.Message
	local topbar = client.UI.Get("TopBar")
	
	client.UI.Remove("Notif",script.Parent.Parent)
	
	local log  = {
		Type = "Notif";
		Title = "Notif";
		Message = str;
		Icon = "rbxassetid://7501175708";
		Time = os.date("%X");
		Function = nil;
	}

	table.insert(client.Variables.CommunicationsHistory, log) 
	service.Events.CommsPanel:Fire(log)

	
	if str and type(str)=="string" then
		label.Text = str
		label.Position = UDim2.new(0, 0, 0, ((topbar and 40) or 0) - 35)
		gTable:Ready()
	else
		gui:Destroy()
	end
end
-- dependencies : (dictionary<string, table>) a map of requirements
-- dependencies.networking : (table) an object that implements POST and returns a promise
function GAReporter.new(dependencies)
	local reporter = {
		-- trackingId sends the data to the right GA property.
		trackingId = PROPERTY_ID,

		-- userId is meant to help identify recurring users,
		-- If you plan on using GAReporter on a per-client basis, you should set this value
		userId = HttpService:GenerateGUID(),

		-- clientId is meant to identify a given session that data is coming from.
		clientId = HttpService:GenerateGUID(),

		-- our HTTP handler
		_networking = dependencies.networking,
	}
	setmetatable(reporter, GAReporter)

	return reporter
end

function GAReporter:setUserId(userId)
	assert(type(userId) == "string", "userId must be a string")
	self.userId = userId
end
--[[**
	matches any type except nil

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]
function t.any(value)
	if value ~= nil then
		return true
	else
		return false, "any expected, got nil"
	end
end
--[[Steering]]
	Tune.SteerInner		= 48		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 45		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .05		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .1		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree
	
	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness
---------------------------------------------------

This = script.Parent
Elevator = This.Parent.Parent.Parent
CustomLabel = require(This.Parent.Parent.Parent.CustomLabel)
Characters = require(script.Characters)

CustomText = CustomLabel["CUSTOMFLOORLABEL"]

Elevator:WaitForChild("Floor").Changed:connect(function(floor)
  --custom indicator code--
  ChangeFloor(tostring(floor))
end)

function ChangeFloor(SF)
	if CustomText[tonumber(SF)] then
		SF = CustomText[tonumber(SF)]
	end
	SetDisplay(1,(string.len(SF) == 2 and SF:sub(1,1) or "NIL"))		
	SetDisplay(2,(string.len(SF) == 2 and SF:sub(2,2) or SF))
end



function SetDisplay(ID,CHAR)
	if This.Display:FindFirstChild("DIG"..ID) and Characters[CHAR] ~= nil then
 		for i,l in pairs(Characters[CHAR]) do 
			for r=1,57 do	
				This.Display["DIG"..ID]["D"..r].Transparency = (l:sub(r,r) == "1" and 0 or 0.997)
			end
		end
	end
end
-- Create component
local Dock = Roact.PureComponent:extend(script.Name)

function Dock:init()
    self.DockSize, self.SetDockSize = Roact.createBinding(UDim2.new())
end

function Dock:render()
    return new('Frame', {
        Active = true;
        AnchorPoint = Vector2.new(1, 0.5);
        BackgroundTransparency = 1;
        Position = UDim2.new(1, -10, 0.6, 0);
        Size = self.DockSize;
        ZIndex = 0;
    }, {
        Layout = new('UIListLayout', {
            Padding = UDim.new(0, 1);
            FillDirection = Enum.FillDirection.Vertical;
            HorizontalAlignment = Enum.HorizontalAlignment.Left;
            VerticalAlignment = Enum.VerticalAlignment.Top;
            SortOrder = Enum.SortOrder.LayoutOrder;
            [Roact.Ref] = function (rbx)
                if rbx then
                    self.SetDockSize(UDim2.fromOffset(rbx.AbsoluteContentSize.X, rbx.AbsoluteContentSize.Y))
                end
            end;
            [Roact.Change.AbsoluteContentSize] = function (rbx)
                self.SetDockSize(UDim2.fromOffset(rbx.AbsoluteContentSize.X, rbx.AbsoluteContentSize.Y))
            end;
        });
        ToolList = new(ToolList, {
            LayoutOrder = 0;
            Tools = self.props.Tools;
            Core = self.props.Core;
        });
        SelectionPane = new(SelectionPane, {
            LayoutOrder = 1;
            Core = self.props.Core;
        });
        AboutPane = new(AboutPane, {
            LayoutOrder = 2;
            Core = self.props.Core;
        });
    })
end

return Dock
------------------------------------------------------------------------

local pi    = math.pi
local abs   = math.abs
local clamp = math.clamp
local exp   = math.exp
local rad   = math.rad
local sign  = math.sign
local sqrt  = math.sqrt
local tan   = math.tan

local ContextActionService = game:GetService("ContextActionService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local StarterGui = game:GetService("StarterGui")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")

local LocalPlayer = Players.LocalPlayer
if not LocalPlayer then
	Players:GetPropertyChangedSignal("LocalPlayer"):Wait()
	LocalPlayer = Players.LocalPlayer
end

local Camera = Workspace.CurrentCamera
Workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
	local newCamera = Workspace.CurrentCamera
	if newCamera then
		Camera = newCamera
	end
end)
--[[Engine]]
	--Torque Curve
	Tune.Horsepower		= 100		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 800		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 8000		--		Use sliders to manipulate values
	Tune.Redline		= 9000		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 6100
	Tune.PeakSharpness	= 3.8
	Tune.CurveMult		= 0.07
	
	--Incline Compensation
	Tune.InclineComp	= 1.5		-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)
	
	--Misc
	Tune.RevAccel		= 450		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 150		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 0			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response, lower = more stable RPM)
--Run
local ver=require(car["A-Chassis Tune"].README)
print("//INSPARE: AC6 Loaded - Build "..ver)

while wait() do 
	Steering()
	Engine()
	if _Tune.AutoFlip then Flip() end
	
	_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 * 5250 / _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))
	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.Velocity.Value = car.DriveSeat.Velocity

	if _PGear~=_CGear then
		_PGear=_CGear
		car.DriveSeat.MaxSpeed = car.DriveSeat.Velocity.Magnitude*(_Tune.Redline/_RPM) + script.Parent.Values.PSI.Value
	end
	
end