Prompt: --LIGHTING FUNCTIONS

Response:
script.Parent.OnServerEvent:connect(function(pl,n) if lt~=1 then pr = true else pr=false end lt=n
	if lt == 0 then
		RefMt.DesiredAngle = RefMt.CurrentAngle%math.rad(360)
		RefMt.CurrentAngle = RefMt.CurrentAngle%math.rad(360)
		UpdateLt(1,white)
		UpdatePt(false,white)
		StopMt(pr)
		repeat wait() until lt~=0
	elseif lt == 1 then
		wait(.125)
		RefMt.DesiredAngle = RefMt.CurrentAngle%math.rad(360)
		RefMt.CurrentAngle = RefMt.CurrentAngle%math.rad(360)
		UpdateLt(.25,red)
		UpdatePt(true,red)
		UpdateMt(0,math.rad(225),4)
		wait(.75)
		repeat
			UpdateMt(0,math.rad(135),0)
			wait(.5)
			if lt~=1 then break end
			UpdateMt(0,math.rad(225),0)
			wait(.5)
		until lt~=1
	elseif lt == 2 then
		UpdateLt(.25,amber)
		UpdatePt(true,amber)
		UpdateMt(0,9e9,1)
		repeat
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 90 then UpdateLt(.25,red) end
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 90 then UpdatePt(true,red) end
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 270 then UpdateLt(.25,amber) end
			if math.deg(RefMt.CurrentAngle%math.rad(360)) >= 270 then UpdatePt(true,amber) end
			wait()
		until lt~=2
	elseif lt == 3 then
		wait(1/6)
		UpdateLt(.25,blue)
		UpdatePt(true,blue)
		UpdateMt(0,9e9,1)
		repeat wait() until lt~=3
	end
end)


Prompt:
-- ================================================================================
-- LOCAL FUNCTIONS
-- ================================================================================

Response:
local function statusChanged()
	local raceStatus = RaceManager:GetRaceStatus()
	GameStatus.Text = raceStatus

	-- Hide GUI when round is in session and player is a speeder
	if raceStatus == RaceManager.Status.RoundInProgress then
		StatusBar.Visible = false
	else
		StatusBar.Visible = true
	end
end -- statusChanged()


Prompt:
--[=[
	Returns whether or not the promise is fulfilled

	@return bool -- True if fulfilled
]=]

Response:
function Promise:IsFulfilled()
	return self._fulfilled ~= nil
end


Prompt: --                                                     in the mainUI

Response:
closeButton.MouseButton1Down:Connect(function()
	topbar_closeButton_p:Play()
	hideMainWindow()
end)

closeButton.MouseButton1Up:Connect(function()
	topbar_closeButton_f:Cancel()
	topbar_closebutton_r:Play()
	topbar_closebutton_r.Completed:Wait()
	topbar_closeButton_nf:Play()
end)


Prompt: --wait(WaitTime)

Response:
local Finished = 0
local AF = 0
for l,i in pairs(Edit) do
AF = AF+1
Spawn(function()
for j, v in pairs(i) do
wait(v[3] and v[3] or 0)
for k = 1, v[2]  do
for m, n in pairs(Parts:GetChildren()) do
if n.Name == l then


Prompt:
-------------------------------------------------------
--Start Important Functions--
-------------------------------------------------------

Response:
s.Size = Vector3.new(4, 0.05, 4)
function swait(num)
	if num == 0 or num == nil then
		game:service("RunService").Stepped:wait(0)
	else
		for i = 0, num do
			game:service("RunService").Stepped:wait(0)
		end
	end
end

wait(1)
coroutine.resume(coroutine.create(function()
for i = 1,25 do
swait(0)
s.Size = s.Size - Vector3.new(0.04,0,0.04)
end
s:Destroy()
end))


Prompt: --Get existing seats

Response:
for _ , seat in pairs(CollectionService:GetTagged(SeatTag)) do
	Seats[seat] = seat
end


Prompt: --navyblue 13

Response:
if k == "n" and ibo.Value==true then
	bin.Blade.BrickColor = BrickColor.new("Navy blue")
	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=false colorbin.red.Value = false
	bin.Blade.Silver.Enabled=false colorbin.silver.Value = false
	bin.Blade.Black.Enabled=false colorbin.black.Value = false
	bin.Blade.NavyBlue.Enabled=true colorbin.navyblue.Value = true
	bin.Blade.Yellow.Enabled=false colorbin.yellow.Value = false
	bin.Blade.Cyan.Enabled=false colorbin.cyan.Value = false
end
end

function bladeupdate()
if ibo.Value == true then
	if idb.Value == true then
		bin.Blade.Transparency = 0.4
		bin.Blade2.Transparency = 0
	else
		bin.Blade.Transparency = 0.4
		bin.Blade2.Transparency = 0
		end
else
	bin.Blade.Transparency = 1
	bin.Blade2.Transparency = 1
	bin.Blade.White.Enabled=false
	bin.Blade.Red.Enabled=false
	bin.Blade.Blue.Enabled=false
	bin.Blade.Green.Enabled=false
	bin.Blade.Magenta.Enabled=false
	bin.Blade.Orange.Enabled=false
	bin.Blade.Viridian.Enabled=false
	bin.Blade.Violet.Enabled=false
	bin.Blade.Silver.Enabled=false
	bin.Blade.Black.Enabled=false
	bin.Blade.NavyBlue.Enabled=false
	bin.Blade.Yellow.Enabled=false
	bin.Blade.Cyan.Enabled=false
	end
end

function bladeupdate2()
if colorbin.white.Value==true and ibo.Value==true then bin.Blade.White.Enabled=true
end
if colorbin.red.Value==true and ibo.Value==true then bin.Blade.Red.Enabled=true
end
if colorbin.blue.Value==true and ibo.Value==true then bin.Blade.Blue.Enabled=true
end
if colorbin.green.Value==true  and ibo.Value==true then bin.Blade.Green.Enabled=true
end
if colorbin.magenta.Value==true and ibo.Value==true then bin.Blade.Magenta.Enabled=true
end
if colorbin.orange.Value==true and ibo.Value==true then bin.Blade.Orange.Enabled=true
end
if colorbin.viridian.Value==true and ibo.Value==true then bin.Blade.Viridian.Enabled=true
end
if colorbin.violet.Value==true and ibo.Value==true then	bin.Blade.Violet.Enabled=true
end
if colorbin.silver.Value==true and ibo.Value==true then	bin.Blade.Silver.Enabled=true
end
if colorbin.black.Value==true and ibo.Value==true then	bin.Blade.Black.Enabled=true
end
if colorbin.navyblue.Value==true and ibo.Value==true then bin.Blade.NavyBlue.Enabled=true
end
if colorbin.yellow.Value==true and ibo.Value==true then	bin.Blade.Yellow.Enabled=true
end
if colorbin.cyan.Value==true and ibo.Value==true then bin.Blade.Cyan.Enabled=true
end
end

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

function onUnequippedLocal(mouse)
loop.Volume = 0
end

Tool.Unequipped:connect(onUnequippedLocal)
Tool.Equipped:connect(onEquippedLocal)
if con ~= nil then con:disconnect() end
if con2 ~= nil then con2:disconnect() end


Response:
local HitboxObject = {}
local Hitbox = {}
Hitbox.__index = Hitbox

function Hitbox:__tostring()
	return string.format("Hitbox for instance %s [%s]", self.object.Name, self.object.ClassName)
end

function HitboxObject:new()
    return setmetatable({}, Hitbox)
end

function Hitbox:config(object, ignoreList)
	self.active = false
	self.deleted = false
	self.partMode = false
	self.debugMode = false
	self.points = {}
	self.targetsHit = {}
	self.endTime = 0
	self.OnHit = Signal:Create()
	self.OnUpdate = Signal:Create()
	self.raycastParams = RaycastParams.new()
	self.raycastParams.FilterType = Enum.RaycastFilterType.Blacklist
	self.raycastParams.FilterDescendantsInstances = ignoreList or {}

	self.object = object
	CollectionService:AddTag(self.object, "RaycastModuleManaged")
end

function Hitbox:SetPoints(object, vectorPoints, groupName)
	if object and (object:IsA("BasePart") or object:IsA("MeshPart") or object:IsA("Attachment")) then
		for _, vectors in ipairs(vectorPoints) do
			if typeof(vectors) == "Vector3" then
				local Point = {
					IsAttachment = object:IsA("Attachment"),
					RelativePart = object,
					Attachment = vectors,
					LastPosition = nil,
					group = groupName,
					solver = CastVectorPoint
				}
				table.insert(self.points, Point)
			end
		end
	end
end

function Hitbox:RemovePoints(object, vectorPoints)
	if object then
		if object:IsA("BasePart") or object:IsA("MeshPart") then --- for some reason it doesn't recognize meshparts unless I add it in
			for i = 1, #self.points do
				local Point = self.points[i]
				for _, vectors in ipairs(vectorPoints) do
					if typeof(Point.Attachment) == "Vector3" and Point.Attachment == vectors and Point.RelativePart == object then
						self.points[i] = nil
					end
				end
			end
		end
	end
end

function Hitbox:LinkAttachments(primaryAttachment, secondaryAttachment)
	if primaryAttachment:IsA("Attachment") and secondaryAttachment:IsA("Attachment") then
		local group = primaryAttachment:FindFirstChild("Group")
		local Point = {
			RelativePart = nil,
			Attachment = primaryAttachment,
			Attachment0 = secondaryAttachment,
			LastPosition = nil,
			group = group and group.Value,
			solver = CastLinkAttach
		}
		table.insert(self.points, Point)
	end
end

function Hitbox:UnlinkAttachments(primaryAttachment)
	for i, Point in ipairs(self.points) do
		if Point.Attachment and Point.Attachment == primaryAttachment then
			table.remove(self.points, i)
			break
		end
	end
end

function Hitbox:seekAttachments(attachmentName, canWarn)
	if #self.points <= 0 then
		table.insert(self.raycastParams.FilterDescendantsInstances, workspace.Terrain)
	end
	for _, attachment in ipairs(self.object:GetDescendants()) do
		if attachment:IsA("Attachment") and attachment.Name == attachmentName then
			local group = attachment:FindFirstChild("Group")
			local Point = {
				Attachment = attachment,
				RelativePart = nil,
				LastPosition = nil,
				group = group and group.Value,
				solver = CastAttachment
			}
			table.insert(self.points, Point)
		end
	end

	if canWarn then
		if #self.points <= 0 then
			warn(string.format("\n[[RAYCAST WARNING]]\nNo attachments with the name '%s' were found in %s. No raycasts will be drawn. Can be ignored if you are using SetPoints.",
				attachmentName, self.object.Name)
			)
		else
			print(string.format("\n[[RAYCAST MESSAGE]]\n\nCreated Hitbox for %s - Attachments found: %s",
				self.object.Name, #self.points)
			)
		end
	end
end

function Hitbox:Destroy()
	if self.deleted then return end
	if self.OnHit then self.OnHit:Delete() end
	if self.OnUpdate then self.OnUpdate:Delete() end

	self.points = nil
	self.active = false
	self.deleted = true
end

function Hitbox:HitStart(seconds)
	self.active = true

	if seconds then
		assert(type(seconds) == "number", "Argument #1 must be a number!")

		local minSeconds = 1 / 60 --- Seconds cannot be under 1/60th

		if seconds <= minSeconds or seconds == math.huge then
			seconds = minSeconds
		end

		self.endTime = clock() + seconds
	end
end

function Hitbox:HitStop()
	if self.deleted then return end

	self.active = false
	self.endTime = 0
	table.clear(self.targetsHit)
end

function Hitbox:PartMode(bool)
	self.partMode = bool
end

function Hitbox:DebugMode(bool)
	self.debugMode = bool
end

return HitboxObject


Prompt:
--[=[
	An object that can be cleaned up
	@type MaidTask function | thread | Destructable | RBXScriptConnection
	@within MaidTaskUtils
]=]

Response: local MaidTaskUtils = {}


Prompt: -- SolarCrane

Response:
local MAX_TWEEN_RATE = 2.8 -- per second

local function clamp(low, high, num)
	if low <= high then
		return math.min(high, math.max(low, num))
	end
	return num
end

local function Round(num, places)
	places = places or 0
	local decimalPivot = 10^places
	return math.floor(num * decimalPivot + 0.5) / decimalPivot
end

local function CreateTransparencyController()
	local module = {}

	local LastUpdate = tick()
	local TransparencyDirty = false
	local Enabled = false
	local LastTransparency = nil

	local DescendantAddedConn, DescendantRemovingConn = nil, nil
	local ToolDescendantAddedConns = {}
	local ToolDescendantRemovingConns = {}
	local CachedParts = {}

	local function HasToolAncestor(object)
		if object.Parent == nil then return false end
		return object.Parent:IsA('Tool') or HasToolAncestor(object.Parent)
	end

	local function IsValidPartToModify(part)
		if part:IsA('BasePart') or part:IsA('Decal') then
			return not HasToolAncestor(part)
		end
		return false
	end

	local function CachePartsRecursive(object)
		if object then
			if IsValidPartToModify(object) then
				CachedParts[object] = true
				TransparencyDirty = true
			end
			for _, child in pairs(object:GetChildren()) do
				CachePartsRecursive(child)
			end
		end
	end

	local function TeardownTransparency()
		for child, _ in pairs(CachedParts) do
			child.LocalTransparencyModifier = 0
		end
		CachedParts = {}
		TransparencyDirty = true
		LastTransparency = nil

		if DescendantAddedConn then
			DescendantAddedConn:disconnect()
			DescendantAddedConn = nil
		end
		if DescendantRemovingConn then
			DescendantRemovingConn:disconnect()
			DescendantRemovingConn = nil
		end
		for object, conn in pairs(ToolDescendantAddedConns) do
			conn:disconnect()
			ToolDescendantAddedConns[object] = nil
		end
		for object, conn in pairs(ToolDescendantRemovingConns) do
			conn:disconnect()
			ToolDescendantRemovingConns[object] = nil
		end
	end

	local function SetupTransparency(character)
		TeardownTransparency()

		if DescendantAddedConn then DescendantAddedConn:disconnect() end
		DescendantAddedConn = character.DescendantAdded:connect(function(object)
			local Pet = (object.Name == "Pet" and object) or character:FindFirstChild("Pet");
			if Pet and object:IsDescendantOf(Pet) then
				return;
			end
			-- This is a part we want to invisify
			if IsValidPartToModify(object) then
				CachedParts[object] = true
				TransparencyDirty = true
			-- There is now a tool under the character
			elseif object:IsA('Tool') then
				if ToolDescendantAddedConns[object] then ToolDescendantAddedConns[object]:disconnect() end
				ToolDescendantAddedConns[object] = object.DescendantAdded:connect(function(toolChild)
					CachedParts[toolChild] = nil
					if toolChild:IsA('BasePart') or toolChild:IsA('Decal') then
						-- Reset the transparency
						toolChild.LocalTransparencyModifier = 0
					end
				end)
				if ToolDescendantRemovingConns[object] then ToolDescendantRemovingConns[object]:disconnect() end
				ToolDescendantRemovingConns[object] = object.DescendantRemoving:connect(function(formerToolChild)
					wait() -- wait for new parent
					if character and formerToolChild and formerToolChild:IsDescendantOf(character) then
						if IsValidPartToModify(formerToolChild) then
							CachedParts[formerToolChild] = true
							TransparencyDirty = true
						end
					end
				end)
			end
		end)
		if DescendantRemovingConn then DescendantRemovingConn:disconnect() end
		DescendantRemovingConn = character.DescendantRemoving:connect(function(object)
			if CachedParts[object] then
				CachedParts[object] = nil
				-- Reset the transparency
				object.LocalTransparencyModifier = 0
			end
		end)
		CachePartsRecursive(character)
	end

	function module:SetEnabled(newState)
		if Enabled ~= newState then
			Enabled = newState
			self:Update()
		end
	end

	function module:SetSubject(subject)
		local character = subject and subject:IsA('Humanoid') and subject.Parent
		if character then
			SetupTransparency(character)
		else
			TeardownTransparency()
		end
	end

	function module:Update()
		local instant = false
		local now = tick()
		local currentCamera = workspace.CurrentCamera

		if currentCamera then
			local transparency = 0
			if not Enabled then
				instant = true
			else
				local distance = (currentCamera.Focus.p - currentCamera.CoordinateFrame.p).magnitude
				transparency = (7 - distance) / 5
				if transparency < 0.5 then
					transparency = 0
				end

				if LastTransparency then
					local deltaTransparency = transparency - LastTransparency
					-- Don't tween transparency if it is instant or your character was fully invisible last frame
					if not instant and transparency < 1 and LastTransparency < 0.95 then
						local maxDelta = MAX_TWEEN_RATE * (now - LastUpdate)
						deltaTransparency = clamp(-maxDelta, maxDelta, deltaTransparency)
					end
					transparency = LastTransparency + deltaTransparency
				else
					TransparencyDirty = true
				end

				transparency = clamp(0, 1, Round(transparency, 2))
			end

			if TransparencyDirty or LastTransparency ~= transparency then
				for child, _ in pairs(CachedParts) do
					child.LocalTransparencyModifier = transparency
				end
				TransparencyDirty = false
				LastTransparency = transparency
			end
		end
		LastUpdate = now
	end

	return module
end

return CreateTransparencyController


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

Response:
local v1 = {};
local l__TweenService__2 = game:GetService("TweenService");
v1.module_events = require(script.Parent.Parent.Module_Events);
local u1 = game:GetService("ReplicatedStorage").Misc.Eyes:GetChildren();
function v1.tease(p1, p2, p3, p4, p5)
	local u2 = p4;
	spawn(function()
		if not u2 then
			u2 = math.random(1, 500);
		end;
		u2 = Random.new(u2);
		local v3 = {};
		local v4 = {};
		for v5, v6 in pairs(p2:GetDescendants()) do
			if v6:IsA("BasePart") then
				if v6.Name == "Wall" or v6.Name == "Wall_Strip" then
					table.insert(v3, v6);
				end;
				if v6.Name == "Carpet" then
					table.insert(v4, v6);
				end;
			end;
		end;
		if #v4 <= 0 then
			for v7, v8 in pairs(p2:GetDescendants()) do
				if v8:IsA("BasePart") and v8.Name == "Floor" then
					table.insert(v4, v8);
				end;
			end;
		end;
		local v9 = RaycastParams.new();
		v9.CollisionGroup = "CheckWallStuff";
		local v10 = RaycastParams.new();
		v10.CollisionGroup = "CheckWallStuff";
		v1.module_events.flickerLights(p2, math.clamp(p3 / 5, 0.4, 1));
		local v11 = p3;
		for v12 = 1, 100 do
			local v13 = workspace:Raycast(v4[u2:NextInteger(1, #v4)].Position + Vector3.new(u2:NextInteger(-5, 5), u2:NextInteger(5, 11), u2:NextInteger(-5, 5)), CFrame.Angles(0, math.rad(u2:NextInteger(0, 360)), 0).LookVector * 150, v9);
			local v14 = Vector3.new(4, 2, 0);
			if v13 then
				local l__Position__15 = v13.Position;
				local l__Instance__16 = v13.Instance;
				local l__Normal__17 = v13.Normal;
				if l__Position__15 and l__Instance__16 and l__Instance__16.Anchored == true and (l__Instance__16.Name == "Wall" or l__Instance__16.Name == "WallAlt") then
					for v18 = 1, 4 do
						if v18 <= 2 then
							local v19 = 1;
						else
							v19 = -1;
						end;
						if v18 == 2 or v18 == 4 then
							local v20 = 1;
						else
							v20 = -1;
						end;
						local v21 = workspace:Raycast((CFrame.new(l__Position__15 + l__Normal__17, l__Position__15) * CFrame.new(v14.X / 2 * v19, v14.Y / 2 * v20, 0)).p, l__Normal__17 * -1.1, v10);
						if not v21 then
							local v22 = false;
							break;
						end;
						local l__Instance__23 = v21.Instance;
						local l__Normal__24 = v21.Normal;
						if not v21.Position then
							v22 = false;
							break;
						end;
						if not l__Instance__23 then
							v22 = false;
							break;
						end;
						if l__Instance__23.Anchored ~= true then
							v22 = false;
							break;
						end;
						if l__Instance__23.Name ~= "Wall" and l__Instance__23.Name ~= "WallAlt" then
							v22 = false;
							break;
						end;
					end;
				else
					v22 = false;
				end;
				if v22 == true then
					local v25 = u1[u2:NextInteger(1, #u1)]:Clone();
					v25:SetPrimaryPartCFrame(CFrame.new(l__Position__15, l__Position__15 + l__Normal__17) * CFrame.Angles(0, 0, math.rad(u2:NextInteger(-20, 20))));
					v25.Parent = p2;
					v25.PrimaryPart.PlaySound:Play();
					v25.PrimaryPart.Splat.Pitch = u2:NextInteger(80, 120) / 100;
					v25.PrimaryPart.Splat:Play();
					spawn(function()
						pcall(function()
							task.delay(3, function()
								for v26, v27 in pairs(v25:GetDescendants()) do
									if v27:IsA("BasePart") then
										v27.CanCollide = false;
										v27.CanQuery = false;
										v27.CanTouch = false;
										v27.CollisionGroupId = 1;
									end;
								end;
							end);
						end);
						if UserSettings().GameSettings.SavedQualityLevel.Value >= 5 then
							pcall(function()
								for v28 = 1, math.random(1, 3) do
									wait(math.random(5, 50) / 10);
									v25.Eye.Transparency = 1;
									v25.Eye.Decal.Transparency = 1;
									v25.PrimaryPart.ParticleEmitter:Emit(2);
									v25.PrimaryPart.Blink.Pitch = u2:NextInteger(80, 120) / 120;
									v25.PrimaryPart.Blink:Play();
									wait(0.1);
									v25.Eye.Transparency = 0;
									v25.Eye.Decal.Transparency = 0;
								end;
							end);
						end;
					end);
					v11 = v11 - 1;
				end;
			end;
			task.wait(0.016666666666666666);
			if v11 <= 0 then
				break;
			end;
		end;
	end);
	if p5 == true then
		spawn(function()
			for v29, v30 in pairs(p2:GetDescendants()) do
				if UserSettings().GameSettings.SavedQualityLevel.Value >= 5 and v30:IsA("BasePart") and (v30.Name == "Wall" or v30.Name == "Wall_Strip" or v30.Name == "WallAlt" or v30.Name == "Floor" or v30.Name == "Carpet" or v30.Name == "Ceiling") then
					local v31 = { Enum.NormalId.Front, Enum.NormalId.Back, Enum.NormalId.Right, Enum.NormalId.Left, Enum.NormalId.Top, Enum.NormalId.Bottom };
					if v30.Name == "Wall" or v30.Name == "Wall_Strip" or v30.Name == "WallAlt" then
						v31 = { Enum.NormalId.Front, Enum.NormalId.Back, Enum.NormalId.Right, Enum.NormalId.Left };
					end;
					if v30.Name == "Floor" or v30.Name == "Carpet" then
						v31 = { Enum.NormalId.Top };
					end;
					if v30.Name == "Ceiling" then
						v31 = { Enum.NormalId.Bottom };
					end;
					for v32, v33 in pairs(v31) do
						local v34 = game:GetService("ReplicatedStorage").Misc.EyesTexture:Clone();
						v34.Face = v33;
						v34.Parent = v30;
						task.spawn(function()
							local v35 = tick();
							for v36 = 1, 100 do
								v34.OffsetStudsU = math.random(-50, 50);
								v34.OffsetStudsV = math.random(-50, 50);
								task.wait(math.random(20, 100) / 100);
								if v35 + 12 <= tick() then
									break;
								end;
							end;
						end);
						game.Debris:AddItem(v34, 12);
					end;
				end;
			end;
		end);
	end;
end;
return v1;


Response:
if 	script.Parent.Parent.Parent.IsOn.Value then
	script.Parent.Parent:TweenPosition(UDim2.new(0, 0, 0, 0),Enum.EasingDirection.InOut,Enum.EasingStyle.Quad,1,true)
end
	script.Parent.MouseButton1Click:connect(function()
		if car.Misc.Popups.Parts.L.L.L.Enabled == false and car.Body.Lights.H.L.L.Enabled == false then
			script.Parent.BackgroundColor3 = Color3.new(0,255/255,0)
			script.Parent.TextStrokeColor3 = Color3.new(0,255/255,0)
			car.Misc.Popups.Parts.L.L.L.Enabled = true
			car.Body.Lights.R.L.L.Enabled = true
			car.Body.Lights.H.L.L.Enabled = false
			for index, child in pairs(car.Body.Lights.L:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
			for index, child in pairs(car.Misc.Popups.Parts.L:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
			for index, child in pairs(car.Body.Lights.R:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
			for index, child in pairs(car.Body.Lights.H:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
		elseif car.Misc.Popups.Parts.L.L.L.Enabled == true and car.Body.Lights.H.L.L.Enabled == false then
			script.Parent.BackgroundColor3 = Color3.new(0,0,255/255)
			script.Parent.TextStrokeColor3 = Color3.new(0,0,255/255)
			car.Misc.Popups.Parts.L.L.L.Enabled = false
			car.Body.Lights.R.L.L.Enabled = true
			car.Body.Lights.H.L.L.Enabled = true
			for index, child in pairs(car.Body.Lights.L:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
			for index, child in pairs(car.Misc.Popups.Parts.L:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
			for index, child in pairs(car.Body.Lights.R:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
			for index, child in pairs(car.Body.Lights.H:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
		elseif car.Misc.Popups.Parts.L.L.L.Enabled == false and car.Body.Lights.H.L.L.Enabled == true then
			script.Parent.BackgroundColor3 = Color3.new(0,0,0)
			script.Parent.TextStrokeColor3 = Color3.new(0,0,0)
			car.Misc.Popups.Parts.L.L.L.Enabled = false
			car.Body.Lights.R.L.L.Enabled = false
			car.Body.Lights.H.L.L.Enabled = false
			for index, child in pairs(car.Body.Lights.L:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
			for index, child in pairs(car.Misc.Popups.Parts.L:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
			for index, child in pairs(car.Body.Lights.R:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
			for index, child in pairs(car.Body.Lights.H:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
		end
	end)

	script.Parent.Parent.Parent.Values.Brake.Changed:connect(function()
		if script.Parent.Parent.Parent.Values.Brake.Value ~= 1 and script.Parent.Parent.Parent.IsOn.Value then
			for index, child in pairs(car.Body.Lights.B:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
			car.Body.Lights.B.L.L.Enabled = false
		else
			for index, child in pairs(car.Body.Lights.B:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
			car.Body.Lights.B.L.L.Enabled = true
		end
	end)

	script.Parent.Parent.Parent.Values.Brake.Changed:connect(function()
		if script.Parent.Parent.Parent.Values.Brake.Value ~= 1 then
			for index, child in pairs(car.Body.Lights.B:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			end
			car.Body.Lights.B.L.L.Enabled = false
		else
			for index, child in pairs(car.Body.Lights.B:GetChildren()) do
			child.Material = Enum.Material.Neon
			end
			car.Body.Lights.B.L.L.Enabled = true
		end
	end)

	script.Parent.Parent.Parent.Values.Gear.Changed:connect(function()
		if script.Parent.Parent.Parent.Values.Gear.Value == -1 then
			for index, child in pairs(car.Body.Lights.Rev:GetChildren()) do
			child.Material = Enum.Material.Neon
			car.DriveSeat.Reverse:Play()
			end
		else
			for index, child in pairs(car.Body.Lights.Rev:GetChildren()) do
			child.Material = Enum.Material.SmoothPlastic
			car.DriveSeat.Reverse:Stop()
			end
		end
	end)

	while wait() do
		if (car.DriveSeat.Velocity.magnitude/40)+0.300 < 1.3 then
		car.DriveSeat.Reverse.Pitch = (car.DriveSeat.Velocity.magnitude/40)+0.300
		car.DriveSeat.Reverse.Volume = (car.DriveSeat.Velocity.magnitude/150)
		else
		car.DriveSeat.Reverse.Pitch = 1.3
		car.DriveSeat.Reverse.Volume = .2
		end
	end


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

Response:
local l__LocalPlayer__1 = game.Players.LocalPlayer;
local v2 = require(script.Parent);
local v3 = require(script:FindFirstAncestor("MainUI").Modules.WindShake);
local v4 = require(l__LocalPlayer__1:WaitForChild("PlayerScripts"):WaitForChild("PlayerModule")):GetControls();
local v5 = game["Run Service"];
local l__UserInputService__6 = game:GetService("UserInputService");
local l__TweenService__7 = game:GetService("TweenService");
local v8 = require(game:GetService("ReplicatedStorage"):WaitForChild("ClientModules"):WaitForChild("Module_Events"));
v3:Init();
v2.gd:WaitForChild("ChaseInSession").Changed:Connect(function(p1)

end);
local function v9()
	local v10 = workspace.CurrentRooms:FindFirstChild(v2.gd.LatestRoom.Value);
	if v10 and v10:GetAttribute("RequiresKey") == true then

	end;
	if v10:WaitForChild("Door", 1) then
		local l__Door__11 = v10:FindFirstChild("Door");
		local v12 = 12;
		if v2.chase then
			v12 = 24;
		end;
		if l__Door__11 then
			local l__Value__1 = v2.gd.LatestRoom.Value;
			task.spawn(function()
				for v13 = 1, 10000 do
					wait(0.1);
					if l__Value__1 < tonumber(l__LocalPlayer__1:GetAttribute("CurrentRoom")) then
						return;
					end;
					if (l__LocalPlayer__1.Character.PrimaryPart.Position - l__Door__11.PrimaryPart.Position).Magnitude < v12 then
						local v14 = RaycastParams.new();
						v14.CollisionGroup = "Player";
						v14.FilterDescendantsInstances = { l__Door__11, l__LocalPlayer__1.Character };
						local v15 = workspace:Raycast(l__LocalPlayer__1.Character.PrimaryPart.Position, CFrame.new(l__LocalPlayer__1.Character.PrimaryPart.Position, l__Door__11.PrimaryPart.Position).LookVector * (l__LocalPlayer__1.Character.PrimaryPart.Position - l__Door__11.PrimaryPart.Position).Magnitude, v14);
						if not v15 then
							l__Door__11.ClientOpen:FireServer();
							return;
						end;
						if not v15.Position then
							l__Door__11.ClientOpen:FireServer();
							return;
						end;
					end;
				end;
			end);
		end;
	end;
	if v10:FindFirstChild("Shopkeeper") then
		require(script.Shopkeeper).run(v10);
	end;
	local v16, v17, v18 = ipairs(v10:GetDescendants());
	while true do
		v16(v17, v18);
		if not v16 then
			break;
		end;
		v18 = v16;
		if v17:IsA("BasePart") and v17:GetAttribute("WindShake") == true then
			print("sup");
			v3:AddObjectShake(v17);
		elseif v17.Name == "GuidingLightStuff" or v17.Name == "HelpLight" or v17.Name == "HelpParticle" then
			if v17:IsA("SpotLight") then
				if UserSettings().GameSettings.SavedQualityLevel.Value <= 4 then
					v17.Color = Color3.fromRGB(39, 190, 255);
					v17.Brightness = 8;
					v17.Range = 32;
					v17.Angle = 40;
				end;
			elseif v17:IsA("ParticleEmitter") and UserSettings().GameSettings.SavedQualityLevel.Value <= 5 then
				v17.Rate = 50;
			end;
		end;
	end;
	if v10:GetAttribute("Header") ~= nil and v10:GetAttribute("Header") ~= "" and v10:GetAttribute("Header") ~= " " then
		print("doing header");
		v2.titlelocation(v10:GetAttribute("Header"));
	end;
	if v10:FindFirstChild("FigureSetup", true) then
		local l__FigureRagdoll__19 = v10:FindFirstChild("FigureSetup", true).FigureRagdoll;
		local l__Parent__20 = l__FigureRagdoll__19.Parent;
		local v21 = 0;
		local l__Click__22 = l__FigureRagdoll__19.Head.Click;
		local l__Growl__23 = l__FigureRagdoll__19.Head.Growl;
		local v24 = {};
		for v25, v26 in pairs(l__FigureRagdoll__19:GetDescendants()) do
			if v26:IsA("Light") and v26.Name == "BlisterLight" then
				v26.Enabled = true;
				v26.Brightness = 0;
				table.insert(v24, {
					Light = v26,
					Distance = l__FigureRagdoll__19.Head.Position - v26.Parent.WorldPosition
				});
			end;
		end;
		local v27 = TweenInfo.new(0.1, Enum.EasingStyle.Linear);
		for v28 = 1, 100000000 do
			wait(0.1);
			if not l__FigureRagdoll__19 then
				break;
			end;
			if l__FigureRagdoll__19.Parent ~= l__Parent__20 then
				break;
			end;
			local v29 = (l__Click__22.PlaybackLoudness + l__Growl__23.PlaybackLoudness) / 60;
			if v29 ~= v21 then
				for v30, v31 in v24, nil do
					delay(v31.Distance / 2, function()
						l__TweenService__7:Create(v31.Light, v27, {
							Brightness = v29
						}):Play();
					end);
				end;
			end;
			v21 = v29;
		end;
	end;
	if v10:FindFirstChild("FigureAnimatedWelded", true) then
		local l__FigureAnimatedWelded__32 = v10:FindFirstChild("FigureAnimatedWelded", true);
		local l__Parent__33 = l__FigureAnimatedWelded__32.Parent;
		local v34 = 0;
		local l__Click__35 = l__FigureAnimatedWelded__32.Parent.Head.Click;
		local l__Growl__36 = l__FigureAnimatedWelded__32.Parent.Head.Growl;
		local v37 = {};
		for v38, v39 in pairs(l__FigureAnimatedWelded__32:GetDescendants()) do
			if v39:IsA("Light") and v39.Name == "BlisterLight" then
				v39.Enabled = true;
				v39.Brightness = 0;
				table.insert(v37, {
					Light = v39,
					Distance = l__FigureAnimatedWelded__32.Parent.Head.Position - v39.Parent.WorldPosition
				});
			end;
		end;
		local v40 = TweenInfo.new(0.1, Enum.EasingStyle.Linear);
		for v41 = 1, 100000000 do
			wait(0.1);
			if not l__FigureAnimatedWelded__32 then
				break;
			end;
			if l__FigureAnimatedWelded__32.Parent ~= l__Parent__33 then
				break;
			end;
			local v42 = (l__Click__35.PlaybackLoudness + l__Growl__36.PlaybackLoudness) / 90 - 0.15;
			if v42 ~= v34 then
				for v43, v44 in v37, nil do
					delay(v44.Distance / 4, function()
						l__TweenService__7:Create(v44.Light, v40, {
							Brightness = v42
						}):Play();
					end);
				end;
			end;
			v34 = v42;
		end;
	end;
end;
v2.gd:WaitForChild("FinishedLoadingRoom").Changed:Connect(v9);
v2.gd:WaitForChild("Preload").Changed:Connect(v9);
workspace:WaitForChild("Ambience_Dark").Played:Connect(function()

end);
l__LocalPlayer__1:GetAttributeChangedSignal("CurrentRoom"):Connect(function()
	local v45 = workspace.CurrentRooms:FindFirstChild(l__LocalPlayer__1:GetAttribute("CurrentRoom"));
	if v45 then
		local v46 = Color3.fromRGB(67, 51, 56);
		local v47 = v45:GetAttribute("Ambient");
		if v47 and type(v47) == "userdata" then
			v46 = v47;
		end;
		l__TweenService__7:Create(game.Lighting, TweenInfo.new(0.4, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut), {
			Ambient = v46
		}):Play();
	end;
end);
local l__Shopkeeper__48 = workspace:FindFirstChild("Shopkeeper", true);
if l__Shopkeeper__48 then
	require(script.Shopkeeper).run(l__Shopkeeper__48.Parent);
end;


Prompt: -- If in-game, enable ctrl hotkeys for sibling selection & selection clearing

Response:
if Mode == 'Tool' then
	AssignHotkey({ 'LeftControl', 'LeftBracket' }, Support.Call(Targeting.SelectSiblings, false, false));
	AssignHotkey({ 'RightControl', 'LeftBracket' }, Support.Call(Targeting.SelectSiblings, false, false));
	AssignHotkey({ 'LeftControl', 'R' }, Support.Call(Selection.Clear, true));
	AssignHotkey({ 'RightControl', 'R' }, Support.Call(Selection.Clear, true));
end;

function GroupSelection(GroupType)
	-- Groups the selected items

	-- Create history record
	local HistoryRecord = {
		Items = Support.CloneTable(Selection.Items),
		CurrentParents = Support.GetListMembers(Selection.Items, 'Parent')
	}

	function HistoryRecord:Unapply()
		SyncAPI:Invoke('SetParent', self.Items, self.CurrentParents)
		SyncAPI:Invoke('Remove', { self.NewParent })
		Selection.Replace(self.Items)
	end

	function HistoryRecord:Apply()
		SyncAPI:Invoke('UndoRemove', { self.NewParent })
		SyncAPI:Invoke('SetParent', self.Items, self.NewParent)
		Selection.Replace({ self.NewParent })
	end

	-- Perform group creation
	HistoryRecord.NewParent = SyncAPI:Invoke('CreateGroup', GroupType,
		GetHighestParent(HistoryRecord.Items),
		HistoryRecord.Items
	)

	-- Register history record
	History.Add(HistoryRecord)

	-- Select new group
	Selection.Replace({ HistoryRecord.NewParent })

end

function UngroupSelection()
	-- Ungroups the selected groups

	-- Create history record
	local HistoryRecord = {
		Selection = Selection.Items
	}

	function HistoryRecord:Unapply()
		SyncAPI:Invoke('UndoRemove', self.Groups)

		-- Reparent children
		for GroupId, Items in ipairs(self.GroupChildren) do
			coroutine.resume(coroutine.create(function ()
				SyncAPI:Invoke('SetParent', Items, self.Groups[GroupId])
			end))
		end

		-- Reselect groups
		Selection.Replace(self.Selection)
	end

	function HistoryRecord:Apply()

		-- Get groups from selection
		self.Groups = {}
		for _, Item in ipairs(self.Selection) do
			if Item:IsA 'Model' or Item:IsA 'Folder' then
				self.Groups[#self.Groups + 1] = Item
			end
		end

		-- Perform ungrouping
		self.GroupParents = Support.GetListMembers(self.Groups, 'Parent')
		self.GroupChildren = SyncAPI:Invoke('Ungroup', self.Groups)

		-- Get unpacked children
		local UnpackedChildren = Support.CloneTable(self.Selection)
		for GroupId, Children in pairs(self.GroupChildren) do
			for _, Child in ipairs(Children) do
				UnpackedChildren[#UnpackedChildren + 1] = Child
			end
		end

		-- Select unpacked items
		Selection.Replace(UnpackedChildren)

	end

	-- Perform action
	HistoryRecord:Apply()

	-- Register history record
	History.Add(HistoryRecord)

end


Response:
local  Paint = false

script.Parent.MouseButton1Click:connect(function()
	Paint = not Paint
	handler:FireServer("Alder",Paint)
end)


Prompt:
--[=[
	@within Plasma
	@function arrow
	@tag widgets
	@param from Vector3 | CFrame | BasePart
	@param to Vector3 | BasePart | nil
	@param color Color3? -- Optional color. Random if not specified.

	- `arrow(from: Vector3, to: Vector3)` -> Creates an arrow between `from` and `to`
	- `arrow(point: Vector3)` -> Creates an arrow pointing at `point`
	- `arrow(cframe: CFrame)` -> Creates an arrow with its point at the CFrame position facing the CFrame LookVector
	- `arrow(part: BasePart)` -> Arrow represents the Part's CFrame
	- `arrow(fromPart: BasePart, toPart: BasePart)` -> Arrow between the two parts

	![Arrows](https://i.eryn.io/2150/arrows.png)

	```lua
	Plasma.arrow(Vector3.new(0, 0, 0))
	Plasma.arrow(Vector3.new(5, 5, 5), Vector3.new(10, 10, 10))
	```
]=]

Response:
local function arrow(name, container, scale, color, zindex)
	local body = Instance.new("CylinderHandleAdornment")

	body.Name = name .. "Body"
	body.Color3 = color
	body.Radius = 0.15
	body.Adornee = workspace.Terrain
	body.Transparency = 0
	body.Radius = 0.15 * scale
	body.Transparency = 0
	body.AlwaysOnTop = true
	body.ZIndex = zindex

	body.Parent = container

	local point = Instance.new("ConeHandleAdornment")

	scale = scale == 1 and 1 or 1.4

	point.Name = name .. "Point"
	point.Color3 = color
	point.Radius = 0.5 * scale
	point.Transparency = 0
	point.Adornee = workspace.Terrain
	point.Height = 2 * scale
	point.AlwaysOnTop = true
	point.ZIndex = zindex

	point.Parent = container
end

local function update(body, point, from, to, scale)
	body.Height = (from - to).magnitude - 2
	body.CFrame = CFrame.lookAt(((from + to) / 2) - ((to - from).unit * 1), to)
	point.CFrame = CFrame.lookAt((CFrame.lookAt(to, from) * CFrame.new(0, 0, -2 - ((scale - 1) / 2))).p, to)
end

local Runtime = require(script.Parent.Parent.Runtime)

return Runtime.widget(function(from, to, color)
	local fallbackColor = Runtime.useState(BrickColor.random().Color)
	color = color or fallbackColor

	if typeof(from) == "Instance" then
		if from:IsA("BasePart") then
			from = from.CFrame
		elseif from:IsA("Attachment") then
			from = from.WorldCFrame
		end

		if to ~= nil then
			from = from.p
		end
	end

	if typeof(to) == "Instance" then
		if to:IsA("BasePart") then
			to = to.Position
		elseif to:IsA("Attachment") then
			to = to.WorldPosition
		end
	end

	if typeof(from) == "CFrame" and to == nil then
		local look = from.lookVector
		to = from.p
		from = to + (look * -10)
	end

	if to == nil then
		to = from
		from = to + Vector3.new(0, 10, 0)
	end

	assert(typeof(from) == "Vector3" and typeof(to) == "Vector3", "Passed parameters are of invalid types")

	local refs = Runtime.useInstance(function(ref)
		local container = Instance.new("Folder")
		container.Name = "Arrow"

		ref.folder = container

		arrow("front", container, 1, color, 1)
		arrow("back", container, 2, Color3.new(0, 0, 0), -1)

		return container
	end)

	local folder = refs.folder

	update(folder.frontBody, folder.frontPoint, from, to, 1)
	update(folder.backBody, folder.backPoint, from, to, 1.4)

	folder.frontBody.Color3 = color
	folder.frontPoint.Color3 = color
end)


Prompt:
--[[
	*
	* Signals allow events to be dispatched to any number of listeners.
]]

Response:
local Signal
do
	Signal = setmetatable({}, {
		__tostring = function()
			return "Signal"
		end,
	})
	Signal.__index = Signal
	function Signal.new(...)
		local self = setmetatable({}, Signal)
		return self:constructor(...) or self
	end
	function Signal:constructor()
		self.waitingThreads = {}
		self._handlerListHead = nil
	end
	function Signal:Connect(callback)
		local connection = Connection.new(self, callback)
		if self._handlerListHead ~= nil then
			connection._next = self._handlerListHead
		end
		self._handlerListHead = connection
		return connection
	end
	function Signal:Once(callback)
		local done = false
		local c
		c = self:Connect(function(...)
			local args = { ... }
			if done then
				return nil
			end
			done = true
			c:Disconnect()
			callback(unpack(args))
		end)
		return c
	end
	function Signal:Fire(...)
		local args = { ... }
		local item = self._handlerListHead
		while item do
			if item.Connected then
				task.spawn(item._fn, unpack(args))
			end
			item = item._next
		end
	end
	function Signal:FireDeferred(...)
		local args = { ... }
		local item = self._handlerListHead
		while item do
			if item.Connected then
				task.defer(item._fn, unpack(args))
			end
			item = item._next
		end
	end
	function Signal:Wait()
		local running = coroutine.running()
		self.waitingThreads[running] = true
		self:Once(function(...)
			local args = { ... }
			self.waitingThreads[running] = nil
			task.spawn(running, unpack(args))
		end)
		return coroutine.yield()
	end
	function Signal:DisconnectAll()
		local item = self._handlerListHead
		while item do
			item.Connected = false
			item = item._next
		end
		self._handlerListHead = nil
		local _waitingThreads = self.waitingThreads
		local _arg0 = function(thread)
			return task.cancel(thread)
		end
		for _v in _waitingThreads do
			_arg0(_v, _v, _waitingThreads)
		end
		table.clear(self.waitingThreads)
	end
	function Signal:Destroy()
		self:DisconnectAll()
	end
end
return {
	Connection = Connection,
	Signal = Signal,
}


Prompt: -- BASIC VARIABLES --

Response:
local Player = game.Players.LocalPlayer
local Char
local HumRP
local Humanoid

local Tool = script.Parent


Prompt: --bp.Position = shelly.PrimaryPart.Position

Response:
if not shellyGood then bp.Parent,bg.Parent= nil,nil return end
bp.Parent = nil
wait(math.random(3,8))
end

while true do
if shellyGood then
MoveShelly()
else
wait(1)
end
end


Prompt:
------------------------------------------------------------------------
--
-- * used only in luaK:prefix()
------------------------------------------------------------------------

Response:
function luaK:codenot(fs, e)
  self:dischargevars(fs, e)
  local k = e.k
  if k == "VNIL" or k == "VFALSE" then
    e.k = "VTRUE"
  elseif k == "VK" or k == "VKNUM" or k == "VTRUE" then
    e.k = "VFALSE"
  elseif k == "VJMP" then
    self:invertjump(fs, e)
  elseif k == "VRELOCABLE" or k == "VNONRELOC" then
    self:discharge2anyreg(fs, e)
    self:freeexp(fs, e)
    e.info = self:codeABC(fs, "OP_NOT", 0, e.info, 0)
    e.k = "VRELOCABLE"
  else
    assert(0)  -- cannot happen
  end
  -- interchange true and false lists
  e.f, e.t = e.t, e.f
  self:removevalues(fs, e.f)
  self:removevalues(fs, e.t)
end


Prompt: --REVERSE

Response:
				if _CGear==1 and _GBrake > 0  and car.DriveSeat.Velocity.Magnitude < 0 then
					_CGear = -1
				else
					if _Tune.AutoShiftMode == "RPM" then
						if _RPM>(_Tune.PeakRPM+_Tune.AutoUpThresh) then
							_CGear=math.min(_CGear+1,#_Tune.Ratios-2)
						elseif math.max(math.min(maxSpin*_Tune.Ratios[_CGear+1]*fFDr,_Tune.Redline+100),_Tune.IdleRPM)<(_Tune.PeakRPM-_Tune.AutoDownThresh) then
							_CGear=math.max(_CGear-1,1)
						end
					else
						if car.DriveSeat.Velocity.Magnitude > math.ceil(wDRatio*(_Tune.PeakRPM+_Tune.AutoUpThresh)/_Tune.Ratios[_CGear+2]/fFD) then
							_CGear=math.min(_CGear+1,#_Tune.Ratios-2)
						elseif car.DriveSeat.Velocity.Magnitude < math.ceil(wDRatio*(_Tune.PeakRPM-_Tune.AutoDownThresh)/_Tune.Ratios[_CGear+1]/fFD) then
							_CGear=math.max(_CGear-1,1)
						end
					end
				end
			else
				if _GThrot-(_Tune.IdleThrottle/100) > 0 and car.DriveSeat.Velocity.Magnitude < 20 then
					_CGear = 1
				end
			end
		end

		--Average Rotational Speed Calculation
		local fwspeed=0
		local fwcount=0
		local rwspeed=0
		local rwcount=0

		for i,v in pairs(car.Wheels:GetChildren()) do
			if v.Name=="FL" or v.Name=="FR" or v.Name == "F" then
				fwspeed=fwspeed+v.RotVelocity.Magnitude
				fwcount=fwcount+1
			elseif v.Name=="RL" or v.Name=="RR" or v.Name == "R" then
				rwspeed=rwspeed+v.RotVelocity.Magnitude
				rwcount=rwcount+1
			end
		end
		fwspeed=fwspeed/fwcount
		rwspeed=rwspeed/rwcount
		local cwspeed=(fwspeed+rwspeed)/2

		--Update Wheels
		for i,v in pairs(car.Wheels:GetChildren()) do
			--Reference Wheel Orientation
			local Ref=(CFrame.new(v.Position-((v.Arm.CFrame*cfWRot).lookVector),v.Position)*cfYRot).lookVector
			local aRef=1
			local diffMult=1
			if v.Name=="FL" or v.Name=="RL" then aRef=-1 end

			--AWD Torque Scaling
			if _Tune.Config == "AWD" then _OutTorque = _OutTorque*rtTwo end

			--Differential/Torque-Vectoring
			if v.Name=="FL" or v.Name=="FR" then
				diffMult=math.max(0,math.min(1,1+((((v.RotVelocity.Magnitude-fwspeed)/fwspeed)/(math.max(_Tune.FDiffSlipThres,1)/100))*((_Tune.FDiffLockThres-50)/50))))
				if _Tune.Config == "AWD" then
					diffMult=math.max(0,math.min(1,diffMult*(1+((((fwspeed-cwspeed)/cwspeed)/(math.max(_Tune.CDiffSlipThres,1)/100))*((_Tune.CDiffLockThres-50)/50)))))
				end
			elseif v.Name=="RL" or v.Name=="RR" then
				diffMult=math.max(0,math.min(1,1+((((v.RotVelocity.Magnitude-rwspeed)/rwspeed)/(math.max(_Tune.RDiffSlipThres,1)/100))*((_Tune.RDiffLockThres-50)/50))))
				if _Tune.Config == "AWD" then
					diffMult=math.max(0,math.min(1,diffMult*(1+((((rwspeed-cwspeed)/cwspeed)/(math.max(_Tune.CDiffSlipThres,1)/100))*((_Tune.CDiffLockThres-50)/50)))))
				end
			end

			_TCSActive = false
			_ABSActive = false
			--Output
			if _PBrake and ((_Tune.Config ~= "FWD" and (((v.Name=="FL" or v.Name=="FR") and car.DriveSeat.Velocity.Magnitude<20) or ((v.Name=="RR" or v.Name=="RL") and car.DriveSeat.Velocity.Magnitude>=20))) or (_Tune.Config == "FWD" and (v.Name=="RR" or v.Name=="RL"))) then
				--PBrake
				v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*PBrakeForce
				v["#AV"].angularvelocity=Vector3.new()
			else
				--Apply Power
				if ((_TMode == "Manual" or _TMode == "Semi") and _GBrake==0) or (_TMode == "Auto" and ((_CGear>-1 and _GBrake==0 ) or (_CGear==-1 and _GThrot-(_Tune.IdleThrottle/100)==0 )))then
					local driven = false
					for _,a in pairs(Drive) do if a==v then driven = true end end
					if driven then
						local on=1
						if not script.Parent.IsOn.Value then on=0 end
						local throt = _GThrot
						if _TMode == "Auto" and _CGear==-1 then throt = _GBrake end

						--Apply TCS
						local tqTCS = 1
						if _TCS then
							tqTCS = 1-(math.min(math.max(0,math.abs(v.RotVelocity.Magnitude*(v.Size.x/2) - v.Velocity.Magnitude)-_Tune.TCSThreshold)/_Tune.TCSGradient,1)*(1-(_Tune.TCSLimit/100)))
						end
						if tqTCS < 1 then
							_TCSActive = true
						end

						--Update Forces
						local dir = 1
						if _CGear==-1 then dir = -1 end
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*_OutTorque*(1+(v.RotVelocity.Magnitude/60)^1.15)*throt*tqTCS*diffMult*on
						v["#AV"].angularvelocity=Ref*aRef*_spLimit*dir
					else
						v["#AV"].maxTorque=Vector3.new()
						v["#AV"].angularvelocity=Vector3.new()
					end

				--Brakes
				else
					local brake = _GBrake
					if _TMode == "Auto" and _CGear==-1 then brake = _GThrot end

					--Apply ABS
					local tqABS = 1
					if _ABS and math.abs(v.RotVelocity.Magnitude*(v.Size.x/2) - v.Velocity.Magnitude)-_Tune.ABSThreshold>0 then
						tqABS = 0
					end
					if tqABS < 1 then
						_ABSActive = true
					end

					--Update Forces
					if v.Name=="FL" or v.Name=="FR" or v.Name=="F" then
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*FBrakeForce*brake*tqABS
					else
						v["#AV"].maxTorque=Vector3.new(math.abs(Ref.x),math.abs(Ref.y),math.abs(Ref.z))*RBrakeForce*brake*tqABS
					end
					v["#AV"].angularvelocity=Vector3.new()
				end
			end
		end
	end


Prompt: -- Services

Response:
local playerService = game:GetService("Players")

playerService.PlayerAdded:Connect(function (plr)
	plr.CharacterAdded:wait()
	plr.CameraMode = Enum.CameraMode.LockFirstPerson
end)


Prompt: -- Initialization

Response:
game.StarterGui.ResetPlayerGuiOnSpawn = false
ScreenGui.Parent = Player:WaitForChild("PlayerGui")


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

Response:
local POP_RESTORE_RATE = 0.3
local CAST_SCREEN_SCALES = { -- (Relative)
	Vector2.new(1, 1) / 2, -- Center
	Vector2.new(0, 0), -- Top left
	Vector2.new(1, 0), -- Top right
	Vector2.new(1, 1), -- Bottom right
	Vector2.new(0, 1), -- Bottom left
}
local NEAR_CLIP_PLANE_OFFSET = 0.5 --NOTE: Not configurable


Prompt:
--[[
	Package link auto-generated by Rotriever
]]

Response:
local PackageIndex = script.Parent.Parent.Parent._Index

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

return Package


Prompt: --Main

Response: return require(ReplicatedStorage.Systems.EntitySystem.EntityClient.EntityComponent)


Prompt: --[[Driver Handling]]

Response:
	--Driver Sit
	car.Body.CarName.Value.VehicleSeat.ChildAdded:connect(function(child)
		if child.Name=="SeatWeld" and child:IsA("Weld") and game.Players:GetPlayerFromCharacter(child.Part1.Parent)~=nil then
			--Distribute Client Interface
			local p=game.Players:GetPlayerFromCharacter(child.Part1.Parent)
			car.Body.CarName.Value.VehicleSeat:SetNetworkOwner(p)
			local g=script.Parent["A-Chassis Interface"]:Clone()
			g.Parent=p.PlayerGui
		end
	end)

	--Driver Leave
	car.Body.CarName.Value.VehicleSeat.ChildRemoved:connect(function(child)
		if child.Name=="SeatWeld" and child:IsA("Weld") then
			--Remove Flip Force
			if car.Body.CarName.Value.VehicleSeat:FindFirstChild("Flip")~=nil then
				car.Body.CarName.Value.VehicleSeat.Flip.MaxTorque = Vector3.new()
			end

			--Remove Wheel Force
			for i,v in pairs(car.Wheels:GetChildren()) do
				if v:FindFirstChild("#AV")~=nil then
					if v["#AV"]:IsA("BodyAngularVelocity") then
						if v["#AV"].AngularVelocity.Magnitude>0 then
							v["#AV"].AngularVelocity = Vector3.new()
							v["#AV"].MaxTorque = Vector3.new()
						end
					else
						if v["#AV"].AngularVelocity>0 then
							v["#AV"].AngularVelocity = 0
							v["#AV"].MotorMaxTorque = 0
						end
					end
				end
			end
		end
	end)


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

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

local SLASH_DAMAGE = 100
local DOWNSTAB_DAMAGE = 100
local THROWING_DAMAGE = 100
local HOLD_TO_THROW_TIME = 0.38

local Damage = 100

local MyHumanoid = nil
local MyTorso = nil
local MyCharacter = nil
local MyPlayer = nil

local Tool = script.Parent
local kn = WaitForChild(Tool, 'kn')

local BlowConnection
local Button1DownConnection
local Button1UpConnection

local PlayStabPunch
local PlayDownStab
local PlayThrow
local PlayThrowCharge

local IconUrl = Tool.TextureId  -- URL to the weapon knife icon asset

local DebrisService = Game:GetService('Debris')
local PlayersService = Game:GetService('Players')

local SlashSound

local HitPlayers = {}

local LeftButtonDownTime = nil

local Attacking = false

function Blow(hit)
	if Attacking then
		BlowDamage(hit, Damage)
	end
end

function BlowDamage(hit, damage)
	local humanoid = hit.Parent:FindFirstChild('Humanoid')
	local player = PlayersService:GetPlayerFromCharacter(hit.Parent)
	if humanoid ~= nil and MyHumanoid ~= nil and humanoid ~= MyHumanoid then
		if not MyPlayer.Neutral then
			-- Ignore teammates hit
			if player and player ~= MyPlayer and player.TeamColor == MyPlayer.TeamColor then
				return
			end
		end
		-- final check, make sure weapon is in-hand
		local rightArm = MyCharacter:FindFirstChild('Right Arm')
		if (rightArm ~= nil) then
			-- Check if the weld exists between the hand and the weapon
			local joint = rightArm:FindFirstChild('RightGrip')
			if (joint ~= nil and (joint.Part0 == kn or joint.Part1 == kn)) then
				-- Make sure you only hit them once per swing
				if player and not HitPlayers[player] then
					TagHumanoid(humanoid, MyPlayer)
					print("Sending " .. damage)
					humanoid:TakeDamage(damage)
					kn.Hit.Volume = 1
					HitPlayers[player] = true
				end
			end
		end
	end
end

function TagHumanoid(humanoid, player)
	-- Add more tags here to customize what tags are available.
	while humanoid:FindFirstChild('creator') do
		humanoid:FindFirstChild('creator'):Destroy()
	end

	local creatorTag = Instance.new('ObjectValue')
	creatorTag.Value = player
	creatorTag.Name = 'creator'
	creatorTag.Parent = humanoid
	DebrisService:AddItem(creatorTag, 1.5)

	local weaponIconTag = Instance.new('StringValue')
	weaponIconTag.Value = IconUrl
	weaponIconTag.Name = 'icon'
	weaponIconTag.Parent = creatorTag
	DebrisService:AddItem(weaponIconTag, 1.5)
end

function HardAttack()
	Damage = SLASH_DAMAGE
	SlashSound:play()
	if PlayStabPunch then
		PlayStabPunch.Value = true
		wait(1.0)
		PlayStabPunch.Value = false
	end
end

function NormalAttack()
	Damage = DOWNSTAB_DAMAGE
	KnifeDown()
	SlashSound:play()
	if PlayDownStab then
		PlayDownStab.Value = true
		wait(1.0)
		PlayDownStab.Value = false
	end
	KnifeUp()
end

function ThrowAttack()
	KnifeOut()
	if PlayThrow then
		PlayThrow.Value = true
		wait(0.3)
		if not kn then return end
		local throwingkn = kn:Clone()
		DebrisService:AddItem(throwingkn, 5)
		throwingkn.Parent = Workspace
		if MyCharacter and MyHumanoid then
			throwingkn.Velocity = (MyHumanoid.TargetPoint - throwingkn.CFrame.p).unit * 100
			-- set the orientation to the direction it is being thrown in
			throwingkn.CFrame = CFrame.new(throwingkn.CFrame.p, throwingkn.CFrame.p + throwingkn.Velocity) * CFrame.Angles(0, 0, math.rad(-90))
			local floatingForce = Instance.new('BodyForce', throwingkn)
			floatingForce.force = Vector3.new(0, 196.2 * throwingkn:GetMass() * 0.98, 0)
			local spin = Instance.new('BodyAngularVelocity', throwingkn)
			spin.angularvelocity = throwingkn.CFrame:vectorToWorldSpace(Vector3.new(0, -400, 0))
		end
		kn.Transparency = 1
		-- Wait so that the knife has left the thrower's general area
		wait(0.08)
		if throwingkn then
			local touchedConn = throwingkn.Touched:connect(function(hit) print("hit throw") BlowDamage(hit, THROWING_DAMAGE) end)
		end
		-- must check if it still exists since we waited
		if throwingkn then
			throwingkn.CanCollide = true
		end
		wait(0.6)
		if kn and PlayThrow then
			kn.Transparency = 0
			PlayThrow.Value = false
		end
	end
	KnifeUp()
end

function KnifeUp()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,1)
end

function KnifeDown()
	Tool.GripForward = Vector3.new(-1,0,0)
	Tool.GripRight = Vector3.new(0,1,0)
	Tool.GripUp = Vector3.new(0,0,-1)
end

function KnifeOut()
	Tool.GripForward = Vector3.new(0,0,1)
	Tool.GripRight = Vector3.new(0,-1,0)
	Tool.GripUp = Vector3.new(-1,0,0)
end

Tool.Enabled = true

function OnLeftButtonDown()
	LeftButtonDownTime = time()
	if PlayThrowCharge then
		PlayThrowCharge.Value = true
	end
end

function OnLeftButtonUp()
	if not Tool.Enabled then return end
	-- Reset the list of hit players every time we start a new attack
	HitPlayers = {}
	if PlayThrowCharge then
		PlayThrowCharge.Value = false
	end
	if Tool.Enabled and MyHumanoid and MyHumanoid.Health > 0 then
		Tool.Enabled = false
		local currTime = time()
		if LeftButtonDownTime and currTime - LeftButtonDownTime > HOLD_TO_THROW_TIME and
			currTime - LeftButtonDownTime < 1.15 then
			ThrowAttack()
		else
			Attacking = true
			if math.random(1, 2) == 1 then
				HardAttack()
			else
				NormalAttack()
			end
			Attacking = false
		end
		Tool.Enabled = true
	end
end

function OnEquipped(mouse)
	PlayStabPunch = WaitForChild(Tool, 'PlayStabPunch')
	PlayDownStab = WaitForChild(Tool, 'PlayDownStab')
	PlayThrow = WaitForChild(Tool, 'PlayThrow')
	PlayThrowCharge = WaitForChild(Tool, 'PlayThrowCharge')
 	SlashSound = WaitForChild(kn, 'Equip')
	kn.Splat.Volume = 0
	SlashSound:play()
	BlowConnection = kn.Touched:connect(Blow)
	MyCharacter = Tool.Parent
	MyTorso = MyCharacter:FindFirstChild('Torso')
	MyHumanoid = MyCharacter:FindFirstChild('Humanoid')
	MyPlayer = PlayersService.LocalPlayer
	if mouse then
		Button1DownConnection = mouse.Button1Down:connect(OnLeftButtonDown)
		Button1UpConnection = mouse.Button1Up:connect(OnLeftButtonUp)
	end
	KnifeUp()
end

function OnUnequipped()
	-- Unequip logic here
	if BlowConnection then
		BlowConnection:disconnect()
		BlowConnection = nil
	end
	if Button1DownConnection then
		Button1DownConnection:disconnect()
		Button1DownConnection = nil
	end
	if Button1UpConnection then
		Button1UpConnection:disconnect()
		Button1UpConnection = nil
	end
	MyHumanoid = nil
end

Tool.Equipped:connect(OnEquipped)
Tool.Unequipped:connect(OnUnequipped)


Prompt: -- Initialize the tool

Response:
local PaintTool = {

	Name = 'Paint Tool';
	Color = BrickColor.new 'Really red';

	-- Default options
	BrickColor = nil;

};

function PaintTool:Equip()
	-- Enables the tool's equipped functionality

	-- Set up maid for cleanup
	self.Maid = Maid.new()

	-- Start up our interface
	ShowUI();
	self:BindShortcutKeys()
	self:EnableClickPainting()

end;

function PaintTool:Unequip()
	-- Disables the tool's equipped functionality

	-- Hide UI
	HideUI()

	-- Clean up resources
	self.Maid = self.Maid:Destroy()

end;

function ShowUI()
	-- Creates and reveals the UI

	-- Reveal UI if already created
	if PaintTool.UI then

		-- Reveal the UI
		PaintTool.UI.Visible = true;

		-- Update the UI every 0.1 seconds
		UIUpdater = Support.ScheduleRecurringTask(UpdateUI, 0.1);

		-- Skip UI creation
		return;

	end;

	-- Create the UI
	PaintTool.UI = Core.Tool.Interfaces.BTPaintToolGUI:Clone();
	PaintTool.UI.Parent = Core.UI;
	PaintTool.UI.Visible = true;

	-- Track palette buttons
	PaletteButtons = {};

	-- Enable the palette
	for _, Column in pairs(PaintTool.UI.Palette:GetChildren()) do
		for _, Button in pairs(Column:GetChildren()) do
			if Button.ClassName == 'TextButton' then

				-- Recolor the selection when the button is clicked
				Button.MouseButton1Click:Connect(function ()
					SetColor(BrickColor.new(Button.Name).Color);
				end);

				-- Register the button
				PaletteButtons[Button.Name] = Button;

			end;
		end;
	end;

	-- Paint selection when current color indicator is clicked
	PaintTool.UI.Controls.LastColorButton.MouseButton1Click:Connect(PaintParts);

	-- Enable color picker button
	PaintTool.UI.Controls.ColorPickerButton.MouseButton1Click:Connect(function ()
		Core.Cheer(Core.Tool.Interfaces.BTHSVColorPicker, Core.UI).Start(
			Support.IdentifyCommonProperty(Selection.Parts, 'Color') or Color3.new(1, 1, 1),
			SetColor,
			Core.Targeting.CancelSelecting,
			PreviewColor
		);
	end);

	-- Update the UI every 0.1 seconds
	UIUpdater = Support.ScheduleRecurringTask(UpdateUI, 0.1);

end;

function HideUI()
	-- Hides the tool UI

	-- Make sure there's a UI
	if not PaintTool.UI then
		return;
	end;

	-- Hide the UI
	PaintTool.UI.Visible = false;

	-- Stop updating the UI
	UIUpdater:Stop();

end;

function UpdateUI()
	-- Updates information on the UI

	-- Make sure the UI's on
	if not PaintTool.UI then
		return;
	end;

	-----------------------------------------
	-- Update the color information indicator
	-----------------------------------------

	-- Clear old color indicators
	for Color, Button in pairs(PaletteButtons) do
		Button.Text = '';
	end;

	-- Indicate the variety of colors in the selection
	for _, Part in pairs(Selection.Parts) do
		if PaletteButtons[Part.BrickColor.Name] and Part.Color == Part.BrickColor.Color then
			PaletteButtons[Part.BrickColor.Name].Text = '+';
		end;
	end;

	-- Update the color picker button's background
	local CommonColor = Support.IdentifyCommonProperty(Selection.Parts, 'Color');
	PaintTool.UI.Controls.ColorPickerButton.ImageColor3 = CommonColor or PaintTool.BrickColor or Color3.new(1, 0, 0);

end;

function SetColor(Color)
	-- Changes the color option to `Color`

	-- Set the color option
	PaintTool.BrickColor = Color;

	-- Use BrickColor name if color matches one
	local EquivalentBrickColor = BrickColor.new(Color);
	local RGBText = ('(%d, %d, %d)'):format(Color.r * 255, Color.g * 255, Color.b * 255);
	local ColorText = (EquivalentBrickColor.Color == Color) and EquivalentBrickColor.Name or RGBText;

	-- Shortcuts to color indicators
	local ColorLabel = PaintTool.UI.Controls.LastColorButton.ColorName;
	local ColorSquare = ColorLabel.ColorSquare;

	-- Update the indicators
	ColorLabel.Visible = true;
	ColorLabel.Text = ColorText;
	ColorSquare.BackgroundColor3 = Color;
	ColorSquare.Position = UDim2.new(1, -ColorLabel.TextBounds.X - 18, 0.2, 1);

	-- Paint currently selected parts
	PaintParts();

end;

function PaintParts()
	-- Recolors the selection with the selected color

	-- Make sure painting is possible
	if (not PaintTool.BrickColor) or (#Selection.Parts == 0) then
		return
	end

	-- Create history record
	local Record = PaintHistoryRecord.new()
	Record.TargetColor = PaintTool.BrickColor

	-- Perform action
	Record:Apply(true)

	-- Register history record
	Core.History.Add(Record)

end

function PreviewColor(Color)
	-- Previews the given color on the selection

	-- Reset colors to initial state if previewing is over
	if not Color and InitialState then
		for Part, State in pairs(InitialState) do

			-- Reset part color
			Part.Color = State.Color;

			-- Update union coloring options
			if Part.ClassName == 'UnionOperation' then
				Part.UsePartColor = State.UsePartColor;
			end;
		end;

		-- Clear initial state
		InitialState = nil;

		-- Skip rest of function
		return;

	-- Ensure valid color is given
	elseif not Color then
		return;

	-- Save initial state if first time previewing
	elseif not InitialState then
		InitialState = {};
		for _, Part in pairs(Selection.Parts) do
			InitialState[Part] = { Color = Part.Color, UsePartColor = (Part.ClassName == 'UnionOperation') and Part.UsePartColor or nil };
		end;
	end;

	-- Apply preview color
	for _, Part in pairs(Selection.Parts) do
		Part.Color = Color;

		-- Enable union coloring
		if Part.ClassName == 'UnionOperation' then
			Part.UsePartColor = true;
		end;
	end;

end;

function PaintTool:BindShortcutKeys()
	-- Enables useful shortcut keys for this tool

	-- Track user input while this tool is equipped
	self.Maid.Hotkeys = Support.AddUserInputListener('Began', 'Keyboard', false, function (Input)

		-- Paint selection if Enter is pressed
		if (Input.KeyCode.Name == 'Return') or (Input.KeyCode.Name == 'KeypadEnter') then
			return PaintParts()
		end

		-- Check if the R key was pressed, and it wasn't the selection clearing hotkey
		if (Input.KeyCode.Name == 'R') and (not Selection.Multiselecting) then

			-- Set the current color to that of the current mouse target (if any)
			if Core.Mouse.Target then
				SetColor(Core.Mouse.Target.Color);
			end;

		end;

	end)

end;

function PaintTool:EnableClickPainting()
	-- Allows the player to paint parts by clicking on them

	-- Watch out for clicks on selected parts
	self.Maid.ClickPainting = Selection.FocusChanged:Connect(function (Focus)
		local Target, ScopeTarget = Core.Targeting:UpdateTarget()
		if Selection.IsSelected(ScopeTarget) then

			-- Paint the selected parts
			PaintParts();

		end;
	end);

end;


Prompt:
----------------------------------------------------------------------------------------------------
-----------------=[ RECOIL & PRECISAO ]=------------------------------------------------------------
----------------------------------------------------------------------------------------------------

Response:
	,VRecoil = {14,18}				--- Vertical Recoil
	,HRecoil = {9,12}				--- Horizontal Recoil
	,AimRecover = .65				---- Between 0 & 1

	,RecoilPunch = .15
	,VPunchBase = 2.55				--- Vertical Punch
	,HPunchBase = 1.6				--- Horizontal Punch
	,DPunchBase = 1 				--- Tilt Punch | useless

	,AimRecoilReduction = 5 		--- Recoil Reduction Factor While Aiming (Do not set to 0)
	,PunchRecover = 0.2
	,MinRecoilPower = .5
	,MaxRecoilPower = 3
	,RecoilPowerStepAmount = .25

	,MinSpread = 0.95				--- Min bullet spread value | Studs
	,MaxSpread = 47					--- Max bullet spread value | Studs
	,AimInaccuracyStepAmount = .75
	,WalkMultiplier = 0				--- Bullet spread based on player speed

	,SwayBase = 0.25				--- Weapon Base Sway | Studs
	,MaxSway =	1.5					--- Max sway value based on player stamina | Studs