Prompt: --("IsAHumanoid")

Response:
pl=game.Players:GetPlayerFromCharacter(w.Part1.Parent)
if pl~=nil then


Prompt:
-- NEW V13.1.0 - PartCache tie-in. If you use the PartCache module to create cosmetic bullets, you can now directly tie that in.
-- Ensure you're using the latest version of PartCache.

Response: local CosmeticPartProvider = PartCacheModule.new(CosmeticBullet, 100, CosmeticBulletsFolder)


Prompt: -- Récupérez le joueur local

Response: local player = game.Players.LocalPlayer


Prompt: -- loop through all the arm parts and make them visible in first person

Response:
local function visiblearms(bool)
	if armsvisible then
		local castshadow = not bool
		for i, part in ipairs(armparts) do
			part.LocalTransparencyModifier = armtransparency
			part.CanCollide = false
			part.CastShadow = castshadow
		end
	end
end


Prompt: -- Setup animation objects

Response:
function scriptChildModified(child)
	local fileList = animNames[child.Name]
	if (fileList ~= nil) then
		configureAnimationSet(child.Name, fileList)
	end
end

script.ChildAdded:connect(scriptChildModified)
script.ChildRemoved:connect(scriptChildModified)

for name, fileList in pairs(animNames) do
	configureAnimationSet(name, fileList)
end


Prompt:
-- In build mode, after every time you change this script, copy the script, delete it, and paste it back into your hat, if you don't,
-- nothing will change, I don't know why, but this is how I make my givers.


Prompt: --[[[Default Controls]]

Response:
	--Peripheral Deadzones
	Tune.Peripherals = {
		MSteerWidth				= 67		,	-- Mouse steering control width	(0 - 100% of screen width)
		MSteerDZone				= 10		,	-- Mouse steering deadzone (0 - 100%)

		ControlLDZone			= 5			,	-- Controller steering L-deadzone (0 - 100%)
		ControlRDZone			= 5			,	-- Controller steering R-deadzone (0 - 100%)
	}

	--Control Mapping
	Tune.Controls = {

	--Keyboard Controls
		--Mode Toggles
		ToggleTCS				= Enum.KeyCode.KeypadEquals					,
		ToggleABS				= Enum.KeyCode.KeypadZero					,
		ToggleTransMode			= Enum.KeyCode.KeypadEight					,
		ToggleMouseDrive		= Enum.KeyCode.F1					,

		--Primary Controls
		Throttle				= Enum.KeyCode.Up					,
		Brake					= Enum.KeyCode.Down					,
		SteerLeft				= Enum.KeyCode.Left					,
		SteerRight				= Enum.KeyCode.Right				,

		--Secondary Controls
		Throttle2				= Enum.KeyCode.W					,
		Brake2					= Enum.KeyCode.S					,
		SteerLeft2				= Enum.KeyCode.A					,
		SteerRight2				= Enum.KeyCode.D					,

		--Manual Transmission
		ShiftUp					= Enum.KeyCode.E					,
		ShiftDown				= Enum.KeyCode.Q					,
		Clutch					= Enum.KeyCode.LeftShift			,

		--Handbrake
		PBrake					= Enum.KeyCode.P					,

	--Mouse Controls
		MouseThrottle			= Enum.UserInputType.MouseButton1	,
		MouseBrake				= Enum.UserInputType.MouseButton2	,
		MouseClutch				= Enum.KeyCode.W					,
		MouseShiftUp			= Enum.KeyCode.E					,
		MouseShiftDown			= Enum.KeyCode.Q					,
		MousePBrake				= Enum.KeyCode.LeftShift			,

	--Controller Mapping
		ContlrThrottle			= Enum.KeyCode.ButtonR2				,
		ContlrBrake				= Enum.KeyCode.ButtonL2				,
		ContlrSteer				= Enum.KeyCode.Thumbstick1			,
		ContlrShiftUp			= Enum.KeyCode.ButtonY				,
		ContlrShiftDown			= Enum.KeyCode.ButtonX				,
		ContlrClutch			= Enum.KeyCode.ButtonR1				,
		ContlrPBrake			= Enum.KeyCode.ButtonL1				,
		ContlrToggleTMode		= Enum.KeyCode.DPadUp				,
		ContlrToggleTCS			= Enum.KeyCode.DPadDown				,
		ContlrToggleABS			= Enum.KeyCode.DPadRight			,
	}


Prompt: --[[[Default Controls]]

Response:
	--Peripheral Deadzones
	Tune.Peripherals = {
		MSteerWidth				= 67		,	-- Mouse steering control width	(0 - 100% of screen width)
		MSteerDZone				= 10		,	-- Mouse steering deadzone (0 - 100%)

		ControlLDZone			= 5			,	-- Controller steering L-deadzone (0 - 100%)
		ControlRDZone			= 5			,	-- Controller steering R-deadzone (0 - 100%)
	}

	--Control Mapping
	Tune.Controls = {

	--Keyboard Controls
		--Mode Toggles
		ToggleABS				= Enum.KeyCode.Y					,
		ToggleTransMode			= Enum.KeyCode.M					,
		--Primary Controls
		Throttle				= Enum.KeyCode.Up					,
		Brake					= Enum.KeyCode.Down					,
		SteerLeft				= Enum.KeyCode.Left					,
		SteerRight				= Enum.KeyCode.Right				,

		--Secondary Controls
		Throttle2				= Enum.KeyCode.W					,
		Brake2					= Enum.KeyCode.S					,
		SteerLeft2				= Enum.KeyCode.A					,
		SteerRight2				= Enum.KeyCode.D					,

		--Manual Transmission
		ShiftUp					= Enum.KeyCode.E					,
		ShiftDown				= Enum.KeyCode.Q					,
		Clutch					= Enum.KeyCode.LeftShift			,

		--Handbrake
		PBrake					= Enum.KeyCode.P					,

	--Mouse Controls
		MouseThrottle			= Enum.UserInputType.MouseButton1	,
		MouseBrake				= Enum.UserInputType.MouseButton2	,
		MouseClutch				= Enum.KeyCode.W					,
		MouseShiftUp			= Enum.KeyCode.E					,
		MouseShiftDown			= Enum.KeyCode.Q					,
		MousePBrake				= Enum.KeyCode.LeftShift			,

	--Controller Mapping
		ContlrThrottle			= Enum.KeyCode.ButtonR2				,
		ContlrBrake				= Enum.KeyCode.ButtonL2				,
		ContlrSteer				= Enum.KeyCode.Thumbstick1			,
		ContlrShiftUp			= Enum.KeyCode.ButtonY				,
		ContlrShiftDown			= Enum.KeyCode.ButtonX				,
		ContlrClutch			= Enum.KeyCode.ButtonR1				,
		ContlrPBrake			= Enum.KeyCode.ButtonL1				,
		ContlrToggleTMode		= Enum.KeyCode.DPadUp				,
		ContlrToggleTCS			= Enum.KeyCode.DPadDown				,
		ContlrToggleABS			= Enum.KeyCode.DPadRight			,
	}


Prompt: --[[Drivetrain Initialize]]

Response:
	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


Prompt: --!strict

Response:
local ClientBridge = require(script.ClientBridge)
local ClientIdentifiers = require(script.ClientIdentifiers)
local ClientProcess = require(script.ClientProcess)
local Types = require(script.Parent.Types)

local Client = {}

function Client.start()
	ClientProcess.start()
	ClientIdentifiers.start()
end

function Client.ser(identifierName: Types.Identifier): Types.Identifier?
	return ClientIdentifiers.ser(identifierName)
end

function Client.deser(compressedIdentifier: Types.Identifier): Types.Identifier?
	return ClientIdentifiers.deser(compressedIdentifier)
end

function Client.makeIdentifier(name: string, timeout: number?)
	return ClientIdentifiers.ref(name, timeout)
end

function Client.makeBridge(name: string)
	return ClientBridge(name)
end

return Client


Prompt: --[[Flip]]

Response:
	function Flip()
		--Detect Orientation
		if (car.DriveSeat.CFrame*CFrame.Angles(math.pi/2,0,0)).lookVector.y > .1 or FlipDB then
			FlipWait=tick()

		--Apply Flip
		else
			if tick()-FlipWait>=3 then
				FlipDB=true
				local gyro = car.DriveSeat.Flip
				gyro.maxTorque = Vector3.new(10000,0,10000)
				gyro.P=3000
				gyro.D=500
				wait(1)
				gyro.maxTorque = Vector3.new(0,0,0)
				gyro.P=0
				gyro.D=0
				FlipDB=false
			end
		end
	end


Prompt: --[[ NON-STATIC METHODS ]]

Response:
--
function Path:Destroy()
	for _, event in ipairs(self._events) do
		event:Destroy()
	end
	self._events = nil
	if rawget(self, "_visualWaypoints") then
		self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
	end
	self._path:Destroy()
	setmetatable(self, nil)
	for k, _ in pairs(self) do
		self[k] = nil
	end
end

function Path:Stop()
	if not self._humanoid then
		output(error, "Attempt to call Path:Stop() on a non-humanoid.")
		return
	end
	if self._status == Path.StatusType.Idle then
		output(function(m)
			warn(debug.traceback(m))
		end, "Attempt to run Path:Stop() in idle state")
		return
	end
	disconnectMoveConnection(self)
	self._status = Path.StatusType.Idle
	self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
	self._events.Stopped:Fire(self._model)
end

function Path:Run(target)

	--Non-humanoid handle case
	if not target and not self._humanoid and self._target then
		moveToFinished(self, true)
		return
	end

	--Parameter check
	if not (target and (typeof(target) == "Vector3" or target:IsA("BasePart"))) then
		output(error, "Pathfinding target must be a valid Vector3 or BasePart.")
	end

	--Refer to Settings.TIME_VARIANCE
	if os.clock() - self._t <= self._settings.TIME_VARIANCE and self._humanoid then
		task.wait(os.clock() - self._t)
		declareError(self, self.ErrorType.LimitReached)
		return false
	elseif self._humanoid then
		self._t = os.clock()
	end

	--Compute path
	local pathComputed, _ = pcall(function()
		self._path:ComputeAsync(self._agent.PrimaryPart.Position, (typeof(target) == "Vector3" and target) or target.Position)
	end)

	--Make sure path computation is successful
	if not pathComputed
		or self._path.Status == Enum.PathStatus.NoPath
		or #self._path:GetWaypoints() < 2
		or (self._humanoid and self._humanoid:GetState() == Enum.HumanoidStateType.Freefall) then
		self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
		task.wait()
		declareError(self, self.ErrorType.ComputationError)
		return false
	end

	--Set status to active; pathfinding starts
	self._status = (self._humanoid and Path.StatusType.Active) or Path.StatusType.Idle
	self._target = target

	--Set network owner to server to prevent "hops"
	pcall(function()
		self._agent.PrimaryPart:SetNetworkOwner(nil)
	end)

	--Initialize waypoints
	self._waypoints = self._path:GetWaypoints()
	self._currentWaypoint = 2

	--Refer to Settings.COMPARISON_CHECKS
	if self._humanoid then
		comparePosition(self)
	end

	--Visualize waypoints
	destroyVisualWaypoints(self._visualWaypoints)
	self._visualWaypoints = (self.Visualize and createVisualWaypoints(self._waypoints))

	--Create a new move connection if it doesn't exist already
	self._moveConnection = self._humanoid and (self._moveConnection or self._humanoid.MoveToFinished:Connect(function(...)
		moveToFinished(self, ...)
	end))

	--Begin pathfinding
	if self._humanoid then
		self._humanoid:MoveTo(self._waypoints[self._currentWaypoint].Position)
	elseif #self._waypoints == 2 then
		self._target = nil
		self._visualWaypoints = destroyVisualWaypoints(self._visualWaypoints)
		self._events.Reached:Fire(self._agent, self._waypoints[2])
	else
		self._currentWaypoint = getNonHumanoidWaypoint(self)
		moveToFinished(self, true)
	end
	return true
end

return Path


Prompt: --[[Wheel Alignment]]

Response:
	--[Don't physically apply alignment to wheels]
	--[Values are in degrees]
	Tune.FCamber		= -1
	Tune.RCamber		= -1
	Tune.FToe			= 0
	Tune.RToe			= 0


Prompt: ---[[ Channel Settings ]]

Response: module.GeneralChannelName = "All" -- You can set to nil to turn off echoing to a general channel.


Prompt: --[[Steering]]

Response:
local function Steering()
	local SteerLocal = script.Parent.Values.SteerC.Value
	--Mouse Steer
	if _MSteer then
		local msWidth = math.max(1,mouse.ViewSizeX*_Tune.Peripherals.MSteerWidth/200)
		local mdZone = _Tune.Peripherals.MSteerDZone/100
		local mST = ((mouse.X-mouse.ViewSizeX/2)/msWidth)
		if math.abs(mST)<=mdZone then
			_GSteerT = 0
		else
			_GSteerT = (math.max(math.min((math.abs(mST)-mdZone),(1-mdZone)),0)/(1-mdZone))^_Tune.MSteerExp * (mST / math.abs(mST))
		end
	end

	--Interpolate Steering
	if SteerLocal < _GSteerT then
		if SteerLocal<0 then
			SteerLocal = math.min(_GSteerT,SteerLocal+_Tune.ReturnSpeed)
		else
			SteerLocal = math.min(_GSteerT,SteerLocal+_Tune.SteerSpeed)
		end
	else
		if SteerLocal>0 then
			SteerLocal = math.max(_GSteerT,SteerLocal-_Tune.ReturnSpeed)
		else
			SteerLocal = math.max(_GSteerT,SteerLocal-_Tune.SteerSpeed)
		end
	end

	--Steer Decay Multiplier
	local sDecay = (1-math.min(car.DriveSeat.Velocity.Magnitude/_Tune.SteerDecay,1-(_Tune.MinSteer/100)))

	--Apply Steering
	for _,v in ipairs(car.Wheels:GetChildren()) do
		if v.Name=="F" then
			v.Arm.Steer.CFrame=car.Wheels.F.Base.CFrame*CFrame.Angles(0,-math.rad(SteerLocal*_Tune.SteerInner*sDecay),0)
		elseif v.Name=="FL" then
			if SteerLocal>= 0 then
				v.Arm.Steer.CFrame=car.Wheels.FL.Base.CFrame*CFrame.Angles(0,-math.rad(SteerLocal*_Tune.SteerOuter*sDecay),0)
			else
				v.Arm.Steer.CFrame=car.Wheels.FL.Base.CFrame*CFrame.Angles(0,-math.rad(SteerLocal*_Tune.SteerInner*sDecay),0)
			end
		elseif v.Name=="FR" then
			if SteerLocal>= 0 then
				v.Arm.Steer.CFrame=car.Wheels.FR.Base.CFrame*CFrame.Angles(0,-math.rad(SteerLocal*_Tune.SteerInner*sDecay),0)
			else
				v.Arm.Steer.CFrame=car.Wheels.FR.Base.CFrame*CFrame.Angles(0,-math.rad(SteerLocal*_Tune.SteerOuter*sDecay),0)
			end
		end
	end
end


Prompt: --// Stances

Response:
function Prone()
	L_87_:FireServer("Prone")

	L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
		CameraOffset = Vector3.new(0, -3, 0)
	}):Play()
	L_3_:WaitForChild("Humanoid").WalkSpeed = 4

	L_127_ = 4
	L_126_ = 0.025

	L_47_ = true

	L_67_ = 0.01
	L_66_ = -0.05
	L_68_ = 0.05

	Proned2 = Vector3.new(0, 0.5, 0.5)
	L_102_(L_9_,  CFrame.new(0, -2.4201169, -0.0385534465, -0.99999994, -5.86197757e-012, -4.54747351e-013, 5.52669195e-012, 0.998915195, 0.0465667509, 0, 0.0465667509, -0.998915195), nil, function(L_249_arg1)
		return math.sin(math.rad(L_249_arg1))
	end, 0.25)
	L_102_(L_10_,  CFrame.new(1.00000191, -1, -5.96046448e-008, 1.31237243e-011, -0.344507754, 0.938783348, 0, 0.938783467, 0.344507784, -1, 0, -1.86264515e-009) , nil, function(L_250_arg1)
		return math.sin(math.rad(L_250_arg1))
	end, 0.25)
	L_102_(L_11_,  CFrame.new(-0.999996185, -1, -1.1920929e-007, -2.58566502e-011, 0.314521015, -0.949250221, 0, 0.94925046, 0.314521164, 1, 3.7252903e-009, 1.86264515e-009) , nil, function(L_251_arg1)
		return math.sin(math.rad(L_251_arg1))
	end, 0.25)
end

function Stand()
	L_87_:FireServer("Stand")

	L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
		CameraOffset = Vector3.new(0, 0, 0)
	}):Play()

	L_47_ = false

	if not L_46_ then
		L_3_:WaitForChild("Humanoid").WalkSpeed = 16
		L_126_ = .2
		L_127_ = 17
		L_67_ = L_23_.camrecoil
		L_66_ = L_23_.gunrecoil
		L_68_ = L_23_.Kickback
	elseif L_46_ then
		L_3_:WaitForChild("Humanoid").WalkSpeed = 16
		L_127_ = 10
		L_126_ = 0.02
		L_67_ = L_23_.AimCamRecoil
		L_66_ = L_23_.AimGunRecoil
		L_68_ = L_23_.AimKickback
	end

	Proned2 = Vector3.new(0, 0, 0)
	L_102_(L_9_, CFrame.new(0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 1, -0), nil, function(L_252_arg1)
		return math.sin(math.rad(L_252_arg1))
	end, 0.25)
	L_102_(L_10_,  CFrame.new(1, -1, 0, 0, 0, 1, 0, 1, -0, -1, 0, 0), nil, function(L_253_arg1)
		return math.sin(math.rad(L_253_arg1))
	end, 0.25)
	L_102_(L_11_,  CFrame.new(-1, -1, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0), nil, function(L_254_arg1)
		return math.sin(math.rad(L_254_arg1))
	end, 0.25)
end

function Crouch()
	L_87_:FireServer("Crouch")

	L_14_:Create(L_3_:WaitForChild('Humanoid'), TweenInfo.new(0.3), {
		CameraOffset = Vector3.new(0, -1, 0)
	}):Play()
	L_3_:WaitForChild("Humanoid").WalkSpeed = 9

	L_127_ = 9
	L_126_ = 0.035

	L_47_ = true

	L_67_ = 0.02
	L_66_ = -0.05
	L_68_ = 0.05

	Proned2 = Vector3.new(0, 0, 0)
	L_102_(L_9_, CFrame.new(0, -1.04933882, 0, -1, 0, -1.88871293e-012, 1.88871293e-012, -3.55271368e-015, 1, 0, 1, -3.55271368e-015), nil, function(L_255_arg1)
		return math.sin(math.rad(L_255_arg1))
	end, 0.25)
	L_102_(L_10_,  CFrame.new(1, 0.0456044674, -0.494239986, 6.82121026e-013, -1.22639676e-011, 1, -0.058873821, 0.998265445, -1.09836602e-011, -0.998265445, -0.058873821, 0), nil, function(L_256_arg1)
		return math.sin(math.rad(L_256_arg1))
	end, 0.25)
	L_102_(L_11_,  CFrame.new(-1.00000381, -0.157019258, -0.471293032, -8.7538865e-012, -8.7538865e-012, -1, 0.721672177, 0.692235112, 1.64406284e-011, 0.692235112, -0.721672177, 0), nil, function(L_257_arg1)
		return math.sin(math.rad(L_257_arg1))
	end, 0.25)
	L_102_(L_6_:WaitForChild("Neck"), nil, CFrame.new(0, -0.5, 0, -1, 0, 0, 0, 0, 1, 0, 1, -0), function(L_258_arg1)
		return math.sin(math.rad(L_258_arg1))
	end, 0.25)
end

local L_137_ = false

L_82_.InputBegan:connect(function(L_259_arg1, L_260_arg2)
	if not L_260_arg2 and L_15_ == true then
		if L_15_ then
			if L_259_arg1.KeyCode == Enum.KeyCode.C then
				if L_70_ == 0 and not L_49_ and L_15_ then
					L_70_ = 1
					Crouch()

					L_71_ = false
					L_73_ = true
					L_72_ = false
				elseif L_70_ == 1 and not L_49_ and L_15_ then
					L_70_ = 2
					Prone()

					L_73_ = false
					L_71_ = true
					L_72_ = false
					L_137_ = true
				end
			end

			if L_259_arg1.KeyCode == Enum.KeyCode.X then
				if L_70_ == 2 and not L_49_ and L_15_ then
					L_137_ = false
					L_70_ = 1
					Crouch()

					L_71_ = false
					L_73_ = true
					L_72_ = false
				elseif L_70_ == 1 and not L_49_ and L_15_ then
					L_70_ = 0
					Stand()

					L_71_ = false
					L_73_ = false
					L_72_ = true
				end
			end
		end
	end
end)


Prompt: -- Stuff (do not edit below)

Response:
local configModel = script.Parent.Config
local scoreBlock = script.Parent.ScoreBlock

local uS = configModel.UploadScore
local rS = configModel.RemoteScore
local lSU = configModel.LocalScoreUpdate

uS.Refresh.Value = SCORE_UPDATE
rS.Score.Value = NAME_OF_STAT
rS.Original.Value = PLAYER_SAVE
rS.DataStore.Value = DATA_STORE
lSU.Refresh.Value = PLAYER_UPDATE

uS.Disabled = false
uS.Parent = game.ServerScriptService

rS.Disabled = false
rS.Parent = game.Workspace

lSU.Disabled = false
lSU.Parent = game.StarterGui


Prompt: -- tween engine sound volume when we start driving

Response:
local engineStartTween = TweenInfo.new(0.25, Enum.EasingStyle.Quad, Enum.EasingDirection.In, 0, false, 0)

local Remotes = Vehicle:WaitForChild("Remotes")
local SetThrottleRemote = Remotes:WaitForChild("SetThrottle")
local SetThrottleConnection = nil

local EngineSoundEnabled = true
local TireTrailEnabled = true

local ignitionTime = 1.75 -- seconds

local lastAvgAngularVelocity = 0
local throttleEnabled = false
local lastThrottleUpdate = 0

local enginePower = 0 -- current rpm of the engine
local gainModifier = 1 -- modifier to engine rpm gain (lower if approaching max speed)


Prompt:
--------------------- TEMPLATE ASSAULT RIFLE WEAPON ---------------------------
-- Waits for the child of the specified parent

Response:
local function WaitForChild(parent, childName)
	while not parent:FindFirstChild(childName) do parent.ChildAdded:wait() end
	return parent[childName]
end


Prompt:
--[[
	A simplistic spring implementation.
]]

Response:
local e=2.718281828459045

local function posvel(d,s,p0,v0,p1,v1,x)
	if s==0 then
		return p0
	elseif d<1-1e-8 then
		local h=(1-d*d)^0.5
		local c1=(p0-p1+2*d/s*v1)
		local c2=d/h*(p0-p1)+v0/(h*s)+(2*d*d-1)/(h*s)*v1
		local co=math.cos(h*s*x)
		local si=math.sin(h*s*x)
		local ex=e^(d*s*x)
		return co/ex*c1+si/ex*c2+p1+(x-2*d/s)*v1, s*(co*h-d*si)/ex*c2-s*(co*d+h*si)/ex*c1+v1
	elseif d<1+1e-8 then
		local c1=p0-p1+2/s*v1
		local c2=p0-p1+(v0+v1)/s
		local ex=e^(s*x)
		return (c1+c2*s*x)/ex+p1+(x-2/s)*v1, v1-s/ex*(c1+(s*x-1)*c2)
	else
		local h=(d*d-1)^0.5
		local a=(v1-v0)/(2*s*h)
		local b=d/s*v1-(p1-p0)/2
		local c1=(1-d/h)*b+a
		local c2=(1+d/h)*b-a
		local co=e^(-(h+d)*s*x)
		local si=e^((h-d)*s*x)
		return c1*co+c2*si+p1+(x-2*d/s)*v1, si*(h-d)*s*c2-co*(d+h)*s*c1+v1
	end
end

local function targposvel(p1,v1,x)
	return p1+x*v1,v1
end

local Spring = {}

Spring.__index = Spring


Prompt:
--p.Ground(part"because cframe and position", zone size, size of part, number how many part spawn, time delay and remove)
--P.Ground(script.parent,độ mở của vòng tròn rock,Size Rock,số rock spawm,Thời gian rock còn trên mặt đất)


Prompt: --// Tracer Vars

Response:
	TracerTransparency = 0;
	TracerLightEmission = 1;
	TracerTextureLength = 0.1;
	TracerLifetime = 0.05;
	TracerFaceCamera = true;
	TracerColor = BrickColor.new('White');


Prompt: --[[ Services ]]

Response:
--
local PlayersService = game:GetService('Players')
local VRService = game:GetService("VRService")


Prompt: --[[Brakes]]

Response:
	Tune.ABSEnabled		= true		-- Implements ABS
	Tune.ABSThreshold	= 20		-- Slip speed allowed before ABS starts working (in SPS)

	Tune.FBrakeForce	= 1500		-- Front brake force
	Tune.RBrakeForce	= 1000		-- 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]


Prompt:
-- << CUSTOM >>
-- Theme

Response:
local ratio = 6.1/#themeColors
local themeFrame = pages.custom["AB ThemeSelection"]
local themeDe = true
local function updateThemeSelection(themeName, themeColor)
	if themeName == nil then
		for i,v in pairs(themeColors) do
			if v[1] == main.pdata.Theme then
				themeName = v[1]
				themeColor = v[2]
				break
			end
		end
	end
	if themeName then
		local themeFrames = {}
		for a,b in pairs(main.gui:GetDescendants()) do
			if b:IsA("BoolValue") and b.Name == "Theme" then
				table.insert(themeFrames, b.Parent)
			end
		end
		for _,f in pairs(themeFrames) do
			local newThemeColor = themeColor
			if f.Theme.Value then
				local h,s,v = Color3.toHSV(themeColor)
				newThemeColor = Color3.fromHSV(h, s, v*1.35)
			end
			if f:IsA("TextLabel") then
				local h,s,v = Color3.toHSV(themeColor)
				newThemeColor = Color3.fromHSV(h, s, v*2)
				f.TextColor3 = newThemeColor
			else
				f.BackgroundColor3 = newThemeColor
			end
		end
		for a,b in pairs(themeFrame:GetChildren()) do
			if b:IsA("TextButton") then
				if b.Name == themeName then
					b.BorderSizePixel = 1
				else
					b.BorderSizePixel = 0
				end
			end
		end
	end
end
for i, theme in pairs(themeColors) do
	local themeName = theme[1]
	local themeColor = theme[2]
	local box = themeFrame.ThemeTemplate:Clone()
	box.Name = themeName
	box.UIAspectRatioConstraint.AspectRatio = ratio
	box.BackgroundColor3 = themeColor
	box.MouseButton1Down:Connect(function()
		if themeDe then
			themeDe = false
			main.signals.ChangeSetting:InvokeServer{"Theme", themeName}
			updateThemeSelection(themeName, themeColor)
			themeDe = true
		end
	end)
	box.Visible = true
	box.Parent = themeFrame
end


Prompt: -- a better alternative implementation for the wait function

Response:
function wait_time(duration)
    local start = tick()
    local Heartbeat = game:GetService("RunService").Heartbeat
    repeat Heartbeat:Wait() until (tick() - start) >= duration
    return (tick() - start)
end


Prompt: --Library

Response:
local DataStoreCache = {}

local DataStore2 = {}
local combinedDataStoreInfo = {}


Prompt:
--------------------------------------------------------------------------------------
--------------------[ GUN SETUP ]-----------------------------------------------------
--------------------------------------------------------------------------------------

Response:
serverMain:WaitForChild("Plyr").Value = Player

local gunMomentum = Spring.new(V3())
gunMomentum.s = S.momentumSettings.Speed
gunMomentum.d = S.momentumSettings.Damper

local gunRecoilSpring = Spring.new(V3())
gunRecoilSpring.s = S.recoilSettings.springSpeed
gunRecoilSpring.d = S.recoilSettings.springDamper

local camRecoilSpring = Spring.new(V3())
camRecoilSpring.s = 35
camRecoilSpring.d = 0.5

local crossSpring = Spring.new(V3(crossOffset + (baseSpread + currentSpread) * 50, 0, 0))
crossSpring.s = 20
crossSpring.d = 0.75


Prompt: -- Make the chat work when the top bar is off

Response:
module.ChatOnWithTopBarOff = false
module.ScreenGuiDisplayOrder = 6 -- The DisplayOrder value for the ScreenGui containing the chat.

module.ShowFriendJoinNotification = true -- Show a notification in the chat when a players friend joins the game.


Prompt:
--[[
	berezaa's method of saving data (from the dev forum):

	What I do and this might seem a little over-the-top but it's fine as long as you're not using datastores excessively elsewhere is have a datastore and an ordereddatastore for each player. When you perform a save, add a key (can be anything) with the value of os.time() to the ordereddatastore and save a key with the os.time() and the value of the player's data to the regular datastore. Then, when loading data, get the highest number from the ordered data store (most recent save) and load the data with that as a key.

	Ever since I implemented this, pretty much no one has ever lost data. There's no caches to worry about either because you're never overriding any keys. Plus, it has the added benefit of allowing you to restore lost data, since every save doubles as a backup which can be easily found with the ordereddatastore

	edit: while there's no official comment on this, many developers including myself have noticed really bad cache times and issues with using the same datastore keys to save data across multiple places in the same game. With this method, data is almost always instantly accessible immediately after a player teleports, making it useful for multi-place games.
--]]

Response:
local DataStoreService = game:GetService("DataStoreService")

local OrderedBackups = {}
OrderedBackups.__index = OrderedBackups

function OrderedBackups:Get()
	local success, value = pcall(function()
		return self.orderedDataStore:GetSortedAsync(false, 1):GetCurrentPage()[1]
	end)

	if not success then
		return false, value
	end

	if value then
		local mostRecentKeyPage = value

		local recentKey = mostRecentKeyPage.value
		self.dataStore2:Debug("most recent key", mostRecentKeyPage)
		self.mostRecentKey = recentKey

		local success, value = pcall(function()
			return self.dataStore:GetAsync(recentKey)
		end)

		if not success then
			return false, value
		end

		return true, value
	else
		self.dataStore2:Debug("no recent key")
		return true, nil
	end
end

function OrderedBackups:Set(value)
	local key = (self.mostRecentKey or 0) + 1

	local success, problem = pcall(function()
		self.dataStore:SetAsync(key, value)
	end)

	if not success then
		return false, problem
	end

	local success, problem = pcall(function()
		self.orderedDataStore:SetAsync(key, key)
	end)

	if not success then
		return false, problem
	end

	self.mostRecentKey = key
	return true
end

function OrderedBackups.new(dataStore2)
	local dataStoreKey = dataStore2.Name .. "/" .. dataStore2.UserId

	local info = {
		dataStore2 = dataStore2,
		dataStore = DataStoreService:GetDataStore(dataStoreKey),
		orderedDataStore = DataStoreService:GetOrderedDataStore(dataStoreKey),
	}

	return setmetatable(info, OrderedBackups)
end

return OrderedBackups


Response:
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,7 do
				This.Display["DIG"..ID]["D"..r].Color = (l:sub(r,r) == "1" and DisplayColor or DisabledColor)
				This.Display["DIG"..ID]["D"..r].Material = (l:sub(r,r) == "1" and Lit or Unlit)
			end
		end
	end
end


Prompt: --------------------[ KEYBOARD FUNCTIONS ]--------------------------------------------

Response:
function keyDown(K)
	local Key = string.lower(K)

	if Key == S.Keys.lowerStance and S.canChangeStance then
		if (not Running) then
			if Stance == 0 then
				if S.stanceSettings.Stances.Crouch then
					Crouch()
				elseif S.stanceSettings.Stances.Prone then
					Prone()
				end
			elseif Stance == 1 then
				if S.stanceSettings.Stances.Prone then
					Prone()
				end
			end
		elseif S.dolphinDive then
			wait()
			if Humanoid:GetState() ~= Enum.HumanoidStateType.Freefall and (not UIS:IsKeyDown("Space")) and runReady then
				local tempConnection = Humanoid.Changed:connect(function()
					Humanoid.Jump = false
				end)
				runReady = false
				Dive()
				Running = false
				wait(S.diveSettings.rechargeTime)
				tempConnection:disconnect()
				runReady = true
			end
		end
	end

	if Key == S.Keys.raiseStance and S.canChangeStance then
		if (not Running) then
			if Stance == 2 then
				if S.stanceSettings.Stances.Crouch then
					Crouch()
				else
					Stand()
				end
			elseif Stance == 1 then
				Stand()
			end
		end
	end

	if Key == S.Keys.ADS then
		if S.aimSettings.holdToADS then
			if (not AimingIn) and (not Aimed) then
				AimingIn = true
				aimGun()
				AimingIn = false
			end
		else
			if Aimed then
				unAimGun()
			else
				aimGun()
			end
		end
	end

	if Key == S.Keys.selectFire and S.selectFire then
		if canSelectFire then
			canSelectFire = false
			rawFireMode = rawFireMode + 1
			modeGUI.Text = Modes[((rawFireMode - 1) % numModes) + 1]
			if modeGUI.Text == "AUTO" then
				fireFunction = autoFire
			elseif modeGUI.Text == "BURST" then
				fireFunction = burstFire
			elseif modeGUI.Text == "SEMI" then
				fireFunction = semiFire
			else
				fireFunction = nil
			end
			local speedAlpha = S.selectFireSettings.animSpeed / 0.6
			if S.selectFireSettings.GUI then
				spawn(function()
					fireSelect.Visible = true
					local prevRawFireMode = rawFireMode
					local Increment = 1.5 / (speedAlpha * 0.25)
					local X = 0
					wait(speedAlpha * 0.1)
					while true do
						RS.RenderStepped:wait()
						local newX = X + Increment
						X = (newX > 90 and 90 or newX)
						if prevRawFireMode ~= rawFireMode then break end
						updateModeLabels(rawFireMode - 1, rawFireMode, X)
						if X == 90 then break end
					end
					wait(speedAlpha * 0.25)
					fireSelect.Visible = false
				end)
			end
			if S.selectFireSettings.Animation and (not Aimed) and (not isRunning) and (not isCrawling) then
				spawn(function()
					local sequenceTable = {
						function()
							tweenJoint(RWeld2, nil, CFANG(0, RAD(5), 0), Sine, speedAlpha * 0.15)
							tweenJoint(LWeld, armC0[1], CF(0.1, 1, -0.3) * CFANG(RAD(-7), 0, RAD(-65)), Linear, speedAlpha * 0.15)
							wait(speedAlpha * 0.2)
						end;

						function()
							tweenJoint(LWeld, armC0[1], CF(0.1, 1, -0.3) * CFANG(RAD(-10), 0, RAD(-65)), Linear, speedAlpha * 0.1)
							wait(speedAlpha * 0.2)
						end;

						function()
							tweenJoint(RWeld2, nil, CF(), Sine, speedAlpha * 0.2)
							tweenJoint(LWeld, armC0[1], S.unAimedC1.leftArm, Sine, speedAlpha * 0.2)
							wait(speedAlpha * 0.2)
						end;
					}

					for _, F in pairs(sequenceTable) do
						if Aimed or isRunning or isCrawling or Reloading then
							break
						end
						F()
					end
				end)
			end
			if S.selectFireSettings.Animation or S.selectFireSettings.GUI then
				wait(S.selectFireSettings.animSpeed)
			end
			canSelectFire = true
		end
	end

	if Key == S.Keys.Reload then
		if (not Reloading) and (not isCrawling) then
			Reload()
		end
	end

	if Key == S.Keys.Sprint then
		runKeyPressed = true
		if runReady then
			if (not Idling) and Walking and (not Running) and (not Knifing) and (not (Aimed and S.guiScope and S.Keys.Sprint == S.Keys.scopeSteady)) then
				monitorStamina()
			end
		end
	end

	if Key == S.Keys.scopeSteady then
		steadyKeyPressed = true
		if Aimed and (not Aiming) then
			takingBreath = false
			steadyCamera()
		end
	end

	for _, PTable in pairs(Plugins.KeyDown) do
		if Key == string.lower(PTable.Key) then
			spawn(function()
				PTable.Plugin()
			end)
		end
	end
end

function keyUp(K)
	local Key = string.lower(K)

	if Key == S.Keys.ADS then
		if S.aimSettings.holdToADS then
			if (not AimingOut) and Aimed then
				AimingOut = true
				unAimGun()
				AimingOut = false
			end
		end
	end

	if Key == S.Keys.Sprint then
		runKeyPressed = false
		Running = false
		if (not chargingStamina) then
			rechargeStamina()
		end
	end

	if Key == S.Keys.scopeSteady then
		steadyKeyPressed = false
	end

	for _, PTable in pairs(Plugins.KeyUp) do
		if Key == string.lower(PTable.Key) then
			spawn(function()
				PTable.Plugin()
			end)
		end
	end
end


Prompt:
--[[**
	ensures value is a number where value < 0

	@returns A function that will return true iff the condition is passed
**--]]

Response: t.numberNegative = t.numberMaxExclusive(0)


Prompt: -- Removes any old creator tags and applies a new one to the target

Response:
local function ApplyTags(target)
	while target:FindFirstChild('creator') do
		target.creator:Destroy()
	end

	local creatorTagClone = CreatorTag:Clone()
	DebrisService:AddItem(creatorTagClone, 1.5)
	creatorTagClone.Parent = target
end


Prompt:
----------------------------------
------------FUNCTIONS-------------
----------------------------------

Response:
function UnDigify(digit)
	if digit < 1 or digit > 61 then
		return ""
	elseif digit == 1 then
		return "1"
	elseif digit == 2 then
		return "!"
	elseif digit == 3 then
		return "2"
	elseif digit == 4 then
		return "@"
	elseif digit == 5 then
		return "3"
	elseif digit == 6 then
		return "4"
	elseif digit == 7 then
		return "$"
	elseif digit == 8 then
		return "5"
	elseif digit == 9 then
		return "%"
	elseif digit == 10 then
		return "6"
	elseif digit == 11 then
		return "^"
	elseif digit == 12 then
		return "7"
	elseif digit == 13 then
		return "8"
	elseif digit == 14 then
		return "*"
	elseif digit == 15 then
		return "9"
	elseif digit == 16 then
		return "("
	elseif digit == 17 then
		return "0"
	elseif digit == 18 then
		return "q"
	elseif digit == 19 then
		return "Q"
	elseif digit == 20 then
		return "w"
	elseif digit == 21 then
		return "W"
	elseif digit == 22 then
		return "e"
	elseif digit == 23 then
		return "E"
	elseif digit == 24 then
		return "r"
	elseif digit == 25 then
		return "t"
	elseif digit == 26 then
		return "T"
	elseif digit == 27 then
		return "y"
	elseif digit == 28 then
		return "Y"
	elseif digit == 29 then
		return "u"
	elseif digit == 30 then
		return "i"
	elseif digit == 31 then
		return "I"
	elseif digit == 32 then
		return "o"
	elseif digit == 33 then
		return "O"
	elseif digit == 34 then
		return "p"
	elseif digit == 35 then
		return "P"
	elseif digit == 36 then
		return "a"
	elseif digit == 37 then
		return "s"
	elseif digit == 38 then
		return "S"
	elseif digit == 39 then
		return "d"
	elseif digit == 40 then
		return "D"
	elseif digit == 41 then
		return "f"
	elseif digit == 42 then
		return "g"
	elseif digit == 43 then
		return "G"
	elseif digit == 44 then
		return "h"
	elseif digit == 45 then
		return "H"
	elseif digit == 46 then
		return "j"
	elseif digit == 47 then
		return "J"
	elseif digit == 48 then
		return "k"
	elseif digit == 49 then
		return "l"
	elseif digit == 50 then
		return "L"
	elseif digit == 51 then
		return "z"
	elseif digit == 52 then
		return "Z"
	elseif digit == 53 then
		return "x"
	elseif digit == 54 then
		return "c"
	elseif digit == 55 then
		return "C"
	elseif digit == 56 then
		return "v"
	elseif digit == 57 then
		return "V"
	elseif digit == 58 then
		return "b"
	elseif digit == 59 then
		return "B"
	elseif digit == 60 then
		return "n"
	elseif digit == 61 then
		return "m"
  	else
    	return "?"
	end
end
function IsBlack(note)
	if note%12 == 2 or note%12 == 4 or note%12 == 7 or note%12 == 9 or note%12 == 11 then
		return true
	end
end

local TweenService = game:GetService("TweenService")
function Tween(obj,Goal,Time,Wait,...) local TwInfo = TweenInfo.new(Time,...) local twn = TweenService:Create(obj, TwInfo, Goal) twn:Play() if Wait then twn.Completed:wait() end return
end

local orgins = {} if script.Parent.Keys:FindFirstChild("Keys") then for i,v in pairs(script.Parent.Keys.Keys:GetChildren()) do orgins[v.Name] = {v.Position,v.Orientation} end else for i,v in pairs(script.Parent.Keys:GetChildren()) do if v:IsA("Model") then for a,b in pairs(v:GetChildren()) do orgins[v.Name] = {b.Position,b.Orientation} end end end end function AnimateKey(note1,px,py,pz,ox,oy,oz,Time) pcall(function() local obj = script.Parent.Keys.Keys:FindFirstChild(note1) if obj then local Properties = {} local OrginP = orgins[obj.Name][1] local OrginO = orgins[obj.Name][2] local changep = OrginP - Vector3.new(px,py,pz) local changeo = OrginO - Vector3.new(ox,oy,oz) Properties.Position = Vector3.new(obj.Position.x, changep.Y, changep.Z) Properties.Orientation = changeo Tween(obj,Properties,Time,Enum.EasingStyle.Linear) Properties = {} Properties.Position = Vector3.new(obj.Position.x,OrginP.y,OrginP.z) Properties.Orientation = OrginO Tween(obj,Properties,Time,Enum.EasingStyle.Linear) else print(note1..' was not found, or you do not have the correct configuration for the piano keys') end end) end


Prompt: --Variables--

Response:
local Enabled = true
local mouse = Player:GetMouse()
local ButtonDown = false
local Key = nil

local cooldown = 5
local Debounce = 1


Prompt: --[[Drivetrain]]

Response:
	Tune.Config			= "RWD"		--"FWD" , "RWD" , "AWD"

	--Differential Settings
	Tune.FDiffSlipThres	= 50		-- 1 - 100%				(Max threshold of applying full lock determined by deviation from avg speed)
	Tune.FDiffLockThres	= 50		-- 0 - 100%				(0 - Bias toward slower wheel, 100 - Bias toward faster wheel)
	Tune.RDiffSlipThres	= 50		-- 1 - 100%
	Tune.RDiffLockThres	= 50		-- 0 - 100%
	Tune.CDiffSlipThres	= 50		-- 1 - 100%				[AWD Only]
	Tune.CDiffLockThres	= 50		-- 0 - 100%				[AWD Only]

	--Traction Control Settings
	Tune.TCSEnabled		= true		-- Implements TCS
	Tune.TCSThreshold	= 20		-- Slip speed allowed before TCS starts working (in SPS)
	Tune.TCSGradient	= 20		-- Slip speed gradient between 0 to max reduction (in SPS)
	Tune.TCSLimit		= 10		-- Minimum amount of torque at max reduction (in percent)


Prompt: -- initiate

Response:
for _, drop in pairs(DROPS:GetChildren()) do
	HandleDrop(drop)
end

local t	= 0

RunService.Stepped:connect(function(_, deltaTime)
	t	= t + deltaTime
	for drop, dropInfo in pairs(drops) do
		local offset	= drop.Position - CAMERA.CFrame.p

		if math.abs(offset.X) < UPDATE_RANGE and math.abs(offset.Y) < UPDATE_RANGE and math.abs(offset.Z) < UPDATE_RANGE then
			local localT	= t + (drop.Position.X + drop.Position.Z) * 0.2
			local cframe	= CFrame.new(drop.Position) * CFrame.new(0, math.sin(localT) * 0.2, 0) * CFrame.Angles(0, localT / 4, 0)

			for _, info in pairs(dropInfo.Parts) do
				info.Part.CFrame	= cframe * info.Offset
				local offset		= info.Part.Position - CAMERA.CFrame.p
				info.Outline.CFrame	= info.Part.CFrame + offset.Unit * OUTLINE_WIDTH * 2
			end
		end
	end
end)


Prompt:
--[[
	Returns the platform / user input of the client.
]]

Response:
local function getClientPlatform()
	-- TODO: Get input, and return Keyboard, Controller, or Touch
	return "Keyboard"
end


Prompt:
-- Util
-- Stephen Leitnick
-- April 29, 2022

Response:
type AnyTable = { [any]: any }

local Util = {}

Util.None = newproxy()


Prompt: --[[Steering]]

Response:
	Tune.SteerInner		= 58		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 58		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .5		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .5		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 325		-- 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	= 5000		-- Steering Force
	Tune.SteerP			= 3500		-- Steering Aggressiveness


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local v1 = {
	Died = 0,
	Running = 1,
	Swimming = 2,
	Climbing = 3,
	Jumping = 4,
	GettingUp = 5,
	FreeFalling = 6,
	FallingDown = 7,
	Landing = 8,
	Splash = 9
};
local v2 = nil;
local v3 = {};
local l__ReplicatedStorage__4 = game:GetService("ReplicatedStorage");
local v5 = l__ReplicatedStorage__4:FindFirstChild("DefaultSoundEvents");
local v6 = UserSettings():IsUserFeatureEnabled("UserUseSoundDispatcher");
if v6 then
	if not v5 then
		v5 = Instance.new("Folder", l__ReplicatedStorage__4);
		v5.Name = "DefaultSoundEvents";
		v5.Archivable = false;
	end;
	local v7 = v5:FindFirstChild("RemoveCharacterEvent");
	if v7 == nil then
		v7 = Instance.new("RemoteEvent", v5);
		v7.Name = "RemoveCharacterEvent";
	end;
	local v8 = v5:FindFirstChild("AddCharacterLoadedEvent");
	if v8 == nil then
		v8 = Instance.new("RemoteEvent", v5);
		v8.Name = "AddCharacterLoadedEvent";
	end;
	v8:FireServer();
	game.Players.LocalPlayer.CharacterRemoving:connect(function(p1)
		v7:FireServer(game.Players.LocalPlayer);
	end);
end;
local l__Parent__9 = script.Parent.Parent;
local l__Head__10 = l__Parent__9:WaitForChild("Head");
while not v2 do
	for v11, v12 in pairs(l__Parent__9:GetChildren()) do
		if v12:IsA("Humanoid") then
			v2 = v12;
			break;
		end;
	end;
	if v2 then
		break;
	end;
	l__Parent__9.ChildAdded:wait();
end;
v3[v1.Died] = l__Head__10:WaitForChild("Died");
v3[v1.Running] = l__Head__10:WaitForChild("Running");
v3[v1.Swimming] = l__Head__10:WaitForChild("Swimming");
v3[v1.Climbing] = l__Head__10:WaitForChild("Climbing");
v3[v1.Jumping] = l__Head__10:WaitForChild("Jumping");
v3[v1.GettingUp] = l__Head__10:WaitForChild("GettingUp");
v3[v1.FreeFalling] = l__Head__10:WaitForChild("FreeFalling");
v3[v1.Landing] = l__Head__10:WaitForChild("Landing");
v3[v1.Splash] = l__Head__10:WaitForChild("Splash");
if v6 then
	local v13 = v5:FindFirstChild("DefaultServerSoundEvent");
else
	v13 = game:GetService("ReplicatedStorage"):FindFirstChild("DefaultServerSoundEvent");
end;
if v13 then
	v13.OnClientEvent:connect(function(p2, p3, p4)
		if p4 and p2.TimePosition ~= 0 then
			p2.TimePosition = 0;
		end;
		if p2.IsPlaying ~= p3 then
			p2.Playing = p3;
		end;
	end);
end;
local l__SoundService__1 = game:GetService("SoundService");
local v14 = {
	YForLineGivenXAndTwoPts = function(p5, p6, p7, p8, p9)
		local v15 = (p7 - p9) / (p6 - p8);
		return v15 * p5 + (p7 - v15 * p6);
	end,
	Clamp = function(p10, p11, p12)
		return math.min(p12, math.max(p11, p10));
	end,
	HorizontalSpeed = function(p13)
		return (p13.Velocity + Vector3.new(0, -p13.Velocity.Y, 0)).magnitude;
	end,
	VerticalSpeed = function(p14)
		return math.abs(p14.Velocity.Y);
	end
};
local function u2()
	return game.Workspace.FilteringEnabled and l__SoundService__1.RespectFilteringEnabled;
end;
function v14.Play(p15)
	if u2() then
		p15.CharacterSoundEvent:FireServer(true, true);
	end;
	if p15.TimePosition ~= 0 then
		p15.TimePosition = 0;
	end;
	if not p15.IsPlaying then
		p15.Playing = true;
	end;
end;
function v14.Pause(p16)
	if u2() then
		p16.CharacterSoundEvent:FireServer(false, false);
	end;
	if p16.IsPlaying then
		p16.Playing = false;
	end;
end;
function v14.Resume(p17)
	if u2() then
		p17.CharacterSoundEvent:FireServer(true, false);
	end;
	if not p17.IsPlaying then
		p17.Playing = true;
	end;
end;
function v14.Stop(p18)
	if u2() then
		p18.CharacterSoundEvent:FireServer(false, true);
	end;
	if p18.IsPlaying then
		p18.Playing = false;
	end;
	if p18.TimePosition ~= 0 then
		p18.TimePosition = 0;
	end;
end;
local u3 = {};
function setSoundInPlayingLoopedSounds(p19)
	local v16 = #u3;
	local v17 = 1 - 1;
	while true do
		if u3[v17] == p19 then
			return;
		end;
		if 0 <= 1 then
			if v17 < v16 then

			else
				break;
			end;
		elseif v16 < v17 then

		else
			break;
		end;
		v17 = v17 + 1;
	end;
	table.insert(u3, p19);
end;
function stopPlayingLoopedSoundsExcept(p20)
	local v18 = #u3 - -1;
	while true do
		if u3[v18] ~= p20 then
			v14.Pause(u3[v18]);
			table.remove(u3, v18);
		end;
		if 0 <= -1 then
			if v18 < 1 then

			else
				break;
			end;
		elseif 1 < v18 then

		else
			break;
		end;
		v18 = v18 + -1;
	end;
end;
local v19 = {};
v19[Enum.HumanoidStateType.Dead] = function()
	stopPlayingLoopedSoundsExcept();
	v14.Play(v3[v1.Died]);
end;
v19[Enum.HumanoidStateType.RunningNoPhysics] = function(p21)
	stateUpdated(Enum.HumanoidStateType.Running, p21);
end;
local u4 = UserSettings():IsUserFeatureEnabled("UserFixCharacterSoundIssues");
local u5 = nil;
local u6 = 0;
v19[Enum.HumanoidStateType.Running] = function(p22)
	local v20 = v3[v1.Running];
	stopPlayingLoopedSoundsExcept(v20);
	if u4 and u5 == Enum.HumanoidStateType.Freefall and u6 > 0.1 then
		local v21 = v3[v1.FreeFalling];
		v21.Volume = math.min(1, math.max(0, (u6 - 50) / 110));
		v14.Play(v21);
		u6 = 0;
	end;
	if u4 then
		if p22 ~= nil and p22 > 0.5 then
			v14.Resume(v20);
			setSoundInPlayingLoopedSounds(v20);
			return;
		elseif p22 ~= nil then
			stopPlayingLoopedSoundsExcept();
			return;
		else
			return;
		end;
	elseif not (v14.HorizontalSpeed(l__Head__10) > 0.5) then
		stopPlayingLoopedSoundsExcept();
		return;
	end;
	v14.Resume(v20);
	setSoundInPlayingLoopedSounds(v20);
end;
v19[Enum.HumanoidStateType.Swimming] = function(p23)
	if u4 then
		local v22 = p23;
	else
		v22 = v14.VerticalSpeed(l__Head__10);
	end;
	if u5 ~= Enum.HumanoidStateType.Swimming and v22 > 0.1 then
		local v23 = v3[v1.Splash];
		v23.Volume = v14.Clamp(v14.YForLineGivenXAndTwoPts(v14.VerticalSpeed(l__Head__10), 100, 0.28, 350, 1), 0, 1);
		v14.Play(v23);
	end;
	local v24 = v3[v1.Swimming];
	stopPlayingLoopedSoundsExcept(v24);
	v14.Resume(v24);
	setSoundInPlayingLoopedSounds(v24);
end;
v19[Enum.HumanoidStateType.Climbing] = function(p24)
	local v25 = v3[v1.Climbing];
	if u4 then
		if p24 ~= nil and math.abs(p24) > 0.1 then
			v14.Resume(v25);
			stopPlayingLoopedSoundsExcept(v25);
		else
			v14.Pause(v25);
			stopPlayingLoopedSoundsExcept(v25);
		end;
	elseif v14.VerticalSpeed(l__Head__10) > 0.1 then
		v14.Resume(v25);
		stopPlayingLoopedSoundsExcept(v25);
	else
		stopPlayingLoopedSoundsExcept();
	end;
	setSoundInPlayingLoopedSounds(v25);
end;
v19[Enum.HumanoidStateType.Jumping] = function()
	if u5 == Enum.HumanoidStateType.Jumping then
		return;
	end;
	stopPlayingLoopedSoundsExcept();
	v14.Play(v3[v1.Jumping]);
end;
v19[Enum.HumanoidStateType.GettingUp] = function()
	stopPlayingLoopedSoundsExcept();
	v14.Play(v3[v1.GettingUp]);
end;
v19[Enum.HumanoidStateType.Freefall] = function()
	if u5 == Enum.HumanoidStateType.Freefall then
		return;
	end;
	v3[v1.FreeFalling].Volume = 0;
	stopPlayingLoopedSoundsExcept();
	u6 = math.max(u6, math.abs(l__Head__10.Velocity.y));
end;
v19[Enum.HumanoidStateType.FallingDown] = function()
	stopPlayingLoopedSoundsExcept();
end;
v19[Enum.HumanoidStateType.Landed] = function()
	stopPlayingLoopedSoundsExcept();
	if v14.VerticalSpeed(l__Head__10) > 75 then
		local v26 = v3[v1.Landing];
		v26.Volume = v14.Clamp(v14.YForLineGivenXAndTwoPts(v14.VerticalSpeed(l__Head__10), 50, 0, 100, 1), 0, 1);
		v14.Play(v26);
	end;
end;
v19[Enum.HumanoidStateType.Seated] = function()
	stopPlayingLoopedSoundsExcept();
end;
function stateUpdated(p25, p26)
	if v19[p25] ~= nil then
		if u4 then
			if p25 ~= Enum.HumanoidStateType.Running then
				if p25 ~= Enum.HumanoidStateType.Climbing then
					if p25 ~= Enum.HumanoidStateType.Swimming then
						if p25 == Enum.HumanoidStateType.RunningNoPhysics then
							v19[p25](p26);
						else
							v19[p25]();
						end;
					else
						v19[p25](p26);
					end;
				else
					v19[p25](p26);
				end;
			else
				v19[p25](p26);
			end;
		else
			v19[p25]();
		end;
	end;
	u5 = p25;
end;
v2.Died:connect(function()
	stateUpdated(Enum.HumanoidStateType.Dead);
end);
v2.Running:connect(function(p27)
	stateUpdated(Enum.HumanoidStateType.Running, p27);
end);
v2.Swimming:connect(function(p28)
	stateUpdated(Enum.HumanoidStateType.Swimming, p28);
end);
v2.Climbing:connect(function(p29)
	stateUpdated(Enum.HumanoidStateType.Climbing, p29);
end);
v2.Jumping:connect(function()
	stateUpdated(Enum.HumanoidStateType.Jumping);
end);
v2.GettingUp:connect(function()
	stateUpdated(Enum.HumanoidStateType.GettingUp);
end);
v2.FreeFalling:connect(function()
	stateUpdated(Enum.HumanoidStateType.Freefall);
end);
v2.FallingDown:connect(function()
	stateUpdated(Enum.HumanoidStateType.FallingDown);
end);
v2.StateChanged:connect(function(p30, p31)
	stateUpdated(p31);
end);
function onUpdate(p32, p33)
	local v27 = v3[v1.FreeFalling];
	if u5 == Enum.HumanoidStateType.Freefall then
		if l__Head__10.Velocity.Y < 0 then
			if 75 < v14.VerticalSpeed(l__Head__10) then
				v14.Resume(v27);
				v27.Volume = v14.Clamp(v27.Volume + p33 / 1.1 * (p32 / p33), 0, 1);
			else
				v27.Volume = 0;
			end;
		else
			v27.Volume = 0;
		end;
	else
		v14.Pause(v27);
	end;
	if u5 == Enum.HumanoidStateType.Running then
		if v14.HorizontalSpeed(l__Head__10) < 0.5 then
			v14.Pause(v3[v1.Running]);
		end;
	end;
end;
local v28 = tick();
while true do
	onUpdate(tick() - v28, 0.25);
	v28 = tick();
	wait(0.25);
end;


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local l__Ice__1 = game.Players.LocalPlayer:WaitForChild("Data"):WaitForChild("Ice");
local l__Parent__1 = script.Parent;
l__Ice__1.Changed:Connect(function()
	if l__Ice__1.Value <= 0.9 and l__Ice__1.Value >= 1 then
		l__Parent__1.Crackle.Volume = 0.1;
		return;
	end;
	if l__Ice__1.Value <= 0.1 and l__Ice__1.Value >= 0 then
		l__Parent__1.Crackle.Volume = 0.9;
		return;
	end;
	if l__Ice__1.Value <= 0.2 and l__Ice__1.Value >= 0.1 then
		l__Parent__1.Crackle.Volume = 0.8;
		return;
	end;
	if l__Ice__1.Value <= 0.3 and l__Ice__1.Value >= 0.2 then
		l__Parent__1.Crackle.Volume = 0.7;
		return;
	end;
	if l__Ice__1.Value <= 0.4 and l__Ice__1.Value >= 0.3 then
		l__Parent__1.Crackle.Volume = 0.6;
		return;
	end;
	if l__Ice__1.Value <= 0.5 and l__Ice__1.Value >= 0.4 then
		l__Parent__1.Crackle.Volume = 0.5;
		return;
	end;
	if l__Ice__1.Value <= 0.6 and l__Ice__1.Value >= 0.5 then
		l__Parent__1.Crackle.Volume = 0.4;
		return;
	end;
	if l__Ice__1.Value <= 0.7 and l__Ice__1.Value >= 0.6 then
		l__Parent__1.Crackle.Volume = 0.3;
		return;
	end;
	if l__Ice__1.Value <= 0.8 and l__Ice__1.Value >= 0.7 then
		l__Parent__1.Crackle.Volume = 0.2;
		return;
	end;
	if l__Ice__1.Value <= 0.9 then
		l__Parent__1.Crackle.Volume = 0.1;
		return;
	end;
	if l__Ice__1.Value >= 1 then
		l__Parent__1.Crackle.Volume = 0;
	end;
end);


Prompt: --[[Transmission]]

Response:
	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 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt: --BOV--

Response:
script.Parent.Parent.Values.RPM.Changed:connect(function()
	local t = 0
	t = (totalPSI*20)
	BOVact = math.floor(t)
end)
script.Parent.Parent.Values.RPM.Changed:connect(function()
	wait(0.1)
	local t2 = 0
	t2 = (totalPSI*20)
	BOVact2 = math.floor(t2)
end)
script.Parent.Parent.Values.RPM.Changed:connect(function()
	if BOVact > BOVact2 then
		if BOV.IsPlaying == false then
			BOV:Play()

		end
	end
	if BOVact < BOVact2 then
		if BOV.IsPlaying == true then
			BOV:Stop()

		end
	end
end)


Prompt: --Formula secreta del crustacio kaskarudo

Response:
local RebirthFormule = game:GetService("ReplicatedStorage").GameProperties.RebirthFormule
local Formula = RebirthFormule.Value + (RebirthFormule.Value * Multiplier.Value)
local MultiplierFormule = game:GetService("ReplicatedStorage").GameProperties.MultiplierFormule


Prompt: --[[Wheel Stabilizer Gyro]]

Response:
	Tune.FGyroDamp		= 100		-- Front Wheel Non-Axial Dampening
	Tune.RGyroDamp		= 100		-- Rear Wheel Non-Axial Dampening


Prompt: --[[ The Module ]]

Response:
--
local MouseLockController = {}
MouseLockController.__index = MouseLockController

function MouseLockController.new()
	local self = setmetatable({}, MouseLockController)

	self.isMouseLocked = false
	self.savedMouseCursor = nil
	self.boundKeys = {Enum.KeyCode.Z} -- defaults

	self.mouseLockToggledEvent = Instance.new("BindableEvent")

	local boundKeysObj: StringValue = script:FindFirstChild("BoundKeys") :: StringValue
	if (not boundKeysObj) or (not boundKeysObj:IsA("StringValue")) then
		-- If object with correct name was found, but it's not a StringValue, destroy and replace
		if boundKeysObj then
			boundKeysObj:Destroy()
		end

		boundKeysObj = Instance.new("StringValue")
		boundKeysObj.Name = "BoundKeys"
		boundKeysObj.Value = "Z"
		boundKeysObj.Parent = script
	end

	if boundKeysObj then
		boundKeysObj.Changed:Connect(function(value)
			self:OnBoundKeysObjectChanged(value)
		end)
		self:OnBoundKeysObjectChanged(boundKeysObj.Value) -- Initial setup call
	end

	-- Watch for changes to user's ControlMode and ComputerMovementMode settings and update the feature availability accordingly
	GameSettings.Changed:Connect(function(property)
		if property == "ControlMode" or property == "ComputerMovementMode" then
			self:UpdateMouseLockAvailability()
		end
	end)

	-- Watch for changes to DevEnableMouseLock and update the feature availability accordingly
	PlayersService.LocalPlayer:GetPropertyChangedSignal("DevEnableMouseLock"):Connect(function()
		self:UpdateMouseLockAvailability()
	end)

	-- Watch for changes to DevEnableMouseLock and update the feature availability accordingly
	PlayersService.LocalPlayer:GetPropertyChangedSignal("DevComputerMovementMode"):Connect(function()
		self:UpdateMouseLockAvailability()
	end)

	self:UpdateMouseLockAvailability()

	return self
end

function MouseLockController:GetIsMouseLocked()
	return self.isMouseLocked
end

function MouseLockController:GetBindableToggleEvent()
	return self.mouseLockToggledEvent.Event
end

function MouseLockController:GetMouseLockOffset()
	local offsetValueObj: Vector3Value = script:FindFirstChild("CameraOffset") :: Vector3Value
	if offsetValueObj and offsetValueObj:IsA("Vector3Value") then
		return offsetValueObj.Value
	else
		-- If CameraOffset object was found but not correct type, destroy
		if offsetValueObj then
			offsetValueObj:Destroy()
		end
		offsetValueObj = Instance.new("Vector3Value")
		offsetValueObj.Name = "CameraOffset"
		offsetValueObj.Value = Vector3.new(1.75,0,0) -- Legacy Default Value
		offsetValueObj.Parent = script
	end

	if offsetValueObj and offsetValueObj.Value then
		return offsetValueObj.Value
	end

	return Vector3.new(1.75,0,0)
end

function MouseLockController:UpdateMouseLockAvailability()
	local devAllowsMouseLock = PlayersService.LocalPlayer.DevEnableMouseLock
	local devMovementModeIsScriptable = PlayersService.LocalPlayer.DevComputerMovementMode == Enum.DevComputerMovementMode.Scriptable
	local userHasMouseLockModeEnabled = GameSettings.ControlMode == Enum.ControlMode.MouseLockSwitch
	local userHasClickToMoveEnabled =  GameSettings.ComputerMovementMode == Enum.ComputerMovementMode.ClickToMove
	local MouseLockAvailable = devAllowsMouseLock and userHasMouseLockModeEnabled and not userHasClickToMoveEnabled and not devMovementModeIsScriptable

	if MouseLockAvailable~=self.enabled then
		self:EnableMouseLock(MouseLockAvailable)
	end
end

function MouseLockController:OnBoundKeysObjectChanged(newValue: string)
	self.boundKeys = {} -- Overriding defaults, note: possibly with nothing at all if boundKeysObj.Value is "" or contains invalid values
	for token in string.gmatch(newValue,"[^%s,]+") do
		for _, keyEnum in pairs(Enum.KeyCode:GetEnumItems()) do
			if token == keyEnum.Name then
				self.boundKeys[#self.boundKeys+1] = keyEnum :: Enum.KeyCode
				break
			end
		end
	end
	self:UnbindContextActions()
	self:BindContextActions()
end


Prompt:
--[[
	UI to select the surface art to place onto the canvas.
]]

Response:
local SurfaceArtSelector = Roact.Component:extend("SurfaceArtSelector")

SurfaceArtSelector.defaultProps = {
	numItemsPerPage = 3,
}

function SurfaceArtSelector:init()
	self.isAnimating = false
	self.position, self.updatePosition = Roact.createBinding(0)
	self.target, self.updateTarget = Roact.createBinding(0)
	self.motor = Otter.createSingleMotor(self.position:getValue())
	self.motor:onStep(self.updatePosition)

	self.state = {
		-- Selected surface art index in self.props.images
		selectedIndex = 1,

		-- Offset to render overflow items in order to avoid empty items during pagination
		offset = 0,
	}
	self.useSinglePagination = function()
		return UserInputService.TouchEnabled or self.props.orientation.isPortrait
	end
	self.onApply = modules.onApply(self)
	self.onCancel = modules.onCancel(self)
	self.prevPage = function()
		local prevPage = modules.prevPage(self)
		prevPage(math.min(self.props.numItemsPerPage, #self.props.images))
	end
	self.prevItem = function()
		local prevPage = modules.prevPage(self)
		prevPage(1)
	end
	self.nextPage = function()
		local nextPage = modules.nextPage(self)
		nextPage(math.min(self.props.numItemsPerPage, #self.props.images))
	end
	self.nextItem = function()
		local nextPage = modules.nextPage(self)
		nextPage(1)
	end
	self.setCurrentIndex = modules.setCurrentIndex(self)
	self.getRenderedIndexes = modules.getRenderedIndexes(self)
	self.formatTargetIndex = modules.formatTargetIndex()
	self.getItemTransparency = modules.getItemTransparency(self)
end

function SurfaceArtSelector:render()
	local items = {
		UIListLayout = Roact.createElement("UIListLayout", {
			SortOrder = Enum.SortOrder.LayoutOrder,
			FillDirection = Enum.FillDirection.Horizontal,
			VerticalAlignment = Enum.VerticalAlignment.Center,
			HorizontalAlignment = Enum.HorizontalAlignment.Center,
		}),
	}

	local indexes = self.getRenderedIndexes()
	local mid = math.floor((#indexes + 1) / 2)
	for i, index in ipairs(indexes) do
		-- Avoid the same image being shown as selected when they are shown on the same page
		local isSelected = self.state.selectedIndex == index and i == mid

		-- Offset from the current selected index
		local offset = mid - i

		local item = Roact.createElement("Frame", {
			LayoutOrder = i,
			BackgroundTransparency = 1,
			AutomaticSize = Enum.AutomaticSize.XY,
		}, {
			Roact.createElement(SurfaceArtSelectorItem, {
				image = self.props.images[index],
				isSelected = isSelected,
				transparency = self.getItemTransparency(i, index, mid),
				onClick = function()
					self.setCurrentIndex(index, offset)
				end,
			}),
		})

		items[self.formatTargetIndex(index, offset)] = item
	end

	local actionBarHeight = self.props.orientation.isPortrait and ACTION_BAR_HEIGHT_PORTRAIT
		or ACTION_BAR_HEIGHT_LANDSCAPE

	return Roact.createElement("Frame", {
		Size = UDim2.fromScale(1, 1),
		BackgroundTransparency = 1,
	}, {
		Background = Roact.createElement("Frame", {
			Size = UDim2.fromScale(1, 1),
			BackgroundColor3 = Color3.fromRGB(0, 0, 0),
			ZIndex = 1,
		}, {
			Gradient = Roact.createElement("UIGradient", {
				Transparency = NumberSequence.new({
					NumberSequenceKeypoint.new(0, 0),
					NumberSequenceKeypoint.new(0.2, 0.5),
					NumberSequenceKeypoint.new(0.8, 0.5),
					NumberSequenceKeypoint.new(1, 0),
				}),
				Rotation = self.props.orientation.isPortrait and 90 or 0,
			}),
		}),
		Container = Roact.createElement("Frame", {
			Size = UDim2.fromScale(1, 1),
			BackgroundTransparency = 1,
			ZIndex = 2,
		}, {
			Scroller = Roact.createElement("Frame", {
				Size = UDim2.new(1, 0, 1, -(actionBarHeight + ACTION_BAR_TOP_SPACING)),
				BackgroundTransparency = 1,
				Position = UDim2.fromScale(0.5, 0.5),
				AnchorPoint = Vector2.new(0.5, 0.5),
				ZIndex = 1,
			}, {
				UIListLayout = Roact.createElement("UIListLayout", {
					FillDirection = Enum.FillDirection.Horizontal,
					SortOrder = Enum.SortOrder.LayoutOrder,
				}),
				LeftButton = not self.useSinglePagination() and Roact.createElement(NavButton, {
					order = 1,
					image = self.props.configuration.leftArrowPageImage,
					onClick = self.prevPage,
					keyCode = self.props.configuration.usePageHotkeys and self.props.configuration.prevPageKey or nil,
				}),
				LeftSingleButton = Roact.createElement(NavButton, {
					order = 2,
					image = self.props.configuration.leftArrowItemImage,
					keyCode = self.props.configuration.usePageHotkeys and self.props.configuration.prevItemKey or nil,
					onClick = self.prevItem,
				}),
				Page = Roact.createElement("Frame", {
					LayoutOrder = 3,
					Size = self.useSinglePagination() and UDim2.fromScale(0.8, 1) or UDim2.fromScale(0.6, 1),
					BackgroundTransparency = 1,
					ClipsDescendants = true,
				}, {
					Container = Roact.createElement("Frame", {
						BackgroundTransparency = 1,
						Size = UDim2.fromScale(1, 1),
						AnchorPoint = Vector2.new(0.5, 0.5),
						Position = self.position:map(function(position)
							-- Calculate position for animation using pixel offset instead of scale.
							--
							-- This is because this Frame's size is not computed with all SurfaceArtSelectorItems rendered, but only
							-- those that are visible.
							return UDim2.new(0.5, position, 0.5, 0)
						end),
					}, items),
				}),
				RightSingleButton = Roact.createElement(NavButton, {
					order = 4,
					image = self.props.configuration.rightArrowItemImage,
					onClick = self.nextItem,
					keyCode = self.props.configuration.usePageHotkeys and self.props.configuration.nextItemKey or nil,
				}),
				RightButton = not self.useSinglePagination() and Roact.createElement(NavButton, {
					order = 5,
					image = self.props.configuration.rightArrowPageImage,
					onClick = self.nextPage,
					keyCode = self.props.configuration.usePageHotkeys and self.props.configuration.nextPageKey or nil,
				}),
			}),
			ActionBar = Roact.createElement("Frame", {
				Size = UDim2.new(1, 0, 0, actionBarHeight + ACTION_BAR_TOP_SPACING),
				BackgroundTransparency = 0.5,
				BackgroundColor3 = Color3.fromRGB(0, 0, 0),
				Position = UDim2.fromScale(0.5, 1),
				AnchorPoint = Vector2.new(0.5, 1),
				ZIndex = 3,
			}, {
				UIPadding = Roact.createElement("UIPadding", {
					PaddingTop = UDim.new(0, 16),
					PaddingBottom = UDim.new(0, 16),
				}),
				UIListLayout = Roact.createElement("UIListLayout", {
					SortOrder = Enum.SortOrder.LayoutOrder,
				}),
				TextLabel = Roact.createElement("TextLabel", {
					LayoutOrder = 1,
					Size = UDim2.fromScale(1, self.props.orientation.isPortrait and 0.5 or 0.4),
					BackgroundTransparency = 1,
					TextSize = 16,
					Font = Enum.Font.GothamSemibold,
					TextColor3 = Color3.fromRGB(255, 255, 255),
					TextYAlignment = Enum.TextYAlignment.Top,
					TextXAlignment = Enum.TextXAlignment.Center,
					TextWrapped = true,
					Text = string.format(
						"Choose a decal to place on the wall. You can add up to %d decals.",
						self.props.configuration.quotaPerPlayer
					),
				}, {
					UIPadding = Roact.createElement("UIPadding", {
						PaddingLeft = UDim.new(0, 8),
						PaddingRight = UDim.new(0, 8),
					}),
				}),
				Roact.createElement("Frame", {
					LayoutOrder = 2,
					Size = UDim2.fromScale(1, self.props.orientation.isPortrait and 0.5 or 0.6),
					BackgroundTransparency = 1,
				}, {
					ButtonGroup = Roact.createElement("Frame", {
						Size = UDim2.fromScale(0.5, 1),
						BackgroundTransparency = 1,
						Position = UDim2.fromScale(0.5, 0.5),
						AnchorPoint = Vector2.new(0.5, 0.5),
					}, {
						UIListLayout = Roact.createElement("UIListLayout", {
							FillDirection = Enum.FillDirection.Horizontal,
							SortOrder = Enum.SortOrder.LayoutOrder,
							Padding = UDim.new(0, 12),
						}),
						Cancel = Roact.createElement(Button, {
							LayoutOrder = 1,
							Text = "Cancel",
							TextColor3 = Color3.fromRGB(255, 255, 255),
							keyCode = Enum.KeyCode.B,
							onActivated = self.onCancel,
						}),
						Apply = Roact.createElement(Button, {
							LayoutOrder = 2,
							Text = "Apply",
							BackgroundColor3 = Color3.fromRGB(255, 255, 255),
							TextColor3 = Color3.fromRGB(0, 0, 0),
							keyCode = Enum.KeyCode.Return,
							onActivated = self.onApply,
						}),
					}),
				}),
			}),
		}),
	})
end

return ConfigurationContext.withConfiguration(OrientationContext.withOrientation(SurfaceArtSelector))


Prompt:
--[[**
	ensures Roblox Instance type

	@param value The value to check against

	@returns True iff the condition is satisfied, false otherwise
**--]]

Response: t.Instance = primitive("Instance")


Prompt: -- METHODS

Response:
function IconController.setGameTheme(theme)
	IconController.gameTheme = theme
	local icons = IconController.getIcons()
	for _, icon in pairs(icons) do
		icon:setTheme(theme)
	end
end

function IconController.setDisplayOrder(value)
	value = tonumber(value) or TopbarPlusGui.DisplayOrder
	TopbarPlusGui.DisplayOrder = value
end
IconController.setDisplayOrder(10)

function IconController.getIcons()
	local allIcons = {}
	for otherIcon, _ in pairs(topbarIcons) do
		table.insert(allIcons, otherIcon)
	end
	return allIcons
end

function IconController.getIcon(name)
	for otherIcon, _ in pairs(topbarIcons) do
		if otherIcon.name == name then
			return otherIcon
		end
	end
	return false
end

function IconController.disableHealthbar(bool)
	local finalBool = (bool == nil or bool)
	IconController.healthbarDisabled = finalBool
	IconController.healthbarDisabledSignal:Fire(finalBool)
end

function IconController.canShowIconOnTopbar(icon)
	if (icon.enabled == true or icon.accountForWhenDisabled) and icon.presentOnTopbar then
		return true
	end
	return false
end

function IconController.getMenuOffset(icon)
	local alignment = icon:get("alignment")
	local alignmentGap = IconController[alignment.."Gap"]
	local iconSize = icon:get("iconSize") or UDim2.new(0, 32, 0, 32)
	local sizeX = iconSize.X.Offset
	local iconWidthAndGap = (sizeX + alignmentGap)
	local extendLeft = 0
	local extendRight = 0
	local additionalRight = 0
	if icon.menuOpen then
		local menuSize = icon:get("menuSize")
		local menuSizeXOffset = menuSize.X.Offset
		local direction = icon:_getMenuDirection()
		if direction == "right" then
			extendRight += menuSizeXOffset + alignmentGap/6--2
		elseif direction == "left" then
			extendLeft = menuSizeXOffset + 4
			extendRight += alignmentGap/3--4
			additionalRight = menuSizeXOffset
		end
	end
	return extendLeft, extendRight, additionalRight
end


Prompt: -- Don't edit below unless you know what you're doing.

Response:
local O = true
function onClicked()
if O == true then
	O = false
	One()

elseif O == false then
	O = true
    Two()
end
end

script.Parent.MouseButton1Down:connect(onClicked)


Prompt:
--[=[
	@interface Service
	.Name string
	.Client ServiceClient
	.KnitComm Comm
	.[any] any
	@within KnitServer
]=]

Response:
type Service = {
	Name: string,
	Client: ServiceClient,
	KnitComm: any,
	[any]: any,
}


Prompt: --// Dev Vars

Response:
	CameraGo = true; -- No touchy
	FirstPersonOnly = false; -- SET THIS TO FALSE TO ENABLE THIRD PERSON, TRUE FOR FIRST PERSON ONLY
	TPSMouseIcon = 1415957732; -- Image used as the third person reticle


Prompt:
--RUNNING SCRIPT--
-------------------------------

Response:
local RunSpeed = 23 -- Change this to the speed you want the player to go
local AfterSpeed = 16 -- Best if you leave this alone. This is the speed the player will be after pressing shift.


Prompt:
--[[

	Returns true if a table/dictionary contains userdata (somewhat deep)

	Functions.HasUserdata(
		table, 					<-- |REQ|	Table/dictionary
	)

--]]

Response:
return function(tbl)
	--- Variables
	local found = false

	--- Scan local function
	local function Scan(v)
		--- Already found userdata
		if found then
			return
		end

		--- Iterate
		for key, value in pairs(v) do
			--- Already found userdata
			if found then
				return
			end

			--- Main check
			if type(value) == "userdata" or type(key) == "userdata" then
				--- Userdata located
				found = true
				return

			elseif type(value) == "table" then
				--- Re-iterate
				Scan(value)
			end
		end
	end

	--- Scan
	Scan(tbl)

	--
	return found
end


Prompt: -- Libraries

Response: local Support = require(Libraries:WaitForChild 'SupportLibrary')


Prompt: --//Handling//--

Response:
SteeringAngle = 40 --{Steering angle in degrees}
SteerSpeed = 0.05 --{.01 being slow, 1 being almost instantly}
TiresFront = 2 --{1 = eco, 2 = road, 3 = sport}
TiresRear = 2 --{1 = eco, 2 = road, 3 = sport}
DownforceF = 0 --{[0-5] Provides downforce to the front at the cost of drag}
DownforceR = 0 --{[0-5] Provides downforce to the rear at the cost of drag}
BrakeBias = 72 --{100 = all on front || 0 = all on rear}
BrakePower = 80  --{100 = strong brakes 0 = close to no brakes}
TC = false
ABS = true


Prompt:
--[[
	param targetFps  Task scheduler won't run a task if it'd make the FPS drop below this amount
					 (WARNING) this only holds true if it is used properly. If you try to complete 10 union operations
					 at once in a single task then of course your FPS is going to drop -- queue the union operations
					 up one at a time so the task scheduler can do its job.

	returns scheduler
		method Pause      Pauses the scheduler so it won't run tasks. Tasks may still be added while the scheduler is
						  paused. They just won't be touched until it's resumed. Performance efficient -- disables
						  renderstepped loop entirely until scheduler is resumed.

		method Resume     Resumes the paused scheduler.

		method Destroy    Destroys the scheduler so it can't be used anymore.

		method QueueTask  Queues a task for automatic execution.
			param callback  function (task) to be run.

	Example usage:

	local scheduler = TaskScheduler:CreateScheduler(60)
	local totalOperations = 0
	local paused
	for i=1,100 do
		scheduler:QueueTask(function()
			local partA = Instance.new("Part", workspace)
			local partB = Instance.new("Part", workspace)
			plugin:Union({partA, partB}):Destroy()
			totalOperations = totalOperations + 1
			print("Times unioned:", totalOperations)
			if totalOperations == 50 then
				scheduler:Pause()
				paused = true
			end
		end)
	end

	repeat wait() until paused
	wait(2)
	scheduler:Resume()
--]]

Response:
function TaskScheduler:CreateScheduler(targetFps)
	local scheduler = {}
	local queue = {}
	local sleeping = true
	local event,paused

	local start
	local frameUpdateTable = {}
	local sleep--get syntax highlighter to shut up on line 68
	local function onEvent()
		local iterationStart = tick()
		local targetFrameUpdates = (iterationStart-start) < 1 and math.floor(targetFps * (iterationStart-start)) or targetFps

		for i=#frameUpdateTable,1,-1 do
			frameUpdateTable[i+1] = (frameUpdateTable[i] >= iterationStart-1) and frameUpdateTable[i] or nil
		end
		frameUpdateTable[1] = iterationStart

		if #frameUpdateTable >= targetFrameUpdates then
			if #queue > 0 then
				queue[1]()
				table.remove(queue, 1)
			else
				sleep()
			end
		end
	end

	--used for automatically turning off renderstepped loop when there's nothing in the queue
	sleep = function()
		sleeping = true
		if event then
			event:disconnect()
			event = nil
		end
	end

	--turns renderstepped loop back on when something is added to the queue and scheduler isn't paused
	local function wake()
		if sleeping and not event then
			sleeping = false
			if not paused then
				start = tick()
				event = game:GetService("RunService").RenderStepped:connect(onEvent)
			end
		end
	end

	function scheduler:Pause()
		paused = true
		if event then
			event:disconnect()
			event = nil
		end
	end

	function scheduler:Resume()
		if paused and not event then
			paused = false
			sleeping = false
			start = tick()
			event = game:GetService("RunService").RenderStepped:connect(onEvent)
		end
	end

	function scheduler:Destroy()
		scheduler:Pause()
		for i in next,scheduler do
			scheduler[i] = nil
		end
		setmetatable(scheduler, {
			__index = function()
				error("Attempt to use destroyed scheduler")
			end;
			__newindex = function()
				error("Attempt to use destroyed scheduler")
			end;
		})
	end

	function scheduler:QueueTask(callback)
		queue[#queue+1] = callback
		if sleeping then
			wake()
		end
	end

	start = tick()
	event = game:GetService("RunService").RenderStepped:connect(onEvent)

	return scheduler
end

return TaskScheduler


Prompt: -- Position the frames and sizes for the Backpack GUI elements

Response: UpdateBackpackLayout()


Prompt: -- Setup animation objects

Response:
for name, fileList in pairs(animNames) do
	animTable[name] = {}
	animTable[name].count = 0
	animTable[name].totalWeight = 0

	-- check for config values
	local config = script:FindFirstChild(name)
	if (config ~= nil) then


Prompt: --[[Brakes]]

Response:
--
	Tune.FBrakeForce	= 300 		-- Front brake force
	Tune.RBrakeForce	= 250 		-- Rear brake force
	Tune.PBrakeForce	= 500 		-- Parking brake force

	Tune.LinkedBrakes	= true 		-- Links brakes up, uses both brakes while braking
	Tune.BrakesRatio	= 60 		-- The ratio of the brakes (0 = rear brake; 100 = front brake)


Response:
Queue._gameMode = Conf.default_game_mode
Queue._destinationId = Conf.modes[Queue._gameMode].gameplay_place
Queue._timeoutEnabled = true


Prompt: --[[START]]

Response: _BuildVersion = require(script.Parent.README)


Prompt: --// Extras

Response:
	WalkAnimEnabled = true; -- Set to false to disable walking animation, true to enable
	SwayEnabled = true;	 -- Set to false to disable sway, true to enable
	TacticalModeEnabled = false; -- SET THIS TO TRUE TO TURN ON TACTICAL MODEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE


Prompt: -- Decompiled with the Synapse X Luau decompiler.

Response:
local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Resources"));
end)();
local v1 = {
	New = function(p1, p2, p3, p4)
		p2 = p2 or Color3.new(0.2, 0.2, 0.2);
		p3 = p3 or Enum.Font.FredokaOne;
		p4 = p4 or Enum.FontSize.Size18;
		u1.StarterGui:SetCore("ChatMakeSystemMessage", {
			Text = p1,
			Color = p2,
			Font = p3,
			FontSize = p4
		});
	end
};
u1.Network.Fired("Chat Msg"):Connect(function(...)
	v1.New(...);
end);
return v1;


Prompt: -- Compiled with roblox-ts v1.3.3

Response:
local function fields(defaults)
	if defaults == nil then
		defaults = {}
	end
	return function(input)
		local _object = {}
		for _k, _v in pairs(defaults) do
			_object[_k] = _v
		end
		if type(input) == "table" then
			for _k, _v in pairs(input) do
				_object[_k] = _v
			end
		end
		return _object
	end
end
return {
	fields = fields,
}


Prompt: --[[Weight Scaling]]

Response:
	--[Cubic stud : pounds ratio]
	--[STANDARDIZED: Don't touch unless needed]
	Tune.WeightScaling = 1/50	--Default = 1/50 (1 cubic stud = 50 lbs)
	Tune.LegacyScaling = 1/10	--Default = 1/10 (1 cubic stud = 10 lbs) [PGS OFF]

return Tune


Prompt: --Variables--

Response:
local set = script.Settings
local sp = set.Speed
local enabled = set.Enabled
local loop = set.Loop
local debug_ = set.Debug
local hum = script.Parent:WaitForChild("Humanoid")
if debug_.Value == true then
	if hum then
		print("Success")
	else
		print("No Humanoid")
	end
end
local humanim = hum:LoadAnimation(script:FindFirstChildOfClass("Animation"))


Prompt: --Tuck in

Response:
R6TorsoTuckIn = .5
R6RightArmTuckIn = .2
R6LeftArmTuckIn = .2


Prompt:
--	====================
--	CHARGED SHOT
--	Make a gun charging before firing. Useful for a gun like "Railgun" or "Laser Cannon"
--	====================

Response:
		ChargedShotEnabled = false;
		ChargingTime = 1;


Prompt: --This module is for any client FX related to the DoubleDoor

Response:
local DoorFX = {}

local tweenService = game:GetService("TweenService")

local tweenInfo = TweenInfo.new(2, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)

function DoorFX.OPEN(door)
	if not door then return end

	for i = 1, 2 do
		tweenService:Create(door["Door" .. i].PrimaryPart, tweenInfo, {CFrame = door["Door"..i.."Goal"].CFrame}):Play()
		door["Door" .. i].PrimaryPart.DoorOpenFADEOUT:Play()
	end
end

function DoorFX.CLOSE(door)
	if not door then return end

	for i = 1, 2 do
		door["Door" .. i].PrimaryPart.CFrame = door["Door"..i.."Start"].CFrame
	end

end

return DoorFX


Prompt:
--[=[
	Initializes the service bag and ensures recursive initialization
	can occur
]=]

Response:
function ServiceBag:Init()
	assert(not self._initializing, "Already initializing")
	assert(self._serviceTypesToInitializeSet, "Already initialized")
	self._initializing = true

	while next(self._serviceTypesToInitializeSet) do
		local serviceType = next(self._serviceTypesToInitializeSet)
		self._serviceTypesToInitializeSet[serviceType] = nil

		self:_ensureInitialization(serviceType)
	end

	self._serviceTypesToInitializeSet = nil
	self._initializing = false
end


Prompt: --[[Transmission]]

Response:
	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.5			-- 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 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt: --[[Weight and CG]]

Response:
	Tune.Weight			= 3000		-- Total weight (in pounds)
	Tune.WeightBSize	= {			-- Size of weight brick (dimmensions in studs ; larger = more stable)
	 --[[Width]]		6		,
	 --[[Height]]		3.5		,
	 --[[Length]]		14		}
	Tune.WeightDist		= 50		-- Weight distribution (0 - on rear wheels, 100 - on front wheels, can be <0 or >100)
	Tune.CGHeight		= .8		-- Center of gravity height (studs relative to median of all wheels)
	Tune.WBVisible		= false		-- Makes the weight brick visible

	--Unsprung Weight
	Tune.FWheelDensity	= .1		-- Front Wheel Density
	Tune.RWheelDensity	= .1		-- Rear Wheel Density
	Tune.FWLgcyDensity	= 1			-- Front Wheel Density [PGS OFF]
	Tune.RWLgcyDensity	= 1			-- Rear Wheel Density [PGS OFF]

	Tune.AxleSize		= 2			-- Size of structural members (larger = more stable/carry more weight)
	Tune.AxleDensity	= .1		-- Density of structural members


Prompt: -- server side setup

Response:
local Pcolors = {{255, 255, 255}, {255, 180, 161}, {226, 231, 255}}
local Lcolors = {{255, 255, 255}, {255, 237, 199}, {205, 227, 255}}

local INDcolor = {255, 130, 80}
local plactive = false
local prevChild

F.Setup = function(light_type, popups, tb, fog_color)
	event.IndicatorsAfterLeave.Disabled = true
	for idx, child in pairs(lights.Brake:GetChildren()) do
		if child.Name == "L" and #child:GetChildren() < 1  then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Back
			spot.Color = Color3.fromRGB(255, 0, 0)
			spot.Shadows = true
		elseif child.Name == "LN" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = Color3.fromRGB(255, 96, 96)
			child.Transparency = 1
		end
	end

	for idx, child in pairs(lights.Rear:GetChildren()) do
		if child.Name == "L" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Back
			spot.Color = Color3.fromRGB(255, 0, 0)
			spot.Shadows = true
		elseif child.Name == "LN" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = Color3.fromRGB(255, 96, 96)
			child.Transparency = 1
		end
	end

	for idx, child in pairs(lights.Reverse:GetChildren()) do
		if child.Name == "L" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Back
			spot.Color = Color3.fromRGB(255, 255, 255)
			spot.Shadows = true
		elseif child.Name == "LN" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = Color3.fromRGB(255, 255, 255)
			child.Transparency = 1
		end
	end

	for idx, child in pairs(lights.LeftInd:GetDescendants()) do
		if child.Name == "L" and child.Parent.Name == "Front" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Front
			spot.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			spot.Shadows = true
		elseif child.Name == "L" and child.Parent.Name == "Rear" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Back
			spot.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			spot.Shadows = true
		elseif child.Name == "L" and child.Parent.Name == "Side" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Left
			spot.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			spot.Shadows = true
		elseif child.Name == "LN" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			child.Transparency = 1
		elseif string.sub(child.Name, 1, 2) == "SI" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			child.Transparency = 1
		end
	end

	for idx, child in pairs(lights.RightInd:GetDescendants()) do
		if child.Name == "L" and child.Parent.Name == "Front" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Front
			spot.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			spot.Shadows = true
		elseif child.Name == "L" and child.Parent.Name == "Rear" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Back
			spot.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			spot.Shadows = true
		elseif child.Name == "L" and child.Parent.Name == "Side" and #child:GetChildren() < 1 then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Right
			spot.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			spot.Shadows = true
		elseif child.Name == "LN" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			child.Transparency = 1
		elseif string.sub(child.Name, 1, 2) == "SI" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = Color3.fromRGB(INDcolor[1], INDcolor[2], INDcolor[3])
			child.Transparency = 1
		end
	end

	for idx, child in pairs(tb) do
		child.ImageTransparency = 1
	end

	if not popups then
		if light_type == "Pure White" then
			for idx, child in pairs(lights.Headlights:GetDescendants()) do
				if child.Name == "L" and #child:GetChildren() < 1 then
					local spot = Instance.new("SpotLight", child)
					spot.Name = "L"
					spot.Brightness = 0
					spot.Range = 0
					spot.Face = Enum.NormalId.Front
					spot.Color = Color3.fromRGB(Lcolors[1][1], Lcolors[1][2], Lcolors[1][3])
					spot.Shadows = true
				elseif child.Name == "LN" then
					if child:IsA("MeshPart") then
						child.TextureID = ""
					end
					child.Material = Enum.Material.Neon
					child.Color = Color3.fromRGB(Pcolors[1][1], Pcolors[1][2], Pcolors[1][3])
					child.Transparency = 1
				end
			end
		elseif light_type == "OEM White" then
			for idx, child in pairs(lights.Headlights:GetDescendants()) do
				if child.Name == "L" and #child:GetChildren() < 1 then
					local spot = Instance.new("SpotLight", child)
					spot.Name = "L"
					spot.Brightness = 0
					spot.Range = 0
					spot.Face = Enum.NormalId.Front
					spot.Color = Color3.fromRGB(Lcolors[2][1], Lcolors[2][2], Lcolors[2][3])
					spot.Shadows = true
				elseif child.Name == "LN" then
					if child:IsA("MeshPart") then
						child.TextureID = ""
					end
					child.Material = Enum.Material.Neon
					child.Color = Color3.fromRGB(Pcolors[2][1], Pcolors[2][2], Pcolors[2][3])
					child.Transparency = 1
				end
			end
		elseif light_type == "Xenon" then
			for idx, child in pairs(lights.Headlights:GetDescendants()) do
				if child.Name == "L" and #child:GetChildren() < 1 then
					local spot = Instance.new("SpotLight", child)
					spot.Name = "L"
					spot.Brightness = 0
					spot.Range = 0
					spot.Face = Enum.NormalId.Front
					spot.Color = Color3.fromRGB(Lcolors[3][1], Lcolors[3][2], Lcolors[3][3])
					spot.Shadows = true
				elseif child.Name == "LN" then
					if child:IsA("MeshPart") then
						child.TextureID = ""
					end
					child.Material = Enum.Material.Neon
					child.Color = Color3.fromRGB(Pcolors[3][1], Pcolors[3][2], Pcolors[3][3])
					child.Transparency = 1
				end
			end
		end
	else
		if light_type == "Pure White" then
			for idx, child in pairs(PHeadlights.Parts.Headlights:GetChildren()) do
				if child.Name == "L" and #child:GetChildren() < 1 then
					local spot = Instance.new("SpotLight", child)
					spot.Name = "L"
					spot.Brightness = 0
					spot.Range = 0
					spot.Face = Enum.NormalId.Front
					spot.Color = Color3.fromRGB(Lcolors[1][1], Lcolors[1][2], Lcolors[1][3])
					spot.Shadows = true
				elseif child.Name == "LN" then
					if child:IsA("MeshPart") then
						child.TextureID = ""
					end
					child.Material = Enum.Material.Neon
					child.Color = Color3.fromRGB(Pcolors[1][1], Pcolors[1][2], Pcolors[1][3])
					child.Transparency = 1
				end
			end
		elseif light_type == "OEM White" then
			for idx, child in pairs(PHeadlights.Parts.Headlights:GetChildren()) do
				if child.Name == "L" and #child:GetChildren() < 1 then
					local spot = Instance.new("SpotLight", child)
					spot.Name = "L"
					spot.Brightness = 0
					spot.Range = 0
					spot.Face = Enum.NormalId.Front
					spot.Color = Color3.fromRGB(Lcolors[2][1], Lcolors[2][2], Lcolors[2][3])
					spot.Shadows = true
				elseif child.Name == "LN" then
					if child:IsA("MeshPart") then
						child.TextureID = ""
					end
					child.Material = Enum.Material.Neon
					child.Color = Color3.fromRGB(Pcolors[2][1], Pcolors[2][2], Pcolors[2][3])
					child.Transparency = 1
				end
			end
		elseif light_type == "Xenon" then
			for idx, child in pairs(PHeadlights.Parts.Headlights:GetChildren()) do
				if child.Name == "L" and #child:GetChildren() < 1 then
					local spot = Instance.new("SpotLight", child)
					spot.Name = "L"
					spot.Brightness = 0
					spot.Range = 0
					spot.Face = Enum.NormalId.Front
					spot.Color = Color3.fromRGB(Lcolors[3][1], Lcolors[3][2], Lcolors[3][3])
					spot.Shadows = true
				elseif child.Name == "LN" then
					if child:IsA("MeshPart") then
						child.TextureID = ""
					end
					child.Material = Enum.Material.Neon
					child.Color = Color3.fromRGB(Pcolors[3][1], Pcolors[3][2], Pcolors[3][3])
					child.Transparency = 1
				end
			end
		end
	end
	for idx, child in pairs(lights.Fog:GetChildren()) do
		if child.Name == "L" then
			local spot = Instance.new("SpotLight", child)
			spot.Name = "L"
			spot.Brightness = 0
			spot.Range = 0
			spot.Face = Enum.NormalId.Front
			spot.Color = fog_color
			spot.Shadows = true
		elseif child.Name == "LN" then
			if child:IsA("MeshPart") then
				child.TextureID = ""
			end
			child.Material = Enum.Material.Neon
			child.Color = fog_color
			child.Transparency = 1
		end
	end
	print("EpicLights Version 2 // Setup completed!")
end


Prompt: --[[Engine]]

Response:
	--Torque Curve
	Tune.Horsepower		= script.Tune_HorsePower.Value		--	[TORQUE CURVE VISUAL]
	Tune.IdleRPM		= 700		--		https://www.desmos.com/calculator/2uo3hqwdhf
	Tune.PeakRPM		= 6000		--		Use sliders to manipulate values
	Tune.Redline		= 6700		--		Copy and paste slider values into the respective tune values
	Tune.EqPoint		= 5500
	Tune.PeakSharpness	= 7.5
	Tune.CurveMult		= 0.16

	--Incline Compensation
	Tune.InclineComp	= 4.7			-- Torque compensation multiplier for inclines (applies gradient from 0-90 degrees)

	--Misc
	Tune.RevAccel		= 150		-- RPM acceleration when clutch is off
	Tune.RevDecay		= 75		-- RPM decay when clutch is off
	Tune.RevBounce		= 500		-- RPM kickback from redline
	Tune.IdleThrottle	= 3			-- Percent throttle at idle
	Tune.ClutchTol		= 500		-- Clutch engagement threshold (higher = faster response)


Prompt: -- you can mess with these settings

Response:
CanToggleMouse = {allowed = true; activationkey = Enum.KeyCode.F;} -- lets you move your mouse around in firstperson
CanViewBody = true 		-- whether you see your body
Sensitivity = 0.6		-- anything higher would make looking up and down harder; recommend anything between 0~1
Smoothness = 0.05		-- recommend anything between 0~1
FieldOfView = 80		-- fov
HeadOffset = CFrame.new(0,0.7,0) -- how far your camera is from your head

local cam = game.Workspace.CurrentCamera
local player = players.LocalPlayer
local m = player:GetMouse()
m.Icon = "http://www.roblox.com/asset/?id=569021388" -- replaces mouse icon
local character = player.Character or player.CharacterAdded:wait()
local human = character.Humanoid
local humanoidpart = character.HumanoidRootPart

local head = character:WaitForChild("Head")
local CamPos,TargetCamPos = cam.CoordinateFrame.p,cam.CoordinateFrame.p
local AngleX,TargetAngleX = 0,0
local AngleY,TargetAngleY = 0,0

local running = true
local freemouse = false
local defFOV = FieldOfView

local w, a, s, d, lshift = false, false, false, false, false


Prompt: -- Module 3

Response:
function NpcModule.Walk(Npc, Pos, PathParams, Return)
	local Path = NpcModule.GetPath(Npc, Pos, PathParams)
	local Humanoid = Npc:FindFirstChild("Humanoid")

	if Path ~= false then
		if Humanoid then
			for I, Waypoint in pairs(Path:GetWaypoints()) do
				Humanoid:MoveTo(Waypoint.Position)
				Humanoid.MoveToFinished:Wait()
			end
		end
	end

	if Return ~= nil then
		return
	end
end


Prompt: --[[ Services ]]

Response:
--
local PlayersService = game:GetService('Players')
local VRService = game:GetService("VRService")

local CameraInput = require(script.Parent:WaitForChild("CameraInput"))
local Util = require(script.Parent:WaitForChild("CameraUtils"))


Prompt: -- Local player

Response:
local player = game.Players.LocalPlayer
local character = player.Character or player.CharacterAdded:wait()
local humanoid = character:WaitForChild("Humanoid")

local PlayerGui = player:WaitForChild("PlayerGui")


Prompt: -- functions

Response:
function onRunning(speed)
	if speed>0 then
		pose = "Running"
	else
		pose = "Standing"
	end
end

function onDied()
	pose = "Dead"
end

function onJumping()
	pose = "Jumping"
end

function onClimbing()
	pose = "Climbing"
end

function onGettingUp()
	pose = "GettingUp"
end

function onFreeFall()
	pose = "FreeFall"
end

function onFallingDown()
	pose = "FallingDown"
end

function onSeated()
	pose = "Seated"
end

function onPlatformStanding()
	pose = "PlatformStanding"
end

function onSwimming(speed)
	if speed>0 then
		pose = "Running"
	else
		pose = "Standing"
	end
end

function moveJump()
	RightShoulder.MaxVelocity = jumpMaxLimbVelocity
	LeftShoulder.MaxVelocity = jumpMaxLimbVelocity
  RightShoulder:SetDesiredAngle(3.14)
	LeftShoulder:SetDesiredAngle(-3.14)
	RightHip:SetDesiredAngle(0)
	LeftHip:SetDesiredAngle(0)
end