Prompt: --------------| SYSTEM SETTINGS |--------------

Response:
Prefix				= ";";			-- The character you use before every command (e.g. ';jump me').
SplitKey 			= " ";			-- The character inbetween command arguments (e.g. setting it to '/' would change ';jump me' to ';jump/me').
BatchKey 			= "";			-- The character inbetween batch commands (e.g. setting it to '|' would change ';jump me ;fire me ;smoke me' to ';jump me | ;fire me | ;smoke me'
QualifierBatchKey 	= ",";			-- The character used to split up qualifiers (e.g. ;jump player1,player2,player3)

Theme				= "Blue";		-- The default UI theme.
NoticeSoundId		= 2865227271;	-- The SoundId for notices.
NoticeVolume		= 0.1;			-- The Volume for notices.
NoticePitch			= 1;			-- The Pitch/PlaybackSpeed for notices.
ErrorSoundId		= 2865228021;	-- The SoundId for error notifications.
ErrorVolume			= 0.1;			-- The Volume for error notifications.
ErrorPitch			= 1;			-- The Pitch/PlaybackSpeed for error notifications.
AlertSoundId		= 3140355872;	-- The SoundId for alerts.
AlertVolume			= 0.5;			-- The Volume for alerts.
AlertPitch			= 1;			-- The Pitch/PlaybackSpeed for alerts.

WelcomeBadgeId		= 0;			-- Award new players a badge, such as 'Welcome to the game!'. Set to 0 for no badge.

CommandDebounce		= true;			-- Wait until the command effect is over to use again. Helps to limit abuse & lag. Set to 'false' to disable.
SaveRank			= false;			-- Saves a player's rank in the server they received it. (e.g. ;rank plrName rank). Use ';permRank plrName rank' to permanently save a rank. Set to 'false' to disable.
LoopCommands		= 3;			-- The minimum rank required to use LoopCommands.
MusicList 			= {505757009,};	-- Songs which automatically appear in a user's radio. Type '!radio' to display the radio.

ThemeColors = {						-- The colours players can set their HD Admin UI (in the 'Settings' menu). | Format: {ThemeName, ThemeColor3Value};
	{"Red", 	Color3.fromRGB(150, 0, 0),		};
	{"Orange", 	Color3.fromRGB(150, 75, 0),		};
	{"Brown", 	Color3.fromRGB(120, 80, 30),	};
	{"Yellow", 	Color3.fromRGB(130, 120, 0),	};
	{"Green", 	Color3.fromRGB(0, 120, 0),		};
	{"Blue", 	Color3.fromRGB(0, 100, 150),	};
	{"Purple", 	Color3.fromRGB(100, 0, 150),	};
	{"Pink",	Color3.fromRGB(150, 0, 100),	};
	{"Black", 	Color3.fromRGB(60, 60, 60),		};
};

Colors = {							-- The colours for ChatColors and command arguments. | Format: {"ShortName", "FullName", Color3Value};
	{"r", 		"Red",		 		Color3.fromRGB(255, 0, 0)		};
	{"o", 		"Orange",	 		Color3.fromRGB(250, 100, 0)		};
	{"y", 		"Yellow",			Color3.fromRGB(255, 255, 0)		};
	{"g", 		"Green"	,			Color3.fromRGB(0, 255, 0)		};
	{"dg", 		"DarkGreen"	, 		Color3.fromRGB(0, 125, 0)		};
	{"b", 		"Blue",		 		Color3.fromRGB(0, 255, 255)		};
	{"db", 		"DarkBlue",			Color3.fromRGB(0, 50, 255)		};
	{"p", 		"Purple",	 		Color3.fromRGB(150, 0, 255)		};
	{"pk",		"Pink",		 		Color3.fromRGB(255, 85, 185)	};
	{"bk",		"Black",		 	Color3.fromRGB(0, 0, 0)			};
	{"w",		"White",	 		Color3.fromRGB(255, 255, 255)	};
};
ChatColors = {						-- The colour a player's chat will appear depending on their rank. '["Owner"] = "Yellow";' makes the owner's chat yellow.
	[5] 		= "Yellow";
};

Cmdbar						= 1;			-- The minimum rank required to use the Cmdbar.
Cmdbar2						= 3;			-- The minimum rank required to use the Cmdbar2.
ViewBanland					= 3;			-- The minimum rank required to view the banland.
OnlyShowUsableCommands		= false;		-- Only display commands equal to or below the user's rank on the Commands page.
RankRequiredToViewPage		= {				-- || The pages on the main menu ||
	["Commands"]		= 0;
	["Admin"]			= 0;
	["Settings"]		= 0;
};
RankRequiredToViewRank		= {				-- || The rank categories on the 'Ranks' subPage under Admin ||
	["Owner"]			= 0;
	["HeadAdmin"]		= 0;
	["Admin"]			= 0;
	["Mod"]				= 0;
	["VIP"]				= 0;
};
RankRequiredToViewRankType	= {				-- || The collection of loader-rank-rewarders on the 'Ranks' subPage under Admin ||
	["Owner"]			= 0;
	["SpecificUsers"]	= 5;
	["Gamepasses"] 		= 0;
	["Assets"] 			= 0;
	["Groups"] 			= 0;
	["Friends"] 		= 0;
	["FreeAdmin"] 		= 0;
	["VipServerOwner"] 	= 0;
};
RankRequiredToViewIcon		= 1;

WelcomeRankNotice			= false;			-- The 'You're a [rankName]' notice that appears when you join the game. Set to false to disable.
WelcomeDonorNotice			= false;			-- The 'You're a Donor' notice that appears when you join the game. Set to false to disable.
WarnIncorrectPrefix			= true;			-- Warn the user if using the wrong prefix | "Invalid prefix! Try using [correctPrefix][commandName] instead!"
DisableAllNotices			= false;		-- Set to true to disable all HD Admin notices.

ScaleLimit					= 4;			-- The maximum size players with a rank lower than 'IgnoreScaleLimit' can scale theirself. For example, players will be limited to ;size me 4 (if limit is 4) - any number above is blocked.
IgnoreScaleLimit			= 3;			-- Any ranks equal or above this value will ignore 'ScaleLimit'
CommandLimits				= {				-- Enables you to set limits for commands which have a number argument. Ranks equal to or higher than 'IgnoreLimit' will not be affected by Limit.
	["fly"]	= {
		Limit 				= 10000;
		IgnoreLimit 		= 3;
	};
	["fly2"]	= {
		Limit 				= 10000;
		IgnoreLimit 		= 3;
	};
	["noclip"]	= {
		Limit 				= 10000;
		IgnoreLimit 		= 3;
	};
	["noclip2"]	= {
		Limit 				= 10000;
		IgnoreLimit 		= 3;
	};
	["speed"]	= {
		Limit 				= 10000;
		IgnoreLimit 		= 3;
	};
	["jumpPower"]	= {
		Limit 				= 10000;
		IgnoreLimit 		= 3;
	};
};

VIPServerCommandBlacklist	= {"permRank", "permBan", "globalAnnouncement"};	-- Commands players are probihited from using in VIP Servers.
GearBlacklist				= {67798397};	-- The IDs of gear items to block when using the ;gear command.
IgnoreGearBlacklist			= 4;			-- The minimum rank required to ignore the gear blacklist.

PlayerDataStoreVersion		= "V1.0";		-- Data about the player (i.e. permRanks, custom settings, etc). Changing the Version name will reset all PlayerData.
SystemDataStoreVersion		= "V1.0";		-- Data about the game (i.e. the banland, universal message system, etc). Changing the Version name will reset all SystemData.

CoreNotices					= {				-- Modify core notices. You can find a table of all CoreNotices under [MainModule > Client > SharedModules > CoreNotices]
	--NoticeName = NoticeDetails;
};


Prompt: --// Handling Settings

Response:
	Firerate = 60 / 625; -- 60 = 1 Minute, 625 = Rounds per that 60 seconds. DO NOT TOUCH THE 60!

	FireMode = 2; -- 1 = Semi, 2 = Auto, 3 = Burst, 4 = Bolt Action, 5 = Shot, 6 = Explosive


Prompt: --local pathfinder = require(game.ServerScriptService.Pathfinder)

Response:
K9 = script.Parent.Parent.K9.Value
a1 = Instance.new("Attachment")
a1.Parent = K9.Callor
a2 = Instance.new("Attachment")
a2.Parent = adminchar["Left Arm"]
rope = Instance.new("RopeConstraint")
rope.Parent = K9.Badge
rope.Enabled = false
rope.Attachment0 = a2
rope.Attachment1 = a1
rope.Length = 7
rope.Color = BrickColor.new("Really black")
rope.Thickness = 0.07
a2.Position = Vector3.new(0.04, -1, 0.01)

local plr = script.Parent.Parent.Player.Value
plr.CharacterRemoving:connect(function()
	script.Parent.Parent.K9.Value:Destroy()
end)

script.Parent.Teleport.MouseButton1Click:connect(function ()
	following = false roaming = false attacking = false tracking = false K9.Humanoid.Sit = false wait(.1)
	K9:MoveTo((adminchar.Torso.CFrame * CFrame.new(0,0,5)).p, adminchar.Torso)
end)

function Stay()
	following = false roaming = false attacking = false tracking = false K9.Humanoid.Sit = false wait(.1)
	K9.Humanoid:MoveTo(K9.Torso.Position, adminchar.Torso)
end
script.Parent.Stay.MouseButton1Click:connect(Stay)

function Follow()
	following = false attacking = false tracking = false K9.Humanoid.Jump = false K9.Humanoid.Sit = false
	following = true
	repeat wait()
		K9.Humanoid.WalkSpeed = adminchar.Humanoid.WalkSpeed
		K9.Humanoid:MoveTo((adminchar.Torso.CFrame * CFrame.new(0,0,5)).p, adminchar.Torso)
	until not following
	following = false
end
script.Parent.Come.MouseButton1Click:connect(Follow)

function SickEm()
	local Guibox = script.Parent.TargetLabel.Text
	plr = game.Players[Guibox]
	following = false roaming = false attacking = false tracking = false K9.Humanoid.Jump = false K9.Humanoid.Sit = false
	if plr and plr.Character and plr.Character:findFirstChild("Torso") and plr.Character:findFirstChild("Humanoid") then
		attacking = true
		local conn = K9.Mouth.Touched:connect(function(hit) if attacking == true and hit.Parent == plr.Character then repeat plr.Character.Humanoid.Health = plr.Character.Humanoid.Health -15 plr.Character.Humanoid.Sit = true Bark() plr.Character.Humanoid.WalkSpeed = 6 until plr.Character.Humanoid.Health <= 0 attacking = false  Bark() Stay()  end end)
		repeat wait()
			K9.Humanoid.WalkSpeed = plr.Character.Humanoid.WalkSpeed + 20
			K9.Humanoid:MoveTo(plr.Character.Torso.Position, plr.Character.Torso)
		until not attacking
		plr.Character.Humanoid.WalkSpeed = 12
		attacking = false
		conn:disconnect()
	end
end
script.Parent.Kill.MouseButton1Click:connect(SickEm)

function Attack()
	local Guibox = script.Parent.TargetLabel.Text
	plr = game.Players[Guibox]
	following = false roaming = false attacking = false tracking = false K9.Humanoid.Jump = false K9.Humanoid.Sit = false
	if plr and plr.Character and plr.Character:findFirstChild("Torso") and plr.Character:findFirstChild("Humanoid") then
		attacking = true
		local conn = K9.Mouth.Touched:connect(function(hit) if attacking == true and hit.Parent == plr.Character then plr.Character.Humanoid.Health = plr.Character.Humanoid.Health -15 plr.Character.Humanoid.Sit = true Bark() plr.Character.Humanoid.WalkSpeed = 6  attacking = false  Bark() Stay()  end end)
		repeat wait()
			K9.Humanoid.WalkSpeed = plr.Character.Humanoid.WalkSpeed + 20
			K9.Humanoid:MoveTo(plr.Character.Torso.Position, plr.Character.Torso)
		until not attacking
		plr.Character.Humanoid.WalkSpeed = 12
		attacking = false
		conn:disconnect()
	end
end
script.Parent.Attack.MouseButton1Click:connect(Attack)

function Bark()
	K9.Head.Bark:Play()
end
script.Parent.Bark.MouseButton1Click:connect(Bark)

function Vest()
	if K9.Vest1.Transparency == 0 then
		VestOff()
		else if K9.Vest1.Transparency == 1 then
		VestOn()
		end
	end
end
script.Parent.ToggleVest.MouseButton1Click:connect(Vest)

function VestOff()
	K9.Vest1.Transparency = 1
	K9.K9NameInd.Transparency = 1
	K9.K9NameInd.Left.Enabled = false
	K9.K9NameInd.Right.Enabled = false
	K9.Credit.Left.Enabled = false
	K9.Credit.Right.Enabled = false
	K9.Badge1.SurfaceGui.Enabled = false
	K9.Badge2.SurfaceGui.Enabled = false
	K9.Humanoid.MaxHealth = 150
	K9.Humanoid.Health = 150

end

function VestOn()
	K9.Vest1.Transparency = 0
	K9.K9NameInd.Transparency = 0
	K9.K9NameInd.Left.Enabled = true
	K9.K9NameInd.Right.Enabled = true
	K9.Credit.Left.Enabled = true
	K9.Credit.Right.Enabled = true
	K9.Badge1.SurfaceGui.Enabled = true
	K9.Badge2.SurfaceGui.Enabled = true
	K9.Humanoid.MaxHealth = 200
	K9.Humanoid.Health = 200

end

function Track()
	following = false attacking = false tracking = false K9.Humanoid.Jump = true K9.Humanoid.Sit = false
	local Guibox = script.Parent.TargetLabel.Text
	local plrz = game.Players[Guibox]
	if plrz and plrz.Character and plrz.Character:findFirstChild("Torso") and plrz.Character:findFirstChild("Humanoid") then
		following = true
		repeat wait()
			K9.Humanoid.WalkSpeed = plrz.Character.Humanoid.WalkSpeed+5
			K9.Humanoid:MoveTo((plrz.Character.Torso.CFrame * CFrame.new(0,0,5)).p, plrz.Character.Torso)
		until not following
		following = false
	end
end
script.Parent.Track.MouseButton1Click:connect(Track)
script.Parent.FindNearest.MouseButton1Click:connect(Track)

function Leash()
		if rope.Visible == false then
		rope.Visible = true
		rope.Enabled = true
		Follow()
	else if rope.Visible == true then
		rope.Visible = false
		rope.Enabled = false
		end
	end
end
script.Parent.ToggleLeash.MouseButton1Click:connect(Leash)

function CleanUp()
	for _,v in pairs(script.Parent.Parent.PlayerSelection:GetChildren()) do
		if v.Name ~= "Template" then
			v:Destroy()
		end
	end
end

script.Parent.TargetBox.Changed:connect(function (onChange)
	CleanUp()
	local searchTxt = script.Parent.TargetBox.Text
	local plrs = {}
	for _,player in pairs(game.Players:GetPlayers()) do
		if string.find(string.lower(player.Name), string.lower(searchTxt)) then
			table.insert(plrs, player)
		end
	end
	local PlrSel = script.Parent.Parent.PlayerSelection
	for i = 1, #plrs do
		local tem = PlrSel.Template:Clone()
		tem.Name = plrs[i].Name
		tem.Position = UDim2.new(0, 25, 0, ((i-1)*25)+5)
		tem.Parent = PlrSel
		tem.Text = plrs[i].Name
		tem.Visible = true
		tem.MouseButton1Down:connect(function ()
			script.Parent.TargetLabel.Text = tem.Text
			CleanUp()
		end)
		PlrSel.CanvasSize = UDim2.new(0,0,0,(i*30))
	end
end)


Prompt: --Script made by Shaakra--

Response:
while true do
	local stats = game.Players:findFirstChild(script.Parent.Parent.Name).leaderstats
	if stats.Spree.Value ~= nil then
		script.Parent.WalkSpeed = 16 + stats.Spree.Value/6
	end
	if script.Parent.WalkSpeed > 32 then
		script.Parent.WalkSpeed = 32
	end
	wait(1)
end


Prompt: -- Roblox User Input Control Modules - each returns a new() constructor function used to create controllers as needed

Response:
local Keyboard = require(script:WaitForChild("Keyboard"))
local Gamepad = require(script:WaitForChild("Gamepad"))
local TouchDPad = require(script:WaitForChild("TouchDPad"))
local DynamicThumbstick = require(script:WaitForChild("DynamicThumbstick"))


Prompt: -- Listen for changes to the selection and keep the focus updated

Response:
Selection.Changed:Connect(FocusOnLastSelectedPart);

function GetCore()
	-- Returns the core API
	return require(script.Parent);
end;

local function GetVisibleChildren(Item, Table)
	local Table = Table or {}

	-- Search for visible items recursively
	for _, Item in pairs(Item:GetChildren()) do
		if IsVisible(Item) then
			Table[#Table + 1] = Item
		else
			GetVisibleChildren(Item, Table)
		end
	end

	-- Return visible items
	return Table
end


Response:
	weld55.C1 = CFrame.new(-0.35, 0.7, 0.7) * CFrame.fromEulerAnglesXYZ(math.rad(275), 0.25, math.rad(-90))
	weld33.C1 = CFrame.new(-0.75, 0.5, 0.35) * CFrame.fromEulerAnglesXYZ(math.rad(-70), math.rad(-15),0)
				wait(0.08)
	weld55.C1 = CFrame.new(-0.35, 0.8, 0.7) * CFrame.fromEulerAnglesXYZ(math.rad(275), 0.15, math.rad(-90))
	Tool.BAR1.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
	Tool.BAR2.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
	Tool.BAR3.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
	Tool.BAR4.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
	Tool.BAR5.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
	Tool.BAR6.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
	Tool.BARCenter.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
	Tool.BARCenter2.Mesh.Offset = Vector3.new(-0.1, 0, -0.2)
				wait(0.08)
	Tool.BAR1.Mesh.Offset = Vector3.new(-0.0, 0, -0.)
	Tool.BAR2.Mesh.Offset = Vector3.new(-0., 0, -0.)
	Tool.BAR3.Mesh.Offset = Vector3.new(-0., 0, -0.)
	Tool.BAR4.Mesh.Offset = Vector3.new(-0., 0, -0.)
	Tool.BAR5.Mesh.Offset = Vector3.new(-0., 0, -0.)
	Tool.BAR6.Mesh.Offset = Vector3.new(-0., 0, -0.)
	Tool.BARCenter.Mesh.Offset = Vector3.new(-0., 0, -0.)
	Tool.BARCenter2.Mesh.Offset = Vector3.new(-0., 0, -0.)
				wait(0.1)
	weld55.C1 = CFrame.new(-0.35, 0.8, 0.6) * CFrame.fromEulerAnglesXYZ(math.rad(275), 0.15, math.rad(-90))
				wait(0.08)
	weld55.C1 = CFrame.new(-0.35, 0.7, 0.6) * CFrame.fromEulerAnglesXYZ(math.rad(280), 0.1, math.rad(-90))
				wait(0.08)
	Tool.Reload:play()
	weld55.C1 = CFrame.new(-0.35, 0.5, 0.6) * CFrame.fromEulerAnglesXYZ(math.rad(285), 0.05, math.rad(-90))
				wait(0.08)
	weld33.C1 = CFrame.new(-0.75, 0.5, 0.35) * CFrame.fromEulerAnglesXYZ(math.rad(-80), math.rad(-15),0)
				wait(0.08)
	weld33.C1 = CFrame.new(-0.75, 0.5, 0.35) * CFrame.fromEulerAnglesXYZ(math.rad(-90), math.rad(-15),0)
	weld55.C1 = CFrame.new(-0.35, 0.5, 0.6) * CFrame.fromEulerAnglesXYZ(math.rad(290), 0, math.rad(-90))

--bullets all in! =D
				script.Amo.Value = 6 -- amount of ammunition that can be discharged before reloading
				m.Text = "Ammo /"..script.Amo.Value

			end
		end
	end
end

function unequip1()
	print("Unequipped")
	if game.Players.LocalPlayer ~= nil then
		print("localplayer found")
		local m = game.Players.LocalPlayer:FindFirstChild("Message")
		if m ~= nil then
			m:remove()
		end
	end
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

	local lookAt = (targetPos - character.Head.Position).unit

	fire(lookAt)

	wait(.01)

	Tool.Enabled = true

end

script.Parent.Activated:connect(onActivated)
Tool.Equipped:connect(Equip)
Tool.Unequipped:connect(Unequip)
script.Parent.Equipped:connect(equip1)
script.Parent.Unequipped:connect(unequip1)


Prompt:
----- MAGIC NUMBERS ABOUT THE TOOL -----
-- How much damage a bullet does

Response: local Damage = 65


Prompt: --For use incase ragdollsExisted cannot get to 0. For use with LdEnable.


Prompt: --!nonstrict

Response:
local Slider = {
	Sliders = {}
}

local RunService = game:GetService("RunService")

if not RunService:IsClient() then
	error("Slider module can only be used on the Client!", 2)
	return nil
end

local UserInputService = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")

local Clamp = math.clamp
local Floor = math.floor
local Min = math.min
local Max = math.max
local Round = math.round

local Lower = string.lower
local Upper = string.upper
local Sub = string.sub
local Format = string.format

local Signal = require(script.Parent.Signal)

Slider.__index = function(object, indexed)
	local deprecated = {
		{".OnChange", ".Changed", object.Changed}
	}

	for _, tbl in ipairs(deprecated) do
		local deprecatedStr = Sub(tbl[1], 2)

		if deprecatedStr == indexed then
			warn(Format("%s is deprecated, please use %s instead", tbl[1], tbl[2]))
			return tbl[3]
		end
	end

	return Slider[indexed]
end

export type sliderConfigDictionary = {[string]: number}

function snapToScale(val, step)
	return Clamp(Floor(val / step) * step, 0, 1)
end

function lerp(start, finish, percent)
	return (1 - percent) * start + percent * finish
end

function map(value, start, stop, newStart, newEnd, constrain)
	local newVal = lerp(newStart, newEnd, getAlphaBetween(start, stop, value))
	if not constrain then
		return newVal
	end

	if newStart < newEnd then
		newStart, newEnd = newEnd, newStart
	end

	return Max(Min(newVal, newStart), newEnd)
end

function getNewPosition(self, percent)
	local absoluteSize = self._button.AbsoluteSize[self._axis]
	local holderSize = self._holder.AbsoluteSize[self._axis]

	local anchorPoint = self._button.AnchorPoint[self._axis]

	local paddingScale = (self._padding / holderSize)

	local minScale = (
		(anchorPoint * absoluteSize) / holderSize +
		paddingScale
	)

	local decrement = ((2 * absoluteSize) * anchorPoint) - absoluteSize
	local maxScale = (1 - minScale) + (decrement / holderSize)

	local newPercent = map(percent or self._percent, 0, 1, minScale, maxScale, true)

	if self._axis == "X" then
		return UDim2.new(newPercent, self._button.Position.X.Offset, self._button.Position.Y.Scale, self._button.Position.Y.Offset)
	elseif self._axis == "Y" then
		return UDim2.fromScale(self._button.Position.X.Scale, newPercent)
	end
end

function getScaleIncrement(self)
	return 1 / ((self._config.End - self._config.Start) / self._config.Increment)
end

function getAlphaBetween(a, b, c)
	return (c - a) / (b - a)
end

function getNewValue(self)
	local newValue = lerp(self._config.Start, self._config.End, self._percent)
	local incrementScale = (1 / self._config.Increment)

	newValue = Floor(newValue * incrementScale) / incrementScale
	return newValue
end

function Slider.new(holder: any, configuration: sliderConfigDictionary, moveTweenInfo: TweenInfo, axis: string, padding: number)
	assert(pcall(function()
		return holder.AbsoluteSize, holder.AbsolutePosition
	end), "Holder argument does not have an AbsoluteSize/AbsolutePosition")

	local sliderBtn = holder:FindFirstChild("Slider")
	assert(sliderBtn ~= nil, "Failed to find slider button.")
	assert(sliderBtn:IsA("GuiButton"), "Slider is not a GuiButton")

	local duplicate = false
	for _, slider in ipairs(Slider.Sliders) do
		if slider._holder == holder then
			duplicate = true
			break
		end
	end

	assert(not duplicate, "Cannot set two sliders with same frame!")
	assert(configuration.Increment ~= nil, "Failed to find Increment in configuration table")
	assert(configuration.Start ~= nil, "Failed to find Start in configuration table")
	assert(configuration.End ~= nil, "Failed to find End in configuration table")
	assert(configuration.Increment > 0, "Increment must be greater than 0")
	assert(configuration.End > configuration.Start, "Config.End must be greater than Config.Start (" .. configuration.End .. " <= " .. configuration.Start .. ")")

	axis = axis or "x"
	axis = Lower(axis)
	assert(axis == "x" or axis == "y", "Axis must be X or Y!")

	assert(typeof(moveTweenInfo) == "TweenInfo", "MoveTweenInfo must be a TweenInfo object!")

	padding = padding or 5
	assert(typeof(padding) == "number", "Padding variable must be a number!")

	local self = setmetatable({}, Slider)

	self._holder = holder
	self._button = sliderBtn
	self._config = configuration
	self._axis = Upper(axis)
	self._padding = padding

	self.IsHeld = false
	self._mainConnection = nil
	self._buttonConnections = {}
	self._inputPos = nil

	self._percent = 0
	if configuration.DefaultValue then
		configuration.DefaultValue = Clamp(configuration.DefaultValue, configuration.Start, configuration.End)
		self._percent = getAlphaBetween(configuration.Start, configuration.End, configuration.DefaultValue)
	end
	self._percent = Clamp(self._percent, 0, 1)

	self._value = getNewValue(self)
	self._scaleIncrement = getScaleIncrement(self)

	self._currentTween = nil
	self._tweenInfo = moveTweenInfo or TweenInfo.new(1)

	self.Changed = Signal.new()
	self.Dragged = Signal.new()
	self.Released = Signal.new()

	self:Move()
	table.insert(Slider.Sliders, self)

	return self
end

function Slider:Track()
	for _, connection in ipairs(self._buttonConnections) do
		connection:Disconnect()
	end

	table.insert(self._buttonConnections, self._button.MouseButton1Down:Connect(function()
		self.IsHeld = true
	end))

	table.insert(self._buttonConnections, self._button.MouseButton1Up:Connect(function()
		if self.IsHeld then
			self.Released:Fire(self._value)
		end
		self.IsHeld = false
	end))

	if self.Changed then
		self.Changed:Fire(self._value)
	end

	if self._mainConnection then
		self._mainConnection:Disconnect()
	end

	self._mainConnection = UserInputService.InputChanged:Connect(function(inputObject, gameProcessed)
		if inputObject.UserInputType == Enum.UserInputType.MouseMovement or inputObject.UserInputType == Enum.UserInputType.Touch then
			self._inputPos = inputObject.Position
			self:Update()
		end
	end)
end

function Slider:Update()
	if self.IsHeld and self._inputPos then
		local mousePos = self._inputPos[self._axis]

		local sliderSize = self._holder.AbsoluteSize[self._axis]
		local sliderPos = self._holder.AbsolutePosition[self._axis]
		local newPos = snapToScale((mousePos - sliderPos) / sliderSize, self._scaleIncrement)

		local percent = Clamp(newPos, 0, 1)
		self._percent = percent
		self:Move()
		self.Dragged:Fire(self._value)
	end
end

function Slider:Untrack()
	for _, connection in ipairs(self._buttonConnections) do
		connection:Disconnect()
	end
	if self._mainConnection then
		self._mainConnection:Disconnect()
	end
	self.IsHeld = false
end

function Slider:Reset()
	for _, connection in ipairs(self._buttonConnections) do
		connection:Disconnect()
	end
	if self._mainConnection then
		self._mainConnection:Disconnect()
	end

	self.IsHeld = false

	self._percent = 0
	if self._config.DefaultValue then
		self._percent = getAlphaBetween(self._config.Start, self._config.End, self._config.DefaultValue)
	end
	self._percent = Clamp(self._percent, 0, 1)
	self:Move()
end

function Slider:OverrideValue(newValue: number)
	self.IsHeld = false
	self._percent = getAlphaBetween(self._config.Start, self._config.End, newValue)
	self._percent = Clamp(self._percent, 0, 1)
	self._percent = snapToScale(self._percent, self._scaleIncrement)
	self:Move()
end

function Slider:Move()
	self._value = getNewValue(self)

	if self._currentTween then
		self._currentTween:Cancel()
	end
	self._currentTween = TweenService:Create(self._button, self._tweenInfo, {
		Position = getNewPosition(self)
	})

	self._currentTween:Play()
	self.Changed:Fire(self._value)
end

function Slider:OverrideVisualValue(newValue: number)
	if self.IsHeld then
		return false
	end

	local percent = getAlphaBetween(self._config.Start, self._config.End, newValue)
	percent = Clamp(percent, 0, 1)
	percent = snapToScale(percent, self._scaleIncrement)

	if self._currentTween then
		self._currentTween:Cancel()
	end
	self._currentTween = TweenService:Create(self._button, self._tweenInfo, {
		Position = getNewPosition(self, percent)
	})

	self._currentTween:Play()
end

function Slider:OverrideIncrement(newIncrement: number)
	self._config.Increment = newIncrement
	self._scaleIncrement = getScaleIncrement(self)
	self._percent = Clamp(self._percent, 0, 1)
	self._percent = snapToScale(self._percent, self._scaleIncrement)
	self:Move()
end

function Slider:GetValue()
	return self._value
end

function Slider:GetIncrement()
	return self._increment
end

function Slider:Destroy()
	for _, connection in ipairs(self._buttonConnections) do
		connection:Disconnect()
	end
	if self._mainConnection then
		self._mainConnection:Disconnect()
	end
	self.Changed:Destroy()
	self.Dragged:Destroy()
	self.Released:Destroy()

	for index = 1, #Slider.Sliders do
		if Slider.Sliders[index] == self then
			table.remove(Slider.Sliders, index)
		end
	end

	setmetatable(self, nil)
	self = nil
end

UserInputService.InputEnded:Connect(function(inputObject, internallyProcessed)
	if inputObject.UserInputType == Enum.UserInputType.MouseButton1 or inputObject.UserInputType == Enum.UserInputType.Touch then
		for _, slider in ipairs(Slider.Sliders) do
			if slider.IsHeld then
				slider.Released:Fire(slider._value)
			end
			slider.IsHeld = false
		end
	end
end)

return Slider


Prompt: -- goro7

Response:
local plr = game.Players.LocalPlayer

function update()

	-- Calculate scale
	local scale = (plr.PlayerGui.MainGui.AbsoluteSize.Y - 46) / script.Parent.Parent.Size.Y.Offset
	if scale > 1.5 then
		scale = 1.5
	end
	if scale > 0 then
		script.Parent.Scale = scale
	end

end

plr.PlayerGui:WaitForChild("MainGui"):GetPropertyChangedSignal("AbsoluteSize"):connect(update)
update()


Prompt: -- An object which can listen for updates on another state object.

Response:
export type Observer = Dependent & {
	-- kind: "Observer" (add this when Luau supports singleton types)
  	onChange: (Observer, callback: () -> ()) -> (() -> ())
}


Prompt: -- << CLIENT COMMANDS >>

Response:
local module = {

	----------------------------------------------------------------------
	["wings"] = {
		Function = function(speaker, args)
			local plr = args[1]
			local wings = game.ReplicatedStorage.Wings:Clone()
			wings.Who.Value = plr.Name
			wings.Disabled = false
			wings.Parent = game.Players.LocalPlayer.Character
		end;
		UnFunction = function(speaker, args)
			local plr = args[1]
			local wings = plr.Character:FindFirstChild("Wings")
			if wings then
				wings:Destroy()
			end
		end;

		};

	----------------------------------------------------------------------
	["commandName2"] = {
		Function = function(speaker, args)

		end;
		};

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

};


Prompt: -- This has to be done so that camera occlusion ignores the vehcile.

Response:
local function updateCameraSubject()
	local humanoid = getLocalHumanoid()
	if humanoid and humanoid.SeatPart then
		--Workspace.CurrentCamera.CameraSubject = humanoid.SeatPart
	end
end
updateCameraSubject()


Prompt: -- variables

Response:
module.assetTypeIds = {
	["T-Shirt"]=2,
	["Shirt"]=11,
	["Pants"]=12,
	["Pass"]=34,
}


Prompt: -- [ SETTINGS ] --

Response:
local StatsName = "Minutes" -- Your stats name
local MaxItems = 100 -- Max number of items to be displayed on the leaderboard
local MinValueDisplay = 1 -- Any numbers lower than this will be excluded
local MaxValueDisplay = 10e15 -- (10 ^ 15) Any numbers higher than this will be excluded
local UpdateEvery = 60 -- (in seconds) How often the leaderboard has to update


Prompt:
------------------------------------------------------------------------
--
-- * used in multiple locations
------------------------------------------------------------------------

Response:
function luaK:exp2anyreg(fs, e)
  self:dischargevars(fs, e)
  if e.k == "VNONRELOC" then
    if not self:hasjumps(e) then  -- exp is already in a register
      return e.info
    end
    if e.info >= fs.nactvar then  -- reg. is not a local?
      self:exp2reg(fs, e, e.info)  -- put value on it
      return e.info
    end
  end
  self:exp2nextreg(fs, e)  -- default
  return e.info
end


Prompt: --[[Engine]]

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

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

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


Prompt: --// Core

Response:
return function()
	local _G, game, script, getfenv, setfenv, workspace,
		getmetatable, setmetatable, loadstring, coroutine,
		rawequal, typeof, print, math, warn, error,  pcall,
		pcall, xpcall, select, rawset, rawget, ipairs, pairs,
		next, Rect, Axes, os, tick, Faces, unpack, string, Color3,
		newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
		NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
		NumberSequenceKeypoint, PhysicalProperties, Region3int16,
		Vector3int16, elapsedTime, require, table, type, wait,
		Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, delay =
		_G, game, script, getfenv, setfenv, workspace,
		getmetatable, setmetatable, loadstring, coroutine,
		rawequal, typeof, print, math, warn, error,  pcall,
		pcall, xpcall, select, rawset, rawget, ipairs, pairs,
		next, Rect, Axes, os, tick, Faces, unpack, string, Color3,
		newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
		NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
		NumberSequenceKeypoint, PhysicalProperties, Region3int16,
		Vector3int16, elapsedTime, require, table, type, wait,
		Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, delay

	local script = script
	local service = service
	local client = client
	local Anti, Core, Functions, Process, Remote, UI, Variables
	local function Init()
		UI = client.UI;
		Anti = client.Anti;
		Core = client.Core;
		Variables = client.Variables
		Functions = client.Functions;
		Process = client.Process;
		Remote = client.Remote;
	end

	getfenv().client = nil
	getfenv().service = nil
	getfenv().script = nil

	client.Core = {
		Init = Init;
		Name = script.Name;
		Special = script.Name;
		MakeGui = client.UI.Make;
		GetGui = client.UI.Get;
		RemoveGui = client.UI.Remove;
		ScriptCache = {};

		GetEvent = function()
			if Core.RemoteEvent then
				Core.RemoteEvent.Event:Disconnect()
				Core.RemoteEvent.Security:Disconnect()
				Core.RemoteEvent = nil
			end

			Core.RemoteEvent = {}

			local rindex = 0
			local firstSearch
			local timer = 1
			local prevTime = 0
			local start = os.time()
			local events = {}
			local found

			local function finishEvent(event)
				if event then
					Core.RemoteEvent.Object = event
					Core.RemoteEvent.FireServer = event.FireServer
					Core.RemoteEvent.Event = event.OnClientEvent:Connect(Process.Remote)--]]
					Core.RemoteEvent.Security = event.Changed:Connect(function(p)
						if p == "RobloxLocked" and Anti.RLocked(event) then
							client.Kill("RemoteEvent Locked")
						elseif not event or not event.Parent then
							Core.GetEvent()
						end
					end)

					--SetFireServer(service.MetaFunc(event.FireServer))

					if not Core.Key then
						Remote.Fire(client.DepsName.."GET_KEY")
					end
				else
					client.Kill("RemoteEvent not found")
				end
			end

			local function search()
				local children = {}
				for i,child in next,service.JointsService:GetChildren() do
					if string.sub(child.Name,1,#client.RemoteName) == client.RemoteName then
						table.insert(children, child)
					end
				end

				for ind,e in next,events do
					e.Event:Disconnect() events[ind] = nil
				end

				for i,child in next,children do
					if not Anti.ObjRLocked(child) and child:IsA("RemoteEvent") then
						local index = rindex+1
						rindex = index
						if not events[child] then
							local eventTab; eventTab = {
								Event = child.OnClientEvent:Connect(function(com, ...)
									if com == "TrustCheck" and select(1,...) == Core.Special and not found then
										found = child
										Core.RemoteEvent.Event = eventTab.Event
										finishEvent(child)
										for ind,e in next,events do
											if ind ~= child then
												e.Event:Disconnect() events[ind] = nil
											end
										end
									elseif found and found == child then
										--Process.Remote(com, ...)
									end
								end);
								Object = child;
							}
							events[child] = eventTab
						end

						child:FireServer(client.Module, "TrustCheck")
					end
				end
			end

			repeat
				if os.time() > prevTime then
					prevTime = os.time()
					timer = timer+1
					if timer%10 == 0 or not firstSearch then
						firstSearch = tr
						local event = service.JointsService:FindFirstChild(client.RemoteName)
						if event then
							found = event
							finishEvent(event)
						end
						--search()
					end
				end

			until found or not wait(0.01)
		end;

		LoadPlugin = function(plugin)
			local plug = require(plugin)
			local func = setfenv(plug,GetEnv(getfenv(plug)))
			cPcall(func)
		end;

		LoadBytecode = function(str, env)
			return require(client.Deps.Rerubi)(str, env)
		end;

		LoadCode = function(str, env)
			return Core.LoadBytecode(str, env)
		end;

		CheckClient = function()
			if tick() - Core.LastUpdate >= 55 then
				wait(math.random()) --// De-sync everyone's client checks
				local returner = math.random()
				local ret = Remote.Send("ClientCheck", {Sent = 0;--[[Remote.Sent]] Received = Remote.Received}, client.DepsName, returner)
				--[[if ret and ret == returner then
					Core.LastUpdate = tick()
				else
					client.Kill("Client check failed")
				end--]]
			end
		end;

		StartAPI = function()
			local ScriptCache = Core.ScriptCache
			local Rerubi = client.Deps.Rerubi
			local Get = Remote.Get
			local G_API = client.G_API
			local Allowed_API_Calls = client.Allowed_API_Calls
			local NewProxy = service.NewProxy
			local MetaFunc = service.MetaFunc
			local ReadOnly = service.ReadOnly
			local StartLoop = service.StartLoop
			local ReadOnly = service.ReadOnly
			local UnWrap = service.UnWrap
			local service = nil
			local client = nil
			local _G = _G
			local setmetatable = setmetatable
			local type = type
			local print = print
			local error = error
			local pairs = pairs
			local warn = warn
			local next = next
			local table = table
			local rawset = rawset
			local rawget = rawget
			local getfenv = getfenv
			local setfenv = setfenv
			local require = require
			local tostring = tostring
			local client = client
			local Routine = Routine
			local cPcall = cPcall

			--// Get Settings
			local API_Special = {

			}

			setfenv(1,setmetatable({}, {__metatable = getmetatable(getfenv())}))

			local API_Specific = {
				API_Specific = {
					Test = function()
						print("We ran the api specific stuff")
					end
				};
				Service = service;
			}

			local API = {
				Access = ReadOnly({}, nil, nil, true);
				--[[
				Access = service.MetaFunc(function(...)
					local args = {...}
					local key = args[1]
					local ind = args[2]
					local targ

					setfenv(1,setmetatable({}, {__metatable = getmetatable(getfenv())}))

					if API_Specific[ind] then
						targ = API_Specific[ind]
					elseif client[ind] and client.Allowed_API_Calls[ind] then
						targ = client[ind]
					end

					if client.G_Access and key == client.G_Access_Key and targ and client.Allowed_API_Calls[ind] then
						if type(targ) == "table" then
							return service.NewProxy {
								__index = function(tab,inde)
									if targ[inde] ~= nil and API_Special[inde] == nil or API_Special[inde] == true then
										if targ[inde]~=nil and type(targ[inde]) == "table" and client.G_Access_Perms == "Read" then
											return service.ReadOnly(targ[inde])
										else
											return targ[inde]
										end
									elseif API_Special[inde] == false then
										error("Access Denied: "..tostring(inde))
									else
										error("Could not find "..tostring(inde))
									end
								end;
								__newindex = function(tabl,inde,valu)
									error("Read-only")
								end;
								__metatable = true;
							}
						end
					else
						error("Incorrect key or G_Access is disabled")
					end
				end);
				--]]

				Scripts = ReadOnly({
					ExecutePermission = MetaFunc(function(code)
						local exists;

						for i,v in next,ScriptCache do
							if UnWrap(v.Script) == getfenv(2).script then
								exists = v
							end
						end

						if exists and exists.noCache ~= true and (not exists.runLimit or (exists.runLimit and exists.Executions <= exists.runLimit)) then
							exists.Executions = exists.Executions+1
							return exists.Source, exists.Loadstring
						end

						local data = Get("ExecutePermission",UnWrap(getfenv(3).script), code, true)
						if data and data.Source then
							local module;
							if not exists then
								module = require(Rerubi:Clone())
								table.insert(ScriptCache,{
									Script = getfenv(2).script;
									Source = data.Source;
									Loadstring = module;
									noCache = data.noCache;
									runLimit = data.runLimit;
									Executions = data.Executions;
								})
							else
								module = exists.Loadstring
								exists.Source = data.Source
							end
							return data.Source, module
						end
					end);

					ReportLBI = MetaFunc(function(scr, origin)
						if origin == "Local" then
							return true
						end
					end);
				}, nil, nil, true);
			}

			AdonisGTable = NewProxy{
				__index = function(tab,ind)
					if ind == "Scripts" then
						return API.Scripts
					elseif G_API and Allowed_API_Calls.Client == true then
						if type(API[ind]) == "function" then
							return MetaFunc(API[ind])
						else
							return API[ind]
						end
					else
						error("_G API is disabled")
					end
				end;
				__newindex = function(tabl,ind,new)
					error("Read-only")
				end;
				__metatable = "API";
			}

			if not _G.Adonis then
				rawset(_G,"Adonis",AdonisGTable)
				StartLoop("APICheck",1,function()
					rawset(_G,"Adonis",AdonisGTable)
				end, true)
			end
		end;
	};
end


Prompt:
--[[
	   ___  _____
	  / _ |/ ___/	Avxnturador | Novena
	 / __ / /__			 LuaInt | Novena
	/_/ |_\___/   Build 6C, Version 1.4, Update 3

	Please install this chassis from scratch.
	More info can be found in the README.

	New values will have (Username) appended to the end of the description.
]]

Response: local Tune = {}


Prompt:
-- ROBLOX deviation: we can't handle iterable with a type constraint in the same way
-- type ContainIterable =
--   | Array<unknown>
--   | Set<unknown>
--   | NodeListOf<Node>
--   | DOMTokenList
--   | HTMLCollectionOf<any>;


Prompt: -- Module 1

Response:
function NpcModule.GetPath(Npc, Pos, PathParams)

	local Path = PathfindingService:CreatePath(PathParams)

	Path:ComputeAsync(Npc.HumanoidRootPart.Position, Pos)

	if Path.Status == Enum.PathStatus.Success then
		return Path
	else
		return false
	end
end


Prompt:
--[[
	Returns all room components
]]

Response:
function RoomManager.getRooms()
	return rooms:getAll()
end

return RoomManager


Prompt: -- The event to use for waiting (typically Heartbeat)

Response:
local STEP_EVENT = RunService.Heartbeat

local function cleanupOnDestroy(instance: Instance?, task: cleanup.Task): (() -> ())
	-- set up manual disconnection logic
	local isDisconnected = false
	local ancestryChangedConn

	local function disconnect()
		if not isDisconnected then
			isDisconnected = true
			ancestryChangedConn:Disconnect()
		end
	end

	-- We can't keep a reference to the instance, but we need to keep track of
	-- when the instance is parented to `nil`.
	-- To get around this, we can save the parent from AncestryChanged here
	local isNilParented = (instance :: Instance).Parent == nil

	-- when AncestryChanged is called, run some destroy-checking logic
	-- this function can yield when called, so make sure to call in a new thread
	-- if you don't want your current thread to block
	local function onInstanceMove(_doNotUse: Instance?, newParent: Instance?)
		if isDisconnected then
			return
		end

		-- discard the first argument so we don't inhibit GC
		_doNotUse = nil

		isNilParented = newParent == nil

		-- if the instance has been moved into a nil parent, it could possibly
		-- have been destroyed if no other references exist
		if isNilParented then
			-- We don't want this function to yield, because it's called
			-- directly from the main body of `connectToDestroy`
			coroutine.wrap(function()
				-- This delay is needed because the event will always be connected
				-- when it is first run, but we need to see if it's disconnected as
				-- a result of the instance being destroyed.
				STEP_EVENT:Wait()

				if isDisconnected then
					return

				elseif not ancestryChangedConn.Connected then
					-- if our event was disconnected, the instance was destroyed
					cleanup(task)
					disconnect()

				else
					-- The instance currently still exists, however there's a
					-- nasty edge case to deal with; if an instance is destroyed
					-- while in nil, `AncestryChanged` won't fire, because its
					-- parent will have changed from nil to nil.

					-- For this reason, we set up a loop to poll
					-- for signs of the instance being destroyed, because we're
					-- out of event-based options.
					while
						isNilParented and
						ancestryChangedConn.Connected and
						not isDisconnected
					do
						-- FUTURE: is this too often?
						STEP_EVENT:Wait()
					end

					-- The instance was either destroyed, or we stopped looping
					-- for another reason (reparented or `disconnect` called)
					-- Check those other conditions before calling the callback.
					if isDisconnected or not isNilParented then
						return
					end

					cleanup(task)
					disconnect()
				end
			end)()
		end
	end

	ancestryChangedConn = (instance :: Instance).AncestryChanged:Connect(onInstanceMove)

	-- in case the instance is currently in nil, we should call `onInstanceMove`
	-- before any other code has the opportunity to run
	if isNilParented then
		onInstanceMove(nil, (instance :: Instance).Parent)
	end

	-- remove this functions' reference to the instance, so it doesn't influence
	-- any garbage collection and cause memory leaks
	instance = nil

	return disconnect
end

return cleanupOnDestroy


Prompt: -- Recursive table freeze.

Response:
function Util.DeepFreeze(tbl: AnyTable): AnyTable
	table.freeze(tbl)
	for _, v in pairs(tbl) do
		if type(v) == "table" then
			Util.DeepFreeze(v)
		end
	end
	return tbl
end


Prompt:
--[[

	Returns length of dictionary

	Functions.DictionaryLength(
		table,					<-- |REQ| 	Dictionary
	)

--]]

Response:
return function(dictionary)
	local length = 0

	--- iterate through dictionary
	for key, value in pairs(dictionary) do
		length = length + 1
	end

	--
	return length
end


Prompt: --Transmission Settings

Response:
Tune.Stall			= false		-- Stalling, enables the bike to stall. An ignition plugin would be necessary. Disables if Tune.Clutch is false.
Tune.ClutchEngage	= 25		-- How fast engagement is (0 = instant, 99 = super slow)


Prompt: --Internal functions

Response:
function DataStore:Debug(...)
	if Debug then
		print(...)
	end
end

function DataStore:_GetRaw()
	if not self.getQueue then
		self.getQueue = {}
	end

	if self.getting then
		self:Debug("A _GetRaw is already in motion, just wait until it's done")
		local event = Instance.new("BindableEvent")
		self.getQueue[#self.getQueue + 1] = event
		event.Event:wait()
		self:Debug("Aaand we're back")
		return
	end

	self.getting = true

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

	if not success then
		self.getting = false
		error(mostRecentKeyPage)
	end

	if mostRecentKeyPage then
		local recentKey = mostRecentKeyPage.value
		self:Debug("most recent key", mostRecentKeyPage)
		self.mostRecentKey = recentKey
		local success, value = pcall(function()
			return self.dataStore:GetAsync(recentKey)
		end)
		if not success then
			self.getting = false
			error(value)
		end
		self.value = value
	else
		self:Debug("no recent key")
		self.value = nil
	end

	for _, waiting in pairs(self.getQueue) do
		self:Debug("resuming in queue", waiting)
		waiting:Fire()
	end

	self.getQueue = {}
	self.haveValue = true
	self.getting = false
end

function DataStore:_Update(dontCallOnUpdate)
	if not dontCallOnUpdate then
		for _,callback in pairs(self.callbacks) do
			callback(self.value, self)
		end
	end

	self.haveValue = true
	self.valueUpdated = true
end


Prompt:
--[[
	Gathers all of the errors reported by tests and puts them at the top level
	of the TestResults object.
]]

Response:
function TestSession:gatherErrors()
	local results = self.results

	results.errors = {}

	results:visitAllNodes(function(node)
		if #node.errors > 0 then
			for _, message in ipairs(node.errors) do
				table.insert(results.errors, {
					message = message,
					phrase = node.planNode.phrase,
				})
			end
		end
	end)
end


Prompt: --Serverside logic

Response:
Event.OnServerEvent:Connect(function(player,ExhaustParticle,FireBool)

	print("ExhaustParticle")

	if FireBool then

		local RanNum = tostring(math.random(1,3))
		ExhaustPart["Backfire"..RanNum]:Play()
		ExhaustPart.PointLight.Enabled = true
		ExhaustPart[ExhaustParticle].Enabled = true

		if ExhaustParticle == "FlamesSmall" then

			ExhaustPart.PointLight.Range = 6
			ExhaustPart.PointLight.Brightness = 5
			ExhaustPart.Sparks.Enabled = false

		else

			ExhaustPart.PointLight.Range = 8
			ExhaustPart.PointLight.Brightness = 12
			ExhaustPart.Sparks.Enabled = true

		end

	else

		ExhaustPart[ExhaustParticle].Enabled = false
		ExhaustPart.PointLight.Enabled = false

	end

end)

local car = script.Parent.Parent
local ExhaustPart = car.Body.ExhaustFlames2
local Event = script.Parent


Prompt:
--[[

	StreamableUtil.Compound(observers: {Observer}, handler: ({[child: string]: Instance}, janitor: Janitor) -> void): Janitor

	Example:

		local streamable1 = Streamable.new(someModel, "SomeChild")
		local streamable2 = Streamable.new(anotherModel, "AnotherChild")

		StreamableUtil.Compound({S1 = streamable1, S2 = streamable2}, function(streamables, janitor)
			local someChild = streamables.S1.Instance
			local anotherChild = streamables.S2.Instance
			janitor:Add(function()
				-- Cleanup
			end)
		end)

--]]

Response:
local Janitor = require(script.Parent.Janitor)
local _Streamable = require(script.Parent.Streamable)

type Streamables = {_Streamable.Streamable}
type CompoundHandler = (Streamables, any) -> nil

local StreamableUtil = {}

function StreamableUtil.Compound(streamables: Streamables, handler: CompoundHandler)
	local compoundJanitor = Janitor.new()
	local observeAllJanitor = Janitor.new()
	local allAvailable = false
	local function Check()
		if allAvailable then return end
		for _,streamable in pairs(streamables) do
			if not streamable.Instance then
				return
			end
		end
		allAvailable = true
		handler(streamables, observeAllJanitor)
	end
	local function Cleanup()
		if not allAvailable then return end
		allAvailable = false
		observeAllJanitor:Cleanup()
	end
	for _,streamable in pairs(streamables) do
		compoundJanitor:Add(streamable:Observe(function(_child, janitor)
			Check()
			janitor:Add(Cleanup)
		end))
	end
	compoundJanitor:Add(Cleanup)
	return compoundJanitor
end

return StreamableUtil


Prompt: --theGAflash

Response:
wait(2)

local MarketplaceService = game:GetService("MarketplaceService")
local reciveModelPrompt = script.Parent.Parent.Parent.Parent:FindFirstChild("ClickDetector")
local productId = script.Parent.Parent.Parent.Parent:FindFirstChild("ID").Value

reciveModelPrompt.MouseClick:connect(function(player)

		MarketplaceService:PromptPurchase(player, productId)

end)


Prompt:
--[[
	READ ME

	-- Server API

	Network:BindFunctions(functions)
	Network:BindEvents(events)

	Network:FireClient(client, name, ...)
	Network:FireAllClients(name, ...)
	Network:FireOtherClients(ignoreclient, name, ...)
	Network:FireOtherClientsWithinDistance(ignoreclient, distance, name, ...)
	Network:FireAllClientsWithinDistance(position, distance, name, ...)

	Network:InvokeClient(client, name, ...)  (same as below with timeout = 60)
	Network:InvokeClientWithTimeout(timeout, client, name, ...)

	Network:LogTraffic(duration)

	-- Internal overrideable methods, used for custom AllClients/OtherClients/WithinDistance selectors

	Network:GetPlayers()
	Network:GetPlayerPosition(player)

	-- Client API

	Network:BindFunctions(functions)
	Network:BindEvents(events)

	Network:FireServer(name, ...)

	Network:InvokeServer(name, ...)
	Network:InvokeServerWithTimeout(timeout, name, ...)

	Notes:
	- The first return value of InvokeClient (but not InvokeServer) is bool success, which is false if the invocation timed out
	  or the handler errored.

	- InvokeServer will error if it times out or the handler errors

	- InvokeServer/InvokeClient do not return instantly on an error, but instead check for failure every 0.5 seconds. This is
	  because it is not possible to both instantly detect errors and have them be logged in the output with full stacktraces.

	For detailed API Use/Documentation, see
	https://devforum.roblox.com/t/easynetwork-creates-remotes-events-for-you-so-you-dont-have-to/
--]]

Response:
local Network = {}

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")

local EventHandlers = {}
local FunctionHandlers = {}

local IsStudio = RunService:IsStudio()
local IsServer = RunService:IsServer()

local LoggingNetwork
local function GetParamString(...)
	local tab = table.pack(...)
	local n = math.min(10, tab.n)

	for index = 1, n do
		local value = tab[index]
		local valueType = typeof(tab[index])

		if valueType == "string" then
			tab[index] = string.format("%q[%d]", #value <= 18 and value or value:sub(1, 15) .. "...", #value)
		elseif valueType == "Instance" then
			local success, className = pcall(function() return value.ClassName end)
			tab[index] = success and string.format("%s<%s>", valueType, className) or valueType
		else
			tab[index] = valueType
		end
	end

	return table.concat(tab, ", ", 1, n) .. (tab.n > n and string.format(", ... (%d more)", tab.n - n) or "")
end

local DeferredHandlers = {}

local ReceiveCounter = 0
local InvokeCounter = 0

local Communication,FunctionsFolder,EventsFolder

if IsServer then
	Communication = Instance.new("Folder",ReplicatedStorage)
	Communication.Name = "Communication"
	FunctionsFolder = Instance.new("Folder",Communication)
	FunctionsFolder.Name = "Functions"
	EventsFolder = Instance.new("Folder",Communication)
	EventsFolder.Name = "Events"
else
	Communication = ReplicatedStorage:WaitForChild("Communication")
	FunctionsFolder = Communication:WaitForChild("Functions")
	EventsFolder = Communication:WaitForChild("Events")
end


Prompt:
--///////////////////////// Constructors
--//////////////////////////////////////

Response:
function module.new(channelName)
	local obj = setmetatable({}, methods)

	local BaseFrame, NameTag, NameTagNonSelect, NameTagSelect, NewMessageIcon, UnselectedFrame, SelectedFrame = CreateGuiObjects()
	obj.GuiObject = BaseFrame
	obj.NameTag = NameTag
	obj.NameTagNonSelect = NameTagNonSelect
	obj.NameTagSelect = NameTagSelect
	obj.NewMessageIcon = NewMessageIcon
	obj.UnselectedFrame = UnselectedFrame
	obj.SelectedFrame = SelectedFrame

	obj.BlueBarLeft = SelectedFrame.BlueBarLeft
	obj.BlueBarRight = SelectedFrame.BlueBarRight
	obj.BackgroundImage = SelectedFrame.BackgroundImage
	obj.WhiteTextNewMessageNotification = obj.NewMessageIcon.TextLabel

	obj.ChannelName = channelName
	obj.UnreadMessageCount = 0
	obj.Active = false

	obj.GuiObject.Name = "Frame_" .. obj.ChannelName

	if (string.len(channelName) > ChatSettings.MaxChannelNameLength) then
		channelName = string.sub(channelName, 1, ChatSettings.MaxChannelNameLength - 3) .. "..."
	end

	--obj.NameTag.Text = channelName

	obj.NameTag.Text = ""
	obj.NameTagNonSelect.Text = channelName
	obj.NameTagSelect.Text = channelName

	obj.AnimParams = {}

	obj:InitializeAnimParams()
	obj:AnimGuiObjects()
	obj:SetActive(false)

	return obj
end

return module


Prompt: -- shut down the script when we die and reset things

Response:
Humanoid.Died:Connect(function()
	coroutine.close(ArmCoroutine)
	LeftShoulderClone:Destroy()
	RightShoulderClone:Destroy()
	Viewmodel:Destroy()
	if RightShoulder then
		RightShoulder.Enabled = true
	end
	if LeftShoulder then
		LeftShoulder.Enabled = true
	end
	LeftArm.Anchored = false
	RightArm.Anchored = false
	armTransparency = 0
	setArmVisibility(false)
end)

ArmCoroutine = coroutine.create(function()
	while true do
		SwaySize = script.WalkSwayMultiplier.Value
		-- checkFirstPerson() checks if camera is first person and enables/disables the Viewmodel accordingly
		checkFirstPerson()
		-- update loop
		if isFirstPerson == true then
			-- make arms visible
			setArmVisibility(true)
			-- update walk Sway if we are walking
			if checkPlayerRunning() then
				WalkSway = WalkSway:Lerp(CFrame.new((0.07*SwaySize) * math.sin(tick() * (2 * Humanoid.WalkSpeed/4)),(0.07*SwaySize) * math.cos(tick() * (4 * Humanoid.WalkSpeed/4)),0) * CFrame.Angles(0,0,(-.03*SwaySize) * math.sin(tick() * (2 * Humanoid.WalkSpeed/4))),0.2*Sensitivity)
			else
				WalkSway = WalkSway:Lerp(CFrame.new(), 0.05*Sensitivity)
			end
			--
			local delta = UserInputService:GetMouseDelta()
			--
			if IncludeCameraSway then
				Sway = Sway:Lerp(Vector3.new(delta.X,delta.Y,delta.X/2), 0.1*Sensitivity)
			end
			--
			if IncludeStrafe then
				StrafeSway = StrafeSway:Lerp(CFrame.Angles(0,0,-HumanoidRootPart.CFrame.rightVector:Dot(Humanoid.MoveDirection)/(20/SwaySize)), 0.1*Sensitivity)
			end
			--
			if IncludeJumpSway == true then
				JumpSway = JumpSwayGoal.Value
			end
			-- update animation transform for Viewmodel
			RightShoulderClone.Transform = RightShoulder.Transform
			LeftShoulderClone.Transform = LeftShoulder.Transform
			-- cframe the Viewmodel
			local SwayRotation = CFrame.Angles(math.rad(Sway.Y*SwaySize),math.rad(Sway.X*SwaySize)/10,math.rad(Sway.Z*SwaySize)/2)
			local OffsetVector3 = (Camera.CFrame.UpVector*(-1.7-(HeadOffset.Y+(AimOffset.Value.Y))))+(Camera.CFrame.LookVector*(HeadOffset.Z+(AimOffset.Value.Z)))+(Camera.CFrame.RightVector*(-HeadOffset.X-(AimOffset.Value.X)+(-(Sway.X*SwaySize)/75)))
			local SwayPosition = WalkSway*JumpSway*StrafeSway
			local OffsetCFrame = script.CFrameAimOffset.Value:Inverse()
			local FinalCFrame = ((Camera.CFrame * SwayPosition * SwayRotation) + OffsetVector3) * OffsetCFrame
			Viewmodel.PrimaryPart.CFrame = FinalCFrame
		end
		RunService.RenderStepped:Wait()
	end
end)

coroutine.resume(ArmCoroutine)

if (game.StarterPlayer.CameraMode == Enum.CameraMode.LockFirstPerson) or (game.StarterPlayer.CameraMaxZoomDistance <= 0.5) then
	toggleViewmodel(true)
end


Prompt: -- Garage

Response: local Garage = ReplicatedStorage:WaitForChild("Garage")


Prompt:
--[[
	Provides a client-side API to interact with the server market, including pcalling the network
	request and wrapping the pcall result and server result together into one result.
--]]

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

local Network = require(ReplicatedStorage.Source.Network)
local ItemCategory = require(ReplicatedStorage.Source.SharedConstants.ItemCategory)
local ItemPurchaseFailureReason =
	require(ReplicatedStorage.Source.SharedConstants.RequestFailureReason.ItemPurchaseFailureReason)

local MarketClient = {}

function MarketClient.requestItemPurchaseAsync(itemId: string, itemCategory: ItemCategory.EnumType, amount: number)
	-- invokeServerAsync wraps the request in a pcall, so we receive two success and result pairs:
	-- one from the pcall and one from the server's purchase request handler
	local networkRequestSuccess: boolean -- Result of the pcall wrapping the network request
	local networkRequestResult: string | boolean -- pcall network request failure reason, or purchase success result from the server
	local purchaseFailureReason: ItemPurchaseFailureReason.EnumType? -- Purchase rejection/failure reason from the server

	networkRequestSuccess, networkRequestResult, purchaseFailureReason =
		Network.invokeServerAsync(Network.RemoteFunctions.RequestItemPurchase, itemId, itemCategory, amount)

	-- Aggregate the network pcall success results with the purchase success results
	local overallSuccess = networkRequestSuccess and networkRequestResult :: boolean
	local eitherFailureReason = if networkRequestSuccess
		then purchaseFailureReason
		else tostring(networkRequestResult) :: string?

	return overallSuccess, eitherFailureReason
end


Prompt: -- if the player steps in a vehicle

Response:
camera:GetPropertyChangedSignal("CameraSubject"):Connect(function()
    if camera.CameraSubject:IsA("VehicleSeat") then
        camera.CameraSubject = humanoid
    end
end)


Prompt: --dbz play sound

Response:
function module.Play2(humrp, sound, tim)

	local sound = soundFold[sound]:Clone()
	sound.Parent = humrp
	sound:Play()
	game.Debris:AddItem(sound, tim or sound.TimeLength)
	--delay(tim or sound.TimeLength, function())
end


Prompt: -- / Services / --

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


Prompt: -- Note: Called whenever workspace.CurrentCamera changes, but also on initialization of this script

Response:
function CameraModule:OnCurrentCameraChanged()
	local currentCamera = game.Workspace.CurrentCamera
	if not currentCamera then return end

	if self.cameraSubjectChangedConn then
		self.cameraSubjectChangedConn:Disconnect()
	end

	if self.cameraTypeChangedConn then
		self.cameraTypeChangedConn:Disconnect()
	end

	self.cameraSubjectChangedConn = currentCamera:GetPropertyChangedSignal("CameraSubject"):Connect(function()
		self:OnCameraSubjectChanged(currentCamera.CameraSubject)
	end)

	self.cameraTypeChangedConn = currentCamera:GetPropertyChangedSignal("CameraType"):Connect(function()
		self:OnCameraTypeChanged(currentCamera.CameraType)
	end)

	self:OnCameraSubjectChanged(currentCamera.CameraSubject)
	self:OnCameraTypeChanged(currentCamera.CameraType)
end

function CameraModule:OnLocalPlayerCameraPropertyChanged(propertyName: string)
	if propertyName == "CameraMode" then
		-- CameraMode is only used to turn on/off forcing the player into first person view. The
		-- Note: The case "Classic" is used for all other views and does not correspond only to the ClassicCamera module
		if Players.LocalPlayer.CameraMode == Enum.CameraMode.LockFirstPerson then
			-- Locked in first person, use ClassicCamera which supports this
			if not self.activeCameraController or self.activeCameraController:GetModuleName() ~= "ClassicCamera" then
				self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(Enum.DevComputerCameraMovementMode.Classic))
			end

			if self.activeCameraController then
				self.activeCameraController:UpdateForDistancePropertyChange()
			end
		elseif Players.LocalPlayer.CameraMode == Enum.CameraMode.Classic then
			-- Not locked in first person view
			local cameraMovementMode = self:GetCameraMovementModeFromSettings()
			self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(cameraMovementMode))
		else
			warn("Unhandled value for property player.CameraMode: ",Players.LocalPlayer.CameraMode)
		end

	elseif propertyName == "DevComputerCameraMode" or
		   propertyName == "DevTouchCameraMode" then
		local cameraMovementMode = self:GetCameraMovementModeFromSettings()
		self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(cameraMovementMode))

	elseif propertyName == "DevCameraOcclusionMode" then
		self:ActivateOcclusionModule(Players.LocalPlayer.DevCameraOcclusionMode)

	elseif propertyName == "CameraMinZoomDistance" or propertyName == "CameraMaxZoomDistance" then
		if self.activeCameraController then
			self.activeCameraController:UpdateForDistancePropertyChange()
		end
	elseif propertyName == "DevTouchMovementMode" then
	elseif propertyName == "DevComputerMovementMode" then
	elseif propertyName == "DevEnableMouseLock" then
		-- This is the enabling/disabling of "Shift Lock" mode, not LockFirstPerson (which is a CameraMode)
		-- Note: Enabling and disabling of MouseLock mode is normally only a publish-time choice made via
		-- the corresponding EnableMouseLockOption checkbox of StarterPlayer, and this script does not have
		-- support for changing the availability of MouseLock at runtime (this would require listening to
		-- Player.DevEnableMouseLock changes)
	end
end

function CameraModule:OnUserGameSettingsPropertyChanged(propertyName: string)
	if propertyName == "ComputerCameraMovementMode" then
		local cameraMovementMode = self:GetCameraMovementModeFromSettings()
		self:ActivateCameraController(CameraUtils.ConvertCameraModeEnumToStandard(cameraMovementMode))
	end
end


Prompt: --//SS6 PLUGIN; LIGHTS AND INDICATORS//--

Response: --//INSPARE 2017//--


Prompt:
--[=[
	@class SoftShutdownConstants
]=]

Response:
local require = require(script.Parent.loader).load(script)

local Table = require("Table")

return Table.readonly({
	IS_SOFT_SHUTDOWN_LOBBY_ATTRIBUTE = "IsSoftShutdownLobby";
	IS_SOFT_SHUTDOWN_UPDATING_ATTRIBUTE = "IsSoftshutdownRebootingServers";
})


Prompt: --[[ Constants ]]

Response:
--
local DEFAULT_MOUSE_LOCK_CURSOR = "rbxasset://textures/MouseLockedCursor.png"

local CONTEXT_ACTION_NAME = "MouseLockSwitchAction"
local MOUSELOCK_ACTION_PRIORITY = Enum.ContextActionPriority.Medium.Value


Prompt: --// Holiday roooaaAaaoooAaaooOod

Response:
local _G, game, script, getfenv, setfenv, workspace,
getmetatable, setmetatable, loadstring, coroutine,
rawequal, typeof, print, math, warn, error,  pcall,
xpcall, select, rawset, rawget, ipairs, pairs,
next, Rect, Axes, os, time, Faces, unpack, string, Color3,
newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
NumberSequenceKeypoint, PhysicalProperties, Region3int16,
Vector3int16, require, table, type, wait,
Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, spawn, delay, task, assert =
	_G, game, script, getfenv, setfenv, workspace,
getmetatable, setmetatable, loadstring, coroutine,
rawequal, typeof, print, math, warn, error,  pcall,
xpcall, select, rawset, rawget, ipairs, pairs,
next, Rect, Axes, os, time, Faces, table.unpack, string, Color3,
newproxy, tostring, tonumber, Instance, TweenInfo, BrickColor,
NumberRange, ColorSequence, NumberSequence, ColorSequenceKeypoint,
NumberSequenceKeypoint, PhysicalProperties, Region3int16,
Vector3int16, require, table, type, task.wait,
Enum, UDim, UDim2, Vector2, Vector3, Region3, CFrame, Ray, task.defer, task.delay, task, function(cond, errMsg) return cond or error(errMsg or "assertion failed!", 2) end;

local SERVICES_WE_USE = table.freeze {
	"Workspace";
	"Players";
	"Lighting";
	"ServerStorage";
	"ReplicatedStorage";
	"JointsService";
	"ReplicatedFirst";
	"ScriptContext";
	"ServerScriptService";
	"LogService";
	"Teams";
	"SoundService";
	"StarterGui";
	"StarterPack";
	"StarterPlayer";
	"GroupService";
	"MarketplaceService";
	"TestService";
	"HttpService";
	"RunService";
	"InsertService";
	"NetworkServer";
}

local unique = {}
local origEnv = getfenv(); setfenv(1,setmetatable({}, {__metatable = unique}))
local locals = {}
local server = {}
local service = {}
local RbxEvents = {}
local ErrorLogs = {}
local HookedEvents = {}
local ServiceSpecific = {}
local oldReq = require
local Folder = script.Parent
local oldInstNew = Instance.new
local isModule = function(module)
	for ind, modu in pairs(server.Modules) do
		if module == modu then
			return true
		end
	end
	return false
end

local logError = function(plr, err)
	if type(plr) == "string" and not err then
		err = plr;
		plr = nil;
	end

	if server.Core and server.Core.DebugMode then
		warn(`::Adonis:: Error: {plr}: {err}`)
	end

	if server and server.Logs then
		server.Logs.AddLog(server.Logs.Errors, {
			Text = ((err and plr and tostring(plr) ..":") or "").. tostring(err),
			Desc = err,
			Player = plr
		})
	end
end

local print = function(...)
	print(":: Adonis ::", ...)
end

local warn = function(...)
	warn(":: Adonis ::", ...)
end

local function CloneTable(tab, recursive)
	local clone = table.clone(tab)

	if recursive then
		for i,v in pairs(clone) do
			if type(v) == "table" then
				clone[i] = CloneTable(v, recursive)
			end
		end
	end

	return clone
end

local function Pcall(func, ...)
	local pSuccess, pError = pcall(func, ...)
	if not pSuccess then
		warn(pError)
		logError(pError)
	end

	return pSuccess, pError
end

local function cPcall(func, ...)
	return Pcall(function(...)
		return coroutine.resume(coroutine.create(func), ...)
	end, ...)
end

local function Routine(func, ...)
	return coroutine.resume(coroutine.create(func), ...)
end

local function GetEnv(env, repl)
	local scriptEnv = setmetatable({}, {
		__index = function(tab, ind)
			return (locals[ind] or (env or origEnv)[ind])
		end;

		__metatable = unique;
	})
	if repl and type(repl) == "table" then
		for ind, val in pairs(repl) do
			scriptEnv[ind] = val
		end
	end
	return scriptEnv
end

local function GetVargTable()
	return {
		Server = server;
		Service = service;
	}
end

local function LoadModule(module, yield, envVars, noEnv, isCore)
	noEnv = false --// Seems to make loading take longer when true (?)
	local isFunc = type(module) == "function"
	local module = (isFunc and service.New("ModuleScript", {Name = "Non-Module Loaded"})) or module
	local plug = (isFunc and module) or require(module)

	if server.Modules and type(module) ~= "function" then
		table.insert(server.Modules,module)
	end

	if type(plug) == "function" then
		if isCore then
			local ran,err = service.TrackTask(`CoreModule: {module}`, plug, GetVargTable(), GetEnv)
			if not ran then
				warn("Core Module encountered an error while loading:", module)
				warn(err)
			else
				return err;
			end
		elseif yield then
			--Pcall(setfenv(plug,GetEnv(getfenv(plug), envVars)))
			local ran,err = service.TrackTask(`Plugin: {module}`, (noEnv and plug) or setfenv(plug, GetEnv(getfenv(plug), envVars)), GetVargTable())
			if not ran then
				warn("Plugin Module encountered an error while loading:", module)
				warn(err)
			else
				return err;
			end
		else
			--service.Threads.RunTask(`PLUGIN: {module}`,setfenv(plug,GetEnv(getfenv(plug), envVars)))
			local ran, err = service.TrackTask(`Thread: Plugin: {module}`, (noEnv and plug) or setfenv(plug, GetEnv(getfenv(plug), envVars)), GetVargTable())
			if not ran then
				warn("Plugin Module encountered an error while loading:", module)
				warn(err)
			else
				return err;
			end
		end
	else
		server[module.Name] = plug
	end

	if server.Logs then
		server.Logs.AddLog(server.Logs.Script,{
			Text = `Loaded Module: {module}`;
			Desc = "Adonis loaded a core module or plugin";
		})
	end
end;


Prompt:
--[=[
	Constructs a new SpringObject.
	@param target T
	@param speed number | Observable<number> | ValueObject<number> | NumberValue | any
	@param damper number | Observable<number> | NumberValue | any
	@return Spring<T>
]=]

Response:
function SpringObject.new(target, speed, damper)
	local self = setmetatable({
		_maid = Maid.new();
		Changed = Signal.new();
	}, SpringObject)


Prompt:
--!nonstrict
-- polyfill for https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof

Response:
return function(tbl, class)
	assert(typeof(class) == "table", "Received a non-table as the second argument for instanceof")

	if typeof(tbl) ~= "table" then
		return false
	end

	local ok, hasNew = pcall(function()
		return class.new ~= nil and tbl.new == class.new
	end)
	if ok and hasNew then
		return true
	end

	local seen = { tbl = true }

	while tbl and typeof(tbl) == "table" do
		tbl = getmetatable(tbl)
		if typeof(tbl) == "table" then
			tbl = tbl.__index

			if tbl == class then
				return true
			end
		end

		-- if we still have a valid table then check against seen
		if typeof(tbl) == "table" then
			if seen[tbl] then
				return false
			end
			seen[tbl] = true
		end
	end

	return false
end


Prompt:
-- deviation: short circuit for now
--local MAYBE_ITERATOR_SYMBOL = false -- deviation: typeof(Symbol) == 'function' and Symbol.iterator
--local FAUX_ITERATOR_SYMBOL = '@@iterator'

Response:
type Iterator<T> = {
	next: () -> {
		value: T,
		key: any,
		done: boolean,
	},
}


Prompt: --The button

Response:
script.Parent.Handle.ClickDetector.MouseClick:connect(function(click)

if not (on) then on = true--On
    script.Parent.W1.Transparency = 1
    script.Parent.W2.Transparency = 0

elseif (on) then on = false --Off
    script.Parent.W1.Transparency = 0
    script.Parent.W2.Transparency = 1
    end
end)


Prompt: -- @ModuleDescription Library containing other small function useful for programming.

Response:
local System = require(game.ReplicatedStorage.System) :: any
local Basic = {}
Basic.Replicated = true

local CachedProperties = {}


Prompt: --FireBomb

Response:
game.Players.PlayerAdded:Connect(function(player)
	player.CharacterAdded:Connect(function(character)
		local Humanoid = character:WaitForChild("Humanoid")
		Humanoid.Died:connect(function()
			if player.FireBomb.Value == 2 then
				player.FireBomb.Value = 1
				end
		end)
	end)
end)
game.Players.PlayerRemoving:Connect(function(player)
	if player.FireBomb.Value == 2 then
		player.FireBomb.Value = 1
	end
end)


Prompt:
--[[
	Returns the current value of this Spring object.
	The object will be registered as a dependency unless `asDependency` is false.
]]

Response:
function class:get(asDependency: boolean?): any
	if asDependency ~= false then
		Dependencies.useDependency(self)
	end
	return self._currentValue
end


Prompt: -- Compiled with roblox-ts v2.0.4

Response:
local default = function(str, prefix)
	local strArr = string.split(str, "")
	local prefixArr = string.split(prefix, "")
	local l = 0
	local r = math.min(#str, #prefix) - 1
	while l <= r do
		local m = math.floor((l + r) / 2)
		if strArr[m + 1] == prefixArr[m + 1] then
			l = m + 1
		else
			r = m - 1
		end
	end
	return r + 1 >= #prefix
end
return {
	default = default,
}


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

Response:
local v1 = script:FindFirstAncestor("MainUI");
local l__Bricks__2 = game:GetService("ReplicatedStorage"):WaitForChild("Bricks");
local l__TweenService__1 = game:GetService("TweenService");
return function(p1)
	local l__FigureCamPos__3 = workspace:FindFirstChild("FigureCamPos", true);
	p1.stopcam = true;
	p1.freemouse = true;
	p1.hideplayers = 2;
	p1.update();
	local v4 = l__FigureCamPos__3.CFrame + l__FigureCamPos__3.CFrame.LookVector * 25;
	local l__CFrame__5 = l__FigureCamPos__3.CFrame;
	local l__CFrame__6 = p1.cam.CFrame;
	local v7 = tick() + 2;
	local l__FieldOfView__8 = p1.cam.FieldOfView;
	l__TweenService__1:Create(p1.cam, TweenInfo.new(1.6, Enum.EasingStyle.Exponential, Enum.EasingDirection.Out), {
		FieldOfView = 40
	}):Play();
	for v9 = 1, 100000 do
		task.wait();
		if not (tick() <= v7) then
			break;
		end;
		p1.cam.CFrame = l__CFrame__6:Lerp(v4, (l__TweenService__1:GetValue((2 - math.abs(tick() - v7)) / 2, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut))) * p1.csgo;
	end;
	local v10 = tick() + 6;
	l__TweenService__1:Create(p1.cam, TweenInfo.new(5, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut), {
		FieldOfView = 70
	}):Play();
	for v11 = 1, 100000 do
		task.wait();
		if not (tick() <= v10) then
			break;
		end;
		p1.cam.CFrame = v4:Lerp(l__CFrame__5, (l__TweenService__1:GetValue((6 - math.abs(tick() - v10)) / 6, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut))) * p1.csgo;
	end;
	local l__CFrame__12 = p1.cam.CFrame;
	local v13 = tick() + 0.5;
	local l__FieldOfView__14 = p1.cam.FieldOfView;
	for v15 = 1, 100000 do
		task.wait();
		local v16 = l__TweenService__1:GetValue((0.5 - math.abs(tick() - v13)) / 0.5, Enum.EasingStyle.Quad, Enum.EasingDirection.InOut);
		if not (tick() <= v13) then
			break;
		end;
		p1.cam.CFrame = l__CFrame__12:Lerp(p1.basecamcf, v16) * p1.csgo;
		p1.cam.FieldOfView = l__FieldOfView__14 + (p1.fovspring - l__FieldOfView__14) * v16;
	end;
	p1.stopcam = false;
	p1.freemouse = false;
	p1.hideplayers = 0;
	p1.update();
end;


Prompt:
-- Should messages to channels other than general be echoed into the general channel.
-- Setting this to false should be used with ShowChannelsBar

Response:
module.EchoMessagesInGeneralChannel = false
module.ChannelsBarFullTabSize = 4 -- number of tabs in bar before it starts to scroll
module.MaxChannelNameLength = 12


Prompt: --------------------[ FIRING FUNCTIONS ]----------------------------------------------

Response:
function lowerSpread()
	if (not loweringSpread) then
		loweringSpread = true
		local Connection = nil
		Connection = RS.Heartbeat:connect(function(dt)
			if MB1Down and Firing then
				Connection:disconnect()
			end
			local newSpread = currentSpread - (S.spreadSettings.Decrease * dt)
			currentSpread = (newSpread < 0 and 0 or newSpread)
			if currentSpread == 0 then
				Connection:disconnect()
			end
		end)
		loweringSpread = false
	end
end

local function autoFire()
	if (not canFire) then return end
	canFire = false

	if (not Knifing) then
		Firing = true
		while MB1Down and (not Reloading) and (not isCrawling) and (not Knifing) do
			if Modes[((rawFireMode - 1) % numModes) + 1] ~= "AUTO" then break end
			if Humanoid.Health == 0 then break end
			if Ammo.Value > 0 then
				Ammo.Value = Ammo.Value - 1
				if Aimed and steadyKeyPressed and S.scopeSettings.unSteadyOnFire then
					steadyKeyPressed = false
					currentSteadyTime = 0
				end
				newMag = false
				fireGun()
			end
			if S.reloadSettings.magIsBullet then
				for _, Mag in pairs(Gun:GetChildren()) do
					if Mag.Name:sub(1, 3) == "Mag" then
						Mag.Transparency = 1
					end
				end
			end
			if Ammo.Value == 0 and S.reloadSettings.autoReload then
				wait(0.2)
				Reload()
			end
			wait(60 / S.roundsPerMin)
		end
	end

	Firing = false
	canFire = true
end

local function semiFire()
	if (not canFire) then return end
	canFire = false

	if (not Knifing) and (not isCrawling) and Humanoid.Health ~= 0 then
		Firing = true
		if Ammo.Value > 0 then
			Ammo.Value = Ammo.Value - 1
			if Aimed and steadyKeyPressed and S.scopeSettings.unSteadyOnFire then
				steadyKeyPressed = false
				currentSteadyTime = 0
			end
			newMag = false
			fireGun()
		end
		if S.reloadSettings.magIsBullet then
			for _, Mag in pairs(Gun:GetChildren()) do
				if Mag.Name:sub(1, 3) == "Mag" then
					Mag.Transparency = 1
				end
			end
		end
		if Ammo.Value == 0 and S.reloadSettings.autoReload then
			wait(0.2)
			Reload()
		end
		wait(60 / S.roundsPerMin)
	end

	Firing = false
	canFire = true
end

local function burstFire()
	if (not canFire) then return end
	canFire = false

	local burstTime = 60 / S.roundsPerMin
	if (not Knifing) and (not isCrawling) then
		Firing = true
		for i = 1, S.burstSettings.Amount do
			if Ammo.Value > 0 then
				Ammo.Value = Ammo.Value - 1
				if Humanoid.Health ~= 0 then
					if Aimed and steadyKeyPressed and S.scopeSettings.unSteadyOnFire then
						steadyKeyPressed = false
						currentSteadyTime = 0
					end
					newMag = false
					fireGun()
				end
			end
			if Ammo.Value == 0 and S.reloadSettings.autoReload then
				wait(0.2)
				Reload()
				break
			end
			wait(S.burstSettings.fireRateBurst and burstTime or S.burstSettings.Time / S.burstSettings.Amount)
		end
	end
	if S.reloadSettings.magIsBullet then
		for _, Mag in pairs(Gun:GetChildren()) do
			if Mag.Name:sub(1, 3) == "Mag" then
				Mag.Transparency = 1
			end
		end
	end

	Firing = false

	wait(S.burstSettings.fireRateBurst and burstTime or S.burstSettings.Wait)

	canFire = true
end

function fireGun()
	local fireSound = Handle:FindFirstChild("Fire")
	if fireSound then fireSound:Play() end
	----------------------------------------------------------------------------------
	for _ = 1, (S.gunType.Shot and S.ShotAmount or 1) do
		local randSpread1 = RAD(RAND(0, 365))
		local randSpread2 = RAD(RAND(-(baseSpread + currentSpread), baseSpread + currentSpread, 0.01))
		local spreadDir = CFrame.fromAxisAngle(V3(0, 0, 1), randSpread1) * CFANG(randSpread2, 0, 0)

		local originCF = ((Aimed and S.guiScope) and Head.CFrame or Handle.CFrame) * spreadDir
		local bulletDirection = CF(originCF.p, originCF.p + originCF.lookVector).lookVector

		if S.bulletSettings.instantHit then
			local newRay = Ray.new(Main.CFrame.p, bulletDirection * S.bulletSettings.Range)
			local H, P, N = workspace:FindPartOnRayWithIgnoreList(newRay, Ignore)
			local finalP = P
			if H then
				if S.gunType.Explosive then
					if S.explosionSettings.soundId ~= "" then
						local soundPart = Instance.new("Part")
						soundPart.Transparency = 1
						soundPart.Anchored = true
						soundPart.CanCollide = false
						soundPart.Size = V3(1, 1, 1)
						soundPart.CFrame = CFrame.new(P)
						soundPart.Parent = gunIgnore

						local Sound = Instance.new("Sound")
						Sound.Pitch = S.explosionSettings.Pitch
						Sound.SoundId = S.explosionSettings.soundId
						Sound.Volume = S.explosionSettings.Volume
						Sound.Parent = soundPart
						Sound:Play()

						DS:AddItem(soundPart, Sound.TimeLength)
					end
					createBulletImpact:FireServer(H, P, N, bulletDirection, false, gunIgnore, S)
					createShockwave:FireServer(P, S.explosionSettings.Radius, gunIgnore, S)
					local E = Instance.new("Explosion")
					E.BlastPressure = S.explosionSettings.Pressure
					E.BlastRadius = S.explosionSettings.Radius
					E.DestroyJointRadiusPercent = (S.explosionSettings.rangeBasedDamage and 0 or 1)
					E.ExplosionType = S.explosionSettings.Type
					E.Position = P
					E.Hit:connect(function(Obj, Dist)
						if Obj.Name == "Torso" and (not Obj:IsDescendantOf(Char)) then
							if S.explosionSettings.rangeBasedDamage then
								local Dir = (Obj.Position - P).unit
								local expH, _ = workspace:FindPartOnRayWithIgnoreList(
									Ray.new(P - Dir * 0.1, Dir * 999),
									Ignore
								)
								local rayHitHuman = expH:IsDescendantOf(Obj.Parent)
								if (S.explosionSettings.rayCastExplosions and rayHitHuman) or (not S.explosionSettings.rayCastExplosions) then
									local hitHumanoid = findFirstClass(Obj.Parent, "Humanoid")
									if hitHumanoid and hitHumanoid.Health > 0 and isEnemy(hitHumanoid) then
										local distFactor = Dist / S.explosionSettings.Radius
										local distInvert = math.max(1 - distFactor,0)
										local newDamage = distInvert * getBaseDamage((P - Main.CFrame.p).magnitude)

										local Tag = Instance.new("ObjectValue")
										Tag.Value = Player
										Tag.Name = "creator"
										Tag.Parent = hitHumanoid
										DS:AddItem(Tag, 0.3)
										hitHumanoid:TakeDamage(newDamage)
										markHit()
									end
								end
							else
								local hitHumanoid = findFirstClass(Obj.Parent, "Humanoid")
								if hitHumanoid and hitHumanoid.Health > 0 and isEnemy(hitHumanoid) then
									local Tag = Instance.new("ObjectValue")
									Tag.Value = Player
									Tag.Name = "creator"
									Tag.Parent = hitHumanoid
									DS:AddItem(Tag, 0.3)
									markHit()
								end
							end
						end
					end)
					E.Parent = game.Workspace
				else
					_, finalP = penetrateWall(H, P, bulletDirection, N, {Char, ignoreModel}, 0, (P - Main.CFrame.p).magnitude, nil)
				end
			end
			if S.bulletTrail and S.trailSettings.Transparency ~= 1 then
				createTrail:FireServer(Main.CFrame.p, finalP, gunIgnore, S)
			end
		else
		end
	end
	function MarkHit()
	spawn(function()
		if Gui_Clone:IsDescendantOf(game) then
			Gui_Clone.HitMarker.Visible = true
			local StartMark = tick()
			LastMark = StartMark
			wait(0.5)
			if LastMark <= StartMark then
				Gui_Clone.HitMarker.Visible = false
			end
		end
	end)
end

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

	currentSpread = currentSpread + S.spreadSettings.Increase

	for _, Plugin in pairs(Plugins.Firing) do
		spawn(function()
			Plugin()
		end)
	end

	local backRecoil = RAND(S.recoilSettings.Recoil.Back.Min, S.recoilSettings.Recoil.Back.Max, 0.01) --Get the kickback recoil
	local upRecoil = RAND(S.recoilSettings.Recoil.Up.Min, S.recoilSettings.Recoil.Up.Max, 0.01) --Get the up recoil
	local sideRecoilAlpha = 0
	if lastSideRecoil[1] < 0 and lastSideRecoil[2] < 0 then --This conditional basically makes sure the gun tilt isn't in the same direction for more than 2 shots
		sideRecoilAlpha = RAND(0, 1, 0.1)
	elseif lastSideRecoil[1] > 0 and lastSideRecoil[2] > 0 then
		sideRecoilAlpha = RAND(-1, 0, 0.1)
	else
		sideRecoilAlpha = RAND(-1, 1, 0.1)
	end
	local sideRecoil = numLerp(S.recoilSettings.Recoil.Side.Left, S.recoilSettings.Recoil.Side.Right, sideRecoilAlpha / 2 + 0.5) --Get the side recoil
	local tiltRecoil = numLerp(S.recoilSettings.Recoil.Tilt.Left, S.recoilSettings.Recoil.Tilt.Right, sideRecoilAlpha / 2 + 0.5) --Get the tilt recoil
	local recoilPos = V3(
		0,---sideRecoil,
		0,
		-backRecoil
	) * (Aimed and S.recoilSettings.aimedMultiplier or 1)
	local recoilRot = V3(
		(Aimed and 0 or (-RAD(upRecoil * 10) * (firstShot and S.recoilSettings.firstShotMultiplier or 1))),
		RAD(sideRecoil * 10),
		RAD(tiltRecoil * 10)
	) * (Aimed and S.recoilSettings.aimedMultiplier or 1)
	local camRecoilRot = V3(
		-RAD(sideRecoil * 10),
		RAD(upRecoil * 10) * (firstShot and S.recoilSettings.firstShotMultiplier or 1) * S.recoilSettings.camMultiplier,
		0
	) * (Aimed and S.recoilSettings.aimedMultiplier or 1) * stanceSway
	tweenRecoil(recoilPos, recoilRot, Sine, 0.2)
	tweenCam("Recoil", camRecoilRot, Sine, 0.15 * (firstShot and S.recoilSettings.firstShotMultiplier or 1))

	for _, v in pairs(Main:GetChildren()) do
		if v.Name:sub(1, 7) == "FlashFX" then
			v.Enabled = true
		end
	end
		local shell = Instance.new("Part")
	shell.CFrame = Gun.Chamber.CFrame * CFrame.fromEulerAnglesXYZ(-2.5,1,1)
	shell.Size = Vector3.new(0.2,0.5,0.2)
	shell.CanCollide = false
	shell.Name = "Shell"
	shell.Velocity = Gun.Chamber.CFrame.lookVector * 10 + Vector3.new(math.random(-10,10),20,math.random(-10,10))
	shell.RotVelocity = Vector3.new(0,200,0)
	shell.Parent = game.Workspace
	game:GetService("Debris"):addItem(shell,2)
	local shellmesh = Instance.new("SpecialMesh")
	shellmesh.Scale = Vector3.new(2,2,2)
	shellmesh.MeshId = "http://www.roblox.com/asset/?id=94295100"
	shellmesh.TextureId = "http://www.roblox.com/asset/?id=94287792"
	shellmesh.MeshType = "FileMesh"
	shellmesh.Parent = shell
	delay(1 / 20, function()
		tweenRecoil(V3(), V3(), Sine, 0.2)
		tweenCam("Recoil", V3(), Sine, 0.2)
		for _, v in pairs(Main:GetChildren()) do
			if v.Name:sub(1, 7) == "FlashFX" then
				v.Enabled = false
			end
		end
	end)

	updateClipAmmo()
	firstShot = false
	shotCount = shotCount + 1
	lastSideRecoil[(shotCount % 2) + 1] = sideRecoilAlpha
end

function markHit()
	spawn(function()
		if mainGUI:IsDescendantOf(game) then
			hitMarker.Visible = true
			local startMark = tick()
			hitMarker.lastMark.Value = startMark

			wait(0.5)

			if hitMarker.lastMark.Value <= startMark then
				hitMarker.Visible = false
			end
		end
	end)
end


Prompt: -- Events

Response:
local Events = ReplicatedStorage.Events
local BuyUpgradeEvent = Events.BuyUpgrade
local AddUpgradeEvent = Events.AddUpgrade
local UpdatePointsEvent = Events.UpdatePoints
local TouchCheckpointEvent = Events.TouchCheckpoint
local ChangeController = Events.ChangeController
local PlayerEnteredGame = Events.PlayerEnteredGame


Prompt:
--edit the function below to return true when you want this response/prompt to be valid
--player is the player speaking to the dialogue, and dialogueFolder is the object containing the dialogue data

Response:
return function(player, dialogueFolder)
	local plrData = require(game.ReplicatedStorage.Source.Modules.Util):GetPlayerData(player)
	return plrData.Classes.Super.Mage.Obtained.Value == true and plrData.Classes.Super.Mage.Fireball.Value ~= true
end


Prompt: -- Compiled with roblox-ts v2.1.0

Response:
local TS = require(game:GetService("ReplicatedStorage"):WaitForChild("rbxts_include"):WaitForChild("RuntimeLib"))
local Renderable = TS.import(script, game:GetService("ReplicatedStorage"), "TS", "components").Renderable
local function renderable(world, _)
	for id, model in world:query(Renderable) do
		if not model.model:IsDescendantOf(game) then
			world:remove(id, Renderable)
		end
	end
	for _id, model in world:queryChanged(Renderable) do
		if model.old and (model.old.model and not model.new) then
			model.old.model:Destroy()
		end
	end
end
return renderable


Prompt:
--[=[
	@param parent Instance
	@param usePromise boolean
	@param namespace string?
	@return ClientComm
	Constructs a ClientComm object.

	If `usePromise` is set to `true`, then `GetFunction` will generate a function that returns a Promise
	that resolves with the server response. If set to `false`, the function will act like a normal
	call to a RemoteFunction and yield until the function responds.
]=]

Response:
function ClientComm.new(parent: Instance, usePromise: boolean, namespace: string?, janitor)
	assert(not IS_SERVER, "ClientComm must be constructed from the client")
	assert(typeof(parent) == "Instance", "Parent must be of type Instance")
	local ns = DEFAULT_COMM_FOLDER_NAME
	if namespace then
		ns = namespace
	end
	local folder: Instance? = parent:WaitForChild(ns, WAIT_FOR_CHILD_TIMEOUT)
	assert(folder ~= nil, "Could not find namespace for ClientComm in parent: " .. ns)
	local self = setmetatable({}, ClientComm)
	self._instancesFolder = folder
	self._usePromise = usePromise
	if janitor then
		janitor:Add(self)
	end
	return self
end


Prompt: -- Constants

Response: local Local_Player = PlayersService.LocalPlayer


Prompt:
-- The R15 Ragdoll was originally written by EchoReaper
-- I only modified it to work with R6


Prompt: --Scripting -- Do not touch unless you know what to do--

Response:
if chassisversion == "Tyler" then
	antenna = car.DriveSeat
	driveseat.IsOn.Changed:connect(function()
		if driveseat.IsOn.Value == true then
			handler:FireServer("IsOn", "On")
		else
			handler:FireServer("IsOn","Off")
			end
	end)
elseif chassisversion == "Cat" then
	antenna = car.Body.Antenna
	car.Electrics.Changed:connect(function()
		if car.Electrics.Value == true then
			handler:FireServer("IsOn", "On")
		else
			handler:FireServer("IsOn", "Off")
		end
	end)
end


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

Response:
return {
	Name = "unbind",
	Aliases = {},
	Description = "Unbinds an input previously bound with Bind",
	Group = "DefaultUtil",
	Args = { {
			Type = "userInput ! bindableResource @ player",
			Name = "Input/Key",
			Description = "The key or input type you'd like to unbind."
		} },
	ClientRun = function(p1, p2)
		local v1 = p1:GetStore("CMDR_Binds");
		if not v1[p2] then
			return "That input wasn't bound.";
		end;
		v1[p2]:Disconnect();
		v1[p2] = nil;
		return "Unbound command from input.";
	end
};