How to remove team elements without breaking the module script for a custom leaderboard

[bIIocky (blocky)]

How would I go about removing the team section of this custom leaderboard gui? I’ve attempted to remove elements of the teams, and everything I’ve tried has failed. The module doesn’t even work on studio, so I’m incapable of finding what element of the module to edit and or remove… Any help would be greatly appreciated. Below, you may find the module script.

--!nocheck

local PS = game:GetService('Players')
local TMS = game:GetService('Teams')
local RPS = game:GetService('ReplicatedStorage')
local CAS = game:GetService('ContextActionService')
local UIS = game:GetService('UserInputService')
local SGS = game:GetService('StarterGui')
local RS = game:GetService('RunService')

type EntityData = {Type : string, Instance : Player | Team, GuiObject : GuiObject?, LayoutOrder : number}
type Stat = {Name : string, IsPrimary : boolean, Priority : number, AddId : number}

SGS:SetCoreGuiEnabled(Enum.CoreGuiType.PlayerList, false)
if not (game:IsLoaded()) then game.Loaded:Wait() end

local Icons = require(script.Modules.Icons)
local CreateGUIObject = require(script.Modules.CreateGUIObject)
local InspectPlayer = require(script.Modules.InspectPlayer)
local FormatStatString = require(script.Modules.FormatStatString)

local localPlayer : Player = PS.LocalPlayer
local Templates = script.Templates

local StatsText : GuiObject = Templates.StatsText
local HeaderText : GuiObject = Templates.HeaderText

local GUI = CreateGUIObject('ScreenGui', 'PlayerList', {Enabled = false, ResetOnSpawn = false, IgnoreGuiInset = true}, nil)
local Container = CreateGUIObject('Frame', 'Container', {
	AnchorPoint = Vector2.new(1,0),
	Position = UDim2.new(1,-4,0,40),
	Size = UDim2.new(0, 166, 0.5, 0),
	Visible = true,
	ZIndex = 1
}, GUI)

local OffsetFrame = CreateGUIObject('Frame', 'OffsetFrame', {
	Size = UDim2.new(1, 0, 1, 0),
	BackgroundTransparency = 1,
	
}, Container)

local Listlayout = CreateGUIObject('UIListLayout', nil, {
	FillDirection = Enum.FillDirection.Vertical,
	HorizontalAlignment = Enum.HorizontalAlignment.Left,
	SortOrder = Enum.SortOrder.LayoutOrder,
	VerticalAlignment = Enum.VerticalAlignment.Top
}, OffsetFrame)

local ScrollingFrame : ScrollingFrame = CreateGUIObject('ScrollingFrame', nil, {
	Size = UDim2.new(1,0,1,-20),
	ScrollBarImageTransparency = 1,
	ScrollBarThickness = 0,
	CanvasSize = UDim2.new(0, 0, 0, 0),
	LayoutOrder = 1,
}, OffsetFrame)

local ToggleFrame = CreateGUIObject('Frame', 'UIToggle', {
	Size = UDim2.new(0,32,0,32),
	Position = UDim2.new(0, 104, 0, 4),
	BackgroundColor3 = Color3.new(0, 0, 0),
	BackgroundTransparency = 0.5,
}, GUI)

local ToggleButton : ImageButton = CreateGUIObject('ImageButton', nil, {
	AnchorPoint = Vector2.new(0.5, 0.5),
	Position = UDim2.new(0.5, 0, 0.5, 0),
	Size = UDim2.new(.8, 0, .8, 0),
	Image = Icons.Button.Toggle
}, ToggleFrame)

do
	local UICorner = Instance.new('UICorner')
	UICorner.CornerRadius = UDim.new(0.25, 0)
	UICorner.Parent = ToggleFrame
end

local Header : GuiObject = Templates.Header
Header.LayoutOrder = 0
Header.Visible = false
Header.Parent = OffsetFrame

local ScrollLayout = Listlayout:Clone()
ScrollLayout.Parent = ScrollingFrame


local FakeNeutralTeam = Templates.EntitySlot:Clone()
do
	FakeNeutralTeam.Name = 'FakeNeutralTeam'
	FakeNeutralTeam.Size = UDim2.new(1, 0, 0, 24)
	FakeNeutralTeam.BackgroundColor3 = BrickColor.Gray().Color
	FakeNeutralTeam.NameFrame.EntityName.NameText.Text = 'Neutral'
	
	
	FakeNeutralTeam.NameFrame.Icon:Destroy()
	FakeNeutralTeam.NameFrame.UIPadding:Destroy()
	
	
	local padding = Instance.new('UIPadding')
	padding.PaddingLeft = UDim.new(0, 15)
	padding.Parent = FakeNeutralTeam.NameFrame.EntityName.NameText
	
	FakeNeutralTeam.LayoutOrder = 1e3
	
	FakeNeutralTeam.NameFrame.EntityName.NameText.TextScaled = false
	FakeNeutralTeam.Visible = false
	FakeNeutralTeam.Parent = ScrollingFrame
end

local isMobile : boolean = UIS.TouchEnabled
local isShowing : boolean = true
local appearPosition : UDim2 = UDim2.new(0,0,0,0)
local disappearPosition : UDim2 = UDim2.new(1.1, 0, 0, 0)

local nameSizeIncrement : number = 11
local guiSizeIncrement : number = 77
local maxStats : number = 4

local insert = table.insert
local remove = table.remove

local currentInspectedPlayer : Player? = nil
local nameProperty : string = 'DisplayName'

local blockedUsers = SGS:GetCore('GetBlockedUserIds')
local playerBlocked = SGS:GetCore('PlayerBlockedEvent')
local playerUnblocked = SGS:GetCore('PlayerUnblockedEvent')
local playerFriended = SGS:GetCore('PlayerFriendedEvent')
local playerUnfriended = SGS:GetCore('PlayerUnfriendedEvent')

local teamData : {EntityData} = {}
local playerData : {EntityData} = {}
local currentGameStats : {Stat} = {}

local playerConnections : {[string] : {RBXScriptConnection}} = {}
local teamConnections : {[string] : {RBXScriptConnection}} = {}
local guiConnections : {[string | number] : RBXScriptConnection} = {}

local function getPrimaryStat() : Stat
	for i, stat : Stat in pairs (currentGameStats) do
		if stat.IsPrimary then
			return stat
		end
	end
end

local function isValidStat(object : Instance) : boolean
	return (object:IsA('IntValue') or object:IsA('NumberValue') or object:IsA('StringValue'))
end

local function find(list, value) : Player | Team
	for i,v in pairs (list) do
		if v.Instance == value then
			return i
		end
	end
end

local function gameStatExists(statName : string) : (boolean, Stat?)
	for i,v in pairs (currentGameStats) do
		if (v.Name == statName) then
			return true, v
		end
	end
		
	return false
end

local function getNumberOfTeamlessPlayers() : number
	local count = 0
	for i,v in pairs (PS:GetPlayers()) do
		if not (v.Team) then
			count += 1
		end
	end
	
	return count
end

local function sortStatOrder()
	table.sort(currentGameStats, function(a, b)
		if a.IsPrimary ~= b.IsPrimary then
			return a.IsPrimary
		end
		if a.Priority == b.Priority then
			return a.AddId < b.AddId
		end
		return a.Priority > b.Priority
	end)
	
	for i,stat in pairs (currentGameStats) do
		local uiObject = Header:FindFirstChild('Stat_'..stat.Name)
		
		if (uiObject) then
			uiObject.LayoutOrder = i
		end
		
		for _,entityData in pairs (playerData) do
			local statObj = entityData.GuiObject:FindFirstChild('Stat_'..stat.Name)
			
			if (statObj) then
				statObj.LayoutOrder = i
			end
		end
		
		for _,entityData in pairs (teamData) do
			local statObj = entityData.GuiObject:FindFirstChild('Stat_'..stat.Name)

			if (statObj) then
				statObj.LayoutOrder = i
			end
		end
	end
end

local function addUpPlayerStatOfTeam(team, statName : string) : number
	local count = 0
	for i,v in pairs (team:GetPlayers()) do
		if (v:FindFirstChild('leaderstats') and v.leaderstats:FindFirstChild(statName)) then
			if (v.leaderstats[statName]:IsA('IntValue') or v.leaderstats[statName]:IsA('NumberValue')) then
				count += v.leaderstats[statName].Value
			end
		end
	end
	return count
end

local function addUIStat(entityData : EntityData, stat : Stat) : Stat
	local statIndex : number = table.find(currentGameStats, stat)
	local newStat : GuiObject = entityData.GuiObject:FindFirstChild('Stat_'..stat.Name) or StatsText:Clone()
	newStat.Name = 'Stat_'..stat.Name
	newStat.LayoutOrder = statIndex
	
	if (entityData.Type == 'Player') then
		local leaderstats = entityData.Instance:FindFirstChild('leaderstats')
		local statObject = leaderstats and leaderstats:FindFirstChild(stat.Name)
		newStat.Text = (statObject and tostring(statObject.Value)) or '-'
	else
		local value = addUpPlayerStatOfTeam(entityData.Instance, stat.Name)
		newStat.Text = FormatStatString(value)
	end
	
	do
		local yOffset = entityData.GuiObject.NameFrame.Size.Y.Offset
		entityData.GuiObject.NameFrame.Size = UDim2.new(0, 150 + (#currentGameStats * nameSizeIncrement), 0, yOffset)
	end
	
	if (newStat.LayoutOrder > 4) then
		newStat.Visible = false
	end
	
	newStat.Parent = entityData.GuiObject
	return newStat
end

local function removeUIStat(entityData : EntityData, stat : Stat)
	local statUIObject = entityData.GuiObject:FindFirstChild('Stat_'..stat.Name)
	local statLayoutOrder = statUIObject.LayoutOrder
	
	if (statUIObject) then
		statUIObject:Destroy()
	end
	
	do
		local yOffset = entityData.GuiObject.NameFrame.Size.Y.Offset
		entityData.GuiObject.NameFrame.Size = UDim2.new(0, 150 + (#currentGameStats * nameSizeIncrement), 0, yOffset)
	end
	
	for i,v in pairs (entityData.GuiObject:GetChildren()) do
		if (v.Name:match('Stat_') and v.LayoutOrder > statLayoutOrder) then
			v.LayoutOrder -= 1
		end
	end
end

local function addGameStat(statObject : ValueBase)
	
	local newIndex = #currentGameStats + 1
	local isPrimary = false
	local priority = 0

	local isPrimaryVal = statObject:FindFirstChild("IsPrimary")
	if isPrimaryVal then
		if isPrimaryVal:IsA("BoolValue") then
			isPrimary = isPrimaryVal.Value
		else
			isPrimary = true
		end
	end
	local priorityVal = statObject:FindFirstChild("Priority")
	if priorityVal and (priorityVal:IsA("IntValue") or priorityVal:IsA("NumberValue")) then
		priority = priorityVal.Value
	end
	
	local stat : Stat = {
		Name = statObject.Name,
		IsPrimary = isPrimary,
		Priority = priority,
		AddId = newIndex
	}
	currentGameStats[newIndex] = stat
	
	if (newIndex <= maxStats) then
		Container.Size = UDim2.new(0, 166 + (guiSizeIncrement * newIndex), 0.5, 0)
		
		local newHeaderStat = HeaderText:Clone()
		newHeaderStat.Text = stat.Name
		newHeaderStat.Name = 'Stat_'..stat.Name
		newHeaderStat.Parent = Header
	end
	
	Header.NameText.Size = UDim2.new(0, 150 + (#currentGameStats * nameSizeIncrement), 1, 0)
	Header.Visible = (#currentGameStats > 0)
	
	sortStatOrder()
	for i,entityData in pairs (playerData) do 
		addUIStat(entityData, stat)
	end
	
	for i,entityData in pairs (teamData) do
		addUIStat(entityData, stat)
	end
end

local function removeGameStat(name : string)
	local statToRemove : Stat = nil
	
	for i, v in pairs (currentGameStats) do
		if (v.Name == name) then
			statToRemove = remove(currentGameStats, i)
			break
		end
	end
	
	do
		local count = math.clamp(#currentGameStats, 0, maxStats)
		Container.Size = UDim2.new(0, 166 + (guiSizeIncrement * count), 0.5, 0)
		
		Header.NameText.Size = UDim2.new(0, 150 + (#currentGameStats * nameSizeIncrement), 1, 0)
		Header.Visible = (#currentGameStats > 0)
		Header['Stat_'..name]:Destroy()
	end
	
	sortStatOrder()
	for i, entityData in pairs (playerData) do
		removeUIStat(entityData, statToRemove)
	end
	
	for i, entityData in pairs (teamData) do
		removeUIStat(entityData, statToRemove)
	end
end

local function getNumberOfPlayersWithLeaderstats() : number
	local count = 0
	for i,entity : EntityData in pairs (playerData) do
		if entity.Instance:FindFirstChild('leaderstats') then
			count += 1
		end
	end
	
	return count
end

local function checkGameStatsExist(playerToIgnore : Player)
	local hasGameStat = {}
	for _, gameStat in ipairs(currentGameStats) do
		hasGameStat[gameStat.Name] = false
	end
	
	if (getNumberOfTeamlessPlayers() > 1) then
		for i, data : EntityData in ipairs(playerData) do
			if (data.Instance == playerToIgnore) then continue end

			local leaderstats = data.Instance:FindFirstChild('leaderstats')
			if (leaderstats) then
				for statName, bool in pairs (hasGameStat) do
					if (bool) then continue end
					if leaderstats:FindFirstChild(statName) then
						hasGameStat[statName] = true
					end

				end
			end

		end
		
	else
		local leaderstats = playerToIgnore:FindFirstChild('leaderstats')
		if (leaderstats) then
			for statName, bool in pairs (hasGameStat) do
				if leaderstats:FindFirstChild(statName) then
					hasGameStat[statName] = true
				end

			end
		end
	end
	for statName, hasStat in pairs(hasGameStat) do
		if not hasStat then
			removeGameStat(statName)
		end
	end
end

local function createEntityTable(entity : Player) : EntityData
	return {Type = entity.ClassName, Instance = entity, GuiObject = nil, LayoutOrder = #playerData + #teamData + 1}
end

local function sortTeams()
	--task.desynchronize()
	print 'SORT'
	if #teamData == 0 then
		print 'team data < 1'
		--task.synchronize()
		return
	end
	
	table.sort(teamData, function(a, b)
		return (a.Instance.Name:lower() < b.Instance.Name:lower())
	end)
	
	
	local numberOfNoTeams = getNumberOfTeamlessPlayers()
	--task.synchronize()
	print(numberOfNoTeams)
	FakeNeutralTeam.Visible = (numberOfNoTeams > 0)
	
	teamData[1].LayoutOrder = 1 + numberOfNoTeams
	teamData[1].GuiObject.LayoutOrder = 1 + numberOfNoTeams
	
	for i = 2, #teamData do
		--task.desynchronize()
		local previous = teamData[i - 1]
		local entityData = teamData[i]
		entityData.LayoutOrder = previous.LayoutOrder + (#previous.Instance:GetPlayers() + 1)
		--task.synchronize()
		entityData.GuiObject.LayoutOrder = entityData.LayoutOrder
	end
	
end

local function sortPlayerData(playerDatas : {EntityData})
	local primaryStat = getPrimaryStat()

	if not (#playerDatas > 1) then
		--task.desynchronize()
		local pData = playerDatas[1]
		if not (pData) then --[[task.synchronize()]] return end

		local playerTeam = pData.Instance.Team
		if (playerTeam) then
			local tData = teamData[find(teamData, playerTeam)]

			if (tData) then
				pData.LayoutOrder = tData.LayoutOrder + 1
				--task.synchronize()
				pData.GuiObject.LayoutOrder = pData.LayoutOrder
			end
		end
		--task.synchronize()
		return
	end

	if (primaryStat) then
		--task.desynchronize()
		table.sort(playerDatas, function(a, b)
			local aLeaderstats = a.Instance:FindFirstChild('leaderstats')
			local aStat = aLeaderstats and a.Instance:FindFirstChild(primaryStat.Name)

			local bLeaderstats = b.Instance:FindFirstChild('leaderstats')
			local bStat = bLeaderstats and b.Instance:FindFirstChild(primaryStat.Name)

			return (aStat and aStat.Value or 0) < (bStat and bStat.Value or 0)
		end)
		--task.synchronize()
	else
		--task.desynchronize()
		table.sort(playerDatas, function(a, b)
			return (a.Instance[nameProperty]:lower() < b.Instance[nameProperty]:lower())
		end)
		--task.synchronize()
	end
end

local function sortPlayers() 
	
	local gameHasTeams = TMS:FindFirstChildOfClass('Team') and true or false
	
	if (gameHasTeams) then
		for i, team : Team in pairs (TMS:GetTeams()) do
			local players = {}
			local tData = teamData[find(teamData, team)]
			for i, player in pairs (team:GetPlayers()) do
				local index = find(playerData, player)
				
				if (index) then
					players[#players + 1] = playerData[index]
				end
			end
			
			
			sortPlayerData(players)
			
			if (tData) then
				for i,pData in pairs (players) do
					pData.LayoutOrder = tData.LayoutOrder + i
					pData.GuiObject.LayoutOrder = tData.LayoutOrder + i
				end
			end
			
		end
		
		local playersWithNoTeams = {}
		for i, entityData in pairs (playerData) do
			if not (entityData.Instance.Team) then
				playersWithNoTeams[#playersWithNoTeams + 1] = entityData
			end
		end
		sortPlayerData(playersWithNoTeams)
		
		for i,player : EntityData in pairs (playersWithNoTeams) do
			player.LayoutOrder = FakeNeutralTeam.LayoutOrder + i
			player.GuiObject.LayoutOrder = FakeNeutralTeam.LayoutOrder + i
		end
		
	else
		for i, entityData in pairs (playerData) do
			entityData.LayoutOrder = i
			entityData.GuiObject.LayoutOrder = i
		end
	end
end

local function sortPlayersAndTeams()
	sortTeams()
	sortPlayers()
end

local function updateIcon(icon, isBlocked, otherPlayer)
	if (otherPlayer.UserId == RPS:GetAttribute('Creator')) then
		icon.Image = Icons.Display.Owner
	elseif localPlayer:IsFriendsWith(otherPlayer.UserId) then
		icon.Image = Icons.Display.Friended
	elseif isBlocked then
		icon.Image = Icons.Display.Blocked
	elseif localPlayer.TeamColor == BrickColor.new("Crimson") then
		icon.Image = Icons.Display.TestTeam
	else
		icon.Image = Icons.Display.Empty
	end
end

local function addSlot(data : EntityData)
	local slot = Templates.EntitySlot:Clone()
	local name = (data.Type == 'Team' and data.Instance.Name) or data.Instance[nameProperty]
	
	data.GuiObject = slot
	slot.NameFrame.EntityName.NameText.Text = name
	
	slot.Name = data.Instance.Name
	slot.Size = UDim2.new(1, 0, 0, data.Type == 'Team' and 24 or 40)
	slot.NameFrame.Size = UDim2.new(0, 150 + (#currentGameStats * nameSizeIncrement), 0, slot.Size.Y.Offset)
	slot.BackgroundTransparency = (data.Type == 'Team' and 0) or slot.BackgroundTransparency
	slot.BackgroundColor3 = (data.Type == 'Team' and data.Instance.TeamColor.Color) or slot.BackgroundColor3
	slot.LayoutOrder = data.LayoutOrder

	-- Event Connections
	local function updateStats()
		if (#currentGameStats > 0) then
			for i, stat in pairs (currentGameStats) do
				local statText : TextLabel = slot:FindFirstChild('Stat_'..stat.Name)
				statText = statText or addUIStat(data, stat)
				statText.Text = data.Type == 'Team' and FormatStatString(addUpPlayerStatOfTeam(data.Instance, stat.Name)) or data.Instance.leaderstats[stat.Name].Value

			end
		end
	end
	
	if data.Type == 'Player' then
		
		local tIcon = slot.NameFrame.Icon

		slot.MouseEnter:Connect(function()
			local hue, sat, value = slot.BackgroundColor3:ToHSV()
			value = (value >= .75 and value - .25) or value + .25
			slot.BackgroundColor3 = Color3.fromHSV(hue, sat, value)
		end)
		
		slot.MouseLeave:Connect(function()
			local hue, sat, value = slot.BackgroundColor3:ToHSV()
			value = (value <= .5 and value + .25) or value - .25
			slot.BackgroundColor3 = Color3.fromHSV(hue, sat, value)
		end)
		
		slot.InputBegan:Connect(function(inputObject : InputObject)
			if not (inputObject.UserInputType == Enum.UserInputType.MouseButton1) and not (inputObject.UserInputType == Enum.UserInputType.Touch) then return end
			
			if (inputObject.UserInputState == Enum.UserInputState.Begin) then
				if not (Container:FindFirstChild(data.Instance.Name..'Inspector')) then
					InspectPlayer(data.Instance, data.GuiObject, blockedUsers)
				end
			end
		end)
		
		updateIcon(tIcon, (table.find(blockedUsers, data.Instance.UserId) and true) or false, data.Instance)
		updateStats()
	else
		
		do
			local padding = Instance.new('UIPadding')
			padding.PaddingLeft = UDim.new(0, 15)
			padding.Parent = slot.NameFrame.EntityName.NameText
		end
		
		slot.NameFrame.Icon:Destroy()
		slot.NameFrame.UIPadding:Destroy()
		slot.NameFrame.EntityName.NameText.TextScaled = false
		
		teamConnections[data.Instance.Name] = {
			data.Instance.PlayerAdded:Connect(updateStats),
			data.Instance.PlayerRemoved:Connect(updateStats)
		}
		
		updateStats()
	end
	
	slot.Parent = ScrollingFrame
end

local function removeSlot(data)
	if (data.GuiObject) then
		data.GuiObject:Destroy()
	end
	
	local connectionTable = data.Type == 'Player' and playerConnections or teamConnections
	local connectionData = connectionTable[data.Instance.Name]
	if (connectionData) then
		for i,connection in pairs (connectionData) do
			connection:Disconnect()
		end
	end
	
	connectionTable[data.Instance.Name] = nil
end

local function onPlayerAdded(player)
	if find(playerData, player) then return end
	
	playerConnections[player.Name] = {}
	local connections = playerConnections[player.Name]

	local playerTable = createEntityTable(player)
	insert(playerData, playerTable)
	addSlot(playerTable)
	
	local leaderstatsObject 
	
	local function onLeaderstatChildRemoved(statChild : Instance)
		checkGameStatsExist(player)

		local statText = playerTable.GuiObject and playerTable.GuiObject:FindFirstChild('Stat_'..statChild.Name)
		if (statText) then
			statText.Text = '-'
		end

		if (player.Team) then
			local tData = teamData[find(teamData, player.Team)]
			local statObj = tData.GuiObject:FindFirstChild('Stat_'..statChild.Name)

			if (statObj) then
				local value = addUpPlayerStatOfTeam(tData.Instance, statChild.Name)
				statObj.Text = FormatStatString(value)
			end
		end

		connections[statChild.Name]:Disconnect()
		connections[statChild.Name] = nil
	end
	
	local function onLeaderstatsAdded(child : Instance)
		if (child.Name == 'leaderstats' and not leaderstatsObject) then
			leaderstatsObject = child
			
			local function leaderstatsChildAdded(statChild : Instance)
				if (isValidStat(statChild)) then
					local exists, stat : Stat = gameStatExists(statChild.Name)
					if not (exists) then
						addGameStat(statChild)
					else
						addUIStat(playerTable, stat)
					end
					
					connections[statChild.Name] = statChild.Changed:Connect(function(newValue)
						local statText = playerTable.GuiObject and playerTable.GuiObject:FindFirstChild('Stat_'..statChild.Name)
						local statType = type(newValue)

						if (statText) then
							if (statType == 'number') then
								statText.Text = FormatStatString(newValue)
							else
								statText.Text = newValue
							end
						end

						if (player.Team and statType == 'number') then
							local tData = teamData[find(teamData, player.Team)]
							local value = addUpPlayerStatOfTeam(tData.Instance, statChild.Name)
							tData.GuiObject['Stat_'..statChild.Name].Text = FormatStatString(value)
						end
					end)
				end
			end

			connections.LeaderstatsChildAdded = child.ChildAdded:Connect(leaderstatsChildAdded)
			connections.LeaderstatsChildRemoved = child.ChildRemoved:Connect(onLeaderstatChildRemoved)
			
			for i, preExistingChild in pairs (child:GetChildren()) do
				leaderstatsChildAdded(preExistingChild)
			end
		else
			if (child.Name == 'leaderstats') then
				child:Destroy()
				warn("Cannot have more than one child with the name of 'leaderstats' inside of Player object")
			end
		end
	end
	
	connections.LeaderstatsAdded = player.ChildAdded:Connect(onLeaderstatsAdded)
	connections.LeaderstatsRemoved = player.ChildRemoved:Connect(function(child : Instance)
		if (child == leaderstatsObject) then
			leaderstatsObject = nil
			checkGameStatsExist(player)
			
			for i,v in pairs (child:GetChildren()) do
				onLeaderstatChildRemoved(v)
			end
			
			connections.LeaderstatsChildAdded:Disconnect()
			connections.LeaderstatsChildRemoved:Disconnect()
			connections.LeaderstatsChildAdded = nil
			connections.LeaderstatsChildRemoved = nil
		end
	end)
	
	connections.TeamChanged = player:GetPropertyChangedSignal('Team'):Connect(sortPlayersAndTeams)
	
	ScrollingFrame.CanvasSize = UDim2.new(0, 0, 0, (#teamData * 24) + (#playerData * 40))
	if player:FindFirstChild('leaderstats') then
		onLeaderstatsAdded(player.leaderstats)
	end
	sortPlayersAndTeams()
end

local function onPlayerRemoving(player)
	local dataIndex = find(playerData, player)
	removeSlot(playerData[dataIndex])
	remove(playerData, dataIndex)
	
	ScrollingFrame.CanvasSize = UDim2.new(0, 0, 0, (#teamData * 24) + (#playerData * 40))
	sortPlayersAndTeams()
end

local function onTeamAdded(team)
	if find(teamData, team) then return end
	local teamTable = createEntityTable (team)
	insert(teamData, teamTable)
	addSlot(teamTable)
	
	ScrollingFrame.CanvasSize = UDim2.new(0, 0, 0, (#teamData * 24) + (#playerData * 40))
	sortPlayersAndTeams()
end

local function onTeamRemoved(team)
	local dataIndex = find(teamData, team)
	removeSlot(teamData[dataIndex])
	remove(teamData, dataIndex)
	
	ScrollingFrame.CanvasSize = UDim2.new(0, 0, 0, (#teamData * 24) + (#playerData * 40))
	sortPlayersAndTeams()
end

local function onInput(action, state)
	if state == Enum.UserInputState.Begin then
		isShowing = not isShowing
		
		do
			local h, s, v = ToggleButton.ImageColor3:ToHSV()
			local h2, s2, v2 = ToggleFrame.BackgroundColor3:ToHSV()

			ToggleButton.ImageColor3 = Color3.fromHSV(h, s, (1 - v))
			ToggleFrame.BackgroundColor3 = Color3.fromHSV(h2, s2, (1 - v2))
		end
		
		if (isShowing) then
			OffsetFrame.Visible = true
			OffsetFrame:TweenPosition(appearPosition, Enum.EasingDirection.InOut, Enum.EasingStyle.Linear, .05, false)
		else
			
			OffsetFrame:TweenPosition(disappearPosition, Enum.EasingDirection.InOut, Enum.EasingStyle.Linear, .05, false, function()
				OffsetFrame.Visible = false
			end)
		end
	end
end

guiConnections[#guiConnections + 1] = PS.PlayerAdded:Connect(onPlayerAdded)
guiConnections[#guiConnections + 1] = PS.PlayerRemoving:Connect(onPlayerRemoving)
guiConnections[#guiConnections + 1] = TMS.ChildAdded:Connect(onTeamAdded)
guiConnections[#guiConnections + 1] = TMS.ChildRemoved:Connect(onTeamRemoved)

guiConnections[#guiConnections + 1] = playerBlocked.Event:Connect(function(blockedPlayer)
	local pData = playerData[find(playerData, blockedPlayer)] 
	blockedUsers[#blockedUsers + 1] = blockedPlayer.UserId

	if not (pData) then
		task.spawn(function()
			repeat task.wait() pData = playerData[find(playerData, blockedPlayer)] until pData

			if not pData.GuiObject then
				repeat task.wait() until pData.GuiObject
			end

			local icon = pData.GuiObject.NameFrame.Icon
			updateIcon(icon, true, blockedPlayer)
		end)

	elseif not pData.GuiObject then

		task.spawn(function()
			repeat task.wait() until pData.GuiObject

			local icon = pData.GuiObject.NameFrame.Icon
			updateIcon(icon, true, blockedPlayer)
		end)

	else
		local icon = pData.GuiObject.NameFrame.Icon
		updateIcon(icon, true, blockedPlayer)
	end
	
end)

guiConnections[#guiConnections + 1] = playerUnblocked.Event:Connect(function(blockedPlayer)
	local icon = playerData[find(playerData, blockedPlayer)].GuiObject.NameFrame.Icon
	local index = table.find(blockedUsers, blockedPlayer.UserId)
	remove(blockedUsers, blockedPlayer)
	updateIcon(icon, false, blockedPlayer)
end)

guiConnections[#guiConnections + 1] = playerFriended.Event:Connect(function(friendedPlayer)
	local pData = playerData[find(playerData, friendedPlayer)]
	
	if not (pData) then
		task.spawn(function()
			repeat task.wait() pData = playerData[find(playerData, friendedPlayer)] until pData
			
			if not pData.GuiObject then
				repeat task.wait() until pData.GuiObject
			end
			
			local icon = pData.GuiObject.NameFrame.Icon
			updateIcon(icon, (table.find(blockedUsers, friendedPlayer) and true) or false, friendedPlayer)
		end)
		
	elseif not (pData.GuiObject) then
		
		task.spawn(function()
			repeat task.wait() until pData.GuiObject
			
			local icon = pData.GuiObject.NameFrame.Icon
			updateIcon(icon, (table.find(blockedUsers, friendedPlayer) and true) or false, friendedPlayer)
		end)
		
	else
		local icon = pData.GuiObject.NameFrame.Icon
		updateIcon(icon, (table.find(blockedUsers, friendedPlayer) and true) or false, friendedPlayer)
	end
end)

guiConnections[#guiConnections + 1] = playerUnfriended.Event:Connect(function(friendedPlayer)
	local icon = playerData[find(playerData, friendedPlayer)].GuiObject.NameFrame.Icon
	updateIcon(icon, (table.find(blockedUsers, friendedPlayer) and true) or false, friendedPlayer)
end)

guiConnections[#guiConnections + 1] = ToggleButton.MouseButton1Click:Connect(function()
	onInput(nil, Enum.UserInputState.Begin)
end)

for i,v in ipairs (TMS:GetTeams()) do
	onTeamAdded(v)
end

for i,v in ipairs (PS:GetPlayers()) do
	onPlayerAdded(v)
end

CAS:BindAction('Appear', onInput, false, Enum.KeyCode.Tab)
sortPlayersAndTeams()

GUI.Enabled = true
GUI.Parent = localPlayer.PlayerGui
return GUI