Prompt:
--[[
-- {PoisonApple, PoisonCake, PoisonPorkChop}
local BaseIdUrl = 'http://www.roblox.com/asset/?id='
local IconIds = {'87862872', '87863072', '87871704'}
local MeshIds = {'87862943', '87863104', '87863169'}
local TextureIds = {'87862921', '87863090', '87863148'}
local HandleSizes = {Vector3.new(1.2, 1.2, 1.2), Vector3.new(1.08, 1.11, 1.14), Vector3.new(0.45, 1.82, 1.33)}
--]]

Response:
local MyModel = nil
local MyPlayer = nil

uses = 0

local function OnEquipped()
	MyModel = Tool.Parent
	MyPlayer = PlayersService:GetPlayerFromCharacter(MyModel)
end

local function OnActivated()
	if not MyModel or not MyModel:FindFirstChild('Humanoid') or not Tool.Enabled then return end
	Tool.Enabled = false

	uses = uses + 1

	ThrowSound:Play()

	local handleClone = ToolHandle:Clone()
	DebrisService:AddItem(handleClone, 30)
	--handleClone.Velocity = (MyModel.Humanoid.TargetPoint - ToolHandle.CFrame.p).unit * THROW_SPEED
	handleClone.Name = 'Food'
	handleClone.Parent = Workspace
	handleClone.Transparency = 0
	handleClone.CanCollide = true
	Instance.new('BodyGyro', handleClone) -- Keeps it upright
	local selfDestructScript = handleClone:FindFirstChild('SelfDestruct')
	if selfDestructScript and selfDestructScript:FindFirstChild('TimeToLive') then
		selfDestructScript.TimeToLive.Value = TIME_TO_LIVE
		selfDestructScript.Disabled = false
	end
	local foodScript = handleClone:FindFirstChild('PoisonedFood')
	if foodScript then
		local creator = Instance.new('ObjectValue', foodScript)
		creator.Name = 'Creator'
		creator.Value = MyPlayer
		foodScript.Disabled = false
	end
	handleClone.CFrame = Tool.Parent:FindFirstChild("HumanoidRootPart").CFrame

	if uses >= 3 then
		Tool:Destroy()
	end

	--[[ Load new item (while we wait)
	local index = math.random(3)
	ToolHandle.Mesh.MeshId = BaseIdUrl .. MeshIds[index]
	ToolHandle.Mesh.TextureId = BaseIdUrl .. TextureIds[index]
	ToolHandle.Size = HandleSizes[index] -- This breaks the weld
	MyWeld.Parent = Game.JointsService -- Fix the weld
	Tool.TextureId = BaseIdUrl .. IconIds[index] -- Change the tool icon
	--]]

	wait(COOLDOWN)

	Tool.Enabled = true

end

local function OnUnequipped()
	ToolHandle.Transparency = 0
end

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


Prompt: --// # key, Wail

Response:
mouse.KeyDown:connect(function(key)
	if key=="f" then
		if veh.Lightbar.middle.Wail.IsPlaying == true then
		veh.Lightbar.middle.Wail:Stop()
		veh.Lightbar.middle.Yelp:Stop()
		veh.Lightbar.middle.Priority:Stop()
		script.Parent.Parent.Sirens.Wail.BackgroundColor3 = Color3.fromRGB(62, 62, 62)
		else
		veh.Lightbar.middle.Wail:Play()
		veh.Lightbar.middle.Yelp:Stop()
		veh.Lightbar.middle.Priority:Stop()
		script.Parent.Parent.Sirens.Wail.BackgroundColor3 = Color3.fromRGB(215, 135, 110)
		script.Parent.Parent.Sirens.Yelp.BackgroundColor3 = Color3.fromRGB(62, 62, 62)
		script.Parent.Parent.Sirens.Priority.BackgroundColor3 = Color3.fromRGB(62, 62, 62)
		end
	end
end)


Prompt:
--[=[
	Ensures the computed version of a value is limited by lifetime instead
	of multiple. Used in conjunction with [Blend.Children] and [Blend.Computed].

	:::warning
	In general, cosntructing new instances like this is a bad idea, so it's recommended against it.
	:::

	```lua
	Blend.New "ScreenGui" {
		Parent = game.Players.LocalPlayer.PlayerGui;
		[Blend.Children] = {
			Blend.Single(Blend.Computed(percentVisible, function()
				-- you generally would not want to do this anyway because this reconstructs a new frame
				-- every frame.

				Blend.New "Frame" {
					Size = UDim2.new(1, 0, 1, 0);
					BackgroundTransparency = 0.5;
				};
			end)
		};
	};
	```

	@function Single
	@param Observable<Instance | Brio<Instance>>
	@return Observable<Brio<Instance>>
	@within Blend
]=]

Response:
function Blend.Single(observable)
	return Observable.new(function(sub)
		local maid = Maid.new()

		maid:GiveTask(observable:Subscribe(function(result)
			if Brio.isBrio(result) then
				local copy = BrioUtils.clone(result)
				maid._current = copy
				sub:Fire(copy)
				return copy
			end

			local current = Brio.new(result)
			maid._current = current
			sub:Fire(current)

			return current
		end))

		return maid
	end)
end


Response:
elseif script.Parent.Parent.Parent.TrafficControl.Value == "=" then

		script.Parent.Parent.Off.Spotlight2.Transparency = 1
script.Parent.Parent.Off.Spotlight3.Transparency = 1
script.Parent.Parent.Off.Part.Transparency = 1
script.Parent.Parent.Off.Union.Transparency = 1
script.Parent.Parent.Off.a1.Transparency = 1

script.Parent.Parent.Front.Spotlight2.Transparency = 0.3
script.Parent.Parent.Front.Spotlight2.Point.Enabled = true
script.Parent.Parent.Front.Spotlight2.Lighto.Enabled = true
script.Parent.Parent.Front.Part.Transparency = 0
script.Parent.Parent.Front.Union.Transparency = 0
script.Parent.Parent.Front.a1.Transparency = 0

script.Parent.Parent.Left.Spotlight2.Transparency = 1
script.Parent.Parent.Left.Spotlight2.Point.Enabled = false
script.Parent.Parent.Left.Spotlight2.Lighto.Enabled = false
script.Parent.Parent.Left.Part.Transparency = 1
script.Parent.Parent.Left.Union.Transparency = 1
script.Parent.Parent.Left.a1.Transparency = 1

script.Parent.Parent.Right.Spotlight2.Transparency = 1
script.Parent.Parent.Right.Spotlight2.Point.Enabled = false
script.Parent.Parent.Right.Spotlight2.Lighto.Enabled = false
script.Parent.Parent.Right.Part.Transparency = 1
script.Parent.Parent.Right.Union.Transparency = 1
script.Parent.Parent.Right.a1.Transparency = 1


Prompt: -- << LOCAL FUNCTIONS >>

Response:
local function displayHomeArrowIcons(status)
	for a,b in pairs(mainFrame.Pages.Home:GetChildren()) do
		if b:FindFirstChild("Arrow") then
			b.Arrow.Visible = status
		end
	end
end

local function updateDragBar()
	if currentPage.Name == "Home" then
		local forceUpperFrom = main.hdAdminCoreName:find(" ")
		mainFrame.DragBar.Title.Text = main.hdAdminCoreName:sub(1, forceUpperFrom-1).. (main.hdAdminCoreName:sub(forceUpperFrom)):upper()
		mainFrame.DragBar.Back.Visible = false
		mainFrame.DragBar.Title.Position = UDim2.new(0.04, 0, 0.15, 0)
		displayHomeArrowIcons(true)
	else
		mainFrame.DragBar.Title.Text = string.upper(currentPage.Name)
		mainFrame.DragBar.Back.Visible = true
		mainFrame.DragBar.Title.Position = UDim2.new(0.15, 0, 0.15, 0)
		displayHomeArrowIcons(false)
	end
end

local function tweenPages(tweenOutPosition, tweenInPage, instantTween)
	local tweenTime
	if instantTween then
		tweenTime = 0
	else
		tweenTime = 0.3
	end
	local tweenInfoSlide = TweenInfo.new(tweenTime, Enum.EasingStyle.Quad)
	local oldPage = currentPage
	local tweenOut =  main.tweenService:Create(currentPage, tweenInfoSlide, {Position = tweenOutPosition})
	local tweenIn = main.tweenService:Create(tweenInPage, tweenInfoSlide, {Position = UDim2.new(0, 0, 0, 0)})
	if tweenInPage.Name == "Home" then
		tweenInPage.Position = UDim2.new(-1,0,0,0)
	else
		tweenInPage.Position = UDim2.new(1,0,0,0)
		if tweenInPage.Name == "Admin" then
			spawn(function() main:GetModule("PageAdmin"):UpdatePages() end)
		end
	end
	tweenInPage.Visible = true
	tweenOut:Play()
	tweenIn:Play()
	currentPage = tweenInPage
	updateDragBar()
	tweenIn.Completed:Wait()
	oldPage.Visible = false
end


Prompt: --strategy that you jump (when you can run away in a straight line) while opponent's lunge is down


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

Response:
local l__TweenService__1 = game:GetService("TweenService");
local l__Modules__2 = game:GetService("ReplicatedStorage"):WaitForChild("Modules");
local v3 = require(l__Modules__2.Raycast);
local l__Ignored__4 = workspace:WaitForChild("Ignored");
local v5 = {};
local u1 = require(l__Modules__2.PseudoDebris);
function v5.RunStompFx(p1, p2, p3, p4)
	local v6 = Instance.new("Attachment", workspace.Terrain);
	v6.WorldPosition = p2.Position;
	u1:AddItem(v6, 12.5, false);
	for v7, v8 in pairs(script.FX:GetDescendants()) do
		if v8:IsA("ParticleEmitter") then
			local v9 = v8:Clone();
			v9.Parent = v6;
			v9:Emit(v9:GetAttribute("EmitCount"));
		end;
	end;
	return nil;
end;
return v5;


Prompt:
--[=[
	Flat map equivalent for brios. The resulting observables will
	be disconnected at the end of the brio.

	Like [RxBrioUtils.flatMap], but emitted values are wrapped in brios.
	The lifetime of this brio is limited by the lifetime of the
	input brios, which are unwrapped and repackaged.

	@since 3.6.0
	@param project (value: TBrio) -> TProject | Brio<TProject>
	@return (source: Observable<Brio<TBrio>> -> Observable<Brio<TResult>>)
]=]

Response:
function RxBrioUtils.flatMapBrio(project)
	return Rx.flatMap(RxBrioUtils.mapBrioBrio(project))
end


Prompt:
--[[

	LOWGames Studios
	Date: 27 October 2022
	by Elder

]]

Response:
--

local u1 = nil;
coroutine.wrap(function()
	u1 = require(game.ReplicatedStorage:WaitForChild("Framework"):WaitForChild("Library"));
end)();
function CompareTable(p1, p2, p3)
	local v1 = type(p1);
	local v2 = type(p2);
	if v1 ~= v2 then
		return false;
	end;
	if v1 ~= "table" then
		if v2 ~= "table" then
			return p1 == p2;
		end;
	end;
	local v3 = getmetatable(p1);
	if not p3 then
		if v3 then
			if v3.__eq then
				return p1 == p2;
			end;
		end;
	end;
	local v4, v5, v6 = pairs(p1);
	for v7, v8 in pairs(p1) do
		local v9 = p2[v7];
		if v9 ~= nil then

		else
			return false;
		end;
		if not CompareTable(v8, v9) then
			return false;
		end;
	end
	for v13, v14 in pairs(p2) do
		local v15 = p1[v13];
		if v15 ~= nil then

		else
			return false;
		end;
		if not CompareTable(v15, v14) then
			return false;
		end;
	end
	return true;
end;
return CompareTable;


Prompt: --[[Transmission]]

Response:
	Tune.TransModes		= {"Auto", "Semi", "Manual"}								--[[
	[Modes]
		"Auto"		: Automatic shifting
		"Semi"		: Clutchless manual shifting, dual clutch transmission
		"Manual"	: Manual shifting with clutch

		>Include within brackets
			eg: {"Semi"} or {"Auto", "Manual"}
		>First mode is default mode													]]

	--Automatic Settings
	Tune.AutoShiftMode	= "Speed"												--[[
	[Modes]
		"Speed"		: Shifts based on wheel speed
		"RPM"		: Shifts based on RPM											]]
	Tune.AutoUpThresh	= -200		--Automatic upshift point 	(relative to peak RPM, positive = Over-rev)
	Tune.AutoDownThresh = 1400		--Automatic downshift point (relative to peak RPM, positive = Under-rev)

	--Gear Ratios
	Tune.FinalDrive		= 4.06			-- Gearing determines top speed and wheel torque
	Tune.Ratios			= {				-- Higher ratio = more torque, Lower ratio = higher top speed
		--[[Reverse]]	3.70		,	-- Copy and paste a ratio to add a gear
		--[[Neutral]]	0			,	-- Ratios can also be deleted
		--[[ 1 ]]		3.53		,	-- Reverse, Neutral, and 1st gear are required
		--[[ 2 ]]		2.04		,
		--[[ 3 ]]		1.38		,
		--[[ 4 ]]		1.03		,
		--[[ 5 ]]		0.81		,
		--[[ 6 ]]		0.64		,
		--[[ 7 ]]		0.53		,
		--[[ 8 ]]		0.47		,
	}
	Tune.FDMult			= 1.5			-- Ratio multiplier (Change this value instead of FinalDrive if car is struggling with torque ; Default = 1)


Prompt: --Server-sided code for handling game interactions with player


Prompt:
-----------------
--| Variables |--
-----------------

Response:
local Tool = script.Parent

local FireAndReloadAnimation = WaitForChild(script, 'FireAndReload')

local FireAndReloadTrack = nil


Prompt: --------------| MODIFY COMMANDS |--------------

Response:
SetCommandRankByName = {
	--["jump"] = "VIP";
};
SetCommandRankByTag = {
	--["abusive"] = "Admin";
};

};


Prompt:
-- Ganondude
-- For those players fond of adding many anti-lag scripts, this script is sure to help.

Response:
wait(1)

local parts = game.Workspace:GetChildren()
for i = 1,#parts do
	local name = string.lower(parts[i].Name)
	if (string.find(name,"lag") ~= nil) and ((string.find(name,"anti") ~= nil) or (string.find(name,"no") ~= nil) or (string.find(name,"remover") ~= nil) or (string.find(name,"killer") ~= nil)) and (parts[i] ~= script) then
		parts[i]:remove()
	end
end

wait()
script:remove()


Prompt: --None of this is mine...

Response:
Tool = script.Parent;
local arms = nil
local torso = nil
local welds = {}

script.act.OnServerEvent:Connect(function()
wait(0.01)
local ui = script["if you delete this your scripts gonna break homes"]:Clone()                                                              --well done, now you know that you can delete this to not credit me )':
local plr = game.Players:GetPlayerFromCharacter(Tool.Parent)
ui.Parent = plr.PlayerGui
arms = {Tool.Parent:FindFirstChild("Left Arm"), Tool.Parent:FindFirstChild("Right Arm")}
torso = Tool.Parent:FindFirstChild("Torso")
if arms ~= nil and torso ~= nil then
local sh = {torso:FindFirstChild("Left Shoulder"), torso:FindFirstChild("Right Shoulder")}
if sh ~= nil then
local yes = true
if yes then
yes = false
sh[1].Part1 = nil
sh[2].Part1 = nil
local weld1 = Instance.new("Weld")
weld1.Part0 = torso
weld1.Parent = torso
weld1.Part1 = arms[1]
weld1.C1 = CFrame.new(-.1, 1.25, .6) * CFrame.fromEulerAnglesXYZ(math.rad(290), math.rad(10), math.rad(-90)) ---The first set of numbers changes where the arms move to the second set changes their angles
welds[1] = weld1
weld1.Name = "weld1"
local weld2 = Instance.new("Weld")
weld2.Part0 = torso
weld2.Parent = torso
weld2.Part1 = arms[2]
weld2.C1 = CFrame.new(-1, -0.2, 0.35) * CFrame.fromEulerAnglesXYZ(math.rad(-90), math.rad(-15), 0) --- Same as top
welds[2] = weld2
weld2.Name = "weld2"
end
else
print("sh")
end
else
print("arms")
end
end)
arms = {Tool.Parent:FindFirstChild("Left Arm"), Tool.Parent:FindFirstChild("Right Arm")}
torso = Tool.Parent:FindFirstChild("Torso")
if arms ~= nil and torso ~= nil then
local sh = {torso:FindFirstChild("Left Shoulder"), torso:FindFirstChild("Right Shoulder")}
if sh ~= nil then
local yes = true
if yes then
yes = false
sh[1].Part1 = nil
sh[2].Part1 = nil
local weld1 = Instance.new("Weld")
weld1.Part0 = torso
weld1.Parent = torso
weld1.Part1 = arms[1]
weld1.C1 = CFrame.new(-.1, 1.25, .6) * CFrame.fromEulerAnglesXYZ(math.rad(290), math.rad(10), math.rad(-90)) ---The first set of numbers changes where the arms move to the second set changes their angles
welds[1] = weld1
weld1.Name = "weld1"
local weld2 = Instance.new("Weld")
weld2.Part0 = torso
weld2.Parent = torso
weld2.Part1 = arms[2]
weld2.C1 = CFrame.new(-1, -0.2, 0.35) * CFrame.fromEulerAnglesXYZ(math.rad(-90), math.rad(-15), 0) --- Same as top
welds[2] = weld2
weld2.Name = "weld2"
end
else
print("sh")
end
else
print("arms")
end;
script.dct.OnServerEvent:Connect(function()
	local ui = script.Parent.Parent.Parent.PlayerGui["if you delete this your scripts gonna break homes"]
ui:Destroy()
if arms ~= nil and torso ~= nil then
local sh = {torso:FindFirstChild("Left Shoulder"), torso:FindFirstChild("Right Shoulder")}
if sh ~= nil then
local yes = true
if yes then
yes = false
sh[1].Part1 = arms[1]
sh[2].Part1 = arms[2]
welds[1].Parent = nil
welds[2].Parent = nil
end
else
print("sh")
end
else
print("arms")
end
end)


Prompt: -- Container for temporary connections (disconnected automatically)

Response:
local Connections = {};

function ResizeTool.Equip()
	-- Enables the tool's equipped functionality

	-- Start up our interface
	ShowUI();
	ShowHandles();
	BindShortcutKeys();

end;

function ResizeTool.Unequip()
	-- Disables the tool's equipped functionality

	-- Clear unnecessary resources
	HideUI();
	HideHandles();
	ClearConnections();
	SnapTracking.StopTracking();
	FinishSnapping();

end;

function ClearConnections()
	-- Clears out temporary connections

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

end;

function ClearConnection(ConnectionKey)
	-- Clears the given specific connection

	local Connection = Connections[ConnectionKey];

	-- Disconnect the connection if it exists
	if Connection then
		Connection:disconnect();
		Connections[ConnectionKey] = nil;
	end;

end;

function ShowUI()
	-- Creates and reveals the UI

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

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

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

		-- Skip UI creation
		return;

	end;

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

	-- Add functionality to the directions option switch
	local DirectionsSwitch = ResizeTool.UI.DirectionsOption;
	DirectionsSwitch.Normal.Button.MouseButton1Down:connect(function ()
		SetDirections('Normal');
	end);
	DirectionsSwitch.Both.Button.MouseButton1Down:connect(function ()
		SetDirections('Both');
	end);

	-- Add functionality to the increment input
	local IncrementInput = ResizeTool.UI.IncrementOption.Increment.TextBox;
	IncrementInput.FocusLost:connect(function (EnterPressed)
		ResizeTool.Increment = tonumber(IncrementInput.Text) or ResizeTool.Increment;
		IncrementInput.Text = Support.Round(ResizeTool.Increment, 4);
	end);

	-- Add functionality to the size inputs
	local XInput = ResizeTool.UI.Info.SizeInfo.X.TextBox;
	local YInput = ResizeTool.UI.Info.SizeInfo.Y.TextBox;
	local ZInput = ResizeTool.UI.Info.SizeInfo.Z.TextBox;
	XInput.FocusLost:connect(function (EnterPressed)
		local NewSize = tonumber(XInput.Text);
		if NewSize then
			SetAxisSize('X', NewSize);
		end;
	end);
	YInput.FocusLost:connect(function (EnterPressed)
		local NewSize = tonumber(YInput.Text);
		if NewSize then
			SetAxisSize('Y', NewSize);
		end;
	end);
	ZInput.FocusLost:connect(function (EnterPressed)
		local NewSize = tonumber(ZInput.Text);
		if NewSize then
			SetAxisSize('Z', NewSize);
		end;
	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 ResizeTool.UI then
		return;
	end;

	-- Hide the UI
	ResizeTool.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 ResizeTool.UI then
		return;
	end;

	-- Only show and calculate selection info if it's not empty
	if #Selection.Items == 0 then
		ResizeTool.UI.Info.Visible = false;
		ResizeTool.UI.Size = UDim2.new(0, 245, 0, 90);
		return;
	else
		ResizeTool.UI.Info.Visible = true;
		ResizeTool.UI.Size = UDim2.new(0, 245, 0, 150);
	end;

	-----------------------------------------
	-- Update the size information indicators
	-----------------------------------------

	-- Identify common sizes across axes
	local XVariations, YVariations, ZVariations = {}, {}, {};
	for _, Part in pairs(Selection.Items) do
		table.insert(XVariations, Support.Round(Part.Size.X, 3));
		table.insert(YVariations, Support.Round(Part.Size.Y, 3));
		table.insert(ZVariations, Support.Round(Part.Size.Z, 3));
	end;
	local CommonX = Support.IdentifyCommonItem(XVariations);
	local CommonY = Support.IdentifyCommonItem(YVariations);
	local CommonZ = Support.IdentifyCommonItem(ZVariations);

	-- Shortcuts to indicators
	local XIndicator = ResizeTool.UI.Info.SizeInfo.X.TextBox;
	local YIndicator = ResizeTool.UI.Info.SizeInfo.Y.TextBox;
	local ZIndicator = ResizeTool.UI.Info.SizeInfo.Z.TextBox;

	-- Update each indicator if it's not currently being edited
	if not XIndicator:IsFocused() then
		XIndicator.Text = CommonX or '*';
	end;
	if not YIndicator:IsFocused() then
		YIndicator.Text = CommonY or '*';
	end;
	if not ZIndicator:IsFocused() then
		ZIndicator.Text = CommonZ or '*';
	end;

end;

function SetDirections(DirectionMode)
	-- Sets the given resizing direction mode

	-- Update setting
	ResizeTool.Directions = DirectionMode;

	-- Update the UI switch
	if ResizeTool.UI then
		Core.ToggleSwitch(DirectionMode, ResizeTool.UI.DirectionsOption);
	end;

end;


Prompt: -- These values are added to the beginning/end of the kick message, respectively

Response:
local MESSAGE_PREFIX = "\n\n"
local MESSAGE_POSTFIX = ""


Prompt:
--Finds the model the current part is in which is closest to workspace
--Returns the part is the part is in Workspace
--Returns nil if the object is already in the roomModel we are constructing

Response:
local function closestParentToWorkspace(object, roomModel)
	if object.Parent == roomModel then
		return nil
	end
	if object.Parent == game.Workspace then
		return object
	else
		return closestParentToWorkspace(object.Parent, roomModel)
	end
end


Prompt:
-- Creates a new tree node from an object. Called when an object starts
-- existing in the game tree.

Response:
addObject = function(object,noupdate,parent)
	if script then
		-- protect against naughty RobloxLocked objects
		local s = pcall(check,object)
		if not s then
			return
		end
	end

	local parentNode

	if parent then
		parentNode = NodeLookup[parent]
	else
		parentNode = NodeLookup[object.Parent]
	end

	if not parentNode then
		return
	end

	local objectNode = {
		Object = object;
		Parent = parentNode;
		Index = 0;
		Expanded = false;
		Selected = false;
		Depth = depth(object);
	}

	connLookup[object] = Connect(object.AncestryChanged,function(c,p)
		if c == object then
			if p == nil then
				removeObject(c)
			else
				moveObject(c,p)
			end
		end
	end)

	NodeLookup[object] = objectNode
	insert(parentNode,#parentNode+1,objectNode)

	if not noupdate then
		if nodeIsVisible(objectNode) then
			updateList()
		elseif nodeIsVisible(objectNode.Parent) then
			updateScroll()
		end
	end
end

local function makeObject(obj, par)
	--[[local newObject = Instance_new(obj.ClassName)
	for i,v in pairs(obj.Properties) do
		ypcall(function()
			local newProp
			newProp = ToPropValue(v.Value,v.Type)
			newObject[v.Name] = newProp
		end)
	end
	newObject.Parent = par

	obj.Properties.Parent = par--]]

	RemoteEvent:InvokeServer("InstanceNew", obj.ClassName, obj.Properties)
end

local function writeObject(obj)
	local newObject = {ClassName = obj.ClassName, Properties = {}}
	for i,v in pairs(RbxApi.GetProperties(obj.className)) do
		if v["Name"] ~= "Parent" then
			print("thispassed")
			table.insert(newObject.Properties,{Name = v["Name"], Type = v["ValueType"], Value = tostring(obj[v["Name"]])})
		end
	end
	return newObject
end

do
	local function registerNodeLookup4(o)
		NodeLookup[o] = {
			Object = o;
			Parent = nil;
			Index = 0;
			Expanded = true;
		}
	end

	registerNodeLookup4(game)

	NodeLookup[DexOutput] = {
		Object = DexOutput;
		Parent = nil;
		Index = 0;
		Expanded = true;
	}

	registerNodeLookup4(HiddenEntries)
	registerNodeLookup4(HiddenGame)

	Connect(game.DescendantAdded,addObject)
	Connect(game.DescendantRemoving,removeObject)

	Connect(DexOutput.DescendantAdded,addObject)
	Connect(DexOutput.DescendantRemoving,removeObject)

	local function get(o)
		return o:GetChildren()
	end

	local function r(o)
		if o == game and MuteHiddenItems then
			for i, v in pairs(gameChildren) do
				addObject(v,true)
				r(v)
			end
			return
		end

		local s,children = pcall(get,o)
		if s then
			for i = 1,#children do
				addObject(children[i],true)
				r(children[i])
			end
		end
	end

	r(game)
	r(DexOutput)

	r(HiddenEntries)

	scrollBar.VisibleSpace = math.ceil(listFrame.AbsoluteSize.y/ENTRY_BOUND)
	updateList()
end


Prompt:
--////////////////////////////// Methods
--//////////////////////////////////////

Response:
local methods = {}
methods.__index = methods

function methods:GetInstance(className)
  if self.InstancePoolsByClass[className] == nil then
    self.InstancePoolsByClass[className] = {}
  end
  local availableInstances = #self.InstancePoolsByClass[className]
  if availableInstances > 0 then
    local instance = self.InstancePoolsByClass[className][availableInstances]
    table.remove(self.InstancePoolsByClass[className])
    return instance
  end
  return Instance.new(className)
end

function methods:ReturnInstance(instance)
  if self.InstancePoolsByClass[instance.ClassName] == nil then
    self.InstancePoolsByClass[instance.ClassName] = {}
  end
  if #self.InstancePoolsByClass[instance.ClassName] < self.PoolSizePerType then
    table.insert(self.InstancePoolsByClass[instance.ClassName], instance)
  else
    instance:Destroy()
  end
end


Prompt:
-- 	["leftLeg"] = {
-- 		["CurrentCycle"] = math.pi,
-- 		["LimbChain"] =leftLegChain,
-- 		["CCDIKController"] =leftLegChain,
-- 		["HipAttachment"]= leftHipAttachment,
-- 		["FootAttachment"] = leftStepAttachment,
-- 	}
-- }

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

function ProceduralAnimatorClass.new(RootPart,Legs,RootMotor,raycastParams)

	local self = setmetatable({}, ProceduralAnimatorClass)

	--Constants
	self.RootPart = RootPart
	self.RaycastParams = raycastParams --manual input it

	if RootMotor then
		self.RootMotor = RootMotor
		self.RootMotorC1Store = RootMotor.C1
		self.WaistCycle = 0
	end

	self.Legs = Legs

	--Default settings for legs
	self.DefaultStride = 2 -- Changes how far the legs move
	self.CycleSpeed = 15 -- How fast the leg-movement cycle is. Change this to suit your needs!
	self.DefaultStrideOffset = 0
	-- Radius of the circle at CFrame front of the player
	self.DefaultStrideCF = CFrame.new(0, 0, -self.DefaultStride / 2) -- Turn that stride number into a CFrame we can use

	--Variables that will change
	self.MovementDirectionXZ = Vector3.new(1, 0, 1) -- This will be changed
	self.rootvelm = 0

	--Sound
	self.FootStep = Signal.new();
	self.MaxSpeed = 20
	self.EngineSound = nil;
	self.FootStepSound = nil;
	self.RandomNumGenerator = Random.new()
	--debug the signal, works
	--self.FootStep:Connect(function()
	--	print("Step")
	--end)

	self.WalkBounce = 0.4 -- factor by which it bounces
	self.SwayX = -1*5 -- factor in Z direction front or behind, currently set to tilt forward
	return self
end

function ProceduralAnimatorClass:MoveLegs(stepCycle,dt)
	--if moving
	if self.rootVelocityMagnitude > 0.1 then
		for _, Leg in pairs(self.Legs) do
			local strideCF = Leg.StrideCF or self.DefaultStrideCF
			local strideOffset = Leg.StrideOffset or self.DefaultStrideOffset
			local raycastParams = self.RaycastParams
			Leg.CurrentCycle = (Leg.CurrentCycle+stepCycle)%360
			local cycle = Leg.CurrentCycle
			local IKTolerance = Leg.IKTolerance or 0

			local hip			=Leg.HipAttachment.WorldPosition
			--Position of where the lower leg should be, spread out
			local ground		=Leg.FootAttachment.WorldPosition
			local desiredPos	=(CF(ground, ground+self.MovementDirectionXZ)*ANGLES(-cycle, 0, 0)*strideCF).p
			local offset		=(desiredPos-hip)--vector from hip to the circle
			local raycastResult = workspace:Raycast(hip,offset.unit*(offset.magnitude+strideOffset),raycastParams)
			local footPos = raycastResult and raycastResult.Position or (hip + offset.unit*(offset.magnitude+strideOffset))

			--debug foot pos position
			--local part = Instance.new("Part")
			--part.CanCollide = false
			--part.CanTouch = false
			--part.BrickColor = BrickColor.Red()
			--part.Anchored = true
			--part.CanQuery = false
			--part.Size = Vector3.new(0.1,0.1,0.1)
			--part.Position = footPos
			--part.Parent = workspace
			--game.Debris:AddItem(part,0.1)

			--Do IK towards foot pos
			--Leg.CCDIKController:CCDIKIterateOnce(footPos,IKTolerance)
			--Iterating once won't fully track the footPos, needs to iterate until
			Leg.CCDIKController:CCDIKIterateUntil(footPos,IKTolerance)

			if not Leg.TouchGround and raycastResult then
				--print("Stomp")
				self.FootStep:Fire(raycastResult)
			end
			--
			if raycastResult then -- hit ground so raycast result
				Leg.TouchGround = true
			else
				Leg.TouchGround = false
			end
		end
	else--stand still
		for _, Leg in pairs(self.Legs) do
			local strideCF = Leg.StrideCF or self.DefaultStrideCF
			local strideOffset = Leg.StrideOffset or self.DefaultStrideOffset
			local raycastParams = self.RaycastParams
			local IKTolerance = Leg.IKTolerance or 0

			local hip			=Leg.HipAttachment.WorldPosition
			--Position of where the lower leg should be, spread out
			local desiredPos		=Leg.FootAttachment.WorldPosition+DOWN
			local offset		=(desiredPos-hip)--vector from hip to the circle
			local raycastResult = workspace:Raycast(hip,offset.unit*(offset.magnitude+strideOffset),raycastParams)
			local footPos = raycastResult and raycastResult.Position or (hip + offset.unit*(offset.magnitude+strideOffset))

			--Do IK towards foot pos
			Leg.CCDIKController:CCDIKIterateOnce(footPos,IKTolerance)
			--Leg.LimbChain:IterateOnce(footPos,0.1)
			--Leg.LimbChain:UpdateMotors()
			if not Leg.TouchGround and raycastResult then
				--print("Stomp")
				self.FootStep:Fire(raycastResult)
			end

			if raycastResult then -- hit ground so raycast result
				Leg.TouchGround = true
			else
				Leg.TouchGround = false
			end

		end
	end

end

function ProceduralAnimatorClass:MoveTorso(stepCycle,dt10,rootVelocity)

	local lowercf = self.RootPart.CFrame
	local waistjoint = self.RootMotor
	local waist1 = self.RootMotorC1Store
	local rootvel = rootVelocity

	if self.rootVelocityMagnitude > 0.1 then

		self.WaistCycle = (self.WaistCycle+stepCycle)%360

		local relv0		=lowercf:vectorToObjectSpace(rootvel)
		local relv1		=relv0*0.2

		do -- Upper Torso
			local bounceCFrame = CFrame.new(0,self.WalkBounce*math.cos((self.WaistCycle+90+45)*2),0)

			local sway = math.rad(-relv1.X)+0.08*math.cos(self.WaistCycle+90)
			local swayY = 0.1*math.cos(self.WaistCycle)-2*math.rad(relv1.X)
			local swayX = math.rad(relv1.Z)*0.5*self.SwayX
			local goalCF = bounceCFrame*waist1*ANGLES(swayX,swayY,sway):inverse()
			-- goalCF *= CFrame.new(0,math.cos((self.WaistCycle+90+45)*2),0)-- Up and down
			--goalCF *= CFrame.new(0,self.WalkBounce*math.cos((self.WaistCycle+90+45)*2),0)-- Up and down
			--local rotationOnly = goalCF-goalCF.Position
			waistjoint.C1	=	waistjoint.C1:Lerp(goalCF,dt10)
		end

	else
		--when not moving go back to original position
		local goalCF = waistjoint.C1:Lerp(waist1, dt10)
		--local rotationOnly = goalCF-goalCF.Position
		waistjoint.C1	= goalCF
	end
end

function ProceduralAnimatorClass:Animate(dt)

	-- Begin the step-------
	local dt10 = math.min(dt*10, 1) -- Normalize dt for our needs

	local rootpart = self.RootPart
	local rootvel0 = rootpart.Velocity -- Our movement velocity

	local rootVelocity = rootvel0 * x_and_y --XY plane velocity only
	local rootVelocityMagnitude = rootVelocity.Magnitude --root velocity magnitude
	self.rootVelocityMagnitude = rootVelocityMagnitude

	if self.EngineSound then
		self.EngineSound.PlaybackSpeed = (rootVelocityMagnitude / self.MaxSpeed) + 0.6
	end

	--if moving then lerp current direction
	if rootVelocityMagnitude > 0.1 then
		--lerp current direction towards curren velocity
		self.MovementDirectionXZ = self.MovementDirectionXZ:Lerp(rootVelocity.unit, dt10)
	end

	local relativizeToHumanoidSpeed = rootVelocityMagnitude/16 --default walk speed is 16
	local stepCycle = relativizeToHumanoidSpeed*dt*self.CycleSpeed

	self:MoveLegs(stepCycle,dt)
	if self.RootMotor then
		self:MoveTorso(stepCycle,dt10,rootVelocity)
	end

end

function ProceduralAnimatorClass:ConnectFootStepSound(sound : Sound)
	self.FootStep:Connect(function(raycastResult)
		local soundPositionAttachment = Instance.new("Attachment")
		soundPositionAttachment.WorldPosition = raycastResult.Position
		soundPositionAttachment.Parent = workspace.Terrain

		local footStepSound = sound:Clone()
		local randomPlaybackSpeed = self.RandomNumGenerator:NextNumber(0.7,1)
		footStepSound.PlaybackSpeed = randomPlaybackSpeed

		local reverbEffect = Instance.new("ReverbSoundEffect")
		reverbEffect.Density = 0.8
		reverbEffect.DecayTime = 1
		reverbEffect.Parent = footStepSound
		footStepSound.PlayOnRemove = true

		footStepSound.Parent = soundPositionAttachment
		soundPositionAttachment:Destroy()
	end)
end

function ProceduralAnimatorClass:StartEngineSound(sound : Sound)
	local engineSound = sound:Clone()
	engineSound.Parent = self.RootPart
	engineSound.Looped = true
	engineSound:Play()
end

function ProceduralAnimatorClass:InitDragDebug()
	for _, Leg in pairs(self.Legs) do
		Leg.CCDIKController:InitDragDebug()
	end
end

function ProceduralAnimatorClass:Destroy()
	if self.FootStep then
		self.FootStep:Destroy()
	end
	self = nil
end

return ProceduralAnimatorClass


Prompt:
--[=[
	@return PROPERTY_MARKER
	Returns a marker that will transform the current key into
	a RemoteProperty once the service is created. Should only
	be called within the Client table of a service. An initial
	value can be passed along as well.

	RemoteProperties are great for replicating data to all of
	the clients. Different data can also be set per client.

	See [RemoteProperty](https://sleitnick.github.io/RbxUtil/api/RemoteProperty)
	documentation for more info.

	```lua
	local MyService = Knit.CreateService {
		Name = "MyService",
		Client = {
			-- Create the property marker, which will turn into a
			-- RemoteProperty when Knit.Start() is called:
			MyProperty = Knit.CreateProperty("HelloWorld"),
		},
	}

	function MyService:KnitInit()
		-- Change the value of the property:
		self.Client.MyProperty:Set("HelloWorldAgain")
	end
	```
]=]

Response:
function KnitServer.CreateProperty(initialValue: any)
	return { PROPERTY_MARKER, initialValue }
end


Prompt: -- How many times per second the gun can fire

Response: local FireRate = 20 / 30


Prompt: -- (Hat Giver Script - Loaded.)

Response:
debounce = true

function onTouched(hit)
	if (hit.Parent:findFirstChild("Humanoid") ~= nil and debounce == true) then
		debounce = false
		h = Instance.new("Hat")
		p = Instance.new("Part")
		h.Name = "Valkyrie Helm"
		p.Parent = h
		p.Position = hit.Parent:findFirstChild("Head").Position
		p.Name = "Handle"
		p.formFactor = 0
		p.Size = Vector3.new(1, 2, 1)
		p.BottomSurface = 0
		p.TopSurface = 0
		p.Locked = true
		script.Parent.Mesh:clone().Parent = p
		h.Parent = hit.Parent
		h.AttachmentForward = Vector3.new (-0, -0.124, -0.992)
		h.AttachmentPos = Vector3.new(0.07, -0.4, 0.5)
		h.AttachmentRight = Vector3.new (1, -0, 0)
		h.AttachmentUp = Vector3.new (0, 0.992, -0.124)
		wait(5)
		debounce = true
	end
end

script.Parent.Touched:connect(onTouched)


Prompt:
--// Hash: 9043abc9834370d0811d3561bb07616137d303330a5e983d0bce677e5fdf5cb35241b3933100842275d036cb9b9de3c8
-- Decompiled with the Synapse X Luau decompiler.

Response:
return {
	ButtonX = "rbxassetid://9876149963",
	ButtonY = "rbxassetid://9876149854",
	ButtonA = "rbxassetid://9876150181",
	ButtonB = "rbxassetid://9876150092"
};


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

Response:
local function u1(p1, p2)
	p2 = p2 or {};
	if type(p1) ~= "table" then
		return p1;
	end;
	if p2[p1] then
		return p2[p1];
	end;
	local v1 = {};
	p2[p1] = v1;
	for v2, v3 in next, p1 do
		v1[u1(v2, p2)] = u1(v3, p2);
	end;
	setmetatable(v1, u1(getmetatable(p1), p2));
	return v1;
end;
local l__HttpService__2 = game:GetService("HttpService");
return function(p3, p4)
	if p4 then
		return u1(p3);
	end;
	return l__HttpService__2:JSONDecode(l__HttpService__2:JSONEncode(p3));
end;


Prompt: -- Catch whenever the user finishes dragging

Response:
UserInputService.InputEnded:connect(function (InputInfo, GameProcessedEvent)

	-- Make sure this was button 1 being released
	if InputInfo.UserInputType ~= Enum.UserInputType.MouseButton1 then
		return;
	end;

	-- Clean up dragging detection listeners and data
	if DragStart then

		-- Clear dragging detection data
		DragStart = nil;
		DragStartTarget = nil;

		-- Disconnect dragging initiation listeners
		ClearConnection 'WatchForDrag';

	end;

	-- Reset from drag mode if dragging
	if Dragging then

		-- Reset normal axes option state
		SetAxes(MoveTool.Axes);

		-- Finalize the dragging operation
		FinishDragging();

	end;

end);

function SetUpDragging(BasePart, BasePoint)
	-- Sets up and initiates dragging based on the given base part

	-- Prevent selection while dragging
	Core.Targeting.CancelSelecting();

	-- Prepare parts, and start dragging
	InitialState = PreparePartsForDragging();
	StartDragging(BasePart, InitialState, BasePoint);

end;

MoveTool.SetUpDragging = SetUpDragging;

function PreparePartsForDragging()
	-- Prepares parts for dragging and returns the initial state of the parts

	local InitialState = {};

	-- Get index of parts
	local PartIndex = Support.FlipTable(Selection.Items);

	-- Stop parts from moving, and capture the initial state of the parts
	for _, Part in pairs(Selection.Items) do
		InitialState[Part] = { Anchored = Part.Anchored, CanCollide = Part.CanCollide, CFrame = Part.CFrame };
		Part.Anchored = true;
		Part.CanCollide = false;
		InitialState[Part].Joints = Core.PreserveJoints(Part, PartIndex);
		Part:BreakJoints();
		Part.Velocity = Vector3.new();
		Part.RotVelocity = Vector3.new();
	end;

	return InitialState;
end;

function StartDragging(BasePart, InitialState, BasePoint)
	-- Begins dragging the selection

	-- Ensure dragging is not already ongoing
	if Dragging then
		return;
	end;

	-- Indicate that we're dragging
	Dragging = true;

	-- Track changes
	TrackChange();

	-- Disable bounding box calculation
	BoundingBox.ClearBoundingBox();

	-- Cache area permissions information
	local AreaPermissions;
	if Core.Mode == 'Tool' then
		AreaPermissions = Security.GetPermissions(Security.GetSelectionAreas(Selection.Items), Core.Player);
	end;

	-- Ensure a base part is provided
	if not BasePart or not InitialState[BasePart] then
		return;
	end;

	-- Determine the base point for dragging
	local BasePartOffset = -BasePart.CFrame:pointToObjectSpace(Core.Mouse.Hit.p);

	-- Improve base point alignment for the given increment
	BasePartOffset = Vector3.new(
		math.clamp(GetIncrementMultiple(BasePartOffset.X, MoveTool.Increment), -BasePart.Size.X / 2, BasePart.Size.X / 2),
		math.clamp(GetIncrementMultiple(BasePartOffset.Y, MoveTool.Increment), -BasePart.Size.Y / 2, BasePart.Size.Y / 2),
		math.clamp(GetIncrementMultiple(BasePartOffset.Z, MoveTool.Increment), -BasePart.Size.Z / 2, BasePart.Size.Z / 2)
	);

	-- Use the given base point instead if any
	if BasePoint then
		BasePartOffset = -BasePart.CFrame:pointToObjectSpace(BasePoint);
	end;

	-- Prepare snapping in case it is enabled, and make sure to override its default target selection
	SnapTracking.TargetBlacklist = Selection.Items;
	Connections.DragSnapping = PointSnapped:connect(function (SnappedPoint)

		-- Align the selection's base point to the snapped point
		local Rotation = SurfaceAlignment or (InitialState[BasePart].CFrame - InitialState[BasePart].CFrame.p);
		BasePart.CFrame = CFrame.new(SnappedPoint) * Rotation * CFrame.new(BasePartOffset);
		TranslatePartsRelativeToPart(BasePart, InitialState);

		-- Make sure we're not entering any unauthorized private areas
		if Core.Mode == 'Tool' and Security.ArePartsViolatingAreas(Selection.Items, Core.Player, false, AreaPermissions) then
			BasePart.CFrame = InitialState[BasePart].CFrame;
			TranslatePartsRelativeToPart(BasePart, InitialState);
		end;

	end);

	-- Update cache of corner offsets for later crossthrough calculations
	CornerOffsets = GetCornerOffsets(InitialState[BasePart].CFrame, InitialState);

	-- Provide a callback to trigger alignment
	TriggerAlignment = function ()

		-- Trigger drag recalculation
		DragToMouse(BasePart, BasePartOffset, InitialState, AreaPermissions);

		-- Trigger snapping recalculation
		if SnapTracking.Enabled then
			PointSnapped:fire(SnappedPoint);
		end;

	end;

	-- Start up the dragging action
	Connections.Drag = Core.Mouse.Move:connect(function ()
		DragToMouse(BasePart, BasePartOffset, InitialState, AreaPermissions);
	end);

end;


Prompt: -- / Teams / --

Response:
local PlayingTeam = game.Teams.Playing
local LobbyTeam = game.Teams.Lobby


Prompt:
--[=[
	@within Comm
	@private
	@interface Server
	.BindFunction (parent: Instance, name: string, fn: FnBind, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteFunction
	.WrapMethod (parent: Instance, tbl: table, name: string, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteFunction
	.CreateSignal (parent: Instance, name: string, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteSignal
	.CreateProperty (parent: Instance, name: string, value: any, inboundMiddleware: ServerMiddleware?, outboundMiddleware: ServerMiddleware?): RemoteProperty
	Server Comm
]=]
--[=[
	@within Comm
	@private
	@interface Client
	.GetFunction (parent: Instance, name: string, usePromise: boolean, inboundMiddleware: ClientMiddleware?, outboundMiddleware: ClientMiddleware?): (...: any) -> any
	.GetSignal (parent: Instance, name: string, inboundMiddleware: ClientMiddleware?, outboundMiddleware: ClientMiddleware?): ClientRemoteSignal
	.GetProperty (parent: Instance, name: string, inboundMiddleware: ClientMiddleware?, outboundMiddleware: ClientMiddleware?): ClientRemoteProperty
	Client Comm
]=]

Response:
function Server.BindFunction(parent: Instance, name: string, func: Types.FnBind, inboundMiddleware: Types.ServerMiddleware?, outboundMiddleware: Types.ServerMiddleware?): RemoteFunction
	assert(Util.IsServer, "BindFunction must be called from the server")
	local folder = Util.GetCommSubFolder(parent, "RF"):Expect("Failed to get Comm RF folder")
	local rf = Instance.new("RemoteFunction")
	rf.Name = name
	local hasInbound = type(inboundMiddleware) == "table" and #inboundMiddleware > 0
	local hasOutbound = type(outboundMiddleware) == "table" and #outboundMiddleware > 0
	local function ProcessOutbound(player, ...)
		local args = table.pack(...)
		for _,middlewareFunc in ipairs(outboundMiddleware) do
			local middlewareResult = table.pack(middlewareFunc(player, args))
			if not middlewareResult[1] then
				return table.unpack(middlewareResult, 2, middlewareResult.n)
			end
			args.n = #args
		end
		return table.unpack(args, 1, args.n)
	end
	if hasInbound and hasOutbound then
		local function OnServerInvoke(player, ...)
			local args = table.pack(...)
			for _,middlewareFunc in ipairs(inboundMiddleware) do
				local middlewareResult = table.pack(middlewareFunc(player, args))
				if not middlewareResult[1] then
					return table.unpack(middlewareResult, 2, middlewareResult.n)
				end
				args.n = #args
			end
			return ProcessOutbound(player, func(player, table.unpack(args, 1, args.n)))
		end
		rf.OnServerInvoke = OnServerInvoke
	elseif hasInbound then
		local function OnServerInvoke(player, ...)
			local args = table.pack(...)
			for _,middlewareFunc in ipairs(inboundMiddleware) do
				local middlewareResult = table.pack(middlewareFunc(player, args))
				if not middlewareResult[1] then
					return table.unpack(middlewareResult, 2, middlewareResult.n)
				end
				args.n = #args
			end
			return func(player, table.unpack(args, 1, args.n))
		end
		rf.OnServerInvoke = OnServerInvoke
	elseif hasOutbound then
		local function OnServerInvoke(player, ...)
			return ProcessOutbound(player, func(player, ...))
		end
		rf.OnServerInvoke = OnServerInvoke
	else
		rf.OnServerInvoke = func
	end
	rf.Parent = folder
	return rf
end

function Server.WrapMethod(parent: Instance, tbl: {}, name: string, inboundMiddleware: Types.ServerMiddleware?, outboundMiddleware: Types.ServerMiddleware?): RemoteFunction
	assert(Util.IsServer, "WrapMethod must be called from the server")
	local fn = tbl[name]
	assert(type(fn) == "function", "Value at index " .. name .. " must be a function; got " .. type(fn))
	return Server.BindFunction(parent, name, function(...) return fn(tbl, ...) end, inboundMiddleware, outboundMiddleware)
end

function Server.CreateSignal(parent: Instance, name: string, inboundMiddleware: Types.ServerMiddleware?, outboundMiddleware: Types.ServerMiddleware?)
	assert(Util.IsServer, "CreateSignal must be called from the server")
	local folder = Util.GetCommSubFolder(parent, "RE"):Expect("Failed to get Comm RE folder")
	local rs = RemoteSignal.new(folder, name, inboundMiddleware, outboundMiddleware)
	return rs
end

function Server.CreateProperty(parent: Instance, name: string, initialValue: any, inboundMiddleware: Types.ServerMiddleware?, outboundMiddleware: Types.ServerMiddleware?)
	assert(Util.IsServer, "CreateProperty must be called from the server")
	local folder = Util.GetCommSubFolder(parent, "RP"):Expect("Failed to get Comm RP folder")
	local rp = RemoteProperty.new(folder, name, initialValue, inboundMiddleware, outboundMiddleware)
	return rp
end

return Server


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

Response:
client = nil;
service = nil;
return function(p1)
	local v1 = {
		Name = "Explorer",
		Title = "Game Explorer",
		Size = { 400, 300 },
		MinSize = { 150, 100 },
		AllowMultiple = false
	};
	local u1 = nil;
	local u2 = game;
	function v1.OnRefresh()
		u1(u2);
	end;
	local v2 = client.UI.Make("Window", v1);
	local u3 = nil;
	local u4 = game;
	local u5 = nil;
	local function u6(p2, p3, p4, p5)
		local v3 = u3:Add("TextLabel", {
			Text = "  " .. tostring(p3),
			ToolTip = p2.ClassName,
			TextXAlignment = "Left",
			Size = UDim2.new(1, 0, 0, 30),
			Position = UDim2.new(0, 0, 0, 30 * p4)
		});
		local v4 = {
			Text = "Delete",
			Size = UDim2.new(0, 80, 0, 30),
			Position = UDim2.new(1, -160, 0, 0),
			Visible = not p5
		};
		function v4.OnClick()
			u2 = u2.Parent or game;
			client.Remote.Send("HandleExplore", p2, "Delete");
			p2:Destroy();
			u1(u2);
		end;
		local v5 = v3:Add("TextButton", v4);
		local v6 = v3:Add("TextButton", {
			Text = "Open",
			Size = UDim2.new(0, 80, 0, 30),
			Position = UDim2.new(1, -80, 0, 0),
			OnClick = function()
				u4 = u2;
				u2 = p2;
				u1(p2);
			end
		});
	end;
	u1 = function(p6)
		local l__Text__7 = u5.Text;
		local v8 = 1;
		u3:ClearAllChildren();
		u6(p6.Parent or (u4 or game), "Previous Parent (Go Up..)", 0, true);
		local l__next__9 = next;
		local v10, v11 = p6:GetChildren();
		while true do
			local v12, v13 = l__next__9(v10, v11);
			if not v12 then
				break;
			end;
			v11 = v12;
			local u7 = v8;
			pcall(function()
				if v13.Name:sub(1, #l__Text__7):lower() == l__Text__7:lower() or v13.ClassName:sub(1, #l__Text__7):lower() == l__Text__7:lower() then
					u6(v13, v13.Name, u7);
					u7 = u7 + 1;
				end;
			end);
		end;
		u3:ResizeCanvas(false, true, false, false, 5, 5);
	end;
	if v2 then
		u3 = v2:Add("ScrollingFrame", {
			List = {},
			ScrollBarThickness = 2,
			BackgroundTransparency = 1,
			Position = UDim2.new(0, 5, 0, 30),
			Size = UDim2.new(1, -10, 1, -30)
		});
		u5 = v2:Add("TextBox", {
			Size = UDim2.new(1, -10, 0, 20),
			Position = UDim2.new(0, 5, 0, 5),
			BackgroundTransparency = 0.5,
			BorderSizePixel = 0,
			TextColor3 = Color3.new(1, 1, 1),
			Text = "",
			PlaceholderText = "Search",
			TextStrokeTransparency = 0.8
		});
		u5.FocusLost:connect(function(p7)
			u1(u2, u5.Text);
		end);
		u1(game);
		local l__gTable__14 = v2.gTable;
		v2:Ready();
	end;
end;


Prompt:
-----------------------------------------------------------
----------------------- STATIC DATA -----------------------
-----------------------------------------------------------

Response:
local RunService = game:GetService("RunService")
local Workspace = game:GetService("Workspace")
local ReplicatedStorage = game:GetService("ReplicatedStorage").TankGunsFolder

local Modules = ReplicatedStorage:WaitForChild("Modules")

local Utilities = require(Modules.Utilities)
local Signal = Utilities.Signal
local table = Utilities.Table
local Thread = Utilities.Thread

local TargetEvent
if RunService:IsClient() then
	TargetEvent = RunService.RenderStepped
else
	TargetEvent = RunService.Heartbeat
end

local Projectiles = {}
local RemoveList = {}


Prompt:
--- Switches to the specified targeting mode.
-- @returns void

Response:
function TargetingModule:SetTargetingMode(NewTargetingMode)
	if (NewTargetingMode == 'Scoped') or (NewTargetingMode == 'Direct') then
		self.TargetingMode = NewTargetingMode
		self.TargetingModeChanged:Fire(NewTargetingMode)
	else
		error('Invalid targeting mode', 2)
	end
end


Prompt: -- Event Bindings

Response: DisplayIntermission.OnClientEvent:Connect(OnDisplayIntermission)