Prompt:
--[[

	Component.Auto(folder)
		-> Create components automatically from descendant modules of this folder
		-> Each module must have a '.Tag' string property
		-> Each module optionally can have '.RenderPriority' number property

	component = Component.FromTag(tag)
		-> Retrieves an existing component from the tag name

	component = Component.new(tag, class [, renderPriority])
		-> Creates a new component from the tag name, class module, and optional render priority

	component:GetAll(): ComponentInstance[]
	component:GetFromInstance(instance): ComponentInstance | nil
	component:GetFromID(id): ComponentInstance | nil
	component:Filter(filterFunc): ComponentInstance[]
	component:WaitFor(instanceOrName: Instance | string [, timeout: number = 60]): Promise<ComponentInstance>
	component:Destroy()

	component.Added(obj: ComponentInstance)
	component.Removed(obj: ComponentInstance)

	-----------------------------------------------------------------------

	A component class must look something like this:

		-- DEFINE
		local MyComponent = {}
		MyComponent.__index = MyComponent

		-- CONSTRUCTOR
		function MyComponent.new(instance)
			local self = setmetatable({}, MyComponent)
			return self
		end

		-- FIELDS AFTER CONSTRUCTOR COMPLETES
		MyComponent.Instance: Instance

		-- OPTIONAL LIFECYCLE HOOKS
		function MyComponent:Init() end                     -> Called right after constructor
		function MyComponent:Deinit() end                   -> Called right before deconstructor
		function MyComponent:HeartbeatUpdate(dt) ... end    -> Updates every heartbeat
		function MyComponent:SteppedUpdate(dt) ... end      -> Updates every physics step
		function MyComponent:RenderUpdate(dt) ... end       -> Updates every render step

		-- DESTRUCTOR
		function MyComponent:Destroy()
		end

	A component is then registered like so:

		local Component = require(Knit.Util.Component)
		local MyComponent = require(somewhere.MyComponent)
		local tag = "MyComponent"

		local myComponent = Component.new(tag, MyComponent)

	Components can be listened and queried:

		myComponent.Added:Connect(function(instanceOfComponent)
			-- New MyComponent constructed
		end)

		myComponent.Removed:Connect(function(instanceOfComponent)
			-- New MyComponent deconstructed
		end)

--]]

Response:
local Maid = require(script.Parent.Maid)
local Signal = require(script.Parent.Signal)
local Promise = require(script.Parent.Promise)
local Thread = require(script.Parent.Thread)
local TableUtil = require(script.Parent.TableUtil)
local CollectionService = game:GetService("CollectionService")
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")

local IS_SERVER = RunService:IsServer()
local DEFAULT_WAIT_FOR_TIMEOUT = 60
local ATTRIBUTE_ID_NAME = "ComponentServerId"


Prompt:
-- WorldSpace -> ScreenSpace. Raw function taking a world position and giving you the
-- screen position.

Response:
function ScreenSpace.WorldToScreen(at)
	local point = workspace.CurrentCamera.CoordinateFrame:pointToObjectSpace(at)
	local aspectRatio = ScreenSpace.AspectRatio()
	local hfactor = math.tan(math.rad(workspace.CurrentCamera.FieldOfView)/2)
	local wfactor = aspectRatio*hfactor
	--
	local x = (point.x/point.z) / -wfactor
	local y = (point.y/point.z) /  hfactor
	--
	return Vector2.new(ScreenSpace.ViewSizeX()*(0.5 + 0.5*x), ScreenSpace.ViewSizeY()*(0.5 + 0.5*y))
end


Prompt: -- Exposed API:

Response:
local Rain = {}

Rain.CollisionMode = CollisionMode

function Rain:Enable(tweenInfo)

	if tweenInfo ~= nil and typeof(tweenInfo) ~= "TweenInfo" then
		error("bad argument #1 to 'Enable' (TweenInfo expected, got " .. typeof(tweenInfo) .. ")", 2)
	end

	disconnectLoop() -- Just in case :Enable(..) is called multiple times on accident

	Emitter.RainStraight.Enabled = true
	Emitter.RainTopDown.Enabled = true
	Emitter.Parent = workspace.CurrentCamera

	for i = 1, RAIN_SPLASH_NUM do
		splashAttachments[i].Parent = workspace.Terrain
		rainAttachments[i].Parent = workspace.Terrain
	end

	if RunService:IsRunning() then -- don't need sound in studio preview, it won't work anyway
		SoundGroup.Parent = game:GetService("SoundService")
	end

	connectLoop()

	if tweenInfo then
		TweenService:Create(GlobalModifier, tweenInfo, {Value = 0}):Play()
	else
		GlobalModifier.Value = 0
	end

	if not Sound.Playing then
		Sound:Play()
		Sound.TimePosition = math.random()*Sound.TimeLength
	end

	disabled = false

end

function Rain:Disable(tweenInfo)

	if tweenInfo ~= nil and typeof(tweenInfo) ~= "TweenInfo" then
		error("bad argument #1 to 'Disable' (TweenInfo expected, got " .. typeof(tweenInfo) .. ")", 2)
	end

	if tweenInfo then
		local tween = TweenService:Create(GlobalModifier, tweenInfo, {Value = 1})
		tween.Completed:connect(function(state)
			if state == Enum.PlaybackState.Completed then
				-- Only disable the rain completely once the visual effects are faded out
				disable()
			end
			tween:Destroy()
		end)
		tween:Play()
		-- Start tweening out sound now as well
		disableSound(tweenInfo)
	else
		GlobalModifier.Value = 1
		disable()
	end

	disabled = true

end

function Rain:SetColor(value, tweenInfo)

	if typeof(value) ~= "Color3" then
		error("bad argument #1 to 'SetColor' (Color3 expected, got " .. typeof(value) .. ")", 2)
	elseif tweenInfo ~= nil and typeof(tweenInfo) ~= "TweenInfo" then
		error("bad argument #2 to 'SetColor' (TweenInfo expected, got " .. typeof(tweenInfo) .. ")", 2)
	end

	if tweenInfo then
		TweenService:Create(Color, tweenInfo, {Value = value}):Play()
	else
		Color.Value = value
	end

end

local function makeRatioSetter(methodName, valueObject)
	-- Shorthand because most of the remaining property setters are very similar
	return function(_, value, tweenInfo)

		if typeof(value) ~= "number" then
			error("bad argument #1 to '" .. methodName .. "' (number expected, got " .. typeof(value) .. ")", 2)
		elseif tweenInfo ~= nil and typeof(tweenInfo) ~= "TweenInfo" then
			error("bad argument #2 to '" .. methodName .. "' (TweenInfo expected, got " .. typeof(tweenInfo) .. ")", 2)
		end

		value = math.clamp(value, 0, 1)

		if tweenInfo then
			TweenService:Create(valueObject, tweenInfo, {Value = value}):Play()
		else
			valueObject.Value = value
		end

	end
end

Rain.SetTransparency = makeRatioSetter("SetTransparency", Transparency)
Rain.SetSpeedRatio = makeRatioSetter("SetSpeedRatio", SpeedRatio)
Rain.SetIntensityRatio = makeRatioSetter("SetIntensityRatio", IntensityRatio)
Rain.SetLightEmission = makeRatioSetter("SetLightEmission", LightEmission)
Rain.SetLightInfluence = makeRatioSetter("SetLightInfluence", LightInfluence)

function Rain:SetVolume(volume, tweenInfo)

	if typeof(volume) ~= "number" then
		error("bad argument #1 to 'SetVolume' (number expected, got " .. typeof(volume) .. ")", 2)
	elseif tweenInfo ~= nil and typeof(tweenInfo) ~= "TweenInfo" then
		error("bad argument #2 to 'SetVolume' (TweenInfo expected, got " .. typeof(tweenInfo) .. ")", 2)
	end

	if tweenInfo then
		TweenService:Create(SoundGroup, tweenInfo, {Volume = volume}):Play()
	else
		SoundGroup.Volume = volume
	end

end

function Rain:SetDirection(direction, tweenInfo)

	if typeof(direction) ~= "Vector3" then
		error("bad argument #1 to 'SetDirection' (Vector3 expected, got " .. typeof(direction) .. ")", 2)
	elseif tweenInfo ~= nil and typeof(tweenInfo) ~= "TweenInfo" then
		error("bad argument #2 to 'SetDirection' (TweenInfo expected, got " .. typeof(tweenInfo) .. ")", 2)
	end

	if not (direction.unit.magnitude > 0) then -- intentional statement formatting since NaN comparison
		warn("Attempt to set rain direction to a zero-length vector, falling back on default direction = (" .. tostring(RAIN_DEFAULT_DIRECTION) .. ")")
		direction = RAIN_DEFAULT_DIRECTION
	end

	if tweenInfo then
		TweenService:Create(RainDirection, tweenInfo, {Value = direction}):Play()
	else
		RainDirection.Value = direction
	end

end

function Rain:SetCeiling(ceiling)

	if ceiling ~= nil and typeof(ceiling) ~= "number" then
		error("bad argument #1 to 'SetCeiling' (number expected, got " .. typeof(ceiling) .. ")", 2)
	end

	currentCeiling = ceiling

end

function Rain:SetStraightTexture(asset)

	if typeof(asset) ~= "string" then
		error("bad argument #1 to 'SetStraightTexture' (string expected, got " .. typeof(asset) .. ")", 2)
	end

	Emitter.RainStraight.Texture = asset

	for _,v in pairs(rainAttachments) do
		v.RainStraight.Texture = asset
	end

end

function Rain:SetTopDownTexture(asset)

	if typeof(asset) ~= "string" then
		error("bad argument #1 to 'SetStraightTexture' (string expected, got " .. typeof(asset) .. ")", 2)
	end

	Emitter.RainTopDown.Texture = asset

	for _,v in pairs(rainAttachments) do
		v.RainTopDown.Texture = asset
	end

end

function Rain:SetSplashTexture(asset)

	if typeof(asset) ~= "string" then
		error("bad argument #1 to 'SetStraightTexture' (string expected, got " .. typeof(asset) .. ")", 2)
	end

	for _,v in pairs(splashAttachments) do
		v.RainSplash.Texture = asset
	end

end

function Rain:SetSoundId(asset)

	if typeof(asset) ~= "string" then
		error("bad argument #1 to 'SetSoundId' (string expected, got " .. typeof(asset) .. ")", 2)
	end

	Sound.SoundId = asset

end

function Rain:SetCollisionMode(mode, param)
		collisionList = nil
		collisionFunc = nil
end

return Rain


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

Response:
local l__LocalPlayer__1 = game.Players.LocalPlayer;
local v2 = require(l__LocalPlayer__1:WaitForChild("PlayerScripts"):WaitForChild("PlayerModule")):GetControls();
local v3 = game["Run Service"];
local l__mouse__4 = l__LocalPlayer__1:GetMouse();
local v5 = {};
local u1 = require(script.Parent);
local l__TweenService__2 = game:GetService("TweenService");
local l__UserInputService__3 = game:GetService("UserInputService");
local l__MinigameBackout__4 = script:FindFirstAncestor("MainUI").MinigameBackout;
local l__Parent__5 = script.Parent.Parent.Parent;
local function u6(p1)
	for v6 = #p1, 1, -1 do
		local v7 = math.random(v6);
		p1[v6] = p1[v7];
		p1[v7] = p1[v6];
	end;
end;
local function u7(p2)
	if u1.stopcam == true then
		return;
	end;
	u1.hum:UnequipTools();
	if p2 == "Padlock" then
		require(script.Padlock)(u1);
	end;
	local u8 = nil;
	u8 = coroutine.create(function()
		if p2 == "ElevatorBreaker" then
			u1.stopcam = true;
			u1.freemouse = true;
			u1.hideplayers = 2;
			local v8 = CFrame.new(0, 0, 0);
			local v9 = tick() + 2;
			local l__WorldCFrame__10 = workspace.ElevatorBreaker.Box:WaitForChild("ElevatorBreakerCameraCFrame",true).WorldCFrame
			u1.camShaker:ShakeOnce(2, 0.5, 0.5, 8);
			local l__CFrame__9 = u1.cam.CFrame;
			local l__FieldOfView__10 = u1.cam.FieldOfView;
			local u11 = false;
			task.spawn(function()
				for v11 = 1, 100000 do
					task.wait();
					local v12 = l__TweenService__2:GetValue((2 - math.abs(tick() - v9)) / 2, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut);
					if not (tick() <= v9) then
						break;
					end;
					u1.cam.CFrame = l__CFrame__9:Lerp(l__WorldCFrame__10, v12) * u1.csgo;
					u1.cam.FieldOfView = l__FieldOfView__10 + (57 - l__FieldOfView__10) * v12;
				end;
				u1.cam.CFrame = l__WorldCFrame__10 * u1.csgo;
				for v13 = 1, 10000000000000 do
					task.wait();
					u1.cam.CFrame = l__WorldCFrame__10 * u1.csgo;
					if u11 == true then
						break;
					end;
				end;
			end);
			wait(1);
			u1.char.PrimaryPart.Anchored = true;
			local l__ElevatorBreaker__14 = workspace:FindFirstChild("ElevatorBreaker", true);
			local l__ActivateEventPrompt__15 = l__ElevatorBreaker__14:FindFirstChild("ActivateEventPrompt");
			l__ActivateEventPrompt__15.Parent = nil;
			local v16 = l__ElevatorBreaker__14:Clone();
			v16.Parent = l__ElevatorBreaker__14.Parent;
			l__ActivateEventPrompt__15.Parent = v16;
			l__ActivateEventPrompt__15.Enabled = false;
			local l__Selector__17 = v16.XBoxUI:FindFirstChild("Selector", true);
			v16.XBoxUI.Enabled = l__UserInputService__3.GamepadEnabled;
			l__ElevatorBreaker__14:Destroy();
			v16:WaitForChild("DoorHinge").TargetAngle = 135;
			local l__Door__18 = v16.Door;
			l__Door__18.CFrame = l__Door__18.CFrame + Vector3.new(0, 0.05, 0);
			local l__SurfaceGui__19 = v16:WaitForChild("SurfaceGui");
			local u12 = {};
			local function v20()
				local v21 = 0;
				for v22, v23 in pairs(v16:GetChildren()) do
					if v23.Name == "BreakerSwitch" then
						local v24 = v23:GetAttribute("ID");
						local v25 = v23:GetAttribute("Enabled");
						for v26, v27 in pairs(u12) do
							if v27[1] == v24 and v27[2] == v25 then
								v21 = v21 + 1;
							end;
						end;
					end;
				end;
				return v21;
			end;
			local u13 = nil;
			local u14 = nil;
			local function u15(p3, p4)
				if p4 == nil then
					p4 = not p3:GetAttribute("Enabled");
				end;
				if p3:GetAttribute("Enabled") ~= p4 then
					p3.Sound:Play();
				end;
				p3:SetAttribute("Enabled", p4);
				if p3:GetAttribute("Enabled") == true then
					p3:FindFirstChild("PrismaticConstraint", true).TargetPosition = -0.2;
					p3.Light.Material = Enum.Material.Neon;
					p3.Light.Attachment.Spark:E(1);
					p3.Sound.Pitch = 1.3;
				else
					p3:FindFirstChild("PrismaticConstraint", true).TargetPosition = 0.2;
					p3.Light.Material = Enum.Material.Glass;
					p3.Sound.Pitch = 1.2;
				end;
				p3.Sound:Play();
			end;
			local u16 = 1;
			local function u17()
				if u11 == false then
					pcall(function()
						u13:Disconnect();
						u14:Disconnect();
					end);
					u11 = true;
					l__MinigameBackout__4.Visible = false;
					v16.XBoxUI.Enabled = false;
					u1.hideplayers = 0;
					v16:WaitForChild("DoorHinge").TargetAngle = 0;
					local l__basecamcf__28 = u1.basecamcf;
					local v29 = tick() + 0.5;
					u1.camShaker:ShakeOnce(2, 0.5, 0.5, 8);
					u1.char.PrimaryPart.Anchored = false;
					local l__CFrame__18 = u1.cam.CFrame;
					local l__FieldOfView__19 = u1.cam.FieldOfView;
					task.spawn(function()
						for v30 = 1, 100000 do
							task.wait();
							local v31 = l__TweenService__2:GetValue((0.5 - math.abs(tick() - v29)) / 0.5, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut);
							if not (tick() <= v29) then
								warn("damn daniel. ar ar ar");
								break;
							end;
							u1.cam.CFrame = l__CFrame__18:Lerp(u1.basecamcf, v31) * u1.csgo;
							u1.cam.FieldOfView = l__FieldOfView__19 + (u1.fovspring - l__FieldOfView__19) * v31;
						end;
						u1.stopcam = false;
						u1.freemouse = false;
						l__ActivateEventPrompt__15.Enabled = true;
					end);
					coroutine.yield(u8);
				end;
			end;
			u13 = l__UserInputService__3.InputBegan:Connect(function(p5)
				if p5.UserInputType == Enum.UserInputType.MouseButton1 or p5.UserInputType == Enum.UserInputType.Touch then
					local v32 = u1.cam:ScreenPointToRay(p5.Position.X, p5.Position.Y);
					local v33, v34 = workspace:FindPartOnRay(Ray.new(v32.Origin, v32.Direction * 1000), u1.char);
					print(v33);
					if v33.Name == "BreakerSwitch" then
						u15(v33);
						u1.camShaker:ShakeOnce(0.5, 2, 0.06, 0.2);
						return;
					end;
				elseif p5.KeyCode == Enum.KeyCode.DPadUp or p5.KeyCode == Enum.KeyCode.DPadDown or p5.KeyCode == Enum.KeyCode.DPadLeft or p5.KeyCode == Enum.KeyCode.DPadRight then
					local v35 = math.floor(u16 / 2);
					if p5.KeyCode == Enum.KeyCode.DPadLeft then
						if u16 % 2 == 0 then
							u16 = math.clamp(u16 - 1, 0, 10);
						else
							print("cant do jack L");
						end;
					end;
					if p5.KeyCode == Enum.KeyCode.DPadRight then
						if u16 % 2 ~= 0 then
							u16 = math.clamp(u16 + 1, 0, 10);
						else
							print("cant do jack L");
						end;
					end;
					if p5.KeyCode == Enum.KeyCode.DPadUp then
						u16 = math.clamp(u16 - 2, 0, 10);
					end;
					if p5.KeyCode == Enum.KeyCode.DPadDown then
						u16 = math.clamp(u16 + 2, 0, 10);
					end;
					v16.XBoxUI.Enabled = true;
					for v36, v37 in pairs(v16.XBoxUI:GetChildren()) do
						if v37:GetAttribute("ID") == u16 then
							l__Selector__17.Parent = v37;
						end;
					end;
					return;
				elseif p5.KeyCode == Enum.KeyCode.ButtonA or p5.KeyCode == Enum.KeyCode.ButtonX then
					for v38, v39 in pairs(v16:GetChildren()) do
						if v39.Name == "BreakerSwitch" and v39:GetAttribute("ID") == u16 then
							u15(v39);
						end;
					end;
					return;
				elseif p5.KeyCode == Enum.KeyCode.ButtonB then
					u17();
				end;
			end);
			local l__MinigameBackout__40 = l__Parent__5.MinigameBackout;
			l__MinigameBackout__40.Visible = true;
			l__TweenService__2:Create(l__MinigameBackout__40, TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut, 3, true), {
				ImageColor3 = Color3.fromRGB(107, 129, 179),
				Size = UDim2.new(0.1, 60, 0.1, 60)
			}):Play();
			u14 = l__MinigameBackout__40.MouseButton1Down:Connect(u17);
			spawn(function()
				for v41, v42 in pairs(v16:GetChildren()) do
					if v42.Name == "BreakerSwitch" and v42:IsA("BasePart") then
						delay(v42:GetAttribute("ID") / 10, function()
							l__TweenService__2:Create(v42, TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut, 1, true), {
								Color = Color3.fromRGB(107, 107, 148)
							}):Play();
						end);
					end;
				end;
			end);
			wait(3);
			for v43 = 1, 3 do
				for v44 = 1, 10 do
					u12[v44] = { v44, math.random(1, 5) >= 3 };
				end;
				for v45 = 1, 100 do
					u6(u12);
					l__SurfaceGui__19.Frame.Code.Frame.Visible = true;
					for v46, v47 in pairs(u12) do
						l__SurfaceGui__19.Frame.Code.Text = string.format("%.2i", v47[1]);
						if v47[2] == true then
							l__SurfaceGui__19.Frame.Code.Frame.BackgroundTransparency = 0;
							v16.Box.Beep.Pitch = 1.5;
						else
							l__SurfaceGui__19.Frame.Code.Frame.BackgroundTransparency = 1;
							v16.Box.Beep.Pitch = 1;
						end;
						v16.Box.Beep:Play();
						task.wait(0.66);
						if u11 == true then
							break;
						end;
					end;
					if u11 == true then
						break;
					end;
					wait(1.33);
					if v45 >= 5 then
						spawn(function()
							for v48, v49 in pairs(v16:GetChildren()) do
								if v49.Name == "BreakerSwitch" then
									local v50 = v49:GetAttribute("ID");
									v49.Hint.TextLabel.TextTransparency = 1;
									v49.Hint.TextLabel.Text = v50;
									v49.Hint.Enabled = true;
									l__TweenService__2:Create(v49.Hint.TextLabel, TweenInfo.new(3, Enum.EasingStyle.Exponential, Enum.EasingDirection.InOut, 0, v50 / 20), {
										TextTransparency = 0
									}):Play();
								end;
							end;
						end);
					end;
					local v51 = v20();
					l__SurfaceGui__19.Frame.Code.Text = "...";
					l__SurfaceGui__19.Frame.Code.Frame.Visible = false;
					l__SurfaceGui__19.Frame.Bar.Filled:TweenSize(UDim2.new(v51 / 10, 0, 1, 0), "InOut", "Linear", 3, true);
					v16.Box.Progress:Play();
					l__TweenService__2:Create(v16.Box.Progress, TweenInfo.new(3, Enum.EasingStyle.Linear, Enum.EasingDirection.Out), {
						PlaybackSpeed = 1.01 + v51 / 10
					}):Play();
					wait(3);
					if u11 == true then
						break;
					end;
					v16.Box.Progress:Stop();
					if v51 == 10 then
						if v43 == 3 then
							l__MinigameBackout__40.Visible = false;
						end;
						pcall(function()
							v16.Box.Correct:Play();
							u1.camShaker:ShakeOnce(1, 1, 0.06, 0.5);
							local v52 = l__SurfaceGui__19.Frame.Squares[tostring(v43)];
							v52.BackgroundTransparency = 0;
							v52.Size = UDim2.new(0, 9, 0, 9);
							v52:TweenSize(UDim2.new(0, 5, 0, 5), "In", "Quart", 0.5, true);
							l__SurfaceGui__19.Frame.Squares.Text = v43 .. "/3";
							wait(1);
							v16.Box.Progress.PlaybackSpeed = 1.01;
							l__SurfaceGui__19.Frame.Bar.Filled:TweenSize(UDim2.new(0, 0, 1, 0), "InOut", "Quad", 0.5, true);
							if v43 == 3 then
								for v53, v54 in pairs(v16:GetChildren()) do
									if v54.Name == "BreakerSwitch" then
										delay(v54:GetAttribute("ID") / 20, function()
											u15(v54, true);
										end);
									end;
								end;
								return;
							end;
							for v55, v56 in pairs(v16:GetChildren()) do
								if v56.Name == "BreakerSwitch" then
									delay(v56:GetAttribute("ID") / 20, function()
										if v56:GetAttribute("Enabled") ~= false then
											u15(v56, false);
										end;
									end);
								end;
							end;
							wait(3);
						end);
						break;
					end;
				end;
				if u11 == true then
					break;
				end;
			end;
			if u11 == true then
				return;
			end;
			print("SENT SIGNAL");
			u1.remotes:WaitForChild("EBF"):FireServer();
			l__SurfaceGui__19.Frame.Code.Visible = false;
			l__SurfaceGui__19.Frame.Squares.Visible = false;
			l__SurfaceGui__19.Frame.Line.Visible = false;
			l__SurfaceGui__19.Frame.Bar.Visible = false;
			l__SurfaceGui__19.Frame.TextLabel.Visible = true;
			wait(1);
			u17();
		end;
	end);
	coroutine.resume(u8);
end;
u1.remotes:WaitForChild("EngageMinigame").OnClientEvent:Connect(function(...)
	u7(...);
end);


Response:
m1:Stop() --Initial setup
m2:Stop()


Prompt: --[[Finalize Chassis]]

Response:
	--Misc Weld
	wait()
	for i,v in pairs(script:GetChildren()) do
		if v:IsA("ModuleScript") then
			require(v)
		end
	end

	--Weld Body
	wait()
	ModelWeld(car.Body,car.Body.CarName.Value.VehicleSeat)

	--Unanchor
	wait()
	UnAnchor(car)


Prompt: --- Returns an array of the names of all registered commands (not including aliases)

Response:
function Registry:GetCommandNames ()
	local commands = {}

	for _, command in pairs(self.CommandsArray) do
		table.insert(commands, command.Name)
	end

	return commands
end

Registry.GetCommandsAsStrings = Registry.GetCommandNames


Prompt:
--[[
	Processes and returns an existing instance, with options for setting
	properties, event handlers and other attributes on the instance.
]]

Response:
local applyInstanceProps = require(script.Parent.Parent.ObjectUtility).applyInstanceProps

local function Hydrate(target: Instance)
	return function(props): Instance
		applyInstanceProps(props, target)
		return target
	end
end

return Hydrate


Prompt: --Dont touch

Response:
ZR15RightLegPointZero = 0
XR15RightLegPointZero = 0
YR15RightLegPointZero = 0
R15RightKneePointZero = 0

ZR15RightArmPointZero = 0
YR15RightArmPointZero = 0
XR15RightArmPointZero = 0
R15RightElbowPointZero = 0

ZR15LeftLegPointZero = 0
XR15LeftLegPointZero = 0
YR15LeftLegPointZero = 0
R15LeftKneePointZero = 0

ZR15LeftArmPointZero = 0
YR15LeftArmPointZero = 0
XR15LeftArmPointZero = 0
R15LeftElbowPointZero = 0

ZR15LowerTorsoPointZero = 0
XR15LowerTorsoPointZero = 0
YR15LowerTorsoPointZero = 0
ZR15UpperTorsoPointZero = 0

bike.DriveSeat.ChildRemoved:connect(function(child)
	handler:FireServer("RemovePlayer",C,child)
end)

handler:FireServer("CreatePlayer",C)

while wait(clock) do
	--value*(1-multiplier)+endpoint*multiplier

	Lean = math.rad(-bike.Body.bal.Orientation.Z)

	if C.Humanoid.RigType == Enum.HumanoidRigType.R6 then

	if math.abs(Lean) < R6HeadZ then
		bike.Misc.Anims.R6.Head.Z.M.CurrentAngle = math.abs(Lean)
	else
		bike.Misc.Anims.R6.Head.Z.M.CurrentAngle = R6HeadZ
	end

	if Lean < R6HeadX and Lean > -R6HeadX then
		bike.Misc.Anims.R6.Head.X.M.CurrentAngle = Lean
	elseif Lean > R6HeadX then
		bike.Misc.Anims.R6.Head.X.M.CurrentAngle = R6HeadX
	elseif Lean < -R6HeadX then
		bike.Misc.Anims.R6.Head.X.M.CurrentAngle = -R6HeadX
	end

	if script.Parent.Values.SteerT.Value > 0.01 then
		bike.Misc.Anims.R6.Head.Y.M.CurrentAngle = bike.Misc.Anims.R6.Head.Y.M.CurrentAngle*(1-.1)+math.min((math.abs(script.Parent.Values.SteerT.Value)*(bike.DriveSeat.Velocity.magnitude/20))+(math.abs(script.Parent.Values.SteerT.Value)*R6HeadYStart), R6HeadYFinish)*.1
	elseif script.Parent.Values.SteerT.Value < -0.01 then
		bike.Misc.Anims.R6.Head.Y.M.CurrentAngle = bike.Misc.Anims.R6.Head.Y.M.CurrentAngle*(1-.1)+math.max(-(math.abs(script.Parent.Values.SteerT.Value)*(bike.DriveSeat.Velocity.magnitude/20))+(math.abs(script.Parent.Values.SteerT.Value)*-R6HeadYStart), -R6HeadYFinish)*.1
	else
		bike.Misc.Anims.R6.Head.Y.M.CurrentAngle = bike.Misc.Anims.R6.Head.Y.M.CurrentAngle*(1-.1)+0*.1
	end

	if bike.DriveSeat.Velocity.magnitude > 5 then
		if Lean < 0 then
			bike.Misc.Anims.R6.RightLeg.I.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.I.M.CurrentAngle*(1-.1)+0*.1
			bike.Misc.Anims.R6.RightLeg.Z.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.Z.M.CurrentAngle*(1-.1)+((math.min(math.abs(Lean/R6RightLegLeftLeanD),R6RightLegLeftLean)*R6RightLegLeftLeanM))*.1
			bike.Misc.Anims.R6.LeftLeg.Z.M.CurrentAngle = bike.Misc.Anims.R6.LeftLeg.Z.M.CurrentAngle*(1-.1)+0*.1
			bike.Misc.Anims.R6.RightArm.Y.M.CurrentAngle = bike.Misc.Anims.R6.RightArm.Y.M.CurrentAngle*(1-.1)+((math.min(math.abs(Lean/R6RightArmLeftLeanD),R6RightArmLeftLean)*R6RightArmLeftLeanM))*.1
			bike.Misc.Anims.R6.LeftArm.Y.M.CurrentAngle =  bike.Misc.Anims.R6.LeftArm.Y.M.CurrentAngle*(1-.1)+(-(math.min(math.abs(Lean/R6LeftArmLeftLeanD),R6LeftArmLeftLean)*R6LeftArmLeftLeanM))*.1
			bike.Misc.Anims.R6.RightLeg.X.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.X.M.CurrentAngle*(1-.1)+(-(math.min(math.abs(Lean/R6RightLegLeftLeanD),R6RightLegLeftLean)*R6RightLegLeftLeanM))*.1
			bike.Misc.Anims.R6.LeftLeg.X.M.CurrentAngle = bike.Misc.Anims.R6.LeftLeg.X.M.CurrentAngle*(1-.1)+(-(math.min(math.abs(Lean/R6LeftLegLeftLeanD),R6LeftLegLeftLean)*R6LeftLegLeftLeanM))*.1
			bike.Misc.Anims.R6.Torso.X.M.CurrentAngle = bike.Misc.Anims.R6.Torso.X.M.CurrentAngle*(1-.1)+((math.min(math.abs(Lean/R6TorsoLeftLeanD),R6TorsoLeftLean)*R6TorsoLeftLeanM))*.1
		else
			bike.Misc.Anims.R6.RightLeg.I.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.I.M.CurrentAngle*(1-.1)+0*.1
			bike.Misc.Anims.R6.RightLeg.Z.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.Z.M.CurrentAngle*(1-.1)+0*.1
			bike.Misc.Anims.R6.LeftLeg.Z.M.CurrentAngle = bike.Misc.Anims.R6.LeftLeg.Z.M.CurrentAngle*(1-.1)+((math.min(math.abs(Lean/R6LeftLegRightLeanD),R6LeftLegRightLean)*R6LeftLegRightLeanM))*.1
			bike.Misc.Anims.R6.RightArm.Y.M.CurrentAngle = bike.Misc.Anims.R6.RightArm.Y.M.CurrentAngle*(1-.1)+(-(math.min(math.abs(Lean/R6RightArmRightLeanD),R6RightArmRightLean)*R6RightArmRightLeanM))*.1
			bike.Misc.Anims.R6.LeftArm.Y.M.CurrentAngle =  bike.Misc.Anims.R6.LeftArm.Y.M.CurrentAngle*(1-.1)+((math.min(math.abs(Lean/R6LeftArmRightLeanD),R6LeftArmRightLean)*R6LeftArmRightLeanM))*.1
			bike.Misc.Anims.R6.RightLeg.X.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.X.M.CurrentAngle*(1-.1)+((math.min(math.abs(Lean/R6RightLegRightLeanD),R6RightLegRightLean)*R6RightLegRightLeanM))*.1
			bike.Misc.Anims.R6.LeftLeg.X.M.CurrentAngle = bike.Misc.Anims.R6.LeftLeg.X.M.CurrentAngle*(1-.1)+((math.min(math.abs(Lean/R6LeftLegRightLeanD),R6LeftLegRightLean)*R6LeftLegRightLeanM))*.1
			bike.Misc.Anims.R6.Torso.X.M.CurrentAngle = bike.Misc.Anims.R6.Torso.X.M.CurrentAngle*(1-.1)+(-(math.min(math.abs(Lean/R6TorsoRightLeanD),R6TorsoRightLean)*R6TorsoRightLeanM))*.1
		end
	else
		bike.Misc.Anims.R6.Torso.X.M.CurrentAngle = bike.Misc.Anims.R6.Torso.X.M.CurrentAngle*(1-.1)+(-.3)*.1

		bike.Misc.Anims.R6.RightArm.Y.M.CurrentAngle = bike.Misc.Anims.R6.RightArm.Y.M.CurrentAngle*(1-.1)+(-.3)*.1
		bike.Misc.Anims.R6.RightArm.Z.M.CurrentAngle = bike.Misc.Anims.R6.RightArm.Z.M.CurrentAngle*(1-.1)+.5*.1

		bike.Misc.Anims.R6.LeftArm.Y.M.CurrentAngle = bike.Misc.Anims.R6.LeftArm.Y.M.CurrentAngle*(1-.1)+.4*.1

		bike.Misc.Anims.R6.LeftLeg.X.M.CurrentAngle = bike.Misc.Anims.R6.LeftLeg.X.M.CurrentAngle*(1-.1)+.2*.1
		bike.Misc.Anims.R6.LeftLeg.Z.M.CurrentAngle = bike.Misc.Anims.R6.LeftLeg.Z.M.CurrentAngle*(1-.1)+.3*.1

		bike.Misc.Anims.R6.RightLeg.I.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.I.M.CurrentAngle*(1-.1)+1*.1
		bike.Misc.Anims.R6.RightLeg.X.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.X.M.CurrentAngle*(1-.1)+.8*.1
		bike.Misc.Anims.R6.RightLeg.Z.M.CurrentAngle = bike.Misc.Anims.R6.RightLeg.Z.M.CurrentAngle*(1-.1)+.5*.1
	end

	if bike.DriveSeat.Velocity.magnitude > TuckInSpeed then
		bike.Misc.Anims.R6.Torso.Z.M.CurrentAngle = bike.Misc.Anims.R6.Torso.Z.M.CurrentAngle*(1-.1)+((R6TorsoTuckIn-math.min(math.abs(Lean),R6TorsoTuckIn))*script.Parent.Values.Throttle.Value)*.1
		bike.Misc.Anims.R6.RightArm.Z.M.CurrentAngle = bike.Misc.Anims.R6.RightArm.Z.M.CurrentAngle*(1-.1)+((R6RightArmTuckIn-math.min(math.abs(Lean),R6RightArmTuckIn))*script.Parent.Values.Throttle.Value)*.1
		bike.Misc.Anims.R6.LeftArm.Z.M.CurrentAngle = bike.Misc.Anims.R6.LeftArm.Z.M.CurrentAngle*(1-.1)+((R6LeftArmTuckIn-math.min(math.abs(Lean),R6LeftArmTuckIn))*script.Parent.Values.Throttle.Value)*.1
	else
		bike.Misc.Anims.R6.Torso.Z.M.CurrentAngle = bike.Misc.Anims.R6.Torso.Z.M.CurrentAngle*(1-.15)+0*.15
		bike.Misc.Anims.R6.RightArm.Z.M.CurrentAngle = bike.Misc.Anims.R6.RightArm.Z.M.CurrentAngle*(1-.15)+0*.15
		bike.Misc.Anims.R6.LeftArm.Z.M.CurrentAngle = bike.Misc.Anims.R6.LeftArm.Z.M.CurrentAngle*(1-.15)+0*.15
	end

	else --r15

	if math.abs(Lean) < R15HeadZ then
		bike.Misc.Anims.R15.Torso.Head.Z.M.CurrentAngle = math.abs(Lean)
	else
		bike.Misc.Anims.R15.Torso.Head.Z.M.CurrentAngle = R15HeadZ
	end

	if Lean < R15HeadX and Lean > -R15HeadX then
		bike.Misc.Anims.R15.Torso.Head.X.M.CurrentAngle = Lean
	elseif Lean > R15HeadX then
		bike.Misc.Anims.R15.Torso.Head.X.M.CurrentAngle = R15HeadX
	elseif Lean < -R15HeadX then
		bike.Misc.Anims.R15.Torso.Head.X.M.CurrentAngle = -R15HeadX
	end

	if script.Parent.Values.SteerT.Value > 0.01 then
		bike.Misc.Anims.R15.Torso.Head.Y.M.CurrentAngle = bike.Misc.Anims.R15.Torso.Head.Y.M.CurrentAngle*(1-.1)+math.min((math.abs(script.Parent.Values.SteerT.Value)*(bike.DriveSeat.Velocity.magnitude/20))+(math.abs(script.Parent.Values.SteerT.Value)*R15HeadYStart), R15HeadYFinish)*.1
	elseif script.Parent.Values.SteerT.Value < -0.01 then
		bike.Misc.Anims.R15.Torso.Head.Y.M.CurrentAngle = bike.Misc.Anims.R15.Torso.Head.Y.M.CurrentAngle*(1-.1)+math.max(-(math.abs(script.Parent.Values.SteerT.Value)*(bike.DriveSeat.Velocity.magnitude/20))+(math.abs(script.Parent.Values.SteerT.Value)*-R15HeadYStart), -R15HeadYFinish)*.1
	else
		bike.Misc.Anims.R15.Torso.Head.Y.M.CurrentAngle = bike.Misc.Anims.R15.Torso.Head.Y.M.CurrentAngle*(1-.1)+0*.1
	end

	if bike.DriveSeat.Velocity.magnitude < TuckInSpeed and bike.DriveSeat.Velocity.magnitude > 5 then
		--upright
		bike.Misc.Anims.R15.RightLeg.Foot.I.M.CurrentAngle = bike.Misc.Anims.R15.RightLeg.Foot.I.M.CurrentAngle*(1-.1)+0*.1

		ZR15RightLegPointZero = ZR15RightLegPointZero*(1-.1)+0*.1
		XR15RightLegPointZero = XR15RightLegPointZero*(1-.1)+0*.1
		YR15RightLegPointZero = YR15RightLegPointZero*(1-.1)+0*.1
		R15RightKneePointZero = R15RightKneePointZero*(1-.1)+0*.1

		ZR15RightArmPointZero = ZR15RightArmPointZero*(1-.1)+0*.1
		YR15RightArmPointZero = YR15RightArmPointZero*(1-.1)+0*.1
		XR15RightArmPointZero = XR15RightArmPointZero*(1-.1)+0*.1
		R15RightElbowPointZero = R15RightElbowPointZero*(1-.1)+0*.1

		ZR15LeftLegPointZero = ZR15LeftLegPointZero*(1-.1)+0*.1
		XR15LeftLegPointZero = XR15LeftLegPointZero*(1-.1)+0*.1
		YR15LeftLegPointZero = YR15LeftLegPointZero*(1-.1)+0*.1
		R15LeftKneePointZero = R15LeftKneePointZero*(1-.1)+0*.1

		ZR15LeftArmPointZero = ZR15LeftArmPointZero*(1-.1)+0*.1
		YR15LeftArmPointZero = YR15LeftArmPointZero*(1-.1)+0*.1
		XR15LeftArmPointZero = XR15LeftArmPointZero*(1-.1)+0*.1
		R15LeftElbowPointZero = R15LeftElbowPointZero*(1-.1)+0*.1

		ZR15LowerTorsoPointZero = ZR15LowerTorsoPointZero*(1-.1)+0*.1
		XR15LowerTorsoPointZero = XR15LowerTorsoPointZero*(1-.1)+0*.1
		YR15LowerTorsoPointZero = YR15LowerTorsoPointZero*(1-.1)+0*.1
		ZR15UpperTorsoPointZero = ZR15UpperTorsoPointZero*(1-.1)+0*.1
	elseif bike.DriveSeat.Velocity.magnitude >= TuckInSpeed and bike.DriveSeat.Velocity.magnitude>5 then
		--tuck in
		bike.Misc.Anims.R15.RightLeg.Foot.I.M.CurrentAngle = bike.Misc.Anims.R15.RightLeg.Foot.I.M.CurrentAngle*(1-.1)+0*.1

		ZR15RightLegPointZero = ZR15RightLegPointZero*(1-.1)+(ZR15RightLegTuckIn*script.Parent.Values.Throttle.Value)*.1
		XR15RightLegPointZero = XR15RightLegPointZero*(1-.1)+(XR15RightLegTuckIn*script.Parent.Values.Throttle.Value)*.1
		YR15RightLegPointZero = YR15RightLegPointZero*(1-.1)+(YR15RightLegTuckIn*script.Parent.Values.Throttle.Value)*.1
		R15RightKneePointZero = R15RightKneePointZero*(1-.1)+(R15RightKneeTuckIn*script.Parent.Values.Throttle.Value)*.1

		ZR15RightArmPointZero = ZR15RightArmPointZero*(1-.1)+(ZR15RightArmTuckIn*script.Parent.Values.Throttle.Value)*.1
		YR15RightArmPointZero = YR15RightArmPointZero*(1-.1)+(YR15RightArmTuckIn*script.Parent.Values.Throttle.Value)*.1
		XR15RightArmPointZero = XR15RightArmPointZero*(1-.1)+(XR15RightArmTuckIn*script.Parent.Values.Throttle.Value)*.1
		R15RightElbowPointZero = R15RightElbowPointZero*(1-.1)+(R15RightElbowTuckIn*script.Parent.Values.Throttle.Value)*.1

		ZR15LeftLegPointZero = ZR15LeftLegPointZero*(1-.1)+(ZR15LeftLegTuckIn*script.Parent.Values.Throttle.Value)*.1
		XR15LeftLegPointZero = XR15LeftLegPointZero*(1-.1)+(XR15LeftLegTuckIn*script.Parent.Values.Throttle.Value)*.1
		YR15LeftLegPointZero = YR15LeftLegPointZero*(1-.1)+(YR15LeftLegTuckIn*script.Parent.Values.Throttle.Value)*.1
		R15LeftKneePointZero = R15LeftKneePointZero*(1-.1)+(R15LeftKneeTuckIn*script.Parent.Values.Throttle.Value)*.1

		ZR15LeftArmPointZero = ZR15LeftArmPointZero*(1-.1)+(ZR15LeftArmTuckIn*script.Parent.Values.Throttle.Value)*.1
		YR15LeftArmPointZero = YR15LeftArmPointZero*(1-.1)+(YR15LeftArmTuckIn*script.Parent.Values.Throttle.Value)*.1
		XR15LeftArmPointZero = XR15LeftArmPointZero*(1-.1)+(XR15LeftArmTuckIn*script.Parent.Values.Throttle.Value)*.1
		R15LeftElbowPointZero = R15LeftElbowPointZero*(1-.1)+(R15LeftElbowTuckIn*script.Parent.Values.Throttle.Value)*.1

		ZR15LowerTorsoPointZero = ZR15LowerTorsoPointZero*(1-.1)+(ZR15LowerTorsoTuckIn*script.Parent.Values.Throttle.Value)*.1
		XR15LowerTorsoPointZero = XR15LowerTorsoPointZero*(1-.1)+(XR15LowerTorsoTuckIn*script.Parent.Values.Throttle.Value)*.1
		YR15LowerTorsoPointZero = YR15LowerTorsoPointZero*(1-.1)+(YR15LowerTorsoTuckIn*script.Parent.Values.Throttle.Value)*.1
		ZR15UpperTorsoPointZero = ZR15UpperTorsoPointZero*(1-.1)+(ZR15UpperTorsoTuckIn*script.Parent.Values.Throttle.Value)*.1
	else
		--idle
		bike.Misc.Anims.R15.RightLeg.Foot.I.M.CurrentAngle = bike.Misc.Anims.R15.RightLeg.Foot.I.M.CurrentAngle*(1-.18)+1*.18

		ZR15RightLegPointZero = ZR15RightLegPointZero*(1-.1)+0.6*.1
		XR15RightLegPointZero = XR15RightLegPointZero*(1-.18)+-.8*.18
		YR15RightLegPointZero = YR15RightLegPointZero*(1-.1)+0.4*.1
		R15RightKneePointZero = R15RightKneePointZero*(1-.18)+-1.8*.18

		ZR15RightArmPointZero = ZR15RightArmPointZero*(1-.1)+0.25*.1
		YR15RightArmPointZero = YR15RightArmPointZero*(1-.1)+0.3*.1
		XR15RightArmPointZero = XR15RightArmPointZero*(1-.1)+-0.12*.1
		R15RightElbowPointZero = R15RightElbowPointZero*(1-.1)+0.25*.1

		ZR15LeftLegPointZero = ZR15LeftLegPointZero*(1-.1)+-.05*.1
		XR15LeftLegPointZero = XR15LeftLegPointZero*(1-.1)+0.15*.1
		YR15LeftLegPointZero = YR15LeftLegPointZero*(1-.1)+0.5*.1
		R15LeftKneePointZero = R15LeftKneePointZero*(1-.1)+.5*.1

		ZR15LeftArmPointZero = ZR15LeftArmPointZero*(1-.1)+0*.1
		YR15LeftArmPointZero = YR15LeftArmPointZero*(1-.1)+0.4*.1
		XR15LeftArmPointZero = XR15LeftArmPointZero*(1-.1)+0.05*.1
		R15LeftElbowPointZero = R15LeftElbowPointZero*(1-.1)+0.1*.1

		ZR15LowerTorsoPointZero = ZR15LowerTorsoPointZero*(1-.1)+0*.1
		XR15LowerTorsoPointZero = XR15LowerTorsoPointZero*(1-.1)+-.25*.1
		YR15LowerTorsoPointZero = YR15LowerTorsoPointZero*(1-.1)+0.15*.1
		ZR15UpperTorsoPointZero = ZR15UpperTorsoPointZero*(1-.1)+0*.1
	end

	if Lean > 0 then
		--right lean
		bike.Misc.Anims.R15.RightLeg.Foot.Z.M.CurrentAngle = ((ZR15RightLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15RightLegRightLean*math.abs(Lean))/ZR15RightLegRightLeanD)*ZR15RightLegRightLeanM
		bike.Misc.Anims.R15.RightLeg.Foot.X.M.CurrentAngle = ((XR15RightLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15RightLegRightLean*math.abs(Lean))/XR15RightLegRightLeanD)*XR15RightLegRightLeanM
		bike.Misc.Anims.R15.RightLeg.Foot.Y.M.CurrentAngle = ((YR15RightLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15RightLegRightLean*math.abs(Lean))/YR15RightLegRightLeanD)*YR15RightLegRightLeanM
		bike.Misc.Anims.R15.RightLeg.UpperLeg.X.M.CurrentAngle = ((R15RightKneePointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15RightKneeRightLean*math.abs(Lean))/R15RightKneeRightLeanD)*R15RightKneeRightLeanM

		bike.Misc.Anims.R15.RightArm.Hand.Z.M.CurrentAngle = ((ZR15RightArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15RightArmRightLean*math.abs(Lean))/ZR15RightArmRightLeanD)*ZR15RightArmRightLeanM
		bike.Misc.Anims.R15.RightArm.Hand.X.M.CurrentAngle = ((XR15RightArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15RightArmRightLean*math.abs(Lean))/XR15RightArmRightLeanD)*XR15RightArmRightLeanM
		bike.Misc.Anims.R15.RightArm.Hand.Y.M.CurrentAngle = ((YR15RightArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15RightArmRightLean*math.abs(Lean))/YR15RightArmRightLeanD)*YR15RightArmRightLeanM
		bike.Misc.Anims.R15.RightArm.UpperArm.X.M.CurrentAngle = ((R15RightElbowPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15RightElbowRightLean*math.abs(Lean))/R15RightElbowRightLeanD)*R15RightElbowRightLeanM

		bike.Misc.Anims.R15.LeftLeg.Foot.Z.M.CurrentAngle = ((ZR15LeftLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15LeftLegRightLean*math.abs(Lean))/ZR15LeftLegRightLeanD)*ZR15LeftLegRightLeanM
		bike.Misc.Anims.R15.LeftLeg.Foot.X.M.CurrentAngle = ((XR15LeftLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15LeftLegRightLean*math.abs(Lean))/XR15LeftLegRightLeanD)*XR15LeftLegRightLeanM
		bike.Misc.Anims.R15.LeftLeg.Foot.Y.M.CurrentAngle = ((YR15LeftLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15LeftLegRightLean*math.abs(Lean))/YR15LeftLegRightLeanD)*YR15LeftLegRightLeanM
		bike.Misc.Anims.R15.LeftLeg.UpperLeg.X.M.CurrentAngle = ((R15LeftKneePointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15LeftKneeRightLean*math.abs(Lean))/R15LeftKneeRightLeanD)*R15LeftKneeRightLeanM

		bike.Misc.Anims.R15.LeftArm.Hand.Z.M.CurrentAngle = ((ZR15LeftArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15LeftArmRightLean*math.abs(Lean))/ZR15LeftArmRightLeanD)*ZR15LeftArmRightLeanM
		bike.Misc.Anims.R15.LeftArm.Hand.X.M.CurrentAngle = ((XR15LeftArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15LeftArmRightLean*math.abs(Lean))/XR15LeftArmRightLeanD)*XR15LeftArmRightLeanM
		bike.Misc.Anims.R15.LeftArm.Hand.Y.M.CurrentAngle = ((YR15LeftArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15LeftArmRightLean*math.abs(Lean))/YR15LeftArmRightLeanD)*YR15LeftArmRightLeanM
		bike.Misc.Anims.R15.LeftArm.UpperArm.X.M.CurrentAngle = ((R15LeftElbowPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15LeftElbowRightLean*math.abs(Lean))/R15LeftElbowRightLeanD)*R15LeftElbowRightLeanM

		bike.Misc.Anims.R15.Torso.LowerTorso.Z.M.CurrentAngle = ((ZR15LowerTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15LowerTorsoRightLean*math.abs(Lean))/ZR15LowerTorsoRightLeanD)*ZR15LowerTorsoRightLeanM
		bike.Misc.Anims.R15.Torso.LowerTorso.X.M.CurrentAngle = ((XR15LowerTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15LowerTorsoRightLean*math.abs(Lean))/XR15LowerTorsoRightLeanD)*XR15LowerTorsoRightLeanM
		bike.Misc.Anims.R15.Torso.LowerTorso.Y.M.CurrentAngle = ((YR15LowerTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15LowerTorsoRightLean*math.abs(Lean))/YR15LowerTorsoRightLeanD)*YR15LowerTorsoRightLeanM
		bike.Misc.Anims.R15.Torso.UpperTorso.Z.M.CurrentAngle = ((ZR15UpperTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15UpperTorsoRightLean*math.abs(Lean))/ZR15UpperTorsoRightLeanD)*ZR15UpperTorsoRightLeanM
	else
		--left lean
		bike.Misc.Anims.R15.RightLeg.Foot.Z.M.CurrentAngle = ((ZR15RightLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15RightLegLeftLean*math.abs(Lean))/ZR15RightLegLeftLeanD)*ZR15RightLegLeftLeanM
		bike.Misc.Anims.R15.RightLeg.Foot.X.M.CurrentAngle = ((XR15RightLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15RightLegLeftLean*math.abs(Lean))/XR15RightLegLeftLeanD)*XR15RightLegLeftLeanM
		bike.Misc.Anims.R15.RightLeg.Foot.Y.M.CurrentAngle = ((YR15RightLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15RightLegLeftLean*math.abs(Lean))/YR15RightLegLeftLeanD)*YR15RightLegLeftLeanM
		bike.Misc.Anims.R15.RightLeg.UpperLeg.X.M.CurrentAngle = ((R15RightKneePointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15RightKneeLeftLean*math.abs(Lean))/R15RightKneeLeftLeanD)*R15RightKneeLeftLeanM

		bike.Misc.Anims.R15.RightArm.Hand.Z.M.CurrentAngle = ((ZR15RightArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15RightArmLeftLean*math.abs(Lean))/ZR15RightArmLeftLeanD)*ZR15RightArmLeftLeanM
		bike.Misc.Anims.R15.RightArm.Hand.X.M.CurrentAngle = ((XR15RightArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15RightArmLeftLean*math.abs(Lean))/XR15RightArmLeftLeanD)*XR15RightArmLeftLeanM
		bike.Misc.Anims.R15.RightArm.Hand.Y.M.CurrentAngle = ((YR15RightArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15RightArmLeftLean*math.abs(Lean))/YR15RightArmLeftLeanD)*YR15RightArmLeftLeanM
		bike.Misc.Anims.R15.RightArm.UpperArm.X.M.CurrentAngle = ((R15RightElbowPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15RightElbowLeftLean*math.abs(Lean))/R15RightElbowLeftLeanD)*R15RightElbowLeftLeanM

		bike.Misc.Anims.R15.LeftLeg.Foot.Z.M.CurrentAngle = ((ZR15LeftLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15LeftLegLeftLean*math.abs(Lean))/ZR15LeftLegLeftLeanD)*ZR15LeftLegLeftLeanM
		bike.Misc.Anims.R15.LeftLeg.Foot.X.M.CurrentAngle = ((XR15LeftLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15LeftLegLeftLean*math.abs(Lean))/XR15LeftLegLeftLeanD)*XR15LeftLegLeftLeanM
		bike.Misc.Anims.R15.LeftLeg.Foot.Y.M.CurrentAngle = ((YR15LeftLegPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15LeftLegLeftLean*math.abs(Lean))/YR15LeftLegLeftLeanD)*YR15LeftLegLeftLeanM
		bike.Misc.Anims.R15.LeftLeg.UpperLeg.X.M.CurrentAngle = ((R15LeftKneePointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15LeftKneeLeftLean*math.abs(Lean))/R15LeftKneeLeftLeanD)*R15LeftKneeLeftLeanM

		bike.Misc.Anims.R15.LeftArm.Hand.Z.M.CurrentAngle = ((ZR15LeftArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15LeftArmLeftLean*math.abs(Lean))/ZR15LeftArmLeftLeanD)*ZR15LeftArmLeftLeanM
		bike.Misc.Anims.R15.LeftArm.Hand.X.M.CurrentAngle = ((XR15LeftArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15LeftArmLeftLean*math.abs(Lean))/XR15LeftArmLeftLeanD)*XR15LeftArmLeftLeanM
		bike.Misc.Anims.R15.LeftArm.Hand.Y.M.CurrentAngle = ((YR15LeftArmPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15LeftArmLeftLean*math.abs(Lean))/YR15LeftArmLeftLeanD)*YR15LeftArmLeftLeanM
		bike.Misc.Anims.R15.LeftArm.UpperArm.X.M.CurrentAngle = ((R15LeftElbowPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(R15LeftElbowLeftLean*math.abs(Lean))/R15LeftElbowLeftLeanD)*R15LeftElbowLeftLeanM

		bike.Misc.Anims.R15.Torso.LowerTorso.Z.M.CurrentAngle = ((ZR15LowerTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15LowerTorsoLeftLean*math.abs(Lean))/ZR15LowerTorsoLeftLeanD)*ZR15LowerTorsoLeftLeanM
		bike.Misc.Anims.R15.Torso.LowerTorso.X.M.CurrentAngle = ((XR15LowerTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(XR15LowerTorsoLeftLean*math.abs(Lean))/XR15LowerTorsoLeftLeanD)*XR15LowerTorsoLeftLeanM
		bike.Misc.Anims.R15.Torso.LowerTorso.Y.M.CurrentAngle = ((YR15LowerTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(YR15LowerTorsoLeftLean*math.abs(Lean))/YR15LowerTorsoLeftLeanD)*YR15LowerTorsoLeftLeanM
		bike.Misc.Anims.R15.Torso.UpperTorso.Z.M.CurrentAngle = ((ZR15UpperTorsoPointZero*math.max(-((math.abs(Lean)*2)-1),0))+(ZR15UpperTorsoLeftLean*math.abs(Lean))/ZR15UpperTorsoLeftLeanD)*ZR15UpperTorsoLeftLeanM
	end

	end
end


Prompt: -- Destroys this cache entirely. Use this when you don't need this cache object anymore.

Response:
function PartCacheStatic:Dispose()
	assert(getmetatable(self) == PartCacheStatic, ERR_NOT_INSTANCE:format("Dispose", "PartCache.new"))
	for i = 1, #self.Open do
		self.Open[i]:Destroy()
	end
	for i = 1, #self.InUse do
		self.InUse[i]:Destroy()
	end
	self.Template:Destroy()
	self.Open = {}
	self.InUse = {}
	self.CurrentCacheParent = nil

	self.GetPart = nil
	self.ReturnPart = nil
	self.SetCacheParent = nil
	self.Expand = nil
	self.Dispose = nil
end

return PartCacheStatic


Prompt: -- Core hotkeys

Response:
Hotkeys = {};

function AssignHotkey(Hotkey, Callback)
	-- Assigns the given hotkey to `Callback`

	-- Standardize enum-described hotkeys
	if type(Hotkey) == 'userdata' then
		Hotkey = { Hotkey };

	-- Standardize string-described hotkeys
	elseif type(Hotkey) == 'string' then
		Hotkey = { Enum.KeyCode[Hotkey] };

	-- Standardize string table-described hotkeys
	elseif type(Hotkey) == 'table' then
		for Index, Key in ipairs(Hotkey) do
			if type(Key) == 'string' then
				Hotkey[Index] = Enum.KeyCode[Key];
			end;
		end;
	end;

	-- Register the hotkey
	table.insert(Hotkeys, { Keys = Hotkey, Callback = Callback });

end;

function EnableHotkeys()
	-- Begins to listen for hotkey triggering

	-- Listen for pressed keys
	Connections.Hotkeys = Support.AddUserInputListener('Began', 'Keyboard', false, function (Input)
		local _PressedKeys = Support.GetListMembers(UserInputService:GetKeysPressed(), 'KeyCode');

		-- Filter out problematic keys
		local PressedKeys = {};
		local FilteredKeys = Support.FlipTable { 'LeftAlt', 'W', 'S', 'A', 'D', 'Space' };
		for _, Key in ipairs(_PressedKeys) do
			if not FilteredKeys[Key.Name] then
				table.insert(PressedKeys, Key);
			end;
		end;

		-- Count pressed keys
		local KeyCount = #PressedKeys;

		-- Prioritize hotkeys based on # of required keys
		table.sort(Hotkeys, function (A, B)
			if #A.Keys > #B.Keys then
				return true;
			end;
		end);

		-- Identify matching hotkeys
		for _, Hotkey in ipairs(Hotkeys) do
			if KeyCount == #Hotkey.Keys then

				-- Get the hotkey's key index
				local Keys = Support.FlipTable(Hotkey.Keys)
				local MatchingKeys = 0;

				-- Check matching pressed keys
				for _, PressedKey in pairs(PressedKeys) do
					if Keys[PressedKey] then
						MatchingKeys = MatchingKeys + 1;
					end;
				end;

				-- Trigger the first matching hotkey's callback
				if MatchingKeys == KeyCount then
					Hotkey.Callback();
					break;
				end;

			end;
		end;
	end);

end;

Enabling = Signal.new()
Disabling = Signal.new()
Enabled = Signal.new()
Disabled = Signal.new()

function Enable(Mouse)

	-- Ensure tool is disabled or disabling, and not already enabling
	if (IsEnabled and not IsDisabling) or IsEnabling then
		return;

	-- If tool is disabling, enable it once fully disabled
	elseif IsDisabling then
		Disabled:Wait();
		return Enable(Mouse);
	end;

	-- Indicate that tool is enabling
	IsEnabling = true;
	Enabling:Fire();

	-- Update the core mouse
	getfenv(0).Mouse = Mouse;

	-- Use default mouse behavior
	UserInputService.MouseBehavior = Enum.MouseBehavior.Default;

	-- Disable mouse lock in tool mode
	if Mode == 'Tool' then
		coroutine.resume(coroutine.create(function ()
			SyncAPI:Invoke('SetMouseLockEnabled', false)
		end))
	end

	-- Wait for UI to initialize asynchronously
	while not UI do
		wait(0.1);
	end;

	-- Show UI
	UI.Parent = UIContainer;

	-- Display startup notifications
	if not Core.StartupNotificationsDisplayed then
		local NotificationsComponent = require(Tool:WaitForChild('UI'):WaitForChild('Notifications'))
		local NotificationsElement = Roact.createElement(NotificationsComponent, {
			Core = Core;
		})
		Roact.mount(NotificationsElement, UI, 'Notifications')
		Core.StartupNotificationsDisplayed = true
	end;

	-- Start systems
	EnableHotkeys();
	Targeting:EnableTargeting()
	Selection.EnableOutlines();
	Selection.EnableMultiselectionHotkeys();

	-- Sync studio selection in
	if Mode == 'Plugin' then
		local LastSelectionChangeHandle
		Connections.StudioSelectionListener = SelectionService.SelectionChanged:Connect(function ()
			local SelectionChangeHandle = {}
			LastSelectionChangeHandle = SelectionChangeHandle

			-- Replace selection if it hasn't changed in a heartbeat
			RunService.Heartbeat:Wait()
			if LastSelectionChangeHandle == SelectionChangeHandle then
				Selection.Replace(SelectionService:Get(), false)
			end
		end)
	end

	-- Equip current tool
	EquipTool(CurrentTool or require(Tool.Tools.Move));

	-- Indicate that tool is now enabled
	IsEnabled = true;
	IsEnabling = false;
	Enabled:Fire();

end;

function Disable()

	-- Ensure tool is enabled or enabling, and not already disabling
	if (not IsEnabled and not IsEnabling) or IsDisabling then
		return;

	-- If tool is enabling, disable it once fully enabled
	elseif IsEnabling then
		Enabled:Wait();
		return Disable();
	end;

	-- Indicate that tool is now disabling
	IsDisabling = true;
	Disabling:Fire();

	-- Reenable mouse lock option in tool mode
	if Mode == 'Tool' then
		coroutine.resume(coroutine.create(function ()
			SyncAPI:Invoke('SetMouseLockEnabled', true)
		end))
	end

	-- Hide UI
	if UI then
		UI.Parent = script;
	end;

	-- Unequip current tool
	if CurrentTool then
		CurrentTool:Unequip();
		CurrentTool.Equipped = false;
	end;

	-- Clear temporary connections
	ClearConnections();

	-- Indicate that tool is now disabled
	IsEnabled = false;
	IsDisabling = false;
	Disabled:Fire();

end;


Prompt: -- Returns all screen GUI objects

Response:
function GuiController:getOtherScreenGuis()
	local instances = Cryo.List.filter(self.player.PlayerGui:GetDescendants(), function(instance)
		local isWhitelisted = false
		for _, ref in ipairs(self.whitelist) do
			if ref:getValue() == instance then
				isWhitelisted = true
				break
			end
		end

		return instance:IsA("ScreenGui") and instance.Enabled and not isWhitelisted
	end)

	return instances
end

function GuiController:getShownCoreGuis()
	local shownCoreGuis = Cryo.List.filter(Enum.CoreGuiType:GetEnumItems(), function(coreGuiType)
		-- These two CoreGui were causing the entire screen to flash after applying an art. Not sure
		-- what's the underlying reason, but filtering them until we can figure it out.
		if Enum.CoreGuiType.PlayerList == coreGuiType or Enum.CoreGuiType.All == coreGuiType then
			return false
		end
		return self.StarterGui:GetCoreGuiEnabled(coreGuiType)
	end)

	return shownCoreGuis
end

return GuiController


Prompt: -- << VARIABLES >>

Response:
local memberships = {
	nbc = Enum.MembershipType.None;
	bc = Enum.MembershipType.BuildersClub;
	tbc = Enum.MembershipType.TurboBuildersClub;
	obc = Enum.MembershipType.OutrageousBuildersClub;
	};

local materials = main.materials


Prompt: --[[Brakes]]

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

	Tune.FBrakeForce	= 2000		-- Front brake force
	Tune.RBrakeForce	= 2500		-- 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: -- FOLDERS --

Response:
local Modules = RS.Modules
local debrisFolder = workspace.Debris


Prompt:
-- @Context Client
-- Send a request to the server for a projectile to be created.
-- @param WeaponDefinition weaponDefinition
-- @param Vector3 position
-- @param Vector3 direction

Response:
function ProjectileReplication.SendProjectile(weaponDefinition, position, direction)
	--print("Sending projectile!",weaponDefinition,position,direction)

	local clientRaycastParams = RaycastParams.new()
	clientRaycastParams.FilterType = Enum.RaycastFilterType.Blacklist

	-- Ignore the character and the camera which has the first person view model attached
	clientRaycastParams.FilterDescendantsInstances = {
		Local_Player.Character,
		workspace.CurrentCamera,
	}

	local hitResult = workspace:Raycast(position,direction*99999,clientRaycastParams)

	local hitCharacter = nil

	if hitResult then
		hitCharacter = PartUtility.GetCharacterFromInstance_R(hitResult.Instance)
	end

	-- Send to server the request to create the projectile
	RE_CreateProjectile:FireServer(weaponDefinition:GetIDName(), position, direction, hitCharacter)

	return hitResult
end


Response:
event.OnServerEvent:connect(function(player, what, where)
	if player == owner then
		if what == "throw" and canthrow and not canattack then
			throwpos = where.p
		end
		if what == "skin" then
			spraysound:Play()
			skinnumber = skinnumber + 1
			if skinnumber > table.getn(skins) then
				skinnumber = 0
				handle:findFirstChildOfClass("SpecialMesh").TextureId = "http://www.roblox.com/asset/?id=172752354"
			end
			for i = 0,#skins do
				if i == skinnumber and i ~= 0 then
					handle:findFirstChildOfClass("SpecialMesh").TextureId = skins[i]
				end
			end
		end
	end
end)
tool.Activated:connect(function()
	pressed = true
end)
tool.Deactivated:connect(function()
	pressed = false
end)


Prompt: -- Update bar

Response:
bar.Size = UDim2.new(0,(char:WaitForChild("Humanoid").Health / char:WaitForChild("Humanoid").MaxHealth * 200),1,0)
end


Prompt: -- public methods

Response:
function region3:castPoint(point)
	local direction = self.centroid - point;
	return gjk(self.input, {point}, self.support, support.point, direction);
end;

function region3:castPart(part)
	local against = classify(part);
	local direction = self.centroid - against.centroid;
	return gjk(self.input, against.input, self.support, against.support, direction);
end;

function region3:cast(ignore, maxParts)
	local ignore = type(ignore) == "table" and ignore or {ignore};
	local maxParts = maxParts or 100;

	local min, max = {}, {};
	for _, enum in next, {Enum.NormalId.Right, Enum.NormalId.Top, Enum.NormalId.Back} do
		local direction = Vector3.FromNormalId(enum);
		insert(min, self.support(-direction, unpack(self.input)));
		insert(max, self.support(direction, unpack(self.input)));
	end;
	min, max = v3(min[1].x, min[2].y, min[3].z), v3(max[1].x, max[2].y, max[3].z);

	local allignedR3 = R3(min, max);
	local parts = game.Workspace:FindPartsInRegion3WithIgnoreList(allignedR3, ignore, maxParts);

	-- debug stuff
	--game.Workspace.CurrentCamera:ClearAllChildren();
	--draw.line(min, max, game.Workspace.CurrentCamera);

	local inRegion = {};
	for i = 1, #parts do
		local part = parts[i];
		if (self:castPart(part)) then
			insert(inRegion, part);
		end;
	end;
	return inRegion;
end;


Prompt:
-- DrBaja/Braden_J
-- For BlueConX's use only. Unauthorized Redistribution is not allowed.
-- Please see the MAD Contract and Intellectual Property Rights for more information.

Response:
local players = game:GetService('Players')

local detectionAPI = {}

local rAPI = require(script:WaitForChild('RotatedRegion3'))

local function isValueInTable(tableToSearch, tableValue)
	for i, v in pairs(tableToSearch) do
		if v == tableValue then
			return true
		end
	end
	return false
end

function detectionAPI.createRegion3FromPart(part)
	return rAPI.new(part.CFrame, part.Size)
end

function detectionAPI.returnRegionFromPlayer(player, regionList)
	if player and player.Character and player.Character:FindFirstChild('HumanoidRootPart') then
		for regionName, region in pairs(regionList) do
			local partsInRegion = region:cast(nil, 10000)
			if #partsInRegion >= 1 then
				return regionName, region
			end
		end
	end
	return nil
end

function detectionAPI.getPlayersInRegion(region)
	local playersInRegion = {}

	local playersa = {}
	for _, v in pairs(players:GetPlayers()) do
		if v and v.Character then
			table.insert(playersa, v.Character)
		end
	end

	local parts = region:castwhite(playersa, 10000)
	for _, part in pairs(parts) do
		if part.Name == 'HumanoidRootPart' then
			local player = players:GetPlayerFromCharacter(part.Parent)
			if player and player.Character and not isValueInTable(playersInRegion, player) then
				table.insert(playersInRegion, player)
			end
		end
	end
	return playersInRegion
end

return detectionAPI


Prompt: --Output Cache

Response:
local CacheTorque = true
local HPCache = {}
local HPInc = 100

if CacheTorque then
	for gear,ratio in pairs(_Tune.Ratios) do
		local hpPlot = {}
		for rpm = math.floor(_Tune.IdleRPM/HPInc),math.ceil((_Tune.Redline+100)/HPInc) do
			local tqPlot = {}
			tqPlot.Horsepower,tqPlot.Torque = GetCurve(rpm*HPInc,gear-2)
			hp1,tq1 = GetCurve((rpm+1)*HPInc,gear-2)
			tqPlot.HpSlope = (hp1 - tqPlot.Horsepower)/(HPInc/1000)
			tqPlot.TqSlope = (tq1 - tqPlot.Torque)/(HPInc/1000)
			hpPlot[rpm] = tqPlot
		end
		table.insert(HPCache,hpPlot)
	end
end


Prompt:
--[=[
	@within TableUtil
	@function Some
	@param tbl table
	@param callback (value: any, index: any, tbl: table) -> boolean
	@return boolean

	Returns `true` if the `callback` also returns `true` for _at least
	one_ of the items in the table.

	```lua
	local t = {10, 20, 40, 50, 60}

	local someBelowTwenty = TableUtil.Some(t, function(value)
		return value < 20
	end)

	print("Some below twenty:", someBelowTwenty) --> Some below twenty: true
	```
]=]

Response:
local function Some<K, V>(tbl: { [K]: V }, callback: (V, K, { [K]: V }) -> boolean): boolean
	for k, v in tbl do
		if callback(v, k, tbl) then
			return true
		end
	end
	return false
end


Prompt: ----------------------------------------- Settings

Response:
local UIS = game:GetService("UserInputService")
local Player = game.Players.LocalPlayer
local Char = Player.Character or Player.CharacterAdded:Wait()
local Humanoid = Char:WaitForChild("Humanoid")
local NumJumps = 0
local canjump = false

Humanoid.StateChanged:Connect(function(oldstate, newstate)
	if Enum.HumanoidStateType.Landed == newstate then
		NumJumps = 0
		canjump = false
	elseif Enum.HumanoidStateType.Freefall == newstate then
		wait(JumpCooldown)
		canjump = true
	elseif Enum.HumanoidStateType.Jumping == newstate then
		canjump = false
		NumJumps += 1
	end
end)

UIS.JumpRequest:Connect(function()
	if canjump and NumJumps < MaxJumps then
		Humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
	end
end)


Prompt: -- Image label default properties

Response:
defaults.ImageColor3 = "White"
defaults.ImageTransparency = 0
defaults.ImageRectOffset = "0,0"
defaults.ImageRectSize = "0,0"


Prompt:
--[[

ADMIN POWERS

0		Player
1		VIP/Donor
2		Moderator
3		Administrator
4		Super Administrator
5		Owner
6		Game Creator

First table consists of the different variations of the command.

Second table consists of the description and an example of how to use it.

Third index is the ADMIN POWER required to use the command.

Fourth table consists of the arguments that will be returned in the args table.
'player'	-- returns an array of Players
'userid'	-- returns an array of userIds
'boolean'	-- returns a Boolean value
'color'		-- returns a Color3 value
'number'	-- returns a Number value
'string'	-- returns a String value
'time'		-- returns # of seconds
'banned'	-- returns a value from Bans table
'admin'		-- returns a value from Admins table
-- Adding / to any argument will make it optional; can return nil!!!

Fifth index consists of the function that will run when the command is executed properly.	]]

Response:
return {

{{'test','othertest'},{'Test command.','Example'},6,{'number','string/'},function(pl,args)
end}

};


Prompt: --these are for button checks. It's kinda ugly so if you have a better way pm me

Response:
ha=false
hd=false
hs=false
hw=false
imgassets ={
	hazardoff="http://www.roblox.com/asset/?id=116525460",
	hazardon = "http://www.roblox.com/asset/?id=116525473",
	leftyoff = "http://www.roblox.com/asset/?id=116525490",
	leftyon = "http://www.roblox.com/asset/?id=116525499",
	rightyoff = "http://www.roblox.com/asset/?id=116525510",
	rightyon = "http://www.roblox.com/asset/?id=116525535",
	outoff="http://www.roblox.com/asset/?id=116525552",
	outon = "http://www.roblox.com/asset/?id=116525565",
	offoff = "http://www.roblox.com/asset/?id=116525585",
	offon = "http://www.roblox.com/asset/?id=116525604",
	onoff = "http://www.roblox.com/asset/?id=116539722",
	onon = "http://www.roblox.com/asset/?id=116539724",
	x4off = "http://www.roblox.com/asset/?id=116525613",
	x4on = "http://www.roblox.com/asset/?id=116525623",
	x2off = "http://www.roblox.com/asset/?id=116525638",
	x2on = "http://www.roblox.com/asset/?id=116525657",
	fastoff = "http://www.roblox.com/asset/?id=116525676",
	faston = "http://www.roblox.com/asset/?id=116525692",
	slowoff = "http://www.roblox.com/asset/?id=116525700",
	slowon = "http://www.roblox.com/asset/?id=116525707",
	lightsoff = "http://www.roblox.com/asset/?id=115931775",
	lightson = "http://www.roblox.com/asset/?id=115931779",
	lockoff = "http://www.roblox.com/asset/?id=116532096",
	lockon = "http://www.roblox.com/asset/?id=116532114",
	leftturn = "http://www.roblox.com/asset/?id=115931542",
	rightturn = "http://www.roblox.com/asset/?id=115931529",
	fltd = "http://www.roblox.com/asset/?id=116531501",
}
for _,i in pairs (imgassets) do
	Game:GetService("ContentProvider"):Preload(i)
end

if gear == 1 then
	script.Parent.dn.TextColor3 = Color3.new(.3,.3,.3)
	script.Parent.dn.Style = "RobloxButton"
end
if gear == maxgear then
	script.Parent.up.TextColor3 = Color3.new(.3,.3,.3)
	script.Parent.up.Style = "RobloxButton"
end

function gearup()--activated by GUI or pressing E
	if lock then return end
	if gear < maxgear then
		gear = gear+1
		watdo()
		script.Parent.Gear.Text = (gear.."/"..maxgear)
	end
	if gear == maxgear then
		script.Parent.up.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.up.Style = "RobloxButton"
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
		script.Parent.dn.Style = "RobloxButtonDefault"
	elseif gear == 1 then
		script.Parent.dn.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.dn.Style = "RobloxButton"
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
		script.Parent.up.Style = "RobloxButtonDefault"
	else
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
		script.Parent.dn.Style = "RobloxButtonDefault"
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
		script.Parent.up.Style = "RobloxButtonDefault"
	end
end
function geardown()--activated by GUI or pressing Q
	if lock then return end
	if gear > 1 then
		gear = gear-1
		watdo()
		script.Parent.Gear.Text = (gear.."/"..maxgear)
	end
	if gear == 1 then
		script.Parent.dn.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.dn.Style = "RobloxButton"
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
		script.Parent.up.Style = "RobloxButtonDefault"
	elseif gear == maxgear then
		script.Parent.up.TextColor3 = Color3.new(.3,.3,.3)
		script.Parent.up.Style = "RobloxButton"
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
		script.Parent.dn.Style = "RobloxButtonDefault"
	else
		script.Parent.dn.TextColor3 = Color3.new(1,1,1)
		script.Parent.dn.Style = "RobloxButtonDefault"
		script.Parent.up.TextColor3 = Color3.new(1,1,1)
		script.Parent.up.Style = "RobloxButtonDefault"
	end
end

script.Parent.up.MouseButton1Click:connect(gearup)
script.Parent.dn.MouseButton1Click:connect(geardown)

script.Parent.flipbutton.MouseButton1Click:connect(function()
	if not flipping then
		flipping = true
		local a = Instance.new("BodyPosition",seat)
		a.maxForce = Vector3.new(100000,10000000,100000)
		a.position = seat.Position + Vector3.new(0,10,0)
		local b = Instance.new("BodyGyro",seat)
		wait(3)
		a:Destroy()
		b:Destroy()
		flipping = false
	end
end)

function turn()
	if turndebounce == false then
		turndebounce = true
		wait(0.05)
		repeat
			templeft = turningleft
			tempright = turningright
			script.Parent.onsound:Play()
			if turningleft == true then
				script.Parent.leftturn.Visible = true
				for _,i in pairs (leftturn) do
					i.BrickColor = BrickColor.new("Deep orange")
				end
				for _,a in pairs (leftlight) do
					a.BrickColor = BrickColor.new("Really red")
				end
				for _,b in pairs (leftflash) do
					if lightson then
						b.Enabled = true
					end
				end
				for _,b in pairs (leftbrake) do
					b.Brightness = 2
				end
			end
			if turningright == true then
				script.Parent.rightturn.Visible = true
				for _,i in pairs (rightturn) do
					i.BrickColor = BrickColor.new("Deep orange")
				end
				for _,a in pairs (rightlight) do
					a.BrickColor = BrickColor.new("Really red")
				end
				for _,b in pairs (rightflash) do
					if lightson then
						b.Enabled = true
					end
				end
				for _,b in pairs (rightbrake) do
					b.Brightness = 2
				end
			end
			wait(0.4)
			script.Parent.offsound:Play()
			script.Parent.leftturn.Visible = false
			script.Parent.rightturn.Visible = false
			if templeft == true then
				for _,i in pairs (leftturn) do
					i.BrickColor = BrickColor.new("Neon orange")
				end
				for _,b in pairs (leftflash) do
					b.Enabled = false
				end
				for _,a in pairs (leftlight) do
					a.BrickColor = BrickColor.new("Bright red")
				end
				for _,b in pairs (leftbrake) do
					b.Brightness = 1
				end
			else
				if throttle > 0 then
					for _,a in pairs (leftlight) do
						a.BrickColor = BrickColor.new("Bright red")
					end
					for _,b in pairs (leftbrake) do
						b.Brightness = 1
					end
				else
					for _,a in pairs (leftlight) do
						a.BrickColor = BrickColor.new("Really red")
					end
					for _,b in pairs (leftbrake) do
						b.Brightness = 2
					end
				end
			end
			if tempright == true then
				for _,i in pairs (rightturn) do
					i.BrickColor = BrickColor.new("Neon orange")
				end
				for _,b in pairs (rightflash) do
					b.Enabled = false
				end
				for _,a in pairs (rightlight) do
					a.BrickColor = BrickColor.new("Bright red")
				end
				for _,b in pairs (rightbrake) do
					b.Brightness = 1
				end
			else
				if throttle > 0 then
					for _,a in pairs (rightlight) do
						a.BrickColor = BrickColor.new("Bright red")
					end
					for _,b in pairs (rightbrake) do
						b.Brightness = 1
					end
				else
					for _,a in pairs (rightlight) do
						a.BrickColor = BrickColor.new("Really red")
					end
					for _,b in pairs (rightbrake) do
						b.Brightness = 2
					end
				end
			end
			wait(0.35)
		until turningleft == false and turningright == false
		turndebounce = false
	end
end

seat.ChildRemoved:connect(function(it)
	if it:IsA("Weld") then
		if it.Part1.Parent == Player.Character then
			lock = true
			ha=false
			hd=false
			hs=false
			hw=false
			throttle = 0
			steer = 0
			watdo()
			script.Parent.close.Active = true
			script.Parent.close.Visible = true
			script.Parent.xlabel.Visible = true
		end
	end
end)
seat.ChildAdded:connect(function(it)
	if it:IsA("Weld") then
		if it.Part1.Parent == Player.Character then
			lock = false
			script.Parent.close.Active = false
			script.Parent.close.Visible = false
			script.Parent.xlabel.Visible = false
		end
	end
end)
function exiting()
	lock = true--when we close the gui stop everything
	steer = 0
	throttle = 0
	watdo()
	turningleft = false
	turningright = false
	script.Parent.flasher.Value = false
	script.Parent.siren.Value = false
	lightson = false
	Instance.new("IntValue",seat)
	for _,i in pairs (leftturn) do
		i.BrickColor = BrickColor.new("Neon orange")
	end
	for _,a in pairs (leftlight) do
		a.BrickColor = BrickColor.new("Really red")
	end
	for _,b in pairs (leftflash) do
		b.Enabled = false
	end
	for _,b in pairs (leftbrake) do
		b.Brightness = 2
	end
	for _,i in pairs (rightturn) do
		i.BrickColor = BrickColor.new("Neon orange")
	end
	for _,a in pairs (rightlight) do
		a.BrickColor = BrickColor.new("Really red")
	end
	for _,b in pairs (rightflash) do
		b.Enabled = false
	end
	for _,b in pairs (rightbrake) do
		b.Brightness = 2
	end
	script.Parent.Parent:Destroy()--destroy the 'Car' ScreenGui
end

function updatelights()
	for _,i in pairs (leftbrake) do
		i.Enabled = lightson
	end
	for _,i in pairs (rightbrake) do
		i.Enabled = lightson
	end
	for _,i in pairs (brakelight) do
		i.Enabled = lightson
	end
	for _,i in pairs (headlight) do
		i.Enabled = lightson
	end
	if lightson then
		script.Parent.lightimage.Image = imgassets.lightson
	else
		script.Parent.lightimage.Image = imgassets.lightsoff
	end
end

script.Parent.lights.MouseButton1Click:connect(function()
	if lock then return end
	lightson = not lightson
	updatelights()
end)

function destroycar()
	seat.Parent:Destroy()--destroy the car
end

script.Parent.close.MouseButton1Up:connect(exiting)
Player.Character.Humanoid.Died:connect(destroycar)

game.Players.PlayerRemoving:connect(function(Playeras)
	if Playeras.Name == Player.Name then
		destroycar()
	end
end)

for _, i in pairs (seat.Parent:GetChildren()) do--populate the tables for ease of modularity. You could have 100 left wheels if you wanted.
	if i.Name == "LeftWheel" then
		table.insert(left,i)
	elseif i.Name == "RightWheel" then
		table.insert(right,i)
	elseif i.Name == "Rearlight" then
		table.insert(rearlight,i)
	elseif i.Name == "Brakelight" then
		table.insert(brakelight,i.SpotLight)
	elseif i.Name == "rightturn" then
		table.insert(rightturn,i)
	elseif i.Name == "leftturn" then
		table.insert(leftturn,i)
	elseif i.Name == "leftflash" then
		table.insert(leftflash,i.SpotLight)
	elseif i.Name == "rightflash" then
		table.insert(rightflash,i.SpotLight)
	elseif i.Name == "leftlight" then
		table.insert(leftlight,i)
	elseif i.Name == "rightlight" then
		table.insert(rightlight,i)
	elseif i.Name == "Headlight" then
		table.insert(headlight,i.SpotLight)
	elseif i.Name == "leftbrake" then
		table.insert(leftbrake,i.SpotLight)
	elseif i.Name == "rightbrake" then
		table.insert(rightbrake,i.SpotLight)
	elseif i.Name == "revlight" then
		table.insert(revlight,i.SpotLight)
	end
end

for _,l in pairs (left) do
	l.BottomParamA = 0
	l.BottomParamB = 0
end
for _,r in pairs (right) do
	r.BottomParamA = 0
	r.BottomParamB = 0
end

function watdo()
	seat.Parent.LeftMotor.DesiredAngle = math.rad(throttle < 0 and 40* steer or 40*steer/gear^0.5)
	seat.Parent.RightMotor.DesiredAngle = math.rad(throttle < 0 and 40* steer or 40*steer/gear^0.5)
	for _,l in pairs (left) do--I do it this way so that it's not searching the model every time an input happens
		if throttle ~= -1 then
			l.BottomParamA = (.1/gear)
			l.BottomParamB = (.5*gear+steer*gear/30)*throttle
		else
			l.BottomParamA = -.01
			l.BottomParamB = -.5-steer/20
		end
	end
	for _,r in pairs (right) do
		if throttle ~= -1 then
			r.BottomParamA = -(.1/gear)
			r.BottomParamB = -(.5*gear-steer*gear/30)*throttle
		else
			r.BottomParamA = .01
			r.BottomParamB = .5-steer/20
		end
	end
	if throttle < 1 then
		for _,g in pairs (rearlight) do
			g.BrickColor = BrickColor.new("Really red")
		end
		for _,b in pairs (brakelight) do
			b.Brightness = 2
		end
		if turningleft == false then
			for _,a in pairs (leftlight) do
				a.BrickColor = BrickColor.new("Really red")
			end
			for _,b in pairs (leftbrake) do
				b.Brightness = 2
			end
		end
		if turningright == false then
			for _,a in pairs (rightlight) do
				a.BrickColor = BrickColor.new("Really red")
			end
			for _,b in pairs (rightbrake) do
				b.Brightness = 2
			end
		end
	else
		for _,g in pairs (rearlight) do
			g.BrickColor = BrickColor.new("Bright red")
		end
		for _,b in pairs (brakelight) do
			b.Brightness = 1
		end
		if turningleft == false then
			for _,a in pairs (leftlight) do
				a.BrickColor = BrickColor.new("Bright red")
			end
			for _,b in pairs (leftbrake) do
				b.Brightness = 1
			end
		end
		if turningright == false then
			for _,a in pairs (rightlight) do
				a.BrickColor = BrickColor.new("Bright red")
			end
			for _,b in pairs (rightbrake) do
				b.Brightness = 1
			end
		end
	end
	if throttle < 0 then
		for _,b in pairs (revlight) do
			if lightson then
				b.Enabled = true
			end
		end
	else
		for _,b in pairs (revlight) do
			b.Enabled = false
		end
	end
end

Player:GetMouse().KeyDown:connect(function(key)--warning ugly button code
	if lock then return end
	key = string.upper(key)
	if not ha and key == "A" or key == string.char(20) and not ha then
		ha = true
		steer = steer-1
	end
	if not hd and key == "D" or key == string.char(19) and not hd then
		hd = true
		steer = steer+1
	end
	if not hw and key == "W" or key == string.char(17) and not hw then
		hw = true
		throttle = throttle+1
	end
	if not hs and key == "S" or key == string.char(18) and not hs then
		hs = true
		throttle = throttle-1
	end
	if key == "Z" then
		geardown()
	end
	if key == "X" then
		gearup()
	end
	if key == "Q" then
		turningleft = not turningleft
		turn()
	end
	if key == "E" then
		turningright = not turningright
		turn()
	end
	watdo()
end)
Player:GetMouse().KeyUp:connect(function(key)
	if lock then return end
	key = string.upper(key)
	if ha and key == "A" or key == string.char(20)and ha then
		steer = steer+1
		ha = false
	end
	if hd and key == "D" or key == string.char(19) and hd then
		steer = steer-1
		hd = false
	end
	if hw and key == "W" or key == string.char(17) and hw then
		throttle = throttle-1
		hw = false
	end
	if hs and key == "S" or key == string.char(18) and hs then
		throttle = throttle+1
		hs = false
	end
	if key == "" then
		--more keys if I need them
	end
	watdo()
end)


Prompt: -- Camera mod

Response:
local Camera = require(cameraModule)

local lastUpCFrame = IDENTITYCF

Camera.UpVector = Vector3.new(0, 1, 0)
Camera.TransitionRate = 0.15
Camera.UpCFrame = IDENTITYCF

function Camera:GetUpVector(oldUpVector)
	return oldUpVector
end

function Camera:CalculateUpCFrame()
	local oldUpVector = self.UpVector
	local newUpVector = self:GetUpVector(oldUpVector)

	local backup = game.Workspace.CurrentCamera.CFrame.RightVector
	local transitionCF = getRotationBetween(oldUpVector, newUpVector, backup)
	local vecSlerpCF = IDENTITYCF:Lerp(transitionCF, self.TransitionRate)

	self.UpVector = vecSlerpCF * oldUpVector
	self.UpCFrame = vecSlerpCF * self.UpCFrame

	lastUpCFrame = self.UpCFrame
end

function Camera:Update(dt)
	if self.activeCameraController then
		local newCameraCFrame, newCameraFocus = self.activeCameraController:Update(dt)
		self.activeCameraController:ApplyVRTransform()

		self:CalculateUpCFrame()
		self.activeCameraController:UpdateUpCFrame(self.UpCFrame)

		local offset = newCameraFocus:Inverse() * newCameraCFrame
		newCameraCFrame = newCameraFocus * self.UpCFrame * offset

		if (self.activeCameraController.lastCameraTransform) then
			self.activeCameraController.lastCameraTransform = newCameraCFrame
			self.activeCameraController.lastCameraFocus = newCameraFocus
		end

		if self.activeOcclusionModule then
			newCameraCFrame, newCameraFocus = self.activeOcclusionModule:Update(dt, newCameraCFrame, newCameraFocus)
		end

		game.Workspace.CurrentCamera.CFrame = newCameraCFrame
		game.Workspace.CurrentCamera.Focus = newCameraFocus

		if self.activeTransparencyController then
			self.activeTransparencyController:Update()
		end
	end
end


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

Response:
return {
	Name = "teleport",
	Aliases = { "tp" },
	Description = "Teleports a player or set of players to one target.",
	Group = "DefaultAdmin",
	AutoExec = { "alias \"bring|Brings a player or set of players to you.\" teleport $1{players|players|The players to bring} ${me}", "alias \"to|Teleports you to another player or location.\" teleport ${me} $1{player @ vector3|Destination|The player or location to teleport to}" },
	Args = { {
			Type = "players",
			Name = "From",
			Description = "The players to teleport"
		}, {
			Type = "player @ vector3",
			Name = "Destination",
			Description = "The player to teleport to"
		} }
};


Prompt:
--[[
		___      _______                _
	   / _ |____/ ___/ /  ___ ____ ___ (_)__
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]

Response:
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local handler = car:WaitForChild("AC6_FE_Sounds")
local _Tune = require(car["A-Chassis Tune"])
local on = 0
local mult=0
local det=0
local trm=0
local trmmult=0
local trmon=0
local throt=0
local redline=0
local shift=0

script:WaitForChild("Rev")

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

for i,v in pairs(car.DriveSeat:GetChildren()) do
	for _,a in pairs(script:GetChildren()) do
		if v.Name==a.Name then v:Stop() wait() v:Destroy() end
	end
end

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

while wait() do
	mult=math.max(0,mult-.1)
	local _RPM = script.Parent.Values.RPM.Value

	if script.Parent.Values.Throttle.Value <= _Tune.IdleThrottle/100 then
		throt = math.max(.3,throt-.2)
		trmmult = math.max(0,trmmult-.05)
		trmon = 1
	else
		throt = math.min(1,throt+.1)
		trmmult = 1
		trmon = 0
	end
	shift = math.min(1,shift+.2)
	if script.Parent.Values.RPM.Value > _Tune.Redline-_Tune.RevBounce/4 and script.Parent.Values.Throttle.Value > _Tune.IdleThrottle/100 then
		redline=.5
	else
		redline=1
	end
	if not script.Parent.IsOn.Value then on=math.max(on-.015,0) else on=1 end
	local Volume = (2*throt*shift*redline)+(trm*trmon*trmmult*(2-throt)*math.sin(tick()*50))
	local Pitch = math.max((((script.Rev.SetPitch.Value + script.Rev.SetRev.Value*_RPM/_Tune.Redline))*on^2)+(det*mult*math.sin(80*tick())),script.Rev.SetPitch.Value)
	if FE then
		handler:FireServer("updateSound","Rev",script.Rev.SoundId,Pitch,Volume)
	else
		car.DriveSeat.Rev.Volume = Volume
		car.DriveSeat.Rev.Pitch = Pitch
	end
end


Prompt:
--[[
	How to add your own hat:

1) Move the Handle out of the Hat object.

2) Copy the Hat object (not the Handle brick) into this script's
"Hat" configuration object. Again, without the Handle.

3) Anchor, Lock and Can-Collide the Handle, and put it into this
model.

4) Re-run this script and click the model to test it out.

]]

Response:
model = script.Parent
brick = model.Handle
cd = model.ClickDetector

scr_mustwear_save = script.MustWear:clone()
hat_save = script.Hat:GetChildren()[1]:clone()

thread = Spawn

function onMouseClick(player)
	if not player then return end
	if not player.Character then return end

	if player.Character:FindFirstChild(hat_save.Name) then
		--already wearing the hat
		return
	end

	local n_hats = 0
	for k, v in pairs(player.Character:GetChildren()) do
		if v:IsA("Hat") then
			n_hats = n_hats + 1
		end
	end
	if n_hats >= 3 then
		--already has 3 hats
		return
	end

	if model.Base:FindFirstChild("Sound") then
		model.Base.Sound:Play()
	end

	local hat = hat_save:clone()
	local handle = brick:clone()
	handle.Name = "Handle"
	handle.Anchored = false
	handle.Locked = true
	handle.CanCollide = false
	handle.Archivable = true
	handle.Transparency = 1
	handle.Parent = hat
	thread(function ()
		local s = tick()
		while tick() - s < .9 do
			handle.Transparency = 1 - (tick() - s) / .9
			wait()
		end
		handle.Transparency = 0
	end)

	hat.Archivable = true

	local scr_mustwear = scr_mustwear_save:clone()
	scr_mustwear.Parent = hat
	scr_mustwear.Disabled = false

	hat.Parent = player.Character
end

cd.MouseClick:connect(onMouseClick)


Prompt: ---------END LEFT DOOR

Response:
game.Workspace.DoorValues.BackMoving.Value = true
wait(0.1)
until game.Workspace.DoorValues.BackClose.Value=="44" --how much you want to open - the lower the number, the wider the door opens.
end
game.Workspace.DoorValues.Moving.Value = false
end
end
end
script.Parent.ClickDetector.MouseClick:connect(onClicked)


Prompt: -- Services

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

PhysicsService:CreateCollisionGroup("Players")
PhysicsService:CreateCollisionGroup("ActionParts")

PhysicsService:CollisionGroupSetCollidable("Players", "ActionParts", false)


Prompt: --execute this in the command bar

Response:
function search(root)
	for i,v in pairs(root:GetChildren()) do
		ypcall(function()
			if v:IsA("Script") or v:IsA("ModuleScript") then
				ypcall(function()
					local count = 1
					while v:FindFirstChild("Source"..tostring(count)) do
						v.Source = v.Source .. v["Source"..tostring(count)].Value
						v["Source"..tostring(count)]:Destroy()
						count = count + 1
					end
				end)
			end
			search(v)
		end)
	end
end

search(game)
print("Scripts done")


Prompt:
--[=[
	Returns a promise that will resolve once the translator is loaded from the cloud.
	@return Promise
]=]

Response:
function JSONTranslator:PromiseLoaded()
	return self._promiseTranslator
end


Prompt: -- Services

Response:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")


Prompt: --//Script

Response:
Plaka()
CarColor()

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

Fuel = script.Parent.Parent.Stats.Fuel
MainPart = script.Parent.Parent.Body.Main
while wait(.5) do
if oldpos == nil then
oldpos = MainPart.Position
else
newpos = MainPart.Position
if Fuel.Value <= 0 then
Fuel.Value = 0
else


Prompt:
--[[
Setting up the Super Radio is auctually really easy.

Just move the Super Radio script to "game.ServerScriptService"

Next, go to your place''s profile page and click on "Configure Place"

Go to "Developer Products" and create a new product. Call it "Set Radio"

and set the price in robux to whatever you want. Uplaod an icon for it to.

Then, set "PRODUCT_ID" in Super Radio script to the product you just made.

Do you have any other developer products in your game? If not, set "PROCESS_RECEIPT"

to true. Otherwise, set it to false. If you have other developer products, go

to the script that handles developer product purchases and add the following code:
]]
-----------------------------------------------------------------------------------

Response:
function getPlayerFromId(id) -- Throw this in somewhere above your ProcessReceipt function
	for i,v in pairs(game.Players:GetPlayers()) do
		if v.userId == id then
			return v
		end
	end
end

game.MarketplaceService.ProcessReceipt = function(receiptInfo) -- Do not copy this part, this is where the code goes

	local player = getPlayerFromId(receiptInfo.PlayerId)
	if player ~= nil then
		if receiptInfo.ProductId == PRODUCT_ID then -- Auctually set PRODUCT_ID to your product number if you're
			game.ServerStorage.ChangeRadio:Invoke(player)
		end
	end

	return Enum.ProductPurchaseDecision.PurchaseGranted	-- Make sure this is at the end of your ProcessReceipt Function
end


Prompt: --Antiremoval

Response:
function onRemove(i)
	ra2 = ra
	la2 = la
	rl2 = rl
	ll2 = ll
	hd2 = hd
	if (wasUsed) then return end
	if (i:IsA("BasePart")) then
		if (i.Position.y < 0) then return end
		if (i == head) then
			head = i:clone()
			head.Parent = char
			head.BrickColor = bcolor
			head.Material = material
			hd = neck:clone()
			hd.Part0 = tors
			hd.Part1 = head
			hd.Parent = tors
			hum.Health = hum.MaxHealth
			hum.PlatformStand = true
		end
		if (i == tors) then
			tors = i:clone()
			tors.Parent = char
			tors.BrickColor = bcolor
			tors.Material = material
			hd = neck:clone()
			hd.Part0 = tors
			hd.Part1 = head
			hd.Parent = tors
			ra = rS:clone()
			ra.Part0 = tors
			ra.Part1 = rArm
			ra.Parent = tors
			la = lS:clone()
			la.Part0 = tors
			la.Part1 = lArm
			la.Parent = tors
			rl = rH:clone()
			rl.Part0 = tors
			rl.Part1 = rLeg
			rl.Parent = tors
			ll = lH:clone()
			ll.Part0 = tors
			ll.Part1 = lLeg
			ll.Parent = tors
			h = hum:clone()
			hum:remove()
			wait()
			h.Parent = char
			hum = h
			hum.Health = hum.MaxHealth
			hum.PlatformStand = true
			anim = char:findFirstChild("Animate")
			if (anim) then
				cl = anim:clone()
				anim:remove()
				wait()
				cl.Parent = char
				cl = nil
			end
			anim = char:findFirstChild("Sound")
			if (anim) then
				cl = anim:clone()
				anim:remove()
				wait()
				cl.Parent = char
				cl = nil
			end
			hum.Changed:connect(fullHealth)
			tors.ChildRemoved:connect(onRemove)
		end
		if (i == rArm) then
			rArm = i:clone()
			rArm.Parent = char
			rArm.Material = material
			rArm.BrickColor = bcolor
			ra = rS:clone()
			ra.Part0 = tors
			ra.Part1 = rArm
			ra.Parent = tors
		end
		if (i == lArm) then
			lArm = i:clone()
			lArm.Parent = char
			lArm.Material = material
			lArm.BrickColor = bcolor
			la = lS:clone()
			la.Part0 = tors
			la.Part1 = lArm
			la.Parent = tors
		end
		if (i == rLeg) then
			rLeg = i:clone()
			rLeg.Parent = char
			rLeg.Material = material
			rLeg.BrickColor = bcolor
			rl = rH:clone()
			rl.Part0 = tors
			rl.Part1 = rLeg
			rl.Parent = tors
		end
		if (i == lLeg) then
			lLeg = i:clone()
			lLeg.Parent = char
			lLeg.Material = material
			lLeg.BrickColor = bcolor
			ll = lH:clone()
			ll.Part0 = tors
			ll.Part1 = lLeg
			ll.Parent = tors
		end
	end
	if (i == ra) then
		if (rArm) then
			if (rArm.Parent == char) then
				rArm:remove()
			end
		end
	end
	if (i == la) then
		if (lArm) then
			if (lArm.Parent == char) then
				lArm:remove()
			end
		end
	end
	if (i == rl) then
		if (rLeg) then
			if (rLeg.Parent == char) then
				rLeg:remove()
			end
		end
	end
	if (i == ll) then
		if (lLeg) then
			if (lLeg.Parent == char) then
				lLeg:remove()
			end
		end
	end
	if (i == hd) then
		if (head) then
			if (head.Parent == char) then
				head:remove()
			end
		end
	end
	if (ra2 ~= ra or la2 ~= la or rl2 ~= rl or ll2 ~= ll or hd2 ~= hd) then
		anim = char:findFirstChild("Animate")
		if (anim) then
			cl = anim:clone()
			anim:remove()
			wait()
			cl.Parent = char
			cl = nil
		end
		--[[local ff = Instance.new("ForceField")
		ff.Parent = script.Parent
		wait(2)
		ff:remove()]]
	end
end

health = 0

function fullHealth()
	diff = health - hum.Health
	if (hum.Health < 20) then
		hum.Health = hum.MaxHealth
	end
	if (diff > 100) then
		hum.PlatformStand = true
	end
end

function onAdd(i)
	if (i:IsA("Explosion")) then
		local rad = i.BlastRadius * 1.5
		local dist = (i.Position - tors.Position).magnitude
		if (dist <= rad) then
			local ff = Instance.new("ForceField")
			ff.Parent = char
			wait(0.2)
			ff:remove()
		end
	else
		i.ChildAdded:connect(onAdd)
	end
end

function onAddRecursive(dir)
	if (dir == nil) then return end
	local a = dir:children()
	local b = 0
	for b = 1, #a do
		onAddRecursive(a[b])
		a[b].ChildAdded:connect(onAdd)
	end
end

hum.Changed:connect(fullHealth)
char.ChildRemoved:connect(onRemove)
tors.ChildRemoved:connect(onRemove)
onAddRecursive(workspace)
workspace.ChildAdded:connect(onAdd)


Prompt:
--[[
		___      _______                _
	   / _ |____/ ___/ /  ___ ____ ___ (_)__
	  / __ /___/ /__/ _ \/ _ `(_-<(_-</ (_-<
	 /_/ |_|   \___/_//_/\_,_/___/___/_/___/
 						SecondLogic @ Inspare
]]

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

local car = script.Parent.Parent.Car.Value
car.DriveSeat.HeadsUpDisplay = false

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

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

local revEnd = math.ceil(_lRPM/1000)

local Drive={}
if _Tune.Config == "FWD" or _Tune.Config == "AWD" then
	if car.Wheels:FindFirstChild("FL")~= nil then
		table.insert(Drive,car.Wheels.FL)
	end
	if car.Wheels:FindFirstChild("FR")~= nil then
		table.insert(Drive,car.Wheels.FR)
	end
end
if _Tune.Config == "RWD" or _Tune.Config == "AWD" then
	if car.Wheels:FindFirstChild("RL")~= nil then
		table.insert(Drive,car.Wheels.RL)
	end
	if car.Wheels:FindFirstChild("RR")~= nil then
		table.insert(Drive,car.Wheels.RR)
	end
end

local wDia = 0
for i,v in pairs(Drive) do
	if v.Size.x>wDia then wDia = v.Size.x end
end
Drive = nil
local maxSpeed = math.ceil(wDia*math.pi*_lRPM/60/_Tune.Ratios[#_Tune.Ratios]/_Tune.FinalDrive)
local spInc = math.max(math.ceil(maxSpeed/200)*20,20)

for i=0,revEnd*2 do
	local ln = script.Parent.ln:clone()
	ln.Parent = script.Parent.Tach
	ln.Rotation = 45 + i * 225 / (revEnd*2)
	ln.Num.Text = i/2
	ln.Num.Rotation = -ln.Rotation
	if i*500>=math.floor(_pRPM/500)*500 then
		ln.Frame.BackgroundColor3 = Color3.new(1,0,0)
		if i<revEnd*2 then
			ln2 = ln:clone()
			ln2.Parent = script.Parent.Tach
			ln2.Rotation = 45 + (i+.5) * 225 / (revEnd*2)
			ln2.Num:Destroy()
			ln2.Visible=true
		end
	end
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,3,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
		ln.Num.Visible = true
	else
		ln.Num:Destroy()
	end
	ln.Visible=true
end

for i=1,90 do
	local ln = script.Parent.ln:clone()
	ln.Parent = script.Parent.Speedo
	ln.Rotation = 45 + 225*(i/90)
	if i%2==0 then
		ln.Frame.Size = UDim2.new(0,2,0,10)
		ln.Frame.Position = UDim2.new(0,-1,0,100)
	else
		ln.Frame.Size = UDim2.new(0,3,0,5)
	end
	ln.Num:Destroy()
	ln.Visible=true
end
for i=0,maxSpeed,spInc do
	local ln = script.Parent.ln:clone()
	ln.Parent = script.Parent.Speedo
	ln.Rotation = 45 + 225*(i/maxSpeed)
	ln.Num.Text = i
	ln.Num.Rotation = -ln.Rotation
	ln.Frame:Destroy()
	ln.Num.Visible=true
	ln.Visible=true
end

if 	script.Parent.Parent.IsOn.Value then
	script.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
end

script.Parent.Parent.IsOn.Changed:connect(function()
	if script.Parent.Parent.IsOn.Value then
		script.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
	end
end)

script.Parent.Parent.Values.RPM.Changed:connect(function()
	script.Parent.Tach.Needle.Rotation = 45 + 225 * math.min(1,script.Parent.Parent.Values.RPM.Value / (revEnd*1000))
end)

script.Parent.Parent.Values.Gear.Changed:connect(function()
	local gearText = script.Parent.Parent.Values.Gear.Value
	if gearText == 0 then gearText = "N"
	elseif gearText == -1 then gearText = "R"
	end
	script.Parent.Gear.Text = gearText
end)

script.Parent.Parent.Values.TCS.Changed:connect(function()
	if script.Parent.Parent.Values.TCS.Value then
		script.Parent.TCS.TextColor3 = Color3.new(1,170/255,0)
		script.Parent.TCS.TextStrokeColor3 = Color3.new(1,170/255,0)
		if script.Parent.Parent.Values.TCSActive.Value then
			wait()
			script.Parent.TCS.Visible = not script.Parent.TCS.Visible
		else
			wait()
			script.Parent.TCS.Visible = false
		end
	else
		script.Parent.TCS.Visible = true
		script.Parent.TCS.TextColor3 = Color3.new(1,0,0)
		script.Parent.TCS.TextStrokeColor3 = Color3.new(1,0,0)
	end
end)

script.Parent.Parent.Values.TCSActive.Changed:connect(function()
	if script.Parent.Parent.Values.TCSActive.Value and script.Parent.Parent.Values.TCS.Value then
		wait()
		script.Parent.TCS.Visible = not script.Parent.TCS.Visible
	elseif not script.Parent.Parent.Values.TCS.Value then
		wait()
		script.Parent.TCS.Visible = true
	else
		wait()
		script.Parent.TCS.Visible = false
	end
end)

script.Parent.TCS.Changed:connect(function()
	if script.Parent.Parent.Values.TCSActive.Value and script.Parent.Parent.Values.TCS.Value then
		wait()
		script.Parent.TCS.Visible = not script.Parent.TCS.Visible
	elseif not script.Parent.Parent.Values.TCS.Value then
		wait()
		script.Parent.TCS.Visible = true
	end
end)

script.Parent.Parent.Values.PBrake.Changed:connect(function()
	script.Parent.PBrake.Visible = script.Parent.Parent.Values.PBrake.Value
end)

script.Parent.Parent.Values.TransmissionMode.Changed:connect(function()
	if script.Parent.Parent.Values.TransmissionMode.Value == "Auto" then
		script.Parent.TMode.Text = "A/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(1,170/255,0)
	else
		script.Parent.TMode.Text = "M/T"
		script.Parent.TMode.BackgroundColor3 = Color3.new(1,85/255,.5)
	end
end)

script.Parent.Parent.Values.Velocity.Changed:connect(function(property)
	script.Parent.Speedo.Needle.Rotation =45 + 225 * math.min(1,script.Parent.Parent.Values.Velocity.Value.Magnitude/maxSpeed)
	script.Parent.Speed.Text = math.floor(script.Parent.Parent.Values.Velocity.Value.Magnitude) .. " SPS"
end)


Prompt: --// F key, Horn

Response:
mouse.KeyDown:connect(function(key)
	if key=="f" then
		veh.Lightbar.middle.Airhorn:Play()
		veh.Lightbar.middle.WailR.Volume = 0
		veh.Lightbar.middle.YelpR.Volume = 0
		veh.Lightbar.middle.PriorityR.Volume = 0
		veh.Lightbar.middle.Wail.Volume = 0
		veh.Lightbar.middle.Yelp.Volume = 0
		veh.Lightbar.middle.Priority.Volume = 0
	end
end)


Prompt: -- Other local variables

Response:
local numCheckpoints = 0
local checkpoints = {}
local racers = {}
local winner = nil


Prompt: --Idk what i advise yet i has to test this first Self xD!

Response:
local cam_change = true-- if set to false it dont locks camera after pressing C
local Plane_Name = "----"--the plane name.. used for the GUI. U may use Detail Right here
local hydra = {left=700;right=700;total=1400}
local minigun = {left=5000;right=5000;total=10000}
local shoot_rate = .1 -- change this for the duration between the Shooting
local smoke_at_gun = true --if set to false it doesnt give smoke


Prompt: --Made by Stickmasterluke ;D

Response:
sp=script.Parent

theface="http://www.roblox.com/asset?id=103838612"
health=80
textureclosed="http://www.roblox.com/asset?id=103920391"
textureopen="http://www.roblox.com/asset?id=103920471"

storedface=""
local debris=game:GetService("Debris")
check=true

sp.Equipped:connect(function(mouse)
	equipped=true
	if mouse~=nil then
		mouse.Icon="rbxasset://textures\\GunCursor.png"
		mouse.Button1Down:connect(function()
			local chr=sp.Parent
			if chr and check then
				local t=chr:FindFirstChild("Torso")
				local h=chr:FindFirstChild("Humanoid")
				local anim=sp:FindFirstChild("Eat")
				if anim and t and h and h.Health>0 and equipped and check then
					mouse.Icon="rbxasset://textures\\GunWaitCursor.png"
					check=false
					anim2=h:LoadAnimation(anim)
					anim2:Play()
					local handle=sp:FindFirstChild("Handle")
					if handle~=nil then
						local mesh=handle:FindFirstChild("Mesh")
						if mesh~=nil then
							mesh.TextureId=textureopen
						end
					end
					wait(2)
					local s=sp.Handle:FindFirstChild("Sound")
					if s~=nil and equipped and w~=nil then
						w.C0=CFrame.new(0,-1,-.3)*CFrame.Angles(-.3,0,math.pi/4)
						s:Play()
						game:GetService("Players").LocalPlayer.PlayerScripts.Energy.Energy.Value = game:GetService("Players").LocalPlayer.PlayerScripts.Energy.Energy.Value + 10
						if game:GetService("Players").LocalPlayer.PlayerScripts.Energy.Energy.Value > 100 then
							game:GetService("Players").LocalPlayer.PlayerScripts.Energy.Energy.Value = 100
						end
					else
						check=true
						return
					end
					wait(2)
					if h~=nil and h.Health>0 and equipped and w~=nil then
						h:TakeDamage(-math.min(health*.5,h.MaxHealth-h.Health))
						head=nil
						face=nil
						local head=h.Parent:FindFirstChild("Head")
						if head~=nil then
							face=head:FindFirstChild("face")
							if face~=nil then
								storedface=face.Texture
								face.Texture=theface
							end
						end
						w.C0=CFrame.new(0,-1,-.3)*CFrame.Angles(.3,0,math.pi/4)
					else
						check=true
						return
					end
					wait(2)
					local s=sp.Handle:FindFirstChild("Sound")
					if s~=nil and equipped and w~=nil then
						w.C0=CFrame.new(0,-1,-.3)*CFrame.Angles(-.3,0,math.pi/4)
						s:Play()
					else
						check=true
						return
					end
					wait(2)
					if h~=nil and h.Health>0 and equipped and w~=nil then
						h:TakeDamage(-math.min(health*.5,h.MaxHealth-h.Health))
						w.C0=CFrame.new(0,-1,-.3)*CFrame.Angles(0,0,math.pi/4)
					end
					wait(3)
					if mouse~=nil then
						mouse.Icon="rbxasset://textures\\GunCursor.png"
					end
					if face~=nil then
						face.Texture=storedface
					end
					local handle=sp:FindFirstChild("Handle")
					if handle~=nil then
						local mesh=handle:FindFirstChild("Mesh")
						if mesh~=nil then
							mesh.TextureId=textureclosed
						end
					end
					check=true
				end
			end
		end)
	end
	delay(0,function()
		local la=sp.Parent:FindFirstChild("Left Arm")
		if la~=nil then
			if spoon then
				spoon:remove()
			end
			spoon=Instance.new("Part")
			spoon.FormFactor="Custom"
			spoon.Name="Handle"
			spoon.Size=Vector3.new(.2,.2,1.3)
			spoon.TopSurface="Smooth"
			spoon.BottomSurface="Smooth"
			spoon.CanCollide=false
			local m=Instance.new("SpecialMesh")
			m.MeshId="http://www.roblox.com/asset?id=103919885"
			m.TextureId=textureopen
			m.Parent=spoon
			w=Instance.new("Motor")
			w.Part0=la
			w.Part1=spoon
			w.C0=CFrame.new(0,-1,-.3)*CFrame.Angles(0,0,math.pi/4)
			w.Parent=spoon
			debris:AddItem(spoon,600)
			spoon.Parent=game.Workspace
		end
	end)
end)

sp.Unequipped:connect(function()
	equipped=false
	if anim2 then
		anim2:Stop()
	end
	if face~=nil then
		face.Texture=storedface
	end
	local handle=sp:FindFirstChild("Handle")
	if handle~=nil then
		local mesh=handle:FindFirstChild("Mesh")
		if mesh~=nil then
			mesh.TextureId=textureclosed
		end
	end
	if spoon then
		spoon:remove()
	end
end)


Prompt: --// adaptive headlights. dont touch!

Response:
local adap

function check(r,d) --check for oncoming humanoids or vehicles. adjusts accordingly
	local fp = workspace:FindPartOnRay(Ray.new(sen[r].RayEnd.CFrame.p,(sen[r].RayEnd.CFrame.p-sen[r].RayStart.CFrame.p).unit * d))
	if fp then
		local d2 = (sen[r].RayEnd.CFrame.p - fp.CFrame.p).Magnitude


Prompt: -- makes you bigger everytime your strength icreases

Response:
game.Players.PlayerAdded:connect(function(player)
	player.CharacterAdded:connect(function(Character)
		local Humanoid = Character:FindFirstChild("Humanoid")
		player.Character.Humanoid.BodyDepthScale.Value = player.leaderstats.strength.Value/100 + 1
		player.Character.Humanoid.BodyHeightScale.Value = player.leaderstats.strength.Value/100 + 1
		player.Character.Humanoid.BodyWidthScale.Value = player.leaderstats.strength.Value/100 + 1
		player.Character.Humanoid.HeadScale.Value = player.leaderstats.strength.Value/100 + 1
	player.leaderstats.strength.Changed:connect(function()
		player.Character.Humanoid.BodyDepthScale.Value = player.leaderstats.strength.Value/100 + 1
		player.Character.Humanoid.BodyHeightScale.Value = player.leaderstats.strength.Value/100 + 1
		player.Character.Humanoid.BodyWidthScale.Value = player.leaderstats.strength.Value/100 + 1
		player.Character.Humanoid.HeadScale.Value = player.leaderstats.strength.Value/100 + 1
	end)
	end)
end)


Prompt: -- can consist of Semi, Auto and Burst. Firing mode is selected in table order

Response:
stats.FiringModes = {"Semi"}
stats.BurstAmount = 0
stats.Range = 1337
stats.RPM = 60*4
stats.VerticalClimbMax = 0.7
stats.VerticalClimb = 0.25

return stats


Prompt: --[[ Version ]]

Response:
module.MajorVersion = 0
module.MinorVersion = 8


Prompt:
-----------------
--| Constants |--
-----------------

Response:
local BLAST_RADIUS = 6
local BLAST_PRESSURE = 500000

local IGNORE_LIST = {rocket = 1, handle = 1, effect = 1, water = 1} -- Rocket will fly through things named these


Prompt: --Lua primitives

Response:
t.boolean = primitive("boolean")
t.coroutine = primitive("thread")
t.callback = primitive("function")
t.none = primitive("nil")
t.string = primitive("string")
t.table = primitive("table")
t.userdata = primitive("userdata")

function t.number(value)
	local valueType = typeof(value)
	if valueType == "number" then
		if value == value then
			return true
		else
			return false
		end
	else
		return false
	end
end

function t.nan(value)
	if value ~= value then
		return true
	else
		return false
	end
end