{ "PluginData":{  "Intersect":"local toolbar = plugin:CreateToolbar(\"CSG intersect\")
local button = toolbar:CreateButton(
	\"Intersect\",
	\"intersect\",
	\"rbxassetid://242640007\"
)

local forceButton = toolbar:CreateButton(
	\"Force CSG\",
	\"ForceCSG\",
	\"rbxassetid://245978714\"
)

local storage = {}

-- Returns the intersection between a and b. Will return false if any
-- Solid modeling function errors.
function intersect(a, b)
	local parent = a.Parent

	local aplus = a:Clone()
	aplus.Parent = parent
	table.insert(storage, aplus)

	local amin = a:Clone()
	amin.Parent = parent
	amin = plugin:Negate({amin})[1]
	table.insert(storage, amin)

	local bplus = b:Clone()
	bplus.Parent = parent
	table.insert(storage, bplus)

	local bmin = b:Clone()
	bmin.Parent = parent
	bmin = plugin:Negate({bmin})[1]
	table.insert(storage, bmin)

	local diffab = plugin:Union({aplus, bmin})
	if not diffab then return false end
	diffab = plugin:Negate({diffab})[1]
	table.insert(storage, diffab)

	local diffba = plugin:Union({bplus, amin})
	if not diffba then return false end
	diffba = plugin:Negate({diffba})[1]
	table.insert(storage, diffba)

	local plusab = plugin:Union({a,b})
	if not plusab then return false end
	table.insert(storage, plusab)

	return plugin:Union({plusab, diffab, diffba})
end

function copyTable(t)
    local copy
    if type(t) == \"table\" then
        copy = {}
        for i,v in next,t do
            copy[copyTable(i)] = copyTable(v)
        end
        setmetatable(copy, copyTable(getmetatable(t)))
    else
        copy = t
    end
    return copy
end


function forceFuckingCSG(objects)
	local length = #objects
	for i=1,length do
		for v=1,length do
			local objects = copyTable(objects)
			local removed = table.remove(objects, i)
			table.insert(objects, v, removed)

			--local success = pcall(function()
				print(\"Trying\")
				coroutine.resume(coroutine.create(function() plugin:Union(objects) end))
			--end)
			game:service(\"RunService\").RenderStepped:wait()
			if #game.Selection:Get() == 0 then
				return true
			end
		end
	end
end

button.Click:connect(function()
	local objects = game.Selection:Get()

	-- Create a table to hold a copy of the original objects. If any solid modeling function fails
	-- we want to use this table to restore the parts to their original state.

	local copy = {}
	for _, thing in pairs(objects) do
		local copy0 = thing:Clone()
		copy0.Parent = thing.Parent
		table.insert(copy, copy0)

		-- Also using this loop to start keeping a reference of all new solid modeling parts. If a
		-- function fails we will want to delete all of these parts to keep the workspace clean
		table.insert(storage, thing)
	end

	-- Get the first object in the selection and then try to intersect that with every other object in
	-- the selection one at a time.
	local first = objects[1]
	for i = 2, #objects do
		-- If intersect function fails then clear all of the newly created objects to keep the workspace
		-- clean
		if not intersect( first, objects[i] ) then
			for _, thing in pairs(storage) do
				if thing then thing:Destroy() end
			end
			storage = nil
			error(\"Error creating intersection of the selected parts.\")
			return
		end
	end

	-- If we got to this point then all of the intersection operations succeded. Set an undo waypoint so
	-- user can undo the operation.
	game:GetService(\"ChangeHistoryService\"):SetWaypoint(\"intersection\")

	-- Since the operation succeeded then we do not need the original parts. Clear these out.
	for _, thing in pairs(copy) do
		if thing then thing:Destroy() end
	end
end)

forceButton.Click:connect(function()
	local success = forceFuckingCSG(game.Selection:Get())
	if not success then
		warn(\"Could not union selection :(\")
	end
end)", "StarterGearRemover":"game.Players.PlayerAdded:connect(function(player)
	local childAdded; childAdded = player:WaitForChild(\"StarterGear\").ChildAdded:connect(function(child)
		local gearAdded; gearAdded = player.Character.ChildAdded:connect(function(gear)
			if gear.ClassName == child.ClassName and gear.Name == child.Name then
				spawn(function() gear:Destroy() end)
				gearAdded:disconnect()
			end
		end)
		delay(1, function()
			gearAdded:disconnect()
		end)
		childAdded:disconnect()
	end)
	delay(1, function()
		childAdded:disconnect()
	end)
end)", "StickyNotes":"local notes
local noteGui = Instance.new(\"ScreenGui\", game.CoreGui)
repeat wait(10) until false
noteGui.Name = \"StickyNoteGui\"
local inputService = game:GetService(\"UserInputService\")
local mousePosition

local noteCreation do
	local note = Instance.new(\"Frame\", script)
	note.Name = \"Note\"
	note.BackgroundColor3 = Color3.new(253/255, 252/255, 191/255)
	note.Size = UDim2.new(0,200,0,200)

	local content = Instance.new(\"ScrollingFrame\", note)
	content.Name = \"Content\"
	content.BackgroundTransparency = 1
	content.Position = UDim2.new(0,5,0,25)
	content.Size = UDim2.new(1,-10,1,-30)

	local text = Instance.new(\"TextBox\", content)
	text.Name = \"Text\"
	text.Font = \"SourceSans\"
	text.BackgroundTransparency = 1
	text.Size = UDim2.new(1,0,0,9999)
	text.FontSize = \"Size24\"
	text.Text = \"\"
	text.TextXAlignment = \"Left\"
	text.TextYAlignment = \"Top\"
	text.TextWrapped = true
	text.ClearTextOnFocus = false

	local header = Instance.new(\"TextButton\", note)
	header.ZIndex = 2
	header.Name = \"Header\"
	header.Text = \"\"
	header.BackgroundColor3 = Color3.new(0,0,0)
	header.BackgroundTransparency = 0.9
	header.Size = UDim2.new(0,200,0,20)
	header.Draggable = true

	local x = Instance.new(\"TextButton\", header)
	x.ZIndex = 2
	x.Name = \"Exit\"
	x.BackgroundColor3 = Color3.new(0,0,0)
	x.BackgroundTransparency = 0.9
	x.Position = UDim2.new(1,-20,0,0)
	x.Size = UDim2.new(0,20,0,20)
	x.Font = \"Legacy\"
	x.FontSize = \"Size11\"
	x.Text = \"X\"

	local color = Instance.new(\"ImageButton\", header)
	color.ZIndex = 2
	color.Name = \"Color\"
	color.Image = \"rbxassetid://188940761\"
	color.BackgroundTransparency = 1
	color.Position = UDim2.new(0,2,0,2)
	color.Size = UDim2.new(0,16,0,16)

	local colorPicker = Instance.new(\"Frame\", header)
	colorPicker.Name = \"ColorPicker\"
	colorPicker.Visible = false
	colorPicker.BackgroundColor3 = Color3.new(0,0,0)
	colorPicker.BackgroundTransparency = 0.3
	colorPicker.Size = UDim2.new(0,20,0,128)
	colorPicker.Position = UDim2.new(0,0,0,20)
	colorPicker.ZIndex = 2

	local function newButton(color)
		local button = Instance.new(\"TextButton\", colorPicker)
		button.Text = \"\"
		button.BackgroundColor3 = color
		button.Size = UDim2.new(0,16,0,16)
		button.Position = UDim2.new(0,2,0,2 + (#colorPicker:GetChildren()-1)*18)
		button.ZIndex = 2
	end

	newButton(Color3.new(253/255, 252/255, 191/255))
	newButton(Color3.new(200/255, 230/255, 247/255))
	newButton(Color3.new(196/255, 245/255, 191/255))
	newButton(Color3.new(245/255, 245/255, 245/255))
	newButton(Color3.new(240/255, 192/255, 240/255))
	newButton(Color3.new(207/255, 196/255, 254/255))
end

function newSticky(v)
	local note = script.Note:clone()
	local header = note.Header
	header.Parent = noteGui
	local v = v or Instance.new(\"StringValue\", notes)
	local color = v:FindFirstChild(\"Color\") and v.Color.Value or Color3.new(253/255, 252/255, 191/255)
	local position = v:FindFirstChild(\"Position\") and UDim2.new(0,v.Position.Value.X, 0,v.Position.Value.Y) or UDim2.new(0,0,0,0)
	note.BackgroundColor3 = color
	note.Position = position
	note.Content.Text.Text = v.Value
	note.Content.CanvasSize = UDim2.new(0,0,0,note.Content.Text.TextBounds.Y)

	note.Content.Text.Text = v.Value
	note.BackgroundColor3 = color
	note.Position = position
	header.Position = position

	header.Exit.MouseButton1Click:connect(function()
		v:Destroy()
		header:Destroy()
		note:Destroy()
	end)

	header.Color.MouseButton1Click:connect(function()
		header.ColorPicker.Visible = not header.ColorPicker.Visible
	end)

	for _,button in pairs(header.ColorPicker:GetChildren()) do
		button.MouseButton1Click:connect(function()
			note.BackgroundColor3 = button.BackgroundColor3
			local colorValue = v:FindFirstChild(\"Color\") or Instance.new(\"Color3Value\", v)
			colorValue.Name = \"Color\"
			colorValue.Value = button.BackgroundColor3
			header.ColorPicker.Visible = false
		end)
	end

	header.Changed:connect(function(property)
		if property == \"AbsolutePosition\" then
			local position = v:FindFirstChild(\"Position\") or Instance.new(\"Vector3Value\", v)
			position.Name = \"Position\"
			position.Value = Vector3.new(header.AbsolutePosition.X, header.AbsolutePosition.Y,0)
			if note.Position ~= UDim2.new(0,position.Value.X,0,position.Value.Y) then
				note.Position = UDim2.new(0,position.Value.X,0,position.Value.Y)
			end
		end
	end)

	note.Content.Text.FocusLost:connect(function()
		v.Value = note.Content.Text.Text
	end)

	note.Parent = noteGui

	if mousePosition then
		header.Position = UDim2.new(0,mousePosition.X, 0,mousePosition.Y)
	end
end

function loadStickies()
	noteGui:ClearAllChildren()
	for _,v in pairs(notes:GetChildren()) do
		if v:IsA(\"StringValue\") then
			newSticky(v)
		end
	end
end

if not game:FindFirstChild(\"StickyNotes\") then
	notes = Instance.new(\"Glue\", game)
	notes.Name = \"StickyNotes\"
	Instance.new(\"BoolValue\", notes).Name = \"Hidden\"
	notes.Hidden.Value = true
	game.ChildAdded:connect(function(child)
		if child.Name == \"StickyNotes\" then
			notes:Destroy()
			notes = child
			noteGui.Parent = (notes.Hidden.Value) and script or game.CoreGui
			loadStickies()
		end
	end)
	notes.Parent = game
	noteGui.Parent = script
else
	notes = game.StickyNotes
	if notes.Hidden.Value then
		noteGui.Parent = script
	else
		noteGui.Parent = game.CoreGui
	end
end

loadStickies()
if notes.Hidden.Value and #noteGui:GetChildren() > 0 then
	print(notes.Hidden.Value)
	print(#noteGui:GetChildren()/2 .. \" Sticky Notes Exist\")
end

game.Players.PlayerAdded:connect(function()
	noteGui:Destroy()
	loadStickies = function() end
	newSticky = function() end
end)

local altDown
local rightClickDown

inputService.InputBegan:connect(function(input)
	if input.UserInputType.Name == \"MouseButton2\" then
		rightClickDown = true
		if altDown and rightClickDown and not notes.Hidden.Value then
			newSticky()
		end
	elseif input.KeyCode and input.KeyCode.Name == \"LeftAlt\" then
		altDown = true
	elseif input.KeyCode.Name == \"Backquote\" then
		notes.Hidden.Value = not notes.Hidden.Value
		if notes.Hidden.Value then
			noteGui.Parent = script
		else
			noteGui.Parent = game.CoreGui
		end
	end

end)

inputService.InputEnded:connect(function(input)
	if input.UserInputType.Name == \"MouseButton2\" then
		rightClickDown = false
	elseif input.KeyCode and input.KeyCode.Name == \"LeftAlt\" then
		altDown = false
	end
end)

inputService.InputChanged:connect(function(input)
	if input.UserInputType.Name == \"MouseMovement\" then
		mousePosition = Vector2.new(input.Position.X, input.Position.Y)
	end
end)

", "PartCount":"_G.PartCount = function()
	local partCount = 0
	local selection = game.Selection:Get()

	local function recurse(root,callback)
		for i,v in pairs(root:GetChildren()) do
			callback(i,v)

			if #v:GetChildren() > 0 then
				recurse(v,callback)
			end
		end
	end

	for _,selectionItem in next,selection do
		recurse(selectionItem, function(_,v)
			if v:IsA(\"BasePart\") then
				partCount = partCount + 1
			end
		end)
		if selectionItem:IsA(\"BasePart\") then
			partCount = partCount + 1
		end
	end

	print(\"Total of\", partCount, \"parts in selection.\")
end

function recurse(root,callback)
 for i,v in pairs(root:GetChildren()) do
  callback(i,v)

  if #v:GetChildren() > 0 then
   recurse(v,callback)
  end
 end
end

_G.recurse = recurse

local function reflectOne(part, mirror, mod)

	local x,y,z,r00,r01,r02,r10,r11,r12,r20,r21,r22 = mirror.CFrame:toObjectSpace(part.CFrame):components()

	local mpart = part:Clone()

	mpart.CFrame = mirror.CFrame:toWorldSpace(CFrame.new(-x,y,z,r00,-r01,-r02,-r10,r11,r12,-r20,r21,r22))

	-- CornerWedgeParts are not symmetric so we rotate 90 degrees about
	-- the y axis and exchange the x and z sizes.  (Currently only works
	-- right with integer sized parts since we cannot script other resolutions.)
	if part.className == \"CornerWedgePart\" then

		mpart.Size = Vector3.new(mpart.Size.z, mpart.Size.y, mpart.Size.x)
		mpart.CFrame = mpart.CFrame * CFrame.Angles(0,math.rad(90),0)
	end

	mpart.Parent = mod
end

------------------------------------------------------------
-- Clone and reflect all Parts and WedgeParts in everything in this
-- model and recursively all contained models.

local function reflectAll( srcModel, mirror, tgtModel )

	for k,v in pairs(srcModel:GetChildren()) do

		if v.className == \"Model\" then
			local m2 = Instance.new(\"Model\", tgtModel)
			m2.Name = v.Name

			reflectAll(v, mirror, m2)

		elseif v:IsA(\"BasePart\")  then

			reflectOne(v, mirror, tgtModel)

		else
			local np = v:Clone()
			np.Parent = tgtModel
		end
	end
end


------------------------------------------------------------
function _G.reflect()

	local list = game.Selection:Get()
	if (not list) or (#list ~= 2) then
		error \"Select both the model to be reflected and the mirror part\"
	end

	local model = list[1]
	local mirror = list[2]

	if model.className ~= \"Model\" then
		model,mirror = mirror,model
	end

	if (model.className ~= \"Model\") or (not mirror:IsA(\"BasePart\")) then
		error \"Select both the model to be reflected and the mirror part\"
	end

	local mmodel = Instance.new(\"Model\", model.Parent)
	mmodel.Name = model.Name..\"-M\"

	reflectAll(model, mirror, mmodel)
end

_G.drawCircle = function (CenterCFrame,Radius,Sides, height)--Outer radius.
 local Model=Instance.new(\"Model\",game.Workspace)
 local LastPoint=Vector3.new(Radius,0,0)
 for i=1,Sides do
  local Angle=i*2*math.pi/Sides
  local CurrentPoint=Radius*Vector3.new(math.cos(Angle),0,math.sin(Angle))
  local Part=Instance.new(\"Part\",Model)
  Part.Anchored=true
  Part.FormFactor=\"Custom\"
  local Dist=(CurrentPoint-LastPoint).magnitude
  Part.Size=Vector3.new(1,height,Dist)
  Part.CFrame=CenterCFrame*CFrame.new(LastPoint,CurrentPoint)*CFrame.new(0.5,0,-Dist/2)
  LastPoint=CurrentPoint
 end
 return Model
end

_G.convertToBlocks = function (cylinder, numSides)
	_G.drawCircle(cylinder.CFrame,cylinder.Size.X/2,numSides,cylinder.Size.Y)
	cylinder:Destroy()
end

_G.drawEllipse = function (CenterCFrame,xRadius,yRadius,Sides)--Outer radius.
 local Model=Instance.new(\"Model\",game.Workspace)
 local LastPoint=Vector3.new(xRadius,0,0)
 for i=1,Sides do
  local Angle=i*2*math.pi/Sides
  local CurrentPoint=Vector3.new(xRadius*math.cos(Angle),0,yRadius*math.sin(Angle))
  local Part=Instance.new(\"Part\",Model)
  Part.Anchored=true
  Part.FormFactor=\"Custom\"
  local Dist=(CurrentPoint-LastPoint).magnitude
  Part.Size=Vector3.new(1,1,Dist)
  Part.CFrame=CenterCFrame*CFrame.new(LastPoint,CurrentPoint)*CFrame.new(0.5,0,-Dist/2)
  LastPoint=CurrentPoint
 end
 return Model
end


", "SpawnAtCam":"Instance.new('Part',Game.ChangeHistoryService)
game.ChangeHistoryService:SetWaypoint('yolo')
local camera = workspace.CurrentCamera

if game.ChangeHistoryService:GetCanUndo() then
    local studioCam = game.Geometry:FindFirstChild(\"StudioCam\") or Instance.new(\"CFrameValue\", game.Geometry)
    studioCam.Name = \"StudioCam\"
    camera.Changed:connect(function()
        studioCam.Value = camera.CoordinateFrame
    end)
else
    game.Players.PlayerAdded:connect(function(player)
        player.CharacterAdded:wait()
        wait(0.1)
        local studioCam = game.Geometry:WaitForChild(\"StudioCam\")
        player.Character.Torso.CFrame = CFrame.new(studioCam.Value.p)
    end)
end", "PipeCreator":"local toolbar = plugin:CreateToolbar(\"Pipe Creator\")
local create = toolbar:CreateButton(
	\"CreatePipe\",
	\"Create Pipe\",
	\"rbxassetid://245926521\"
)
local newSegment = toolbar:CreateButton(
	\"CreatePipeSegment\",
	\"Create Pipe Segment\",
	\"rbxassetid://245926554\"
)


local pipes = {}
local ignoreSizeChange

function updatePipe(pipe, point1, point2)
	if ignoreSizeChange then return end
	local targetCFrame = CFrame.new(point2.Position, point1.Position) * CFrame.new(0, 0, -(point2.Position-point1.Position).magnitude/2) * CFrame.Angles(math.pi/2,0,0)
	local targetSize = Vector3.new(point1.Size.X, (point2.Position-point1.Position).magnitude, point1.Size.Z)
	ignoreSizeChange = true
	if (pipe.Size-targetSize).magnitude > 0.001 then
		pipe.Size = targetSize
	end
	if (targetCFrame.p-pipe.CFrame.p).magnitude > 0.001 then
		pipe.CFrame = targetCFrame
	end
	ignoreSizeChange = false
end

function createPipe(point1, point2)
	local objects = {point1, point2}
	local pipe = objects[1]:clone()
	pipe.Shape = \"Block\"
	pipe.FormFactor = \"Custom\"
	pipe:ClearAllChildren()
	Instance.new(\"CylinderMesh\", pipe)
	pipe.CFrame = CFrame.new(objects[2].Position, objects[1].Position) * CFrame.new(0, 0, -(objects[2].Position-objects[1].Position).magnitude/2) * CFrame.Angles(math.pi/2,0,0)
	pipe.Size = Vector3.new(objects[1].Size.X, (objects[2].Position-objects[1].Position).magnitude, objects[1].Size.Z)
	pipe.Name = \"Pipe\"
	objects[1].Name = \"Obj1\"
	objects[2].Name = \"Obj2\"
	pipe.Parent = workspace

	pipes[pipe] = {objects[1], objects[2]}

	local changedEvents = {}
	local function disconnect()
		pcall(function()
			for i,event in next,changedEvents do
				event:disconnect()
				changedEvents[i] = nil
			end
		end)
	end

	local function sync(changedObject, changedProperty)
		changedProperty = changedProperty == \"size\" and \"DraggingV1\" or changedProperty
		if changedProperty ~= \"CFrame\" and changedProperty ~= \"Rotation\" and changedProperty ~= \"Position\" and changedProperty ~= \"DraggingV1\" then
			local items = {[objects[1]] = true, [objects[2]] = true, [pipe] = true}
			items[changedObject] = nil

			for item in next,items do
				if changedProperty == \"Size\" then
					if changedObject == pipe then
						if math.abs(item.Size.magnitude - Vector3.new(pipe.Size.X, pipe.Size.X, pipe.Size.Z).magnitude) > 0.01 then
							local cf1 = item.CFrame
							item.Size = Vector3.new(pipe.Size.X, item.Size.Y, pipe.Size.Z)
							item.CFrame = cf1
						end
					else
						if item == pipe then
							local targetSize = Vector3.new(changedObject.Size.X, pipe.Size.Y, changedObject.Size.Z)
							if pipe.Size ~= targetSize then
								local cf1 = pipe.CFrame
								pipe.Size = targetSize
								pipe.CFrame = cf1
							end
						else
							if item.Size ~= changedObject.Size then
								local cf1 = item.CFrame
								item.Size = changedObject.Size
								item.CFrame = cf1
							end
						end
					end
				else
					if item[changedProperty] ~= changedObject[changedProperty] then
						item[changedProperty] = changedObject[changedProperty]
					end
				end
			end
		end
	end

	local items = {[objects[1]] = true, [objects[2]] = true, [pipe] = true}
	for item in next,items do
		changedEvents[item] = item.Changed:connect(function(property)
			if not (pipe:IsDescendantOf(game) and objects[1]:IsDescendantOf(game) and objects[2]:IsDescendantOf(game)) then
				disconnect()
				return
			end

			if not ignoreSizeChange then
				sync(item, property)
				spawn(function() updatePipe(pipe, objects[1], objects[2]) end)
			end
		end)
	end
end

create.Click:connect(function()
	local objects = game.Selection:Get()
	if #objects > 1 and objects[1]:IsA(\"BasePart\") and objects[2]:IsA(\"BasePart\") then
		createPipe(objects[1], objects[2])
	end
end)

newSegment.Click:connect(function()
	local pipe = game.Selection:Get()[1]
	if pipe and pipe:IsA(\"BasePart\") then
		local objects = {pipes[pipe][1], pipes[pipe][2]}

		objects[3] = objects[1]:clone()
		objects[3].Name = \"Obj3\"
		objects[3].CFrame = CFrame.new(objects[2].Position, objects[1].Position) * CFrame.new(0,0, -(objects[2].Position-objects[1].Position).magnitude/2)
		objects[3].Parent = workspace

		pipe:Destroy()

		createPipe(objects[1], objects[3])
		createPipe(objects[3], objects[2])
		game.Selection:Set({objects[3]})
	end
end)", "AnchorableSeats":"local patchCode = [[local seat = script.Parent

seat.ChildAdded:connect(function(seatWeld)
	if seatWeld.Name == \"SeatWeld\" and seatWeld:IsA(\"Weld\") then
		local rootPart = seatWeld.Part1
		local torso = rootPart.Parent:FindFirstChild(\"Torso\")
		local humanoid = rootPart.Parent:FindFirstChild(\"Humanoid\")

		if rootPart and torso and humanoid and game.Players:GetPlayerFromCharacter(rootPart.Parent) then
			rootPart.CFrame = seat.CFrame * CFrame.new(0,seat.Size.Y/2 + 1.5,0)
			humanoid.Sit = true
			if torso:FindFirstChild(\"Left Hip\") then
				torso[\"Left Hip\"].DesiredAngle = -1.57
			end
			if torso:FindFirstChild(\"Left Shoulder\") then
				torso[\"Left Shoulder\"].DesiredAngle = -1.57
			end
			if torso:FindFirstChild(\"Right Hip\") then
				torso[\"Right Hip\"].DesiredAngle = 1.57
			end
			if torso:FindFirstChild(\"Right Shoulder\") then
				torso[\"Right Shoulder\"].DesiredAngle = 1.57
			end
		else
			spawn(function() seatWeld:Destroy() end)
		end
	end
end)]]

function patch(seat)
	local isPatched
	for _,script in pairs(seat:GetChildren()) do
		if script:IsA(\"Script\") and script.Source == patchCode then
			isPatched = true
			break
		end
	end

	if not isPatched then
		local patch = Instance.new(\"Script\")
		patch.Source = patchCode
		patch.Name = \"SeatPatch\"
		patch.Parent = seat
	end
end

game.DescendantAdded:connect(function(seat)
	pcall(function()
		if seat:IsA(\"Seat\") then
			patch(seat)
		end
	end)
end)", "ReplicatedFirstPlaySolo":"function cloneReplicatedFirst(playergui)
	for _,item in pairs(game.ReplicatedFirst:GetChildren()) do
		item:clone().Parent = playergui
	end
end

game.Players.PlayerAdded:connect(function(player)
	if game.Players.LocalPlayer then
		cloneReplicatedFirst(game.Players.LocalPlayer:WaitForChild(\"PlayerGui\"))
	end
end)" }}