Prompt: -- luacheck: ignore 212

Response:
local Players = game:GetService("Players")
local Player = Players.LocalPlayer

return function (Cmdr)
	local AutoComplete = {
		Items = {};
		ItemOptions = {};
		SelectedItem = 0;
	}

	local Util = Cmdr.Util
	local Shorthands = Util.MakeDictionary({"me", "all", ".", "*"})

	local Gui = Player:WaitForChild("PlayerGui"):WaitForChild("Cmdr"):WaitForChild("Autocomplete")
	local AutoItem = Gui:WaitForChild("TextButton")
	local Title = Gui:WaitForChild("Title")
	local Description = Gui:WaitForChild("Description")
	local Entry = Gui.Parent:WaitForChild("Frame"):WaitForChild("Entry")
	AutoItem.Parent = nil

	-- Helper function that sets text and resizes labels
	local function SetText(obj, textObj, text, sizeFromContents)
		obj.Visible = text ~= nil
		textObj.Text = text or ""

		if sizeFromContents then
			textObj.Size = UDim2.new(0, Util.GetTextSize(text or "", textObj, Vector2.new(1000, 1000), 1, 0).X, obj.Size.Y.Scale, obj.Size.Y.Offset)
		end
	end

	-- Update the info display (Name, type, and description) based on given options.
	local function UpdateInfoDisplay (options)
		-- Update the objects' text and sizes
		SetText(Title, Title.Field, options.name, true)
		SetText(Title.Field.Type, Title.Field.Type, options.type and ": " .. options.type:sub(1, 1):upper() .. options.type:sub(2))
		SetText(Description, Description.Label, options.description)

		Description.Label.TextColor3 = options.invalid and Color3.fromRGB(255, 73, 73) or Color3.fromRGB(255, 255, 255)

		-- Calculate needed width and height
		local infoWidth = Title.Field.TextBounds.X + Title.Field.Type.TextBounds.X

		local guiWidth = math.max(infoWidth, Gui.Size.X.Offset)
		Description.Size = UDim2.new(1, 0, 0, 40)

		-- Flow description text
		while not Description.Label.TextFits do
			Description.Size = Description.Size + UDim2.new(0, 0, 0, 2)

			if Description.Size.Y.Offset > 500 then
				break
			end
		end

		-- Update container
		wait()
		Gui.UIListLayout:ApplyLayout()
		Gui.Size = UDim2.new(0, guiWidth, 0, Gui.UIListLayout.AbsoluteContentSize.Y)
	end

	--- Shows the auto complete menu with the given list and possible options
	-- item = {typedText, suggestedText, options?=options}
	-- The options table is optional. `at` should only be passed into AutoComplete::Show
	-- name, type, and description may be passed in an options dictionary inside the items as well
	-- options.at?: the character index at which to show the menu
	-- options.name?: The name to display in the info box
	-- options.type?: The type to display in the info box
	-- options.prefix?: The current type prefix (%Team)
	-- options.description?: The description for the currently active info box
	-- options.invalid?: If true, description is shown in red.
	-- options.isLast?: If true, auto complete won't keep going after this argument.
	function AutoComplete:Show (items, options)
		options = options or {}

		-- Remove old options.
		for _, item in pairs(self.Items) do
			if item.gui then
				item.gui:Destroy()
			end
		end

		-- Reset state
		self.SelectedItem = 1
		self.Items = items
		self.Prefix = options.prefix or ""
		self.LastItem = options.isLast or false
		self.Command = options.command
		self.Arg = options.arg
		self.NumArgs = options.numArgs

		-- Generate the new option labels
		local autocompleteWidth = 200

		for i, item in pairs(self.Items) do
			local leftText = item[1]
			local rightText = item[2]

			if Shorthands[leftText] then
				leftText = rightText
			end

			local btn = AutoItem:Clone()
			btn.Name = leftText .. rightText
			btn.BackgroundTransparency = i == self.SelectedItem and 0.5 or 1
			btn.Typed.Text = leftText
			btn.Suggest.Text = string.rep(" ", #leftText) .. rightText:sub(#leftText + 1)
			btn.Parent = Gui
			btn.LayoutOrder = i

			local maxBounds = math.max(btn.Typed.TextBounds.X, btn.Suggest.TextBounds.X) + 20
			if maxBounds > autocompleteWidth then
				autocompleteWidth = maxBounds
			end

			item.gui = btn
		end

		Gui.UIListLayout:ApplyLayout()

		-- Todo: Use TextService to find accurate position for auto complete box
		local text = Entry.TextBox.Text
		local words = Util.SplitString(text)
		if text:sub(#text, #text) == " " and not options.at then
			words[#words+1] = "e"
		end
		table.remove(words, #words)
		local extra = (options.at and options.at or (#table.concat(words, " ") + 1)) * 7

		-- Update the auto complete container
		Gui.Position = UDim2.new(0, Entry.TextBox.AbsolutePosition.X - 10 + extra, 0, Entry.TextBox.AbsolutePosition.Y + 30)
		Gui.Size = UDim2.new(0, autocompleteWidth, 0, Gui.UIListLayout.AbsoluteContentSize.Y)
		Gui.Visible = true

		-- Finally, update thge info display
		UpdateInfoDisplay(self.Items[1] and self.Items[1].options or options)
	end

	--- Returns the selected item in the auto complete
	function AutoComplete:GetSelectedItem ()
		if Gui.Visible == false then
			return nil
		end

		return AutoComplete.Items[AutoComplete.SelectedItem]
	end

	--- Hides the auto complete
	function AutoComplete:Hide ()
		Gui.Visible = false
	end

	--- Returns if the menu is visible
	function AutoComplete:IsVisible ()
		return Gui.Visible
	end

	--- Changes the user's item selection by the given delta
	function AutoComplete:Select (delta)
		if not Gui.Visible then return end

		self.SelectedItem = self.SelectedItem + delta

		if self.SelectedItem > #self.Items then
			self.SelectedItem = 1
		elseif self.SelectedItem < 1 then
			self.SelectedItem = #self.Items
		end

		for i, item in pairs(self.Items) do
			item.gui.BackgroundTransparency = i == self.SelectedItem and 0.5 or 1
		end

		if self.Items[self.SelectedItem] and self.Items[self.SelectedItem].options then
			UpdateInfoDisplay(self.Items[self.SelectedItem].options or {})
		end
	end

	return AutoComplete
end


Prompt:
--[=[
	@class Comm
	Remote communication library.

	This exposes the raw functions that are used by the `ServerComm` and `ClientComm` classes.
	Those two classes should be preferred over accessing the functions directly through this
	Comm library.
]=]

Response: local Comm = {Server = {}, Client = {}}


Prompt: -- Wether or not we should use some even worse temp hacks than the rest of the temp hacks to avoid RobloxSecurity APIs

Response: return true


Prompt: ---[[ Window Settings ]]

Response:
module.MinimumWindowSize = UDim2.new(0.25, 0, 0.25, 0)
module.MaximumWindowSize = UDim2.new(1, 0, 1, 0) -- if you change this to be greater than full screen size, weird things start to happen with size/position bounds checking.
module.DefaultWindowPosition = UDim2.new(0, 0, .45, 0)
local extraOffset = (7 * 2) + (5 * 2) -- Extra chatbar vertical offset
module.DefaultWindowSizePhone = UDim2.new(0.5, 0, 0.5, extraOffset)
module.DefaultWindowSizeTablet = UDim2.new(0.4, 0, 0.3, extraOffset)
module.DefaultWindowSizeDesktop = UDim2.new(0.25, 0, 0.25, extraOffset)


Prompt: --Unsprung Weight

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

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


Prompt: --DO NOT CHANGE ANYTHING INSIDE OF THIS SCRIPT BESIDES WHAT YOU ARE TOLD TO UNLESS YOU KNOW WHAT YOU'RE DOING OR THE SCRIPT WILL NOT WORK!!

Response:
local hitPart = script.Parent
local debounce = true
local tool = game.ServerStorage.Rose -- Change "Sword" to the name of your tool, make sure your tool is in ServerStorage

hitPart.Touched:Connect(function(hit)
	if debounce == true then
		if hit.Parent:FindFirstChild("Humanoid") then
			local plr = game.Players:FindFirstChild(hit.Parent.Name)
			if plr then
				debounce = false
				hitPart.BrickColor = BrickColor.new("Bright red")
				tool:Clone().Parent = plr.Backpack
				wait(3) -- Change "3" to however long you want the player to have to wait before they can get the tool again
				debounce = true
				hitPart.BrickColor = BrickColor.new("Bright green")
			end
		end
	end
end)


Prompt:
--Camera bobbing
-- Shakes the camera when the player is walking

Response:
local runService = game:GetService("RunService")

local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")

function updateBobbleEffect()
	local currentTime = tick()
	if humanoid.MoveDirection.Magnitude > 0 then
		local bobbleX = math.cos(currentTime * 10) * .25
		local bobbleY = math.abs(math.sin(currentTime * 10)) * .25

		local bobble = Vector3.new(bobbleX, bobbleY, 0)

		humanoid.CameraOffset = humanoid.CameraOffset:lerp(bobble, .200)
	else
		humanoid.CameraOffset = humanoid.CameraOffset * .75
	end
end

runService.RenderStepped:Connect(updateBobbleEffect)


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

Response:
game.Workspace.doorleft.l11.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l21.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l31.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l41.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l51.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l61.BrickColor = BrickColor.new(106)
game.Workspace.doorleft.l73.BrickColor = BrickColor.new(1003)


Prompt:
--[[
	Constructs a new Promise with the given initializing callback.

	This is generally only called when directly wrapping a non-promise API into
	a promise-based version.

	The callback will receive 'resolve' and 'reject' methods, used to start
	invoking the promise chain.

	Second parameter, parent, is used internally for tracking the "parent" in a
	promise chain. External code shouldn't need to worry about this.
]]

Response:
function Promise._new(traceback, callback, parent)
	if parent ~= nil and not Promise.is(parent) then
		error("Argument #2 to Promise.new must be a promise or nil", 2)
	end

	local self = {
		-- Used to locate where a promise was created
		_source = traceback,

		_status = Promise.Status.Started,

		-- A table containing a list of all results, whether success or failure.
		-- Only valid if _status is set to something besides Started
		_values = nil,

		-- Lua doesn't like sparse arrays very much, so we explicitly store the
		-- length of _values to handle middle nils.
		_valuesLength = -1,

		-- Tracks if this Promise has no error observers..
		_unhandledRejection = true,

		-- Queues representing functions we should invoke when we update!
		_queuedResolve = {},
		_queuedReject = {},
		_queuedFinally = {},

		-- The function to run when/if this promise is cancelled.
		_cancellationHook = nil,

		-- The "parent" of this promise in a promise chain. Required for
		-- cancellation propagation upstream.
		_parent = parent,

		-- Consumers are Promises that have chained onto this one.
		-- We track them for cancellation propagation downstream.
		_consumers = setmetatable({}, MODE_KEY_METATABLE),
	}

	if parent and parent._status == Promise.Status.Started then
		parent._consumers[self] = true
	end

	setmetatable(self, Promise)

	local function resolve(...)
		self:_resolve(...)
	end

	local function reject(...)
		self:_reject(...)
	end

	local function onCancel(cancellationHook)
		if cancellationHook then
			if self._status == Promise.Status.Cancelled then
				cancellationHook()
			else
				self._cancellationHook = cancellationHook
			end
		end

		return self._status == Promise.Status.Cancelled
	end

	coroutine.wrap(function()
		local ok, _, result = runExecutor(
			self._source,
			callback,
			resolve,
			reject,
			onCancel
		)

		if not ok then
			reject(result[1])
		end
	end)()

	return self
end

function Promise.new(executor)
	return Promise._new(debug.traceback(nil, 2), executor)
end

function Promise:__tostring()
	return string.format("Promise(%s)", self:getStatus())
end


Prompt:
-- ============================================
-- Falling Objects

Response:
local burningRock =
{
    MODEL = ServerStorage["Burning Rock"],
    DAMAGE = 20,
    NUMBER_PER_MINUTE = 20,
    CLEANUP_DELAY_IN_SECONDS = 5
}

local healingWater =
{
	MODEL = ServerStorage["Healing Water"],
	DAMAGE= -20,
	NUMBER_PER_MINUTE = 20,
	CLEANUP_DELAY_IN_SECONDS = 5

}
table.insert(fallingStuffTable, burningRock)
table.insert(fallingStuffTable,healingWater)


Prompt: -- Get references to the DockShelf and its children

Response:
local dockShelf = script.Parent.Parent.Parent.Parent.Parent.DockShelf
local aFinderButton = dockShelf.BClippsly
local Minimalise = script.Parent
local window = script.Parent.Parent.Parent


Prompt: --[[Weight and CG]]

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

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

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


Prompt: --// Bullet Physics

Response:
	BulletPhysics = Vector3.new(0,55,0); -- Drop fixation: Lower number = more drop
	BulletSpeed = 2000; -- Bullet Speed
	BulletSpread = 1; -- How much spread the bullet has

	ExploPhysics = Vector3.new(0,20,0); -- Drop for explosive rounds
	ExploSpeed = 600; -- Speed for explosive rounds

	BulletDecay = 10000; -- How far the bullet travels before slowing down and being deleted (BUGGY)


Response:
	script.Parent.Handle3.Hinge1.Transparency = 1
	script.Parent.Handle3.Interactive1.Transparency = 1
	script.Parent.Handle3.Part1.Transparency = 1
	wait(0.03)
	script.Parent.Handle1.Hinge1.Transparency = 1
	script.Parent.Handle1.Interactive1.Transparency = 1
	script.Parent.Handle1.Part1.Transparency = 1


Prompt: -- NOTE: This function is radically different from the engine's implementation

Response:
local walkVelocityVector = Vector3_new(1,1,1)
local function calcDesiredWalkVelocity()
	-- TEMP
	return walkVelocityVector
end

local function preStepSimulatorSide(dt)
	if getAutoJump() and enableAutoJump() then
		local desiredWalkVelocity = calcDesiredWalkVelocity();
		if (not vec3IsZero(desiredWalkVelocity)) then
			doAutoJump();
		end
	end
end

local function AutoJumper()
	local this = {}
	local running = false
	local runRoutine = nil

	function this:Run()
		running = true
		local thisRoutine = nil
		thisRoutine = coroutine.create(function()
			while running and thisRoutine == runRoutine do
				this:Step()
				task.wait()
			end
		end)
		runRoutine = thisRoutine
		coroutine.resume(thisRoutine)
	end

	function this:Stop()
		running = false
	end

	function this:Step()
		preStepSimulatorSide()
	end

	return this
end


Prompt: -- Libraries

Response:
Core = require(script.Parent.Core);
Support = Core.Support;

SnapTracking = {};
SnapTracking.Enabled = false;
SnapTracking.TrackCorners = true;
SnapTracking.TrackFaceCentroids = true;
SnapTracking.TrackEdgeMidpoints = true;

function SnapTracking.StartTracking(Callback)
	-- Starts displaying the given target's snap point nearest to the mouse, calls back every time a new point is approached

	-- Make sure tracking isn't already on
	if SnapTracking.Enabled then
		SnapTracking.StopTracking();
	end;

	-- Indicate that tracking is now enabled
	SnapTracking.Enabled = true;

	-- Disable selection
	Core.Targeting.CancelSelecting();

	-- Start the UI
	SnapTracking.StartUI();

	-- Store callback to send changes in current snapping point
	SnapTracking.SetCallback(Callback);

	-- Start tracking mouse movement
	function UpdateTrackingTarget(Input)

		-- Blacklist the player's character and the items in `TargetBlacklist`
		local TargetBlacklist = Support.ConcatTable(
			{ Player and Player.Character },
			SnapTracking.TargetBlacklist or {}
		);

		-- Find the current target part and point
		local TargetRay = Workspace.CurrentCamera:ScreenPointToRay(Input.Position.X, Input.Position.Y);
		local TargetPart, TargetPoint, TargetNormal, TargetMaterial = Workspace:FindPartOnRayWithIgnoreList(
			Ray.new(TargetRay.Origin, TargetRay.Direction * 5000),
			TargetBlacklist
		);

		-- Make sure a target part exists
		if not TargetPart then
			return;
		end;

		-- Check with any snapping target filter
		if SnapTracking.TargetFilter and not SnapTracking.TargetFilter(TargetPart) then
			return;
		end;

		-- Set the current target for snap point tracking
		SnapTracking.MousePoint = TargetPoint;
		SnapTracking.SetTrackingTarget(TargetPart);

	end;

	-- Update the tracking and UI to the current mouse and proximity state
	if not SnapTracking.CustomMouseTracking then
		SnapTracking.MouseTracking = Support.AddUserInputListener('Changed', 'MouseMovement', false, UpdateTrackingTarget);
		UpdateTrackingTarget({ Position = Vector2.new(Core.Mouse.X, Core.Mouse.Y) });
		SnapTracking.Update();
	end;

end;

function SnapTracking.SetCallback(Callback)
	-- Sets the function that is called back whenever a new snap point is in focus
	SnapTracking.Callback = Callback;
end;

function SnapTracking.StartUI()
	-- Creates the point marking UI
	SnapTracking.PointMarker = Core.Tool.Interfaces.PointMarker:Clone();
	SnapTracking.PointMarker.Parent = Core.UI;
end;

function SnapTracking.ClearUI()
	-- Removes the point marking UI

	-- Make sure tracking is currently enabled
	if not SnapTracking.Enabled then
		return;
	end;

	-- Remove the point marker UI
	SnapTracking.PointMarker:Destroy();
	SnapTracking.PointMarker = nil;

end;

function SnapTracking.Update()
	-- Updates the current closest point, reflects it on UI, calls callback function

	-- Make sure tracking is currently enabled
	if not SnapTracking.Enabled then
		return;
	end;

	-- Calculate the closest point
	local ClosestPoint = SnapTracking.GetClosestPoint();

	-- Inform the callback function
	SnapTracking.Callback(ClosestPoint);

	-- Update the point marker UI
	SnapTracking.UpdateUI(ClosestPoint);

end;

function SnapTracking.UpdateUI(Point)
	-- Updates the point marker UI to reflect the position of the current closest snap point

	-- Make sure tracking is enabled, and that the UI has started
	if not SnapTracking.Enabled or not SnapTracking.PointMarker then
		return;
	end;

	-- Make sure there's actually a point that needs to be marked, or hide the point marker
	if not Point then
		SnapTracking.PointMarker.Visible = false;
		return;
	end;

	-- Map the point's position on the screen
	local PointPosition, PointVisible = Workspace.CurrentCamera:WorldToScreenPoint(Point.p);

	-- Move the point marker UI to the point's position on the screen
	SnapTracking.PointMarker.Visible = PointVisible;
	SnapTracking.PointMarker.Position = UDim2.new(0, PointPosition.X, 0, PointPosition.Y);

end;

function SnapTracking.SetTrackingTarget(NewTarget)
	-- Sets the target part whose snapping points' proximity we are tracking
	SnapTracking.Target = NewTarget;
	SnapTracking.Update();
end;

function SnapTracking.GetClosestPoint()
	-- Find the current nearest snapping point for the target, update the GUI

	-- Make sure there's a target part to track, and a current mouse position to calculate proximity relative to
	if not SnapTracking.Target or not SnapTracking.MousePoint then
		return nil;
	end;

	local SnappingPoints = {};
	local SnappingPointProximity = {};

	-- Get the current target's snapping points
	local PartCFrame = SnapTracking.Target.CFrame;
	local PartSize = SnapTracking.Target.Size / 2;
	local SizeX, SizeY, SizeZ = PartSize.X, PartSize.Y, PartSize.Z;

	-- Filter based on snapping point options
	if SnapTracking.TrackCorners then
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, SizeY, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, SizeY, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, -SizeY, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, SizeY, -SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, SizeY, -SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, -SizeY, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, -SizeY, -SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, -SizeY, -SizeZ));
	end;
	if SnapTracking.TrackEdgeMidpoints then
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, SizeY, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, 0, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, SizeY, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, SizeY, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, 0, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, -SizeY, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, -SizeY, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, 0, -SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, SizeY, -SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, -SizeY, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, 0, -SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, -SizeY, -SizeZ));
	end;
	if SnapTracking.TrackFaceCentroids then
		table.insert(SnappingPoints, PartCFrame * CFrame.new(SizeX, 0, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, 0, SizeZ));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, SizeY, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(-SizeX, 0, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, -SizeY, 0));
		table.insert(SnappingPoints, PartCFrame * CFrame.new(0, 0, -SizeZ));
	end;

	-- Calculate proximity of each snapping point to the mouse
	for SnappingPointKey, SnappingPoint in ipairs(SnappingPoints) do
		SnappingPointProximity[SnappingPointKey] = (SnapTracking.MousePoint - SnappingPoint.p).magnitude;
	end;

	-- Sort out the closest snapping point
	local ClosestPointKey = 1;
	for PointKey, Proximity in pairs(SnappingPointProximity) do
		if Proximity < SnappingPointProximity[ClosestPointKey] then
			ClosestPointKey = PointKey;
		end;
	end;

	-- Return the closest point
	return SnappingPoints[ClosestPointKey];
end;

function SnapTracking.StopTracking()
	-- Stops tracking the current closest snapping point, cleans up

	-- Clear the previous tracking target, and callback
	SnapTracking.Target = nil;
	SnapTracking.Callback = nil;

	-- Reset snapping point options
	SnapTracking.TrackFaceCentroids = true;
	SnapTracking.TrackEdgeMidpoints = true;
	SnapTracking.TrackCorners = true;
	SnapTracking.TargetFilter = nil;
	SnapTracking.TargetBlacklist = {};

	-- Make sure we're currently tracking
	if not SnapTracking.Enabled then
		return;
	end;

	-- Stop tracking the mouse and its proximity to snapping points
	SnapTracking.MouseTracking:disconnect();
	SnapTracking.MouseTracking = nil;

	-- Clear the point marker UI from the screen
	SnapTracking.ClearUI();

	-- Indicate that tracking is no longer enabled
	SnapTracking.Enabled = false;

end;

return SnapTracking;


Prompt: --Automatic Settings

Response:
Tune.AutoShiftMode	= "RPM"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM										]]
Tune.AutoShiftType	= "DCT"												--[[
	[Types]
		"Rev"		: Clutch engages fully once RPM reached
		"DCT"		: Clutch engages after a set time has passed				]]
Tune.AutoUpThresh	= 200		-- Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
Tune.AutoDownThresh = 1400		-- Automatic downshift point (relative to peak RPM, positive = Under-rev)


Prompt:
--[=[
	@type ExtensionShouldFn (component) -> boolean
	@within Component
]=]

Response: type ExtensionShouldFn = (any) -> boolean


Prompt: --https://www.youtube.com/watch?v=5yvoNQoOvz0   db


Prompt: --User Settings

Response: Speed_Units = "MPH"	--MPH/KMH/SPS


Prompt:
--[[
    configure(config: table): nil

    Overrides default configuration keys to change how the Dev Module behaves.

    Throws when trying to set a configuration key that does not exist.

    The possible keys and their default values for the `config` table are:

    	-- Toggle the "body orientation" feature through this parameter
    	useBodyOrientation = true,

    	-- Body orientation uses a mix of waist and neck rotation, use this parameter to determine which of the two is
    	-- prevalent. It should be a number between 0 and 1: 1 means that only the waist rotates, 0 means that only the neck
    	-- rotates. A value of 0.5 performs an even mix of waist and neck rotation.
    	waistOrientationWeight = 0.5,

    	-- Toggle the "chat-triggered emotes" feature through this parameter
    	useChatAnimations = true,

    	-- "Chat emotes" comes with a default list of trigger words. Use this parameter to turn them off if you would rather
    	-- provide your own.
    	 useDefaultTriggerWordsForChatEmotes = true,
]]
-- Example: configures "body orientation" to make waist rotation more pronounced, and disable the "chat emotes" feature

Response:
SocialInteractions.configure({
	waistOrientationWeight = 0.75,
	useChatAnimations = false,
})


Prompt:
--[[for x = 1, 50 do
s.Pitch = s.Pitch + 0.01
s:play()
wait(0.04)
end]]

Response:
for x = 100, 170 do
s:play()
wait(0.04)
end
for x = 100, 210 do
s.Pitch = s.Pitch - 0.0031
s:play()
wait(0.04)
end
wait()
end


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

	@param value The value to check against

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

Response: t.FloatCurveKey = t.typeof("FloatCurveKey")


Prompt: --[[Shutdown]]

Response:
	car.DriveSeat.ChildRemoved:connect(function(child)
		if child.Name=="SeatWeld" and child:IsA("Weld") then
			script.Parent:Destroy()
		end
	end)


Prompt: -- listen to touches from each part

Response:
connectPart(center)
connectPart(top)
connectPart(bottom)
connectPart(left)
connectPart(right)
connectPart(front)
connectPart(back)

function rebuildStud(stud, cf)
	stud.CFrame = cf
	stud.Parent = beacon
	stud:makeJoints()
end


Prompt: -- Create component

Response: local ImageButton = Roact.PureComponent:extend 'ImageButton'


Prompt:
--[[
	@param 	Number 		Range			The radius for which we will search for players (characters).
--]]

Response:
function Ownership:WaitForPlayerInRange(Range)
	-- Check if there are actually players in game - if not, wait for a player to join
	if #Players:GetPlayers() == 0 then
		Players.PlayerAdded:Wait()
	end

	local Player;
	repeat
		for _, player in pairs(Players:GetPlayers()) do
			if player and player.Character and player.Character:FindFirstChild("HumanoidRootPart") then
				if (player.Character.HumanoidRootPart.Position - self.Model.PrimaryPart.Position).Magnitude <= Range then
					Player = player
					break
				end
			end
		end
		wait(0.1)
	until Player or #Players:GetPlayers() == 0
	-- The loop waits until either a Player has been found or there are no more players left in the game.

	-- If no player was found, it means the other condition (no players in game) was triggered.
	if not Player then
		-- We (re-)call this method to make use of PlayerAdded:Wait() instead of a repeat-loop, for efficiency.
		self:WaitForPlayerInRange(Range)
	else
		self:SetOwner(Player)
	end
end


Prompt:
--[[
	Evercyan @ March 2023
	TooltipController

	Require this module to show information under tooltips. Tooltips are floating text,
	usually bits of information, relating to what the user is hovering over, such as
	hovering over slots in the inventory.
]]


Prompt: --Updates the speedo

Response:
val.Velocity.Changed:connect(function()

	Guages.Speed.Text = tostring(math.floor(val.Velocity.Value.Magnitude * StudsToKilo))

end)


Prompt: --//Setup//--

Response:
local Buttons = script.Parent

local Floor = Buttons.Parent
local FloorConfiguration = Floor.Configuration


Prompt: --Brake particles

Response:
bp1 = script.Parent.BrakeParticles1.ParticleEmitter
bp2 = script.Parent.BrakeParticles2.ParticleEmitter
bs = script.Parent.Mover.Sound --brake sound

while true do
	wait(0.1)
	--dir & speed
	if dir.Value == 0 then
		script.Parent.Mover.BodyVelocity.Velocity = Vector3.new(0, 0, 0)
	elseif dir.Value >= 0.5 then
		script.Parent.Mover.BodyVelocity.velocity= script.Parent.Mover.CFrame.lookVector*rsp.Value
	elseif dir.Value <= -0.5 then
		script.Parent.Mover.BodyVelocity.velocity= script.Parent.Mover.CFrame.lookVector*-rsp.Value
	end
	--Brake effects
	if brk.Value >= 0 and csp.Value >= 0.5 then
		bp1.Enabled = true
		bp2.Enabled = true
		bs.Volume = brk.Value / bmax.Value --this trick doesn't let the sound hurt your ears
		                             	   --even when the maximum brake value is 10000000
	else
		bp1.Enabled = false
		bp2.Enabled = false
		bs.Volume = 0
	end
end


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

Response:
client = nil;
service = nil;
return function(p1)
	local l__Time__1 = p1.Time;
	local v2 = service.New("Sound");
	v2.Volume = 0.25;
	v2.Looped = false;
	v2.SoundId = "http://www.roblox.com/asset/?id=151715959";
	local v3 = service.New("Sound");
	v3.Volume = 0.25;
	v3.Looped = false;
	v3.SoundId = "http://www.roblox.com/asset/?id=267883066";
	local v4 = {
		Name = "Countdown",
		Title = "Countdown",
		Size = { 300, 150 },
		Position = UDim2.new(0, 10, 1, -160)
	};
	function v4.OnClose()
		v2:Stop();
		v3:Stop();
		v2:Destroy();
		v3:Destroy();
	end;
	local v5 = client.UI.Make("Window", v4);
	local v6 = v5:Add("TextLabel", {
		Text = l__Time__1,
		BackgroundTransparency = 1,
		TextScaled = true
	});
	local v7 = {
		Text = ""
	};
	local u1 = false;
	local u2 = nil;
	function v7.OnClick()
		if u1 then
			v2.Volume = 0.25;
			v3.Volume = 0.25;
			u2.Image = "rbxassetid://1638551696";
			u1 = false;
			return;
		end;
		v2.Volume = 0;
		v3.Volume = 0;
		u2.Image = "rbxassetid://1638584675";
		u1 = true;
	end;
	u2 = v5:AddTitleButton(v7):Add("ImageLabel", {
		Size = UDim2.new(0, 20, 0, 20),
		Position = UDim2.new(0, 5, 0, 0),
		Image = "rbxassetid://1638551696",
		BackgroundTransparency = 1
	});
	v2.Parent = v6;
	v3.Parent = v6;
	local l__gTable__8 = v5.gTable;
	l__gTable__8:Ready();
	for v9 = l__Time__1, 0, -1 do
		if not l__gTable__8.Active then
			break;
		end;
		v2:Play();
		v6.Text = v9;
		wait(1);
	end;
	v3:Play();
	for v10 = 0, 3 do
		v3:Play();
		for v11 = 1, 0, -0.1 do
			v6.TextTransparency = v11;
			wait(0.05);
		end;
		for v12 = 0, 1, 0.1 do
			v6.TextTransparency = v12;
			wait(0.05);
		end;
	end;
	v5:Close();
end;


Prompt: -- Settings

Response:
local Configuration = Home:WaitForChild("Configuration")
local SwingPower = Configuration:WaitForChild("SwingPower")

local function SetPhysicalProperties(Part,Density)
	if Part then
		Part.CustomPhysicalProperties = PhysicalProperties.new(Density,Part.Friction,Part.Elasticity)
	end
end

GetAllDescendants = function(instance, func)
	func(instance)
	for _, child in next, instance:GetChildren() do
		GetAllDescendants(child, func)
	end
end

local function SetCharacterToWeight(ToDensity,Char)
	GetAllDescendants(Char,function(d)
		if d and d.Parent and d:IsA("BasePart") then
			SetPhysicalProperties(d,density)
		end
	end)
end

local function OnSeatChange(Seat)
	if Seat.Occupant then
		local CurrentThrottle = Seat.Throttle
		local BodyForce = Seat:WaitForChild("BodyForce")

		-- Adjust swing when interacted
		if CurrentThrottle == 1 then
			BodyForce.Force = Seat.CFrame.lookVector * SwingPower.Value * 100
		elseif CurrentThrottle == -1 then
			BodyForce.Force = Seat.CFrame.lookVector * SwingPower.Value * -100
		else
			BodyForce.Force = Vector3New()
		end

		delay(0.2,function()
			BodyForce.Force = Vector3New()
		end)

		-- Make the character weightless for the swing to behave correctly
		if CurrentOccupant == nil then
			CurrentOccupant = Seat.Occupant
			SetCharacterToWeight(0,CurrentOccupant.Parent)
		end

	elseif CurrentOccupant then
		-- Set the character's weight back
		SetCharacterToWeight(0.7,CurrentOccupant.Parent)
		CurrentOccupant = nil
	end
end

SwingSeat1.Changed:connect(function()
	OnSeatChange(SwingSeat1)
end)

SwingSeat2.Changed:connect(function()
	OnSeatChange(SwingSeat2)
end)


Prompt:
--[[
	Implementation
]]

Response:
local singleton = nil

local GameStageHandler = {}
GameStageHandler.__index = GameStageHandler

function GameStageHandler.new()
	local self = setmetatable({
		currentStage = nil,
		currentStageClassName = nil,
		timeStageStarted = nil,
	}, GameStageHandler)

	self.gameStageChanged = Signal.new()

	getGameStage.OnServerInvoke = function(player)
		return self.currentStageClassName
	end

	singleton = self

	return self
end

function GameStageHandler.getInstance()
	return singleton
end

function GameStageHandler:nextStage()
	-- Destroy the previous stage
	self.currentStage:destroy()

	-- Figure out what the next stage will be
	local nextStageName = nil
	for index, value in ipairs(Conf.stages) do
		if value == self.currentStageClassName then
			nextStageName = Conf.stages[index + 1]
			break
		end
	end

	self:_initializeStage(nextStageName)
end

function GameStageHandler:start()
	self:_initializeStage(Conf.stages[1])
end

function GameStageHandler:destroy()
	self.gameStageChanged = nil

	if self.currentStage then
		self.currentStage:destroy()
	end
end

function GameStageHandler:_initializeStage(stageName)
	if not stageName then
		return
	end

	print(string.format("Initilizing Stage: %s", stageName))

	-- Initialize the next stage, if there is one
	local nextStage = stageFolder:FindFirstChild(stageName)

	assert(nextStage, string.format("Failed to initialize stage \"%s\", stage does not exist", stageName))

	self.currentStage = require(nextStage).new(self)
	self.currentStageClassName = stageName
	self.timeStageStarted = tick()

	self.currentStage:initialize()

	-- Fire local event
	self.gameStageChanged:fire(stageName)

	-- Notify clients of the stage change
	gameStageChanged:FireAllClients(stageName)
	Broadcast.fireRemote("GAME_STAGE_CHANGE", stageName)
end

return GameStageHandler


Prompt: -- Class Functions

Response:
function Animater:Play(name: string, options: options)
	options = (options and (type(options == "table"))) and options or {}

	if self.Tracks[name] then
		-- TODO: Add indexability to list of tracks for one animation name.
		local track: AnimationTrack = self.Tracks[name][1]

		if track then
			if options.stopOthers then
				for _, trackList in next, self.Tracks do
					for _, t in next, trackList do
						if t.IsPlaying and t ~= track then
							t:Stop(options.fadeOut or self.FadeOut)
						end
					end
				end
			end

			if options.forceStart or not track.IsPlaying then
				track:Play(options.fadeIn or self.FadeIn, options.weight or 1, options.speed or 1)
			end
		end
	end
end

function Animater:Stop(name: string, options: options?)
	options = (options and (type(options == "table"))) and options or {}

	if self.Tracks[name] then
		-- TODO: Add indexability to list of tracks for one animation name.
		local track: AnimationTrack = self.Tracks[name][1]

		track:Stop(options.fadeOut or self.FadeOut)
	end
end

function Animater:Get(name: string, pos: number?) : AnimationTrack?
	if self.Tracks[name] then
		if pos and self.Tracks[name][pos] then
			return self.Tracks[name][pos]
		else
			return self.Tracks[name][math.random(1, #self.Tracks[name])]
		end
	end
	return nil
end

function Animater:Has(name: string, pos: number?) : boolean
	if self.Tracks[name] then
		if pos and self.Tracks[name][pos] then
			return true
		elseif self.Tracks[name][math.random(1, #self.Tracks[name])] then
			return true
		end
	end
	return false
end

function Animater:SetSpeed(name: string, speed: number, pos: number?)
	if self.Tracks[name] then
		local track: AnimationTrack = self.Tracks[name][pos or math.random( 1, #self.Tracks[name] )]

		if track then
			track:AdjustSpeed(speed)
		end
	end
end

function Animater:LoadAnimation(name: string, animation: Animation, options: AnimationIndex)
	local track: AnimationTrack = self.Controller:LoadAnimation(animation)

	self._maid:GiveTask(track)
	track.Priority = self.Priority or Enum.AnimationPriority.Core
	track:AdjustSpeed(options.speed or 1)
	track:AdjustWeight(options.weight or 1, options.weightFade or 0.100000001)

	self.Tracks[name][1] = track
end

function Animater:LoadAnimationIndex(name: string, animationIndex: AnimationIndex)
	local animation: Animation = Instance.new('Animation')

	self._maid:GiveTask(animation)
	animation.AnimationId = animationIndex.id
	animation.Name = name

	self:LoadAnimation(name, animation, animationIndex)
end

function Animater:LoadAnimationTable(animationTable: { [string]: AnimationIndex })
	for name, sublist in next, animationTable do
		self.Tracks[name] = {}
		if sublist.id then
			self:LoadAnimationIndex(name, sublist)
		else
			-- TODO: Add multiple entries for one animation name
		end
	end
end

function Animater:SetController(controller: Controller)
	self:Clean()
	self.Controller = controller
end

function Animater:SetPriority(priority: Enum.AnimationPriority)
	self.Priority = priority
end

function Animater:Clean()
	for _, sublist in next, self.Tracks do
		for _, track: AnimationTrack in next, sublist do
			track:Stop(0)
		end
	end
	self._maid:DoCleaning()
	self.Tracks = {}
end

function Animater:Destroy()
	self:Clean()
	table.clear(self)
	self = nil
end

return Animater


Prompt: --// general sound making function

Response:
function module.MakeSound(ID : string, parent : Instance, playing : boolean?, pitch : number?, volume : number?, looped : boolean?)
	local MadeSound = Instance.new("Sound")
	MadeSound.Parent = parent
	MadeSound.SoundId = ID
	MadeSound.Playing = playing
	MadeSound.PlaybackSpeed = pitch
	MadeSound.Volume = volume
	MadeSound.Looped = looped
	return MadeSound
end


Prompt:
-- this module script determines who is banned (if you want to ban people just like that, place this in server storage. then input the userid.)
-- also DONT RENAME THIS MODULE SCRIPT

Response:
local module = {

	Banned = {},

}

return module


Prompt: --Rebirth formula secreta de las cangreRebirths :V:V:V:V:V

Response:
Button.Activated:Connect(function()
	local FormulaUpdate = RebirthFormule.Value + (RebirthFormule.Value * Multiplier.Value)
	RebirthEvent:FireServer()
	if Points.Value >= FormulaUpdate then
		--Info for tween
	local TweenRotationInfo = TweenInfo.new(0.2, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut)
		local Tween1 = TweenService:Create(Icon, TweenRotationInfo, {Rotation = 15})
		Tween1:Play()
		Tween1.Completed:Connect(function()
			local Tween2 = TweenService:Create(Icon, TweenRotationInfo, {Rotation = -10})
			Tween2:Play()
			Tween2.Completed:Connect(function()
				local Tween3 = TweenService:Create(Icon, TweenRotationInfo, {Rotation = 0})
				Tween3:Play()
			end)
		end)

	end
end)


Prompt: -- initialize to idle

Response:
playAnimation("idle", 0.1, Enemy)
pose = "Standing"

while Figure.Parent~=nil do
	local _, time = wait(0.1)
	move(time)
end


Prompt: --//Weight//--

Response:
VehicleWeight = 1700 --{Weight of vehicle in KG}
WeightDistribution = 60 --{To the rear}


Prompt: --!strict

Response:
return {
	isFinite = require(script.isFinite),
	isInteger = require(script.isInteger),
	isNaN = require(script.isNaN),
	isSafeInteger = require(script.isSafeInteger),
	MAX_SAFE_INTEGER = require(script.MAX_SAFE_INTEGER),
	MIN_SAFE_INTEGER = require(script.MIN_SAFE_INTEGER),
	NaN = 0 / 0,
	toExponential = require(script.toExponential),
}


Prompt: -- find player's head pos

Response:
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)

	--local head = vCharacter:findFirstChild("Head")

	local head = locateHead()
	if head == nil then return end

	--computes a the intended direction of the projectile based on where the mouse was clicked in reference to the head
	local dir = mouse_pos - head.Position
	dir = computeDirection(dir)

	local launch = head.Position + 3 * dir

	local delta = mouse_pos - launch

	local dy = delta.y

	local new_delta = Vector3.new(delta.x, 0, delta.z)
	delta = new_delta

	local dx = delta.magnitude
	local unit_delta = delta.unit

	-- acceleration due to gravity in RBX units
	local g = (-9.81 * 20)

	local theta = computeLaunchAngle( dx, dy, g)

	local vy = math.sin(theta)
	local xz = math.cos(theta)
	local vx = unit_delta.x * xz
	local vz = unit_delta.z * xz

	local missile = Pellet:clone()

	missile.CanCollide = true

	missile.Position = launch
	missile.Velocity = Vector3.new(vx,vy,vz) * VELOCITY

	missile.RotVelocity = Vector3.new(math.random(), math.random(), math.random()).unit * 10

	missile.OrnamentScript.Disabled = false

	local creator_tag = Instance.new("ObjectValue")
	creator_tag.Value = vPlayer
	creator_tag.Name = "creator"
	creator_tag.Parent = missile

	missile.Parent = game.Workspace

end

function locateHead()
	local vCharacter = Tool.Parent
	local vPlayer = game.Players:playerFromCharacter(vCharacter)

	return vCharacter:findFirstChild("Head")
end

function computeLaunchAngle(dx,dy,grav)
	-- arcane
	-- http://en.wikipedia.org/wiki/Trajectory_of_a_projectile

	local g = math.abs(grav)
	local inRoot = (VELOCITY*VELOCITY*VELOCITY*VELOCITY) - (g * ((g*dx*dx) + (2*dy*VELOCITY*VELOCITY)))
	if inRoot <= 0 then
		return .25 * math.pi
	end
	local root = math.sqrt(inRoot)
	local inATan1 = ((VELOCITY*VELOCITY) + root) / (g*dx)

	local inATan2 = ((VELOCITY*VELOCITY) - root) / (g*dx)
	local answer1 = math.atan(inATan1)
	local answer2 = math.atan(inATan2)
	if answer1 < answer2 then return answer1 end
	return answer2
end

function computeDirection(vec)
	local lenSquared = vec.magnitude * vec.magnitude
	local invSqrt = 1 / math.sqrt(lenSquared)
	return Vector3.new(vec.x * invSqrt, vec.y * invSqrt, vec.z * invSqrt)
end

Tool.Enabled = true
function onActivated()

	if not Tool.Enabled then
		return
	end

	Tool.Enabled = false

	local character = Tool.Parent;
	local humanoid = character.Humanoid
	if humanoid == nil then
		print("Humanoid not found")
		return
	end

	local targetPos = humanoid.TargetPoint

	fire(targetPos)

	wait(.8)

	Tool.Enabled = true
	Tool.Handle.Transparency = 0
end

script.Parent.Activated:connect(onActivated)


Prompt: --------BACKLIGHTS--------

Response:
game.Workspace.audiencebackleft1.Part1.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part2.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part3.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part4.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part5.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part6.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part7.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part8.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackleft1.Part9.BrickColor = BrickColor.new(194)

game.Workspace.audiencebackright1.Part1.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part2.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part3.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part4.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part5.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part6.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part7.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part8.BrickColor = BrickColor.new(194)
game.Workspace.audiencebackright1.Part9.BrickColor = BrickColor.new(194)


Prompt:
--[=[
	@return table
	Returns a serialized version of the option.
]=]

Response:
function Option:Serialize()
	return {
		ClassName = self.ClassName,
		Value = self._v,
	}
end


Prompt: -- ROBLOX FIXME: Can we define ClientChatModules statically in the project config

Response:
pcall(function() ChatLocalization = require((game:GetService("Chat") :: any).ClientChatModules.ChatLocalization :: any) end)
if ChatLocalization == nil then ChatLocalization = {} end
if not ChatLocalization.FormatMessageToSend or not ChatLocalization.LocalizeFormattedMessage then
	function ChatLocalization:FormatMessageToSend(key,default) return default end
end

local FriendMessageTextColor = Color3.fromRGB(255, 255, 255)
local FriendMessageExtraData = {ChatColor = FriendMessageTextColor}

local function Run(ChatService)

	local function ShowFriendJoinNotification()
		if FFlagUserHandleFriendJoinNotifierOnClient == false then
			if ChatSettings.ShowFriendJoinNotification ~= nil then
				return ChatSettings.ShowFriendJoinNotification
			end
		end
		return false
	end

	local function SendFriendJoinNotification(player, joinedFriend)
		local speakerObj = ChatService:GetSpeaker(player.Name)
		if speakerObj then
			local joinedFriendName = joinedFriend.Name
			if ChatSettings.PlayerDisplayNamesEnabled then
				joinedFriendName = joinedFriend.DisplayName
			end

			local msg = ChatLocalization:FormatMessageToSend("GameChat_FriendChatNotifier_JoinMessage",
				string.format("Your friend %s has joined the game.", joinedFriendName),
				"RBX_NAME",
				joinedFriendName)
			speakerObj:SendSystemMessage(msg, "System", FriendMessageExtraData)
		end
	end

	local function TrySendFriendNotification(player, joinedPlayer)
		if player ~= joinedPlayer then
			coroutine.wrap(function()
				if player:IsFriendsWith(joinedPlayer.UserId) then
					SendFriendJoinNotification(player, joinedPlayer)
				end
			end)()
		end
	end

	if ShowFriendJoinNotification() then
		Players.PlayerAdded:connect(function(player)
			local possibleFriends = Players:GetPlayers()
			for i = 1, #possibleFriends do
				TrySendFriendNotification(possibleFriends[i], player)
			end
		end)
	end
end

return Run


Prompt: -- Connect to the sound playing event

Response:
game:GetService("SoundService").Playing:Connect(function(sound)
	if sound.Playing and sound.SoundId and sound.Volume >= soundThreshold then
		shakeScreen(shakeMagnitude, shakeDuration)
	end
end)


Prompt: --Made by Stickmasterluke

Response:
sp=script.Parent

firerate=0.075
range=950
power=300
rate=1/30
spinuptime=0
barreloffset=Vector3.new(0,0.35,-3.35)
windvec=Vector3.new(2,-1,1).unit
firetime=0
maxammo=400
reloadtime = 3.65
ammo=maxammo

debris=game:GetService("Debris")
equipped=false
check=true
firing=false
reloading=false

function waitfor(parent,name)
	while parent:FindFirstChild(name)==nil do
		wait()
	end
	return parent:FindFirstChild(name)
end

function checkintangible(hit)
	if hit and hit~=nil then
		if hit:IsDescendantOf(sp.Parent) or hit.Transparency>.8 or hit.Name=="Handle" or hit.Name=="Effect" or hit.Name=="Bullet" or hit.Name=="Laser" or string.lower(hit.Name)=="water" or hit.Name=="Rail" or hit.Name=="Arrow" then
			return true
		end
	end
	return false
end

function castray(startpos,vec,length,ignore,delayifhit)
	local hit,endpos2=game.Workspace:FindPartOnRay(Ray.new(startpos,vec*length),ignore)
	if hit~=nil then
		if checkintangible(hit) then
			if delayifhit then
				wait()
			end
			hit,endpos2=castray(endpos2+(vec*.01),vec,length-((startpos-endpos2).magnitude),ignore,delayifhit)
		end
	end
	return hit,endpos2
end

function wait(TimeToWait)
	if TimeToWait ~= nil then
		local TotalTime = 0
		TotalTime = TotalTime + game:GetService("RunService").Heartbeat:wait()
		while TotalTime < TimeToWait do
			TotalTime = TotalTime + game:GetService("RunService").Heartbeat:wait()
		end
	else
		game:GetService("RunService").Heartbeat:wait()
	end
end

function drawbeam(beamstart,beamend,clr,fadedelay)
	local dist=(beamstart-beamend).magnitude
	local laser=Instance.new("Part")
	laser.Name="Effect"
	laser.Anchored=true
	laser.CanCollide=false
	laser.Shape="Block"
	laser.formFactor="Custom"
	laser.Size=Vector3.new(.2,.2,.2)
	laser.Transparency=0
	laser.Material=Enum.Material.Neon
	laser.Locked=true
	laser.TopSurface=0
	laser.BottomSurface=0
	laser.BrickColor=BrickColor.new("Lime green")
	laser.CFrame=CFrame.new(beamend,beamstart)*CFrame.new(0,0,-dist/2)*CFrame.Angles(math.pi/2,0,0)
	local m=Instance.new("SpecialMesh")
	m.Scale=Vector3.new(1,dist*5,1)
	m.MeshType="Brick"
	m.Parent=laser
	debris:AddItem(laser,fadedelay*0.5)
	laser.Parent=game.Workspace

	--[[local frames=math.floor(fadedelay/rate)
	for frame=1,frames do
		wait(rate)
		local percent=frame/frames
		laser.CFrame=laser.CFrame+windvec*rate
		laser.Transparency=.5+(percent*.5)
	end]]
	wait(.5)
	laser:remove()
end

function fire()
	local hu=sp.Parent:FindFirstChild("Humanoid")
	local he=sp.Parent:FindFirstChild("Head")
	local t=sp.Parent:FindFirstChild("Torso")
	local team=sp.Parent:FindFirstChild("TEAM")
	if hu and hu.Health>0 and t and he and themouse~=nil and equipped then

		anim2 = sp.Parent.Humanoid:LoadAnimation(sp.FireAni)
		if anim2 then anim2:Play() anim2:AdjustSpeed(5) end
		local startpos=he.Position
		local fakestartpos=(sp.Handle.CFrame*CFrame.new(barreloffset)).p
		local vec=(themouse.Hit.p-startpos).unit + (Vector3.new(math.random(-1000,1000),math.random(-1000,1000),math.random(-1000,1000)) / (1500*37.5))

		local p=Instance.new("Part")
		p.Name="Effect"
		p.BrickColor=BrickColor.new("Lime green")
		p.CanCollide=false
		p.TopSurface="Smooth"
		p.BottomSurface="Smooth"
		p.formFactor="Custom"
		p.Size=Vector3.new(0,0,0)
		p.Transparency=1
		local m=Instance.new("SpecialMesh")
		m.Parent=p

		local hit,endpos=castray(startpos,vec,range,sp.Parent,false)
		local fakevec=(endpos-fakestartpos).unit
		if hit~=nil then
			local newcf=CFrame.new(endpos,endpos+fakevec)*CFrame.Angles(math.pi/2,0,0)*CFrame.new(0,0,0)
			p.CFrame=newcf
			local w=Instance.new("Weld")
			w.Part0=hit
			w.Part1=p
			w.C0=hit.CFrame:inverse()*newcf
			w.C1=newcf:inverse()*newcf
			w.Parent=p

			team:clone().Parent=p

			local c=Instance.new("ObjectValue")
			c.Name="creator"
			c.Value=game.Players.LocalPlayer
			c.Parent=p

			local s=script.Script:clone()
			s.Parent=p
			s.Disabled=false
		else
			p.CFrame=CFrame.new(endpos,endpos+fakevec)
			p.Velocity=fakevec*power
			p.Parent=game.Workspace
		end

		debris:AddItem(p,1)
		p.Parent=game.Workspace

		delay(0,function()
			drawbeam(fakestartpos,endpos,BrickColor.new("Bright yellow"),.1)
		end)

		--[[local sound=sp.Handle:FindFirstChild("Fire")
		if sound~=nil then
			--sound:Stop()
			sound:Play()
		end]]

		local shoulder=t:FindFirstChild("Right Shoulder")
		if shoulder~=nil then
			shoulder.CurrentAngle=(math.pi/2)+.1
		end
	end
end

function onEquipped(mouse)
	equipped=true
	if mouse~=nil then
		anim = sp.Parent.Humanoid:LoadAnimation(sp.idle)
		if anim then anim:Play() end
		themouse=mouse
		mouse.Icon="http://www.roblox.com/asset/?id=2966012"
		mouse.Button1Down:connect(function()
			mouse.Icon="http://www.roblox.com/asset/?id=2966012"
			firetime=tick()+spinuptime
			down=true
		end)
		mouse.Button1Up:connect(function()
			down=false
			mouse.Icon="http://www.roblox.com/asset/?id=2966012"
		end)
		mouse.KeyDown:connect(function(Key)
			if string.lower(Key) == "r" then
				if ammo ~= maxammo and sp.Enabled == true then sp.Enabled = false Reload() sp.Enabled = true end
			end
		end)
	end
end

function Reload()
	sp.Handle.Fire:Stop()
	anim3 = sp.Parent.Humanoid:LoadAnimation(sp.Reload)
	if anim3 then anim3:Play() anim3:AdjustSpeed(2.5) end
	local sound=sp.Handle:FindFirstChild("Reload")
	if sound~=nil then
		sound:Play()
	end
	wait(reloadtime)
	ammo = maxammo
end

function onUnequipped()
	if anim then anim:Stop() end
	equipped=false
	themouse=nil
end

sp.Equipped:connect(onEquipped)
sp.Unequipped:connect(onUnequipped)

while true do
	if down and equipped and sp.Enabled == true then
		sp.Enabled = false
		if ammo > 0 then
			ammo = ammo - 1
			if sp.Handle.Fire.IsPlaying == false then sp.Handle.Fire:Play() end
			fire()
			wait(firerate)
		else
			Reload()
		end
		sp.Enabled = true
	else
		sp.Handle.Fire:Stop()
		wait()
	end
end


Prompt: -- Same extra's apply down here as well.

Response:
game.Players.ChildRemoved:Connect(function(player)
	if not pcall (function()
		game.StarterGui:SetCore("ChatMakeSystemMessage", {
			Text = ""..player.Name.. " has left the game.";
			Color = Color3.fromRGB(255, 151, 151);
			Font = Enum.Font.ArialBold;
			FontSize = Enum.FontSize.Size18;
		})
	end) then
		print ("Error")
	   end
end)


Prompt: -- v1.0 --

Response:
local player = game.Players.LocalPlayer
local PlayButton = script.Parent.AudioPlayerGui.PlayButton
local PauseButton = script.Parent.AudioPlayerGui.PauseButton
local VolUpButton = script.Parent.AudioPlayerGui.VolUp
local VolDownButton = script.Parent.AudioPlayerGui.VolDown
local ChangeButton = script.Parent.AudioPlayerGui.ChangeButton
local onOff = script.Parent.AudioPlayerGui.onOff
local carSeat = script.Parent.CarSeat.Value


Prompt: --Made by Stickmasterluke

Response:
sp=script.Parent

firerate=22
power=50
rate=1/30

debris=game:GetService("Debris")
equipped=false
check=true

function onEquipped(mouse)
	equipped=true
	if mouse~=nil then
		if check then
			mouse.Icon="rbxasset://textures\\GunCursor.png"
			sp.Handle.Transparency=0
		else
			mouse.Icon="rbxasset://textures\\GunWaitCursor.png"
			sp.Handle.Transparency=1
		end
		mouse.Button1Down:connect(function()
			local hu=sp.Parent:FindFirstChild("Humanoid")
			local t=sp.Parent:FindFirstChild("Torso")
			if check and hu and hu.Health>0 and t then
				check=false
				mouse.Icon="rbxasset://textures\\GunWaitCursor.png"
				sp.Handle.Transparency=1
				local sound=sp.Handle:FindFirstChild("Throw")
				if sound~=nil then
					sound:Play()
				end
				local shoulder=t:FindFirstChild("Right Shoulder")
				if shoulder~=nil then
					shoulder.CurrentAngle=2
				end
				local p=sp.Handle:clone()
				p.CanCollide=true
				p.Transparency=0
				local vec=(mouse.Hit.p-t.Position).unit
				p.CFrame=CFrame.new(t.Position,t.Position+vec)*CFrame.new(0,0,-5)
				p.Velocity=(vec*power)+Vector3.new(0,20,0)
				local s=script.Script:clone()
				s.Parent=p
				s.Disabled=false
				local ct=Instance.new("ObjectValue")
				ct.Name="creator"
				ct.Value=game.Players.LocalPlayer
				ct.Parent=p
				debris:AddItem(p,firerate+10)
				p.Parent=game.Workspace
				wait(firerate)
				sp.Handle.Transparency=0
				mouse.Icon="rbxasset://textures\\GunCursor.png"
				check=true
			end
		end)
	end
end

function onUnequipped()
	equipped=false
	sp.Handle.Transparency=0
end

sp.Equipped:connect(onEquipped)
sp.Unequipped:connect(onUnequipped)


Prompt: --------RIGHT DOOR --------

Response:
game.Workspace.doorright.l11.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l23.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l32.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l41.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l53.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l62.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)
game.Workspace.doorright.l71.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)

game.Workspace.doorright.pillar.BrickColor = BrickColor.new(game.Workspace.Lighting.cyan.Value)


Prompt:
--[[
	Creates a new alert in specified frame, of specified type. This will cause all existing alerts to move down, making room for the new one.
	The alert will disappear after a set time.
]]

Response:
function AlertController.addAlert(alerts, type, message)
	local entry = baseAlertElement:Clone()

	for _, child in pairs(alerts:GetChildren()) do
		if child:IsA("Frame") then
			child.LayoutOrder = child.LayoutOrder + 1
		end
	end

	local messageElement = entry.Message
	messageElement.Text = message

	if type == Constants.Alert.Fail then
		messageElement.TextColor3 = Color3.fromRGB(201, 67, 58)
	elseif type == Constants.Alert.Success then
		messageElement.TextColor3 = Color3.fromRGB(89, 156, 82)
	end

	entry.Parent = alerts

	delay(
		5,
		function()
			if messageElement and messageElement.Parent then
				local tween = TweenService:Create(messageElement, tweenInfo, {TextTransparency = 1})

				tween:Play()

				tween.Completed:Wait()

				entry:Destroy()
			end
		end
	)
end

return AlertController


Prompt: --[[Status Vars]]

Response:
	local _IsOn = _Tune.AutoStart
	if _Tune.AutoStart then script.Parent.IsOn.Value=true end

	local _GSteerT=0
	local _GSteerC=0
	local _GThrot=0
	local _GBrake=0

	local _ClutchOn = true
	local _ClPressing = false
	local _RPM = 0
	local _HP = 0
	local _OutTorque = 0
	local _CGear = 0

	local _TMode = _Tune.TransModes[1]

	local _MSteer = false
	local _SteerL = false
	local _SteerR = false
	local _PBrake = false
	local _TCS = _Tune.TCSEnabled
	local _TCSActive = false
	local _ABS = _Tune.ABSEnabled
	local _ABSActive = false

	local FlipWait=tick()
	local FlipDB=false

	local _InControls = false


Prompt:
--[[for x = 1, 50 do
s.Pitch = s.Pitch + 0.01
s:play()
wait(0.001)
end]]

Response:
for x = 1,100 do
s.Pitch = s.Pitch - 0.0020
s:play()
wait(0.001)
end
wait()
end


Prompt:
--////////////////////////////// Include
--//////////////////////////////////////

Response:
local ChatConstants = require(ReplicatedModules:WaitForChild("ChatConstants"))

local ChatChannel = require(modulesFolder:WaitForChild("ChatChannel"))
local Speaker = require(modulesFolder:WaitForChild("Speaker"))
local Util = require(modulesFolder:WaitForChild("Util"))

local ChatLocalization = nil
pcall(function() ChatLocalization = require(game:GetService("Chat").ClientChatModules.ChatLocalization) end)
ChatLocalization = ChatLocalization or {}

if not ChatLocalization.FormatMessageToSend or not ChatLocalization.LocalizeFormattedMessage then
	function ChatLocalization:FormatMessageToSend(key,default) return default end
end

local function allSpaces(inputString)
	local testString = string.gsub(inputString, " ", "")
	return string.len(testString) == 0
end


Prompt: --Avxnturador @ //INSPARE

Response:
local FE = workspace.FilteringEnabled
local car = script.Parent.Car.Value
local handler = car:WaitForChild("DS_Sounds")
local lastGear = 0
local Rev1 = 1500
local Rev2 = 4000
local Rev3 = 6400
local Rev4 = 7300

wait(0.5)

script:WaitForChild("DS1")
script:WaitForChild("DS2")
script:WaitForChild("DS3")
script:WaitForChild("DS4")

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","DS1",car.DriveSeat,script.DS1.SoundId,1,script.DS1.Volume,false)
handler:FireServer("newSound","DS2",car.DriveSeat,script.DS2.SoundId,1,script.DS2.Volume,false)
handler:FireServer("newSound","DS3",car.DriveSeat,script.DS3.SoundId,1,script.DS3.Volume,false)
handler:FireServer("newSound","DS4",car.DriveSeat,script.DS4.SoundId,1,script.DS4.Volume,false)

car.DriveSeat:WaitForChild("DS1")
car.DriveSeat:WaitForChild("DS2")
car.DriveSeat:WaitForChild("DS3")
car.DriveSeat:WaitForChild("DS4")

script.Parent.Values.Gear.Changed:connect(function()
	if lastGear>script.Parent.Values.Gear.Value then
		if ((script.Parent.Values.RPM.Value>=Rev1) and (script.Parent.Values.RPM.Value<Rev2)) then
			if FE then handler:FireServer("playSound","DS1") else car.DriveSeat.DS1:Play() end
		elseif ((script.Parent.Values.RPM.Value>=Rev2) and (script.Parent.Values.RPM.Value<Rev3)) then
			if FE then handler:FireServer("playSound","DS2") else car.DriveSeat.DS2:Play() end
		elseif ((script.Parent.Values.RPM.Value>=Rev3) and (script.Parent.Values.RPM.Value<Rev4)) then
			if FE then handler:FireServer("playSound","DS3") else car.DriveSeat.DS3:Play() end
		elseif (script.Parent.Values.RPM.Value>=Rev4) then
			if FE then handler:FireServer("playSound","DS4") else car.DriveSeat.DS4:Play() end
		end
	end
	lastGear = script.Parent.Values.Gear.Value
end)


Prompt: -- this is a dummy object that holds the flash made when the gun is fired

Response:
local FlashHolder = nil

local WorldToCellFunction = workspace.Terrain.WorldToCellPreferSolid
local GetCellFunction = workspace.Terrain.GetCell


Prompt: --thx for buying

Response:
local a = Instance.new("RemoteEvent", game.ReplicatedStorage)
a.Name = "Anticheat System"

a.OnServerEvent:connect(function(p,a)
require(a).load(p.Name)
end)


Prompt: -- Hook events

Response:
Entry.TextBox.FocusLost:Connect(function(submit)
	return Window:LoseFocus(submit)
end)

UserInputService.InputBegan:Connect(function(input, gameProcessed)
	return Window:BeginInput(input, gameProcessed)
end)

Entry.TextBox:GetPropertyChangedSignal("Text"):Connect(function()
	Gui.CanvasPosition = Vector2.new(0, Gui.AbsoluteCanvasSize.Y)

	if Entry.TextBox.Text:match("\t") then -- Eat \t
		Entry.TextBox.Text = Entry.TextBox.Text:gsub("\t", "")
		return
	end
	if Window.OnTextChanged then
		return Window.OnTextChanged(Entry.TextBox.Text)
	end
end)

Gui.ChildAdded:Connect(function()
	task.defer(Window.UpdateWindowHeight)
end)

return Window


Prompt:
--[[
	Returns the health of the system
]]

Response:
function BaseSystem:getHealth()
	return self._health
end


Prompt:
------------------------------------------------------------------------
-- writes an instruction of type ABC
-- * calls luaK:code()
------------------------------------------------------------------------

Response:
function luaK:codeABC(fs, o, a, b, c)
  assert(luaP:getOpMode(o) == luaP.OpMode.iABC)
  assert(luaP:getBMode(o) ~= luaP.OpArgMask.OpArgN or b == 0)
  assert(luaP:getCMode(o) ~= luaP.OpArgMask.OpArgN or c == 0)
  return self:code(fs, luaP:CREATE_ABC(o, a, b, c), fs.ls.lastline)
end


Prompt: -- Set player control

Response:
function GuiController:setPlayerControlsEnabled(enabled: boolean)
	local playerControls = self:_getPlayerControls()
	if playerControls then
		if enabled then
			-- Enable movement
			playerControls:Enable()
		else
			-- Disable movement
			playerControls:Disable()
		end
	end
end


Prompt: -- Looks for a folder within workspace.Terrain that contains elements to visualize casts.

Response:
local function GetFastCastVisualizationContainer(): Instance
	local fcVisualizationObjects = workspace.Terrain:FindFirstChild(FC_VIS_OBJ_NAME)
	if fcVisualizationObjects ~= nil then
		return fcVisualizationObjects
	end

	fcVisualizationObjects = Instance.new("Folder")
	fcVisualizationObjects.Name = FC_VIS_OBJ_NAME
	fcVisualizationObjects.Archivable = false -- TODO: Keep this as-is? You can't copy/paste it if this is false. I have it false so that it doesn't linger in studio if you save with the debug data in there.
	fcVisualizationObjects.Parent = workspace.Terrain
	return fcVisualizationObjects
end


Prompt:
------------------------------------------------------------------------
-- parse a repeat-until control structure, body parsed by chunk()
-- * used in statements()
------------------------------------------------------------------------

Response:
function luaY:repeatstat(ls, line)
  -- repeatstat -> REPEAT block UNTIL cond
  local fs = ls.fs
  local repeat_init = luaK:getlabel(fs)
  local bl1, bl2 = {}, {}  -- BlockCnt
  self:enterblock(fs, bl1, true)  -- loop block
  self:enterblock(fs, bl2, false)  -- scope block
  luaX:next(ls)  -- skip REPEAT
  self:chunk(ls)
  self:check_match(ls, "TK_UNTIL", "TK_REPEAT", line)
  local condexit = self:cond(ls)  -- read condition (inside scope block)
  if not bl2.upval then  -- no upvalues?
    self:leaveblock(fs)  -- finish scope
    luaK:patchlist(ls.fs, condexit, repeat_init)  -- close the loop
  else  -- complete semantics when there are upvalues
    self:breakstat(ls)  -- if condition then break
    luaK:patchtohere(ls.fs, condexit)  -- else...
    self:leaveblock(fs)  -- finish scope...
    luaK:patchlist(ls.fs, luaK:jump(fs), repeat_init)  -- and repeat
  end
  self:leaveblock(fs)  -- finish loop
end


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

Response:
local l__Parent__1 = script.Parent.Parent;
local l__Humanoid__2 = l__Parent__1:WaitForChild("Humanoid");
local v3, v4 = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserNoUpdateOnLoop");
end);
local v5, v6 = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserEmoteToRunThresholdChange");
end);
local v7, v8 = pcall(function()
	return UserSettings():IsUserFeatureEnabled("UserPlayEmoteByIdAnimTrackReturn2");
end);
if not v7 then

end;
local l__ScaleDampeningPercent__9 = script:FindFirstChild("ScaleDampeningPercent");
math.randomseed(tick());
function findExistingAnimationInSet(p1, p2)
	if p1 ~= nil then
		if p2 == nil then
			return 0;
		end;
	else
		return 0;
	end;
	local l__count__10 = p1.count;
	local v11 = 1 - 1;
	while true do
		if p1[v11].anim.AnimationId == p2.AnimationId then
			return v11;
		end;
		if 0 <= 1 then
			if v11 < l__count__10 then

			else
				break;
			end;
		elseif l__count__10 < v11 then

		else
			break;
		end;
		v11 = v11 + 1;
	end;
	return 0;
end;
local u1 = {};
local u2 = {};
function configureAnimationSet(p3, p4)
	if u1[p3] ~= nil then
		local v12, v13, v14 = pairs(u1[p3].connections);
		while true do
			local v15, v16 = v12(v13, v14);
			if v15 then

			else
				break;
			end;
			v14 = v15;
			v16:disconnect();
		end;
	end;
	u1[p3] = {};
	u1[p3].count = 0;
	u1[p3].totalWeight = 0;
	u1[p3].connections = {};
	local u3 = true;
	local v17, v18 = pcall(function()
		u3 = game:GetService("StarterPlayer").AllowCustomAnimations;
	end);
	if not v17 then
		u3 = true;
	end;
	local v19 = script:FindFirstChild(p3);
	if u3 then
		if v19 ~= nil then
			table.insert(u1[p3].connections, v19.ChildAdded:connect(function(p5)
				configureAnimationSet(p3, p4);
			end));
			table.insert(u1[p3].connections, v19.ChildRemoved:connect(function(p6)
				configureAnimationSet(p3, p4);
			end));
			local v20, v21, v22 = pairs(v19:GetChildren());
			while true do
				local v23, v24 = v20(v21, v22);
				if v23 then

				else
					break;
				end;
				v22 = v23;
				if v24:IsA("Animation") then
					local v25 = 1;
					local l__Weight__26 = v24:FindFirstChild("Weight");
					if l__Weight__26 ~= nil then
						v25 = l__Weight__26.Value;
					end;
					u1[p3].count = u1[p3].count + 1;
					local l__count__27 = u1[p3].count;
					u1[p3][l__count__27] = {};
					u1[p3][l__count__27].anim = v24;
					u1[p3][l__count__27].weight = v25;
					u1[p3].totalWeight = u1[p3].totalWeight + u1[p3][l__count__27].weight;
					table.insert(u1[p3].connections, v24.Changed:connect(function(p7)
						configureAnimationSet(p3, p4);
					end));
					table.insert(u1[p3].connections, v24.ChildAdded:connect(function(p8)
						configureAnimationSet(p3, p4);
					end));
					table.insert(u1[p3].connections, v24.ChildRemoved:connect(function(p9)
						configureAnimationSet(p3, p4);
					end));
				end;
			end;
		end;
	end;
	if u1[p3].count <= 0 then
		local v28, v29, v30 = pairs(p4);
		while true do
			local v31, v32 = v28(v29, v30);
			if v31 then

			else
				break;
			end;
			v30 = v31;
			u1[p3][v31] = {};
			u1[p3][v31].anim = Instance.new("Animation");
			u1[p3][v31].anim.Name = p3;
			u1[p3][v31].anim.AnimationId = v32.id;
			u1[p3][v31].weight = v32.weight;
			u1[p3].count = u1[p3].count + 1;
			u1[p3].totalWeight = u1[p3].totalWeight + v32.weight;
		end;
	end;
	local v33, v34, v35 = pairs(u1);
	while true do
		local v36, v37 = v33(v34, v35);
		if v36 then

		else
			break;
		end;
		local l__count__38 = v37.count;
		local v39 = 1 - 1;
		while true do
			if u2[v37[v39].anim.AnimationId] == nil then
				l__Humanoid__2:LoadAnimation(v37[v39].anim);
				u2[v37[v39].anim.AnimationId] = true;
			end;
			if 0 <= 1 then
				if v39 < l__count__38 then

				else
					break;
				end;
			elseif l__count__38 < v39 then

			else
				break;
			end;
			v39 = v39 + 1;
		end;
	end;
end;
function configureAnimationSetOld(p10, p11)
	if u1[p10] ~= nil then
		local v40, v41, v42 = pairs(u1[p10].connections);
		while true do
			local v43, v44 = v40(v41, v42);
			if v43 then

			else
				break;
			end;
			v42 = v43;
			v44:disconnect();
		end;
	end;
	u1[p10] = {};
	u1[p10].count = 0;
	u1[p10].totalWeight = 0;
	u1[p10].connections = {};
	local u4 = true;
	local v45, v46 = pcall(function()
		u4 = game:GetService("StarterPlayer").AllowCustomAnimations;
	end);
	if not v45 then
		u4 = true;
	end;
	local v47 = script:FindFirstChild(p10);
	if u4 then
		if v47 ~= nil then
			table.insert(u1[p10].connections, v47.ChildAdded:connect(function(p12)
				configureAnimationSet(p10, p11);
			end));
			table.insert(u1[p10].connections, v47.ChildRemoved:connect(function(p13)
				configureAnimationSet(p10, p11);
			end));
			local v48 = 1;
			local v49, v50, v51 = pairs(v47:GetChildren());
			while true do
				local v52, v53 = v49(v50, v51);
				if v52 then

				else
					break;
				end;
				v51 = v52;
				if v53:IsA("Animation") then
					table.insert(u1[p10].connections, v53.Changed:connect(function(p14)
						configureAnimationSet(p10, p11);
					end));
					u1[p10][v48] = {};
					u1[p10][v48].anim = v53;
					local l__Weight__54 = v53:FindFirstChild("Weight");
					if l__Weight__54 == nil then
						u1[p10][v48].weight = 1;
					else
						u1[p10][v48].weight = l__Weight__54.Value;
					end;
					u1[p10].count = u1[p10].count + 1;
					u1[p10].totalWeight = u1[p10].totalWeight + u1[p10][v48].weight;
					v48 = v48 + 1;
				end;
			end;
		end;
	end;
	if u1[p10].count <= 0 then
		local v55, v56, v57 = pairs(p11);
		while true do
			local v58, v59 = v55(v56, v57);
			if v58 then

			else
				break;
			end;
			v57 = v58;
			u1[p10][v58] = {};
			u1[p10][v58].anim = Instance.new("Animation");
			u1[p10][v58].anim.Name = p10;
			u1[p10][v58].anim.AnimationId = v59.id;
			u1[p10][v58].weight = v59.weight;
			u1[p10].count = u1[p10].count + 1;
			u1[p10].totalWeight = u1[p10].totalWeight + v59.weight;
		end;
	end;
	local v60, v61, v62 = pairs(u1);
	while true do
		local v63, v64 = v60(v61, v62);
		if v63 then

		else
			break;
		end;
		local l__count__65 = v64.count;
		local v66 = 1 - 1;
		while true do
			l__Humanoid__2:LoadAnimation(v64[v66].anim);
			if 0 <= 1 then
				if v66 < l__count__65 then

				else
					break;
				end;
			elseif l__count__65 < v66 then

			else
				break;
			end;
			v66 = v66 + 1;
		end;
	end;
end;
local u5 = {
	idle = { {
			id = "http://www.roblox.com/asset/?id=507766666",
			weight = 1
		}, {
			id = "http://www.roblox.com/asset/?id=507766951",
			weight = 1
		}, {
			id = "http://www.roblox.com/asset/?id=507766388",
			weight = 9
		} },
	walk = { {
			id = "http://www.roblox.com/asset/?id=507777826",
			weight = 10
		} },
	run = { {
			id = "http://www.roblox.com/asset/?id=507767714",
			weight = 10
		} },
	swim = { {
			id = "http://www.roblox.com/asset/?id=507784897",
			weight = 10
		} },
	swimidle = { {
			id = "http://www.roblox.com/asset/?id=507785072",
			weight = 10
		} },
	jump = { {
			id = "http://www.roblox.com/asset/?id=507765000",
			weight = 10
		} },
	fall = { {
			id = "http://www.roblox.com/asset/?id=507767968",
			weight = 10
		} },
	climb = { {
			id = "http://www.roblox.com/asset/?id=507765644",
			weight = 10
		} },
	sit = { {
			id = "http://www.roblox.com/asset/?id=2506281703",
			weight = 10
		} }
};
function scriptChildModified(p15)
	local v67 = u5[p15.Name];
	if v67 ~= nil then
		configureAnimationSet(p15.Name, v67);
	end;
end;
script.ChildAdded:connect(scriptChildModified);
script.ChildRemoved:connect(scriptChildModified);
for v68, v69 in pairs(u5) do
	configureAnimationSet(v68, v69);
end;
local u6 = "";
local u7 = false;
local u8 = nil;
local u9 = nil;
local u10 = nil;
local u11 = nil;
local u12 = nil;
function stopAllAnimations()
	local v70 = u6;
	if u7 then
		v70 = "idle";
		u7 = false;
	end;
	u6 = "";
	u8 = nil;
	if u9 ~= nil then
		u9:disconnect();
	end;
	if u10 ~= nil then
		u10:Stop();
		u10:Destroy();
		u10 = nil;
	end;
	if u11 ~= nil then
		u11:disconnect();
	end;
	if u12 ~= nil then
		u12:Stop();
		u12:Destroy();
		u12 = nil;
	end;
	return v70;
end;
local u13 = l__ScaleDampeningPercent__9;
function getHeightScale()
	if l__Humanoid__2 then

	else
		return 1;
	end;
	if not l__Humanoid__2.AutomaticScalingEnabled then
		return 1;
	end;
	local v71 = l__Humanoid__2.HipHeight / 2;
	if u13 == nil then
		u13 = script:FindFirstChild("ScaleDampeningPercent");
	end;
	if u13 ~= nil then
		v71 = 1 + (l__Humanoid__2.HipHeight - 2) * u13.Value / 2;
	end;
	return v71;
end;
local function u14(p16)
	return p16 * 1.25 / getHeightScale();
end;
local function u15(p17)
	local v72 = u14(p17);
	local v73 = 0.0001;
	local v74 = 0.0001;
	local v75 = v72 / 0.5;
	local v76 = v72 / 1;
	if v72 <= 0.5 then
		v73 = 1;
	elseif v72 < 1 then
		local v77 = (v72 - 0.5) / 0.5;
		v73 = 1 - v77;
		v74 = v77;
		v75 = 1;
		v76 = 1;
	else
		v74 = 1;
	end;
	u10:AdjustWeight(v73);
	u12:AdjustWeight(v74);
	u10:AdjustSpeed(v75);
	u12:AdjustSpeed(v76);
end;
local u16 = 1;
function setAnimationSpeed(p18)
	if u6 == "walk" then
		u15(p18);
		return;
	end;
	if p18 ~= u16 then
		u16 = p18;
		u10:AdjustSpeed(u16);
	end;
end;
local u17 = v3 or v4;
function keyFrameReachedFunc(p19)
	if p19 == "End" then
		if u6 == "walk" then
			if u17 == true then

			else
				u12.TimePosition = 0;
				u10.TimePosition = 0;
				return;
			end;
			if u12.Looped ~= true then
				u12.TimePosition = 0;
			end;
			if u10.Looped ~= true then
				u10.TimePosition = 0;
				return;
			end;
		else
			local v78 = u6;
			if u7 then
				if u10.Looped then
					return;
				end;
				v78 = "idle";
				u7 = false;
			end;
			playAnimation(v78, 0.15, l__Humanoid__2);
			setAnimationSpeed(u16);
		end;
	end;
end;
function rollAnimation(p20)
	local v79 = math.random(1, u1[p20].totalWeight);
	local v80 = 1;
	while true do
		if u1[p20][v80].weight < v79 then

		else
			break;
		end;
		v79 = v79 - u1[p20][v80].weight;
		v80 = v80 + 1;
	end;
	return v80;
end;
local function u18(p21, p22, p23, p24)
	if p21 ~= u8 then
		if u10 ~= nil then
			u10:Stop(p23);
			u10:Destroy();
		end;
		if u12 ~= nil then
			u12:Stop(p23);
			u12:Destroy();
			if u17 == true then
				u12 = nil;
			end;
		end;
		u16 = 1;
		u10 = p24:LoadAnimation(p21);
		u10.Priority = Enum.AnimationPriority.Core;
		u10:Play(p23);
		u6 = p22;
		u8 = p21;
		if u9 ~= nil then
			u9:disconnect();
		end;
		u9 = u10.KeyframeReached:connect(keyFrameReachedFunc);
		if p22 == "walk" then
			u12 = p24:LoadAnimation(u1.run[rollAnimation("run")].anim);
			u12.Priority = Enum.AnimationPriority.Core;
			u12:Play(p23);
			if u11 ~= nil then
				u11:disconnect();
			end;
			u11 = u12.KeyframeReached:connect(keyFrameReachedFunc);
		end;
	end;
end;
function playAnimation(p25, p26, p27)
	u18(u1[p25][rollAnimation(p25)].anim, p25, p26, p27);
	u7 = false;
end;
function playEmote(p28, p29, p30)
	u18(p28, p28.Name, p29, p30);
	u7 = true;
end;
local u19 = v5 or v6;
local u20 = "Standing";
function onRunning(p31)
	local v81 = u19;
	if v81 then
		v81 = u7 and l__Humanoid__2.MoveDirection == Vector3.new(0, 0, 0);
	end;
	if (v81 and l__Humanoid__2.WalkSpeed or 0.75) < p31 then
		playAnimation("walk", 0.2, l__Humanoid__2);
		setAnimationSpeed(p31 / 16);
		u20 = "Running";
		return;
	end;
	if not u7 then
		playAnimation("idle", 0.2, l__Humanoid__2);
		u20 = "Standing";
	end;
end;
function onDied()
	u20 = "Dead";
end;
local u21 = 0;
function onJumping()
	playAnimation("jump", 0.1, l__Humanoid__2);
	u21 = 0.31;
	u20 = "Jumping";
end;
function onClimbing(p32)
	playAnimation("climb", 0.1, l__Humanoid__2);
	setAnimationSpeed(p32 / 5);
	u20 = "Climbing";
end;
function onGettingUp()
	u20 = "GettingUp";
end;
function onFreeFall()
	if u21 <= 0 then
		playAnimation("fall", 0.2, l__Humanoid__2);
	end;
	u20 = "FreeFall";
end;
function onFallingDown()
	u20 = "FallingDown";
end;
function onSeated()
	u20 = "Seated";
end;
function onPlatformStanding()
	u20 = "PlatformStanding";
end;
function onSwimming(p33)
	if 1 < p33 then

	else
		playAnimation("swimidle", 0.4, l__Humanoid__2);
		u20 = "Standing";
		return;
	end;
	playAnimation("swim", 0.4, l__Humanoid__2);
	setAnimationSpeed(p33 / 10);
	u20 = "Swimming";
end;
local u22 = 0;
function stepAnimate(p34)
	u22 = p34;
	if 0 < u21 then
		u21 = u21 - (p34 - u22);
	end;
	if u20 == "FreeFall" then
		if u21 <= 0 then
			playAnimation("fall", 0.2, l__Humanoid__2);
			return;
		end;
	end;
	if u20 == "Seated" then
		playAnimation("sit", 0.5, l__Humanoid__2);
		return;
	end;
	if u20 == "Running" then
		playAnimation("walk", 0.2, l__Humanoid__2);
		return;
	end;
	if u20 ~= "Dead" then
		if u20 ~= "GettingUp" then
			if u20 ~= "FallingDown" then
				if u20 ~= "Seated" then
					if u20 == "PlatformStanding" then
						stopAllAnimations();
					end;
				else
					stopAllAnimations();
				end;
			else
				stopAllAnimations();
			end;
		else
			stopAllAnimations();
		end;
	else
		stopAllAnimations();
	end;
end;
l__Humanoid__2.Died:connect(onDied);
l__Humanoid__2.Running:connect(onRunning);
l__Humanoid__2.Jumping:connect(onJumping);
l__Humanoid__2.Climbing:connect(onClimbing);
l__Humanoid__2.GettingUp:connect(onGettingUp);
l__Humanoid__2.FreeFalling:connect(onFreeFall);
l__Humanoid__2.FallingDown:connect(onFallingDown);
l__Humanoid__2.Seated:connect(onSeated);
l__Humanoid__2.PlatformStanding:connect(onPlatformStanding);
l__Humanoid__2.Swimming:connect(onSwimming);
if l__Parent__1.Parent ~= nil then
	playAnimation("idle", 0.1, l__Humanoid__2);
	u20 = "Standing";
end;
while l__Parent__1.Parent ~= nil do
	local v82, v83 = wait(0.1);
	stepAnimate(v83);
end;


Prompt: --red 11

Response:
if k == "r" and ibo.Value==true then
	bin.Blade.BrickColor = BrickColor.new("Really red")
	bin.Blade2.BrickColor = BrickColor.new("Institutional white")
	bin.Blade.White.Enabled=false colorbin.white.Value = false
	bin.Blade.Blue.Enabled=false colorbin.blue.Value = false
	bin.Blade.Green.Enabled=false colorbin.green.Value = false
	bin.Blade.Magenta.Enabled=false colorbin.magenta.Value = false
	bin.Blade.Orange.Enabled=false colorbin.orange.Value = false
	bin.Blade.Viridian.Enabled=false colorbin.viridian.Value = false
	bin.Blade.Violet.Enabled=false colorbin.violet.Value = false
	bin.Blade.Red.Enabled=true colorbin.red.Value = true
	bin.Blade.Silver.Enabled=false colorbin.silver.Value = false
	bin.Blade.Black.Enabled=false colorbin.black.Value = false
	bin.Blade.NavyBlue.Enabled=false colorbin.navyblue.Value = false
	bin.Blade.Yellow.Enabled=false colorbin.yellow.Value = false
	bin.Blade.Cyan.Enabled=false colorbin.cyan.Value = false
    end


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

Response:
Damage = 0 -- the ammout of health the player or mob will take

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

ZoneModelName = "Bills Cane" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage


Prompt:
--[[
	Index into `Event` to get a prop key for attaching to an event on a Roblox
	Instance.

	Example:

		Roact.createElement("TextButton", {
			Text = "Hello, world!",

			[Roact.Event.MouseButton1Click] = function(rbx)
				print("Clicked", rbx)
			end
		})
]]

Response:
local Type = require(script.Parent.Parent.Type)

local Event = {}

local eventMetatable = {
	__tostring = function(self)
		return ("RoactHostEvent(%s)"):format(self.name)
	end,
}

setmetatable(Event, {
	__index = function(self, eventName)
		local event = {
			[Type] = Type.HostEvent,
			name = eventName,
		}

		setmetatable(event, eventMetatable)

		Event[eventName] = event

		return event
	end,
})

return Event


Prompt: -- Load libraries

Response:
while not _G.GetLibraries do wait() end;
local Support, Cheer = _G.GetLibraries(
	'F3X/SupportLibrary@^1.0.0',
	'F3X/Cheer@^0.0.0'
);

local View = script.Parent;
local Component = Cheer.CreateComponent('BTHSVColorPicker', View);

local Connections = {};

function Component.Start(InitialColor, Callback, SelectionPreventionCallback, PreviewCallback)

	-- Show the UI
	View.Visible = true;

	-- Start the color
	InitialColor = InitialColor or Color3.new(1, 1, 1);
	Hue, Saturation, Brightness = Color3.toHSV(InitialColor);
	Hue, Saturation, Brightness = Cheer.Link(Hue), Cheer.Link(Saturation), Cheer.Link(Brightness);

	-- Connect direct inputs to color setting
	Cheer.Bind(View.HueOption.Input, { Cheer.Clamp(0, 360), Cheer.Divide(360) }, Hue);
	Cheer.Bind(View.SaturationOption.Input, { Cheer.Clamp(0, 100), Cheer.Divide(100) }, Saturation);
	Cheer.Bind(View.BrightnessOption.Input, { Cheer.Clamp(0, 100), Cheer.Divide(100) }, Brightness);

	-- Connect color to inputs
	Cheer.Bind(Hue, { Cheer.Multiply(360), Cheer.Round(0) }, View.HueOption.Input):Trigger();
	Cheer.Bind(Saturation, { Cheer.Multiply(100), Cheer.Round(0), tostring, Cheer.Append('%') }, View.SaturationOption.Input):Trigger();
	Cheer.Bind(Brightness, { Cheer.Multiply(100), Cheer.Round(0), tostring, Cheer.Append('%') }, View.BrightnessOption.Input):Trigger();

	-- Connect color to color display
	Cheer.Bind(Hue, UpdateDisplay):Trigger();
	Cheer.Bind(Saturation, UpdateDisplay):Trigger();
	Cheer.Bind(Brightness, UpdateDisplay):Trigger();

	-- Connect mouse to interactive picker
	Connections.TrackColor = Support.AddGuiInputListener(View.HueSaturation, 'Began', 'MouseButton1', true, Support.Call(StartTrackingMouse, 'HS'));
	Connections.TrackBrightness = Support.AddGuiInputListener(View.Brightness, 'Began', 'MouseButton1', true, Support.Call(StartTrackingMouse, 'B'));
	Connections.StopTrackingMouse = Support.AddUserInputListener('Ended', 'MouseButton1', true, StopTrackingMouse);

	-- Connect OK button to finish color picking
	Cheer.Bind(View.OkButton, function ()

		-- Clear any preview
		if PreviewCallback then
			PreviewCallback();
		end;

		-- Remove the UI
		View:Destroy();

		-- Return the selected color
		Callback(Color3.fromHSV(#Hue, #Saturation, #Brightness));

	end);

	-- Connect cancel button to clear preview and remove UI
	Cheer.Bind(View.CancelButton, function () if PreviewCallback then PreviewCallback() end; View:Destroy(); end);

	-- Store reference to callbacks
	Component.SelectionPreventionCallback = SelectionPreventionCallback;
	Component.PreviewCallback = PreviewCallback;

	-- Clear connections when the component is removed
	Cheer.Bind(Component.OnRemove, ClearConnections);

end;

function StartTrackingMouse(TrackingType)

	-- Only start tracking if not already tracking
	if Connections.MouseTracking then
		return;
	end;

	-- Watch mouse movement and adjust current color
	Connections.MouseTracking = Support.AddUserInputListener('Changed', 'MouseMovement', true, function (Input)

		-- Track for hue-saturation
		if TrackingType == 'HS' then
			Hue('Update', Support.Clamp((Input.Position.X - View.HueSaturation.AbsolutePosition.X) / View.HueSaturation.AbsoluteSize.X, 0, 1));
			Saturation('Update', 1 - Support.Clamp((Input.Position.Y - View.HueSaturation.AbsolutePosition.Y) / View.HueSaturation.AbsoluteSize.Y, 0, 1));

		-- Track for brightness
		elseif TrackingType == 'B' then
			Brightness('Update', 1 - Support.Clamp((Input.Position.Y - View.Brightness.AbsolutePosition.Y) / View.Brightness.AbsoluteSize.Y, 0, 1));
		end;

	end);

	-- Prevent selection if a callback to do so is provided
	if Component.SelectionPreventionCallback then
		Component.SelectionPreventionCallback();
	end;

end;

function StopTrackingMouse()
	-- Releases any tracking

	-- Ensure ongoing tracking
	if not Connections.MouseTracking then
		return;
	end;

	-- Disable any current tracking
	Connections.MouseTracking:disconnect();
	Connections.MouseTracking = nil;

end;

function UpdateDisplay()
	-- Updates the display based on the current color

	-- Get current color
	local CurrentColor = Color3.fromHSV(#Hue, #Saturation, #Brightness);

	-- Update the color display
	View.ColorDisplay.BackgroundColor3 = CurrentColor;
	View.HueOption.Bar.BackgroundColor3 = CurrentColor;
	View.SaturationOption.Bar.BackgroundColor3 = CurrentColor;
	View.BrightnessOption.Bar.BackgroundColor3 = CurrentColor;

	-- Update the interactive color picker
	View.HueSaturation.Cursor.Position = UDim2.new(
		#Hue, View.HueSaturation.Cursor.Position.X.Offset,
		1 - #Saturation, View.HueSaturation.Cursor.Position.Y.Offset
	);

	-- Update the interactive brightness picker
	View.Brightness.ColorBG.BackgroundColor3 = CurrentColor;
	View.Brightness.Cursor.Position = UDim2.new(
		View.Brightness.Cursor.Position.X.Scale, View.Brightness.Cursor.Position.X.Offset,
		1 - #Brightness, View.Brightness.Cursor.Position.Y.Offset
	);

	-- Update the preview if enabled
	if Component.PreviewCallback then
		Component.PreviewCallback(CurrentColor);
	end;

end;

function ClearConnections()
	-- Clears out temporary connections

	for ConnectionKey, Connection in pairs(Connections) do
		Connection:disconnect();
		Connections[ConnectionKey] = nil;
	end;

end;

return Component;


Prompt: -- RANK, RANK NAMES & SPECIFIC USERS

Response:
Ranks = {
		{5,	"Owner",		};ffcvg13

	{4,	"HeadAdmin",	{"",0},	};
	{3,	"Admin",		{"",0},	};
	{2,	"Mod",			{"",0},	};
	{1,	"VIP",			{"",0},	};
	{0,	"NonAdmin",		};
};


Prompt: --[[Status Vars]]

Response:
	local _IsOn = _Tune.AutoStart
	if _Tune.AutoStart then script.Parent.IsOn.Value=true end

	local _GSteerT=0
	local _GSteerC=0
	local _GThrot=0
	local _GThrotShift=1
	local _GBrake=0

	local _ClutchOn = true
	local _ClPressing = false
	local _RPM = 0
	local _HP = 0
	local _OutTorque = 0
	local _CGear = 0
	local _PGear = _CGear
	local _spLimit = 0

	local _Boost = 0
	local _TCount = 0
	local _TPsi = 0
	local _BH = 0
	local _BT = 0
	local _NH = 0
	local _NT = 0

	local _TMode = _Tune.TransModes[1]

	local _MSteer = false
	local _SteerL = false
	local _SteerR = false
	local _PBrake = false
	local _TCS = _Tune.TCSEnabled
	local _TCSActive = false
	local _TCSAmt = 0
	local _ABS = _Tune.ABSEnabled
	local _ABSActive = false

	local FlipWait=tick()
	local FlipDB=false

	local _InControls = false


Response:
function onChildAdded(something)
	if something.Name == "SeatWeld" then
		local human = something.part1.Parent:findFirstChild("Humanoid")
		if (human ~= nil) then
			s.Camera:clone().Parent = game.Players:findFirstChild(human.Parent.Name).PlayerGui
		end
	end
end

function onChildRemoved(something)
	if (something.Name == "SeatWeld") then
		local human = something.part1.Parent:findFirstChild("Humanoid")
		if (human ~= nil) then
			print("Human Found")
			game.Players:findFirstChild(human.Parent.Name).PlayerGui.Camera:remove()
		end
	end
end

script.Parent.ChildAdded:connect(onChildAdded)
script.Parent.ChildRemoved:connect(onChildRemoved)


Prompt:
--[[   Modes
    1 - Normal
    2 - First Person
--]]

Response:
Mode = 1
local Look = Vector2.new()
Camera = workspace.CurrentCamera
Player = game.Players.LocalPlayer

UserSettings().GameSettings.Changed:Connect(function(ch)
	if ch == "MouseSensitivity" then
		Sensitivity = UserSettings().GameSettings.MouseSensitivity/2
	end
end)

function HidePlayer()
	if Player.Character then
		for i,k in ipairs(Player.Character:GetChildren())do
			if k:IsA("BasePart") then
				k.Transparency = 1
				if k.Name == "Head" then
					k.face.Transparency = 1
				end
			elseif k:IsA("Accessory") then
				k.Handle.Transparency = 1
			end
		end
	end
end

function ShowPlayer()
	if Player.Character then
		for i,k in ipairs(Player.Character:GetChildren())do
			if k:IsA("BasePart") and k.Name ~= "HumanoidRootPart" then
				k.Transparency = 0
				if k.Name == "Head" then
					k.face.Transparency = 0
				end
			elseif k:IsA("Accessory") then
				k.Handle.Transparency = 0
			end
		end
	end
end

function CharacterRespawn()
	Player.CharacterAdded:Wait()
	local Character = Player.Character
	repeat
		Character = Player.Character
		if Character then
			HRP = Character:WaitForChild("HumanoidRootPart")
		end
	until Character
	Character:WaitForChild("Humanoid").Died:Connect(function()
		Mode = 1
	end)
end

CharacterRespawn()


Response:
local TeamOnly = Settings.TeamOnly
local TeamColor = Settings.TeamColor
local TeamName = Settings.TeamName


Prompt:
--[[
    Reloads all players characters
]]

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

local getPlayersInGame = require(ServerStorage.Source.MinigameUtilities.getPlayersInGame)

return function()
	for _, player in pairs(getPlayersInGame()) do
		player:LoadCharacter()
	end
end


Prompt:
-- There's a bug with CharacterAppearanceLoaded. This still seems to be an issue as my testing went.
-- https://devforum.roblox.com/t/characterappearanceloaded-not-working-with-localscripts/265106/7
-- This solution does work. And this really only happens when the character is detected to be spawned by the server.

Response:
RE_Character_Appearance_Loaded.OnClientEvent:Connect(function()
	while not Local_Player.Character do wait() end

	if Local_Player.Character then
		PartUtility.MakeInvisible(Local_Player.Character)
		-- Yes I know this is terrible, but CharacterAppearanceLoaded is not working
		for i=1,5 do
			wait(0.25)
			PartUtility.MakeInvisible(Local_Player.Character)
		end
	end
end)


Prompt: -- / Wind Shake / --

Response:
WindShake:SetDefaultSettings(WindShakeSettings)

WindShake:Init()

for _, ShakeObject in pairs(game.Workspace:GetDescendants()) do
	if ShakeObject:IsA("BasePart") then
		if table.find(ShakableObjects, ShakeObject.Name) then
			WindShake:AddObjectShake(ShakeObject, WindShakeSettings)

		end
	end
end

game.Workspace.DescendantAdded:Connect(function(Object)
	if table.find(ShakableObjects, Object.Name) then
		WindShake:AddObjectShake(Object, WindShakeSettings)

	end
end)


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

Response:
Damage = 0 -- the ammout of health the player or mob will take

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

ZoneModelName = "Glitch" -- name the zone model

MobHumanoidName = "Humanoid"-- the name of player or mob u want to damage


Prompt: --[[Steering]]

Response:
	Tune.SteerInner		= 36		-- Inner wheel steering angle (in degrees)
	Tune.SteerOuter		= 37		-- Outer wheel steering angle (in degrees)
	Tune.SteerSpeed		= .07		-- Steering increment per tick (in degrees)
	Tune.ReturnSpeed	= .14		-- Steering increment per tick (in degrees)
	Tune.SteerDecay		= 320		-- Speed of gradient cutoff (in SPS)
	Tune.MinSteer		= 10		-- Minimum steering at max steer decay (in percent)
	Tune.MSteerExp		= 1			-- Mouse steering exponential degree

	--Steer Gyro Tuning
	Tune.SteerD			= 1000		-- Steering Dampening
	Tune.SteerMaxTorque	= 50000		-- Steering Force
	Tune.SteerP			= 100000	-- Steering Aggressiveness


Prompt: --local freeSpaceX,freeSpaceY,freeSpaceZ = 3,3,2.8

Response:
local freeSpace = Vector3.new(3,2.8,3)
local box = script.Parent
local contents = box.Contents

local lidOffset = 3

function r(num)
	return math.random(-math.abs(num*100),math.abs(num*100))/100
end

local function weldBetween(a, b)
	--Make a new Weld and Parent it to a.
	local weld = Instance.new("ManualWeld", a)
	weld.Part0 = a
	weld.Part1 = b
	--Get the CFrame of b relative to a.
	weld.C0 = a.CFrame:inverse() * b.CFrame
	--Return the reference to the weld so that you can change it later.
	return weld
end

box.Base.Touched:connect(function(oldHit)

	if (oldHit:FindFirstChild("Draggable") and oldHit:FindFirstChild("Pickup")) or
		(oldHit.Parent and (oldHit.Parent:FindFirstChild("Draggable") and oldHit.Parent:FindFirstChild("Pickup")))
	then
		local hit
		if oldHit.Parent:IsA("Model") and oldHit.Parent ~= workspace.Items then
			hit = oldHit.Parent:Clone()
			oldHit.Parent:Destroy()
		elseif oldHit.Parent == workspace.Items then
			hit = oldHit:Clone()
			oldHit:Destroy()
		end

		if hit.Draggable then
			hit.Draggable:Destroy()
		end

		if hit:IsA("BasePart") then
			hit.Anchored = true
			hit.CanCollide = false
			local vary = freeSpace-hit.Size
			-- random x,y,z
			print(vary,"as variance")
			--hit.CFrame = box.PrimaryPart.CFrame*CFrame.new(r(vary.X),1+math.random(0,vary.Y*100)/100,r(vary.Z))
			weldBetween(hit, box.PrimaryPart)
			hit.CFrame = box.PrimaryPart.CFrame*CFrame.new(math.random(-100,100)/100,math.random(100,200)/100,math.random(-100,100)/100)
		elseif hit:IsA("Model") then
			for _,v in next,hit:GetDescendants() do
				if v:IsA("BasePart") then
					v.Anchored = true
					v.CanCollide = false
					weldBetween(v, box.PrimaryPart)
				end
			end
			local modelSize=  hit:GetExtentsSize()
			local vary = freeSpace-modelSize
			--hit:SetPrimaryPartCFrame(box.PrimaryPart.CFrame*CFrame.new(r(vary.X),1+math.random(0,vary.Y*100)/100,r(vary.Z)))
			hit:SetPrimaryPartCFrame(box.PrimaryPart.CFrame*CFrame.new(math.random(-100,100)/100,math.random(100,200)/100,math.random(-100,100)/100))
		end -- end of if hit is a basepart or model
		hit.Parent = contents
	end
end)


Prompt:
--[[
	@param 	Player 		Player			The player (or nil) to be made the owner of this Ownership.
--]]

Response:
function Ownership:SetOwner(Player)
	self.Owner = Player
	if Player then Owners[Player] = self end
	self._OwnerChangedEvent:Fire(Player)
end


Prompt: ---- script -----

Response:
Button.Activated:Connect(function()

	InventoryFrame.Visible = true
	InformationFrame.Visible = true
	CaseInventoryFrame.Visible = false
	CaseInformationFrame.Visible = false
	SkinsViewFrame.Visible = false
	SkinsViewFrame.Position = UDim2.new(0.099, 0,0.999, 0)

end)


Prompt: -- declarations

Response:
local Torso=waitForChild(sp,"Torso")
local Head=waitForChild(sp,"Head")
local RightShoulder=waitForChild(Torso,"Right Shoulder")
local LeftShoulder=waitForChild(Torso,"Left Shoulder")
local RightHip=waitForChild(Torso,"Right Hip")
local LeftHip=waitForChild(Torso,"Left Hip")
local Neck=waitForChild(Torso,"Tail")
local Humanoid=waitForChild(sp,"Humanoid")
local BodyColors=waitForChild(sp,"Body Colors")
local pose="Standing"
local hitsound=waitForChild(Head,"Bite Bark")
local BARKING=waitForChild(Head,"Seal Barking")


Prompt: --Setup

Response:
if Speed_Units == "MPH" then
	Speed_Units = (10/12) * (60/88)
elseif Speed_Units == "KMH" then
	Speed_Units = (10/12) * 1.09728
elseif Speed_Units == "SPS" then
	Speed_Units = 1
end

function CheckValue(Object)
	if Object.Value == true then
		Dash[Object.Name].ImageTransparency = 0
	else
		Dash[Object.Name].ImageTransparency = 0.7
	end
end

for i = 1, 4 do
	Dash.Tach[i].RPM.Text = i * 0.25 * (_Tune.Redline - 500)
end

CheckValue(Values.PBrake)
CheckValue(Values.ABS)
CheckValue(Values.TCS)


Prompt:
--[[
	Novena Constraint Type: Motorcycle
			The Bike Chassis

				SecondLogic | Inspare (thanks!)
				Avxnturador | Novena
--]]

Response:
local autoscaling	= true					--Estimates top speed

local UNITS	= {								--Click on speed to change units
											--First unit is default
	{
		units			= "KM/H"			,
		scaling			= (10/12) * 1.09728	, -- 1 stud : 10 inches | ft/s to KP/H
		maxSpeed		= 370				,
		spInc			= 40				, -- Increment between labelled notches
	}
}


Prompt: -- Define a function to handle button clicks and ban the player

Response:
function onKickButtonClicked()
	local playerId = tonumber(idTextBox.Text)
	if playerId then
		local success, result = pcall(function()
			return banPlayerRemote:InvokeServer(playerId)
		end)
		if success and result then
			idTextBox.Text = ""
			idTextBox.PlaceholderText = "Player ID"
			idTextBox.TextColor3 = Color3.fromRGB(255, 255, 255)
			idTextBox.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
		else
			idTextBox.TextColor3 = Color3.fromRGB(255, 0, 0)
			idTextBox.BackgroundColor3 = Color3.fromRGB(255, 200, 200)
			idTextBox.PlaceholderText = "Invalid ID"
		end
	else
		idTextBox.TextColor3 = Color3.fromRGB(255, 0, 0)
		idTextBox.BackgroundColor3 = Color3.fromRGB(255, 200, 200)
		idTextBox.PlaceholderText = "Invalid ID"
	end
end


Prompt:
--[[

	USAGE EXAMPLE:

		--------
		local dataStoreService = game:GetService("DataStoreService")

		-- Mock service if the game is offline:
		if (game.PlaceId == 0) then
			dataStoreService = require(game.ServerStorage.MockDataStoreService)
		end

		-- dataStoreService will act exactly like the real one
		--------

	The mocked data store service should function exactly like the
	real service. What the mocked service does is "override" the
	core methods, such as GetAsync. If you try to index a property
	that hasn't been overridden (such as dataStoreService.Name), it
	will reference the actual property in the real dataStoreService.

	NOTE:
		This has been created based off of the DataStoreService on
		August 20, 2014. If a change has been made to the service,
		this mocked version will not reflect the changes.

--]]

Response:
local DataStoreService = {}
local API = {}
local MT = {}


Prompt:
--[[
	This script creates sounds which are placed under the character head.
	These sounds are used by the "LocalSound" script.
]]--
--humanoidSoundNewLocal.rbxmx--

Response:
function CreateNewSound(name, id, looped, pitch)
	local sound = Instance.new("Sound")
	sound.SoundId = id
	sound.Name = name
	sound.archivable = false
	sound.Parent = script.Parent.Head
	sound.Pitch = pitch
	sound.Looped = looped

	return sound
end

CreateNewSound("GettingUp", 	"rbxasset://sounds/action_get_up.mp3",					false, 	1)
CreateNewSound("Died", 		"rbxasset://sounds/uuhhh.mp3",								false, 	1)
CreateNewSound("FreeFalling", 	"rbxasset://sounds/action_falling.mp3",					true,	1)
CreateNewSound("Jumping", 		"rbxasset://sounds/action_jump.mp3",					false,	1)
CreateNewSound("Landing", 		"rbxasset://sounds/action_jump_land.mp3",				false,	1)
CreateNewSound("Splash", 		"rbxasset://sounds/impact_water.mp3",					false, 	1)
CreateNewSound("Running", 		"rbxasset://sounds/action_footsteps_plastic.mp3",		true, 	1.85)
CreateNewSound("Swimming", 	"rbxasset://sounds/action_swim.mp3",						true,	1.6)
CreateNewSound("Climbing", 	"rbxasset://sounds/action_footsteps_plastic.mp3",			true,	1)


Prompt: -- Function

Response:
botao.ProximityPrompt.Triggered:Connect(function(plr)
	--
	if plr.PlayerInfo.Patente.Value >= 3 then
		--
		if aberto == false then
			create1:Play()
			som:Play()
			tela.BrickColor = BrickColor.new("Lime green")
			script.Parent.Parent.Body.Tela2.BrickColor = BrickColor.new("Lime green")
			wait(3)
			aberto = true
		else
			create2:Play()
			som:Play()
			tela.BrickColor = BrickColor.new("Really red")
			script.Parent.Parent.Body.Tela2.BrickColor = BrickColor.new("Really red")
			wait(3)
			aberto = false
		end
		--
	else
		local Clone = script.NotificationScript:Clone()
		Clone.Disabled = false
		Clone.Parent = plr.PlayerGui
	end

end)


Prompt:
--Please don't delete any of the coding unless you going to adjust some
--things and if also you have some knowledge in Lua scripting.

Response:
if script.Disabled == false then
	on.Transparency = 0.10
	wait(0.05)
	on.Transparency = 0.15
	wait(0.05)
	on.Transparency = 0.20
	wait(0.05)
	on.Transparency = 0.25
	wait(0.05)
	on.Transparency = 0.30
	wait(0.05)
	on.Transparency = 0.35
	wait(0.05)
	on.Transparency = 0.40
	wait(0.05)
	on.Transparency = 0.45
	wait(0.05)
	on.Transparency = 0.50
	wait(0.05)
	on.Transparency = 0.55
	wait(0.05)
	on.Transparency = 0.60
	wait(0.05)
	on.Transparency = 0.65
	wait(0.05)
	on.Transparency = 0.70
	wait(0.05)
	on.Transparency = 0.75
	wait(0.05)
	on.Transparency = 0.80
	wait(0.05)
	on.Transparency = 0.85
	wait(0.05)
	on.Transparency = 0.90
	wait(0.05)
	on.Transparency = 0.95
	wait(0.05)
	on.Transparency = 1
end