<roblox version="4">
  <Item class="Folder" referent="0">
    <Properties>
      <string name="Name">RBLXE_Pack</string>
      <BinaryString name="AttributesSerialize">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</BinaryString>
      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
      <Color3 name="IconTint">
        <R>0</R>
        <G>0</G>
        <B>0</B>
      </Color3>
      <bool name="DefinesCapabilities">false</bool>
      <BinaryString name="SerializedOverrides">
      </BinaryString>
      <int64 name="SourceAssetId">-1</int64>
      <BinaryString name="Tags"></BinaryString>
    </Properties>
    <Item class="Folder" referent="1">
      <Properties>
        <string name="Name">ReplicatedStorage</string>
        <BinaryString name="AttributesSerialize"></BinaryString>
        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
        <Color3 name="IconTint">
          <R>0</R>
          <G>0</G>
          <B>0</B>
        </Color3>
        <bool name="DefinesCapabilities">false</bool>
        <BinaryString name="SerializedOverrides">
        </BinaryString>
        <int64 name="SourceAssetId">-1</int64>
        <BinaryString name="Tags"></BinaryString>
      </Properties>
      <Item class="Folder" referent="2">
        <Properties>
          <string name="Name">Kernel</string>
          <BinaryString name="AttributesSerialize">AQAAAAwAAABSQkxYRV9IYXNoZXMCNwMAACNyYmx4ZS1oYXNoZXMgdjEgZm52MWEzMiBsZgpSZXBsaWNhdGVkU3RvcmFnZS9LZXJuZWwvQ29uZmlnCTlhMzY3Nzk0ClJlcGxpY2F0ZWRTdG9yYWdlL0tlcm5lbC9Db250cmFjdHMJYjUwY2JjNmYKUmVwbGljYXRlZFN0b3JhZ2UvS2VybmVsL0xvYWRlcgkyOWU1NWFmZQpSZXBsaWNhdGVkU3RvcmFnZS9LZXJuZWwvTmV0CTgxZjhjMzIyClJlcGxpY2F0ZWRTdG9yYWdlL0tlcm5lbC9Ob3RpZnkJYjUxNDI1YWYKUmVwbGljYXRlZFN0b3JhZ2UvS2VybmVsL1BhY2thZ2VzL1Ryb3ZlCWI1YTdlYWM5ClJlcGxpY2F0ZWRTdG9yYWdlL0tlcm5lbC9TRlgJODZjY2M2NDEKUmVwbGljYXRlZFN0b3JhZ2UvS2VybmVsL1NjaGVtYQkwYTY4M2EzYwpSZXBsaWNhdGVkU3RvcmFnZS9LZXJuZWwvU2lnbmFsCTRkZGRkZDJjClJlcGxpY2F0ZWRTdG9yYWdlL0tlcm5lbC9VSS9NZW51U3lzdGVtCTgzYmZiMGViClJlcGxpY2F0ZWRTdG9yYWdlL0tlcm5lbC9VSS9QYW5lbEFuaW1hdGlvbnMJODg0MTcxNjkKUmVwbGljYXRlZFN0b3JhZ2UvS2VybmVsL1VJL1BhbmVsQW5pbWF0aW9ucy9Cb3VuY2UJNmE1MTJmMmIKUmVwbGljYXRlZFN0b3JhZ2UvS2VybmVsL1VJL1BpZWNlcwljYmY4MzVmMwpSZXBsaWNhdGVkU3RvcmFnZS9LZXJuZWwvVUkvUm9vdFBlcnNpc3RlbmNlCTE4NWMyNmUwClJlcGxpY2F0ZWRTdG9yYWdlL0tlcm5lbC9VSS9TaGVsbAlhOWVlZDUxMgpSZXBsaWNhdGVkU3RvcmFnZS9LZXJuZWwvVmVyc2lvbgljNmY1Yjg0YgpTZXJ2ZXJTY3JpcHRTZXJ2aWNlL0tlcm5lbAlhYmJmZmYyYgpTdGFydGVyUGxheWVyU2NyaXB0cy9LZXJuZWxDbGllbnQJYTAwODgyZjE=</BinaryString>
          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
          <Color3 name="IconTint">
            <R>0</R>
            <G>0</G>
            <B>0</B>
          </Color3>
          <bool name="DefinesCapabilities">false</bool>
          <BinaryString name="SerializedOverrides">
          </BinaryString>
          <int64 name="SourceAssetId">-1</int64>
          <BinaryString name="Tags"></BinaryString>
        </Properties>
        <Item class="ModuleScript" referent="3">
          <Properties>
            <string name="Name">Config</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Config.lua - loads a pack's game-owned configuration (RBLX Essentials 3.0).
--
-- A pack describes its options in `Packs/<PackId>/Schema` (see Schema.lua).
-- The GAME owns the values, in modules no update ever replaces:
--   ReplicatedStorage.RBLXEssentials.Config.<PackId>     options clients may know
--   ServerScriptService.RBLXEssentials.Config.<PackId>   options marked server = true
-- Both return only what the game changes; the rest comes from the schema.
-- The merged value is validated and frozen. A pack whose configuration is
-- invalid does not boot: running with an unexpected price or product id is
-- worse than a clear error that names the option.
--
-- Pure: every Instance and the require function come in through `opts`.
local Config = {}

-- What a caller passed, for error text: an Instance's ClassName, or the Luau
-- type of anything else passed by mistake (a string, a table).
local function classOf(value)
	return if typeof(value) == "Instance" then value.ClassName else typeof(value)
end

local function loadModule(requireFn, module, label, errors)
	if module == nil then
		return nil
	end
	if typeof(module) ~= "Instance" or not module:IsA("ModuleScript") then
		table.insert(errors, ("%s must be a ModuleScript, got %s"):format(label, classOf(module)))
		return nil
	end
	local ok, value = pcall(requireFn, module)
	if not ok then
		table.insert(errors, ("%s errored: %s"):format(label, tostring(value)))
		return nil
	end
	if value ~= nil and type(value) ~= "table" then
		table.insert(errors, ("%s must return a table, got %s"):format(label, type(value)))
		return nil
	end
	return value
end

local function display(value)
	if type(value) == "table" then
		return "a table"
	end
	return type(value) == "string" and ("%q"):format(value) or tostring(value)
end

-- What Config.load calls on schemaLib: anything else is not the Schema module.
local SCHEMA_FUNCTIONS = {
	"check", "serverFields", "merge", "defaults", "stripServer", "validate", "formatErrors", "freeze",
}

local function isSchemaLib(S)
	if type(S) ~= "table" then
		return false
	end
	for _, name in ipairs(SCHEMA_FUNCTIONS) do
		if type(S[name]) ~= "function" then
			return false
		end
	end
	return true
end

function Config.load(opts)
	-- Tools calls this too. The opts a caller can get wrong (side, packId,
	-- schemaLib, requireFn and the three module arguments) come back as
	-- errors, never as a silent guess or a throw: a side typo used to mean
	-- "client" and skip the server module. A game Config that makes the
	-- merge itself throw (a table that contains itself) still throws, so
	-- callers keep a pcall, as the Loader does.
	if opts.side ~= "Server" and opts.side ~= "Client" then
		return nil, { ('side must be "Server" or "Client", got %s'):format(display(opts.side)) }
	end
	if type(opts.packId) ~= "string" or opts.packId == "" then
		return nil, { ("packId must be non-empty text, got %s"):format(display(opts.packId)) }
	end
	local S = opts.schemaLib
	if opts.schemaModule == nil then
		return nil, {}
	end
	if not isSchemaLib(S) then
		return nil, { ("schemaLib must be the Kernel Schema module, got %s"):format(typeof(S)) }
	end
	if type(opts.requireFn) ~= "function" then
		return nil, { "requireFn must be a function, got " .. typeof(opts.requireFn) }
	end
	if typeof(opts.schemaModule) ~= "Instance" or not opts.schemaModule:IsA("ModuleScript") then
		return nil, { ("Schema must be a ModuleScript, got %s"):format(classOf(opts.schemaModule)) }
	end

	local okFactory, factory = pcall(opts.requireFn, opts.schemaModule)
	if not okFactory then
		return nil, { ("Schema errored: %s"):format(tostring(factory)) }
	end
	if type(factory) ~= "function" then
		return nil, { "Schema must return function(S) ... end" }
	end
	local okRoot, root = pcall(factory, S)
	if not okRoot then
		return nil, { ("Schema errored: %s"):format(tostring(root)) }
	end
	local definitionErrors = S.check(root)
	if #definitionErrors > 0 then
		for index, message in ipairs(definitionErrors) do
			definitionErrors[index] = "Schema: " .. message
		end
		return nil, definitionErrors
	end

	local name = "Config." .. opts.packId
	local sharedLabel = "ReplicatedStorage.RBLXEssentials.Config." .. opts.packId
	local serverLabel = "ServerScriptService.RBLXEssentials.Config." .. opts.packId
	local errors = {}
	local shared = loadModule(opts.requireFn, opts.sharedModule, sharedLabel, errors)
	local server = nil
	if opts.side == "Server" then
		server = loadModule(opts.requireFn, opts.serverModule, serverLabel, errors)
	end
	if #errors > 0 then
		return nil, errors
	end

	local serverFields = S.serverFields(root)
	for key in pairs(shared or {}) do
		if serverFields[key] then
			table.insert(errors, ("%s.%s is server-only and must not reach clients: move it to %s"):format(name, tostring(key), serverLabel))
		end
	end
	for key in pairs(server or {}) do
		if root.fields[key] ~= nil and not serverFields[key] then
			table.insert(errors, ("%s.%s is not server-only: move it to %s"):format(name, tostring(key), sharedLabel))
		end
	end
	if #errors > 0 then
		table.sort(errors)
		return nil, errors
	end

	local value = S.merge(root, S.defaults(root), shared)
	if server ~= nil then
		value = S.merge(root, value, server)
	end
	local clientSide = opts.side == "Client"
	if clientSide then
		value = S.stripServer(root, value)
	end
	local problems = S.validate(root, value, name, { skipServer = clientSide })
	if #problems > 0 then
		return nil, S.formatErrors(problems)
	end
	return S.freeze(value), {}
end

return Config
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="ModuleScript" referent="4">
          <Properties>
            <string name="Name">Contracts</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Contracts.lua - interface piece contracts (RBLX Essentials 3.0).
--
-- A pack declares, in `Packs/<PackId>/Pieces`, every piece of interface it
-- drives and what that piece must contain. The declaration is plain data:
--
--   return {
--       CodesPanel = {
--           contract = 1,              -- bumped only by an incompatible change
--           kind = "Panel",            -- Panel | HudButton | HudWidget | Billboard | Layer
--           doc = "Panel for typing and redeeming codes.",
--           requires = { { path = "Container/Button", class = "GuiButton" } },
--           optional = { { path = "Container/ErrorText", class = "TextLabel" } },
--       },
--       CodesButton = { contract = 1, kind = "HudButton", doc = "...", opens = "CodesPanel" },
--   }
--
-- Kernel 3.0.1: `standsInFor = "<PackId>.<Name>"` marks a stand-in, a copy
-- of a piece another pack owns (the General UI Kit's Codes menu stands in
-- for CodesSystem.CodesPanel). validateSpecs checks its shape and that it
-- names another pack; Pieces.plan refuses the stand-in when the owner piece
-- is declared, and checks that both have the same kind.
--
-- A piece root carries RBLXE_Piece = "<PackId>.<Name>" and RBLXE_Contract.
-- The same check runs in the Kernel (which copy to use) and in Tools (before
-- Play), so both always agree. Pure: Instances come in as arguments.
local Contracts = {}

-- Layer (plan B0): a ScreenGui that is itself the piece, such as a layer of
-- notification templates; like a Billboard piece it is its own entry in
-- Interface, never inside another ScreenGui.
Contracts.KINDS = {
	Panel = "GuiObject",
	HudButton = "GuiButton",
	HudWidget = "GuiObject",
	Billboard = "BillboardGui",
	Layer = "ScreenGui",
}
Contracts.PIECE_ATTRIBUTE = "RBLXE_Piece"
Contracts.CONTRACT_ATTRIBUTE = "RBLXE_Contract"

-- What MenuSystem needs to adopt and open a piece, checked on every piece of
-- that kind on top of its declared `requires`: a Panel is adopted through its
-- UI_Panel tag and registered under its PanelId; a HudButton is adopted
-- through its UI_Interactable tag and opens its panel with
-- Action = "TogglePanel" and TargetPanel. Without these a piece could win on
-- the server and still be unusable on every client. Tags are read with
-- Instance:HasTag, which @lune/roblox implements, so the check stays pure.
Contracts.IMPLICIT = {
	Panel = { tag = "UI_Panel", attributes = { PanelId = true } },
	HudButton = { tag = "UI_Interactable", attributes = { Action = "TogglePanel", TargetPanel = true } },
}

local function validateEntries(prefix, list, label, errors)
	if list == nil then
		return
	end
	if type(list) ~= "table" then
		table.insert(errors, ("%s.%s must be a list"):format(prefix, label))
		return
	end
	for index, entry in ipairs(list) do
		if type(entry) ~= "table" or type(entry.path) ~= "string" or entry.path == ""
			or type(entry.class) ~= "string" or entry.class == "" then
			table.insert(errors, ("%s.%s[%d] needs a non-empty path and class"):format(prefix, label, index))
		end
	end
end

function Contracts.validateSpecs(packId, specs)
	if type(specs) ~= "table" then
		return { ("%s.Pieces must return a table"):format(packId) }
	end
	local errors = {}
	for name, spec in pairs(specs) do
		local prefix = ("%s.Pieces.%s"):format(packId, tostring(name))
		if type(name) ~= "string" or not name:match("^[%a][%w_]*$") then
			table.insert(errors, ("%s: piece names must start with a letter and use letters, digits or _"):format(prefix))
		elseif type(spec) ~= "table" then
			table.insert(errors, ("%s must be a table"):format(prefix))
		else
			if type(spec.contract) ~= "number" or spec.contract < 1 or spec.contract % 1 ~= 0 then
				table.insert(errors, ("%s.contract must be a whole number >= 1"):format(prefix))
			end
			if Contracts.KINDS[spec.kind] == nil then
				table.insert(errors, ("%s.kind must be Panel, HudButton, HudWidget, Billboard or Layer"):format(prefix))
			end
			if type(spec.doc) ~= "string" or spec.doc == "" then
				table.insert(errors, ("%s.doc is required"):format(prefix))
			end
			validateEntries(prefix, spec.requires, "requires", errors)
			validateEntries(prefix, spec.optional, "optional", errors)
			if spec.opens ~= nil and (type(spec.opens) ~= "string" or specs[spec.opens] == nil) then
				table.insert(errors, ("%s.opens must name another piece of %s"):format(prefix, packId))
			end
			if spec.standsInFor ~= nil then
				local ownerPack, ownerName = nil, nil
				if type(spec.standsInFor) == "string" then
					ownerPack, ownerName = Contracts.splitId(spec.standsInFor)
				end
				if ownerPack == nil or ownerPack == packId or not ownerName:match("^[%a][%w_]*$") then
					table.insert(errors, ('%s.standsInFor must be "<PackId>.<Name>" naming a piece of another pack'):format(prefix))
				end
			end
		end
	end
	table.sort(errors)
	return errors
end

function Contracts.resolve(root, path)
	local node = root
	for segment in string.gmatch(path, "[^/]+") do
		node = node:FindFirstChild(segment)
		if node == nil then
			return nil
		end
	end
	return node
end

local function display(value)
	if type(value) == "string" then
		return ("%q"):format(value)
	elseif type(value) == "table" then
		return "a table"
	end
	return tostring(value)
end

-- What makes a spec unusable for check. validateSpecs already rejects all of
-- it for a pack's own Pieces module, but Tools also checks pieces against
-- specs nobody validated, and a check answers with problems, never a throw.
local function specProblems(spec)
	local function problem(name, expected, found)
		return { path = "(spec)", problem = "spec", name = name, expected = expected, found = display(found) }
	end
	if type(spec) ~= "table" then
		return { problem("spec", "a table", spec) }
	end
	local problems = {}
	if Contracts.KINDS[spec.kind] == nil then
		table.insert(problems, problem("kind", "Panel, HudButton, HudWidget, Billboard or Layer", spec.kind))
	end
	if type(spec.contract) ~= "number" or spec.contract < 1 or spec.contract % 1 ~= 0 then
		table.insert(problems, problem("contract", "a whole number >= 1", spec.contract))
	end
	for _, label in ipairs({ "requires", "optional" }) do
		local list = spec[label]
		if list ~= nil and type(list) ~= "table" then
			table.insert(problems, problem(label, "a list", list))
		elseif list ~= nil then
			for index, entry in ipairs(list) do
				if type(entry) ~= "table" or type(entry.path) ~= "string" or entry.path == ""
					or type(entry.class) ~= "string" or entry.class == "" then
					table.insert(problems, problem(("%s[%d]"):format(label, index), "a non-empty path and class", entry))
				end
			end
		end
	end
	return problems
end

function Contracts.check(root, spec)
	local problems = specProblems(spec)
	if typeof(root) ~= "Instance" then
		table.insert(problems, { path = "(root)", problem = "root", expected = "an Instance", found = display(root) })
	end
	if #problems > 0 then
		return problems
	end
	local rootClass = Contracts.KINDS[spec.kind]
	if not root:IsA(rootClass) then
		table.insert(problems, { path = "(root)", problem = "wrong class", expected = rootClass, found = root.ClassName })
	end
	local declared = root:GetAttribute(Contracts.CONTRACT_ATTRIBUTE)
	if declared ~= spec.contract then
		table.insert(problems, { path = "(root)", problem = "contract", expected = spec.contract, found = declared })
	end
	local implicit = Contracts.IMPLICIT[spec.kind]
	if implicit ~= nil then
		if not root:HasTag(implicit.tag) then
			table.insert(problems, { path = "(root)", problem = "tag", expected = implicit.tag })
		end
		local names = {}
		for name in pairs(implicit.attributes) do
			table.insert(names, name)
		end
		table.sort(names)
		for _, name in ipairs(names) do
			local want = implicit.attributes[name]
			local value = root:GetAttribute(name)
			if want == true then
				if type(value) ~= "string" or value == "" then
					table.insert(problems, { path = "(root)", problem = "attribute", name = name, expected = "non-empty text", found = value })
				end
			elseif value ~= want then
				table.insert(problems, { path = "(root)", problem = "attribute", name = name, expected = ("%q"):format(want), found = value })
			end
		end
	end
	for _, entry in ipairs(spec.requires or {}) do
		local found = Contracts.resolve(root, entry.path)
		if found == nil then
			table.insert(problems, { path = entry.path, problem = "missing", expected = entry.class })
		elseif not found:IsA(entry.class) then
			table.insert(problems, { path = entry.path, problem = "wrong class", expected = entry.class, found = found.ClassName })
		end
	end
	for _, entry in ipairs(spec.optional or {}) do
		local found = Contracts.resolve(root, entry.path)
		if found ~= nil and not found:IsA(entry.class) then
			table.insert(problems, { path = entry.path, problem = "wrong class", expected = entry.class, found = found.ClassName })
		end
	end
	return problems
end

function Contracts.formatProblems(problems)
	local parts = {}
	for _, p in ipairs(problems) do
		if p.problem == "missing" then
			table.insert(parts, ("missing %s (%s)"):format(p.path, p.expected))
		elseif p.problem == "contract" then
			table.insert(parts, ("contract version %s, expected %s"):format(tostring(p.found), tostring(p.expected)))
		elseif p.problem == "tag" then
			table.insert(parts, ("missing tag %s"):format(tostring(p.expected)))
		elseif p.problem == "attribute" then
			local found = type(p.found) == "string" and ("%q"):format(p.found) or tostring(p.found)
			table.insert(parts, ("attribute %s is %s, expected %s"):format(p.name, found, tostring(p.expected)))
		elseif p.problem == "spec" then
			table.insert(parts, ("invalid contract: %s is %s, expected %s"):format(p.name, p.found, p.expected))
		elseif p.problem == "root" then
			table.insert(parts, ("piece root is %s, expected %s"):format(p.found, p.expected))
		else
			table.insert(parts, ("%s is %s, expected %s"):format(p.path, tostring(p.found), tostring(p.expected)))
		end
	end
	return table.concat(parts, "; ")
end

function Contracts.splitId(pieceId)
	return string.match(pieceId, "^([^.]+)%.([^.]+)$")
end

return Contracts
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="ModuleScript" referent="5">
          <Properties>
            <string name="Name">Loader</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Boots installed packs in dependency order. Shared by Kernel (server) and
-- KernelClient. Pure: all roots come in via opts, so tests can point it at
-- fixture folders.
--
-- Plan B0 (phase B, before the Kernel 3.0.0 API freeze), in every ctx:
--   * companion(packId): another installed pack's frozen configuration for
--     this side and, once it booted, its API (handle:api()), or nil when
--     that pack is not installed. Optional by definition, like the Notify
--     and SFX facades: no manifest declaration, and never an instance path
--     into another pack;
--   * extension(name, defaults) / extensions(defaults): the game's own
--     modules for this pack, in <Service>.RBLXEssentials.Extensions.<PackId>
--     (a game zone no update or uninstall touches), before the pack's own
--     shipped ones in `defaults`;
--   * settings: only for a pack without a Schema (a game's own pack), with
--     a deprecation notice in report.notices; a pack with a Schema reads
--     ctx.config (and a notice says so when it still has a Settings folder).
local Loader = {}

-- RT-5: after its boot the server publishes which packs did not start, in
-- this attribute of ReplicatedStorage.RBLXEssentials (JSON { failed,
-- skipped }), so each client skips them instead of waiting on remotes a
-- server module never creates.
Loader.SERVER_REPORT_ATTRIBUTE = "RBLXE_ServerReport"

-- The report is attribute data, which Roblox does not store past a size
-- limit, while a reason can be long (a stack traceback, every configuration
-- error of a pack). The limit is PackFormat.HASHES_MAX_LENGTH's. A report
-- over it is encoded again with each reason cut to SERVER_REPORT_REASON_LENGTH
-- bytes, then with no reasons: clients need the ids, and the server output
-- keeps every reason whole.
Loader.SERVER_REPORT_MAX_LENGTH = 100000
Loader.SERVER_REPORT_REASON_LENGTH = 500

local DROPPED_REASON = "see the server output"

-- What clients read instead of a reason that may quote server-only values
-- (Loader.boot marks it in report.private): an invalid configuration names
-- the server Config's values (a repeated code, the text a check quoted), and
-- a server module's error can hold anything it read. The server output keeps
-- every reason whole; clients only need to know the pack did not start.
local PRIVATE_REASONS = {
	configuration = "invalid configuration (the server output names each problem; server-only values are never sent to clients)",
	error = "it errored while starting (the server output has the error; server-only values are never sent to clients)",
}

-- cutReason(reason) -> the reason, or its first SERVER_REPORT_REASON_LENGTH
-- bytes (never ending inside a UTF-8 character) and a note that it was cut.
local function cutReason(reason)
	local text = tostring(reason)
	local stop = Loader.SERVER_REPORT_REASON_LENGTH
	if #text <= stop then
		return text
	end
	-- step back over continuation bytes (0x80 to 0xBF) so the cut falls
	-- between two characters
	while stop > 0 and string.byte(text, stop + 1) >= 0x80 and string.byte(text, stop + 1) < 0xC0 do
		stop -= 1
	end
	return string.sub(text, 1, stop) .. " ... (cut; the server output has it whole)"
end

local function mapReasons(map, reasonFor)
	local out = {}
	for id, reason in pairs(map) do
		out[id] = reasonFor(reason)
	end
	return out
end

-- publicFailed(report) -> report.failed as clients may read it: each reason
-- report.private marks is replaced with its PRIVATE_REASONS text.
local function publicFailed(report)
	local private = if type(report.private) == "table" then report.private else {}
	local out = {}
	for id, reason in pairs(report.failed) do
		local kind = private[id]
		out[id] = if kind ~= nil then (PRIVATE_REASONS[kind] or DROPPED_REASON) else reason
	end
	return out
end

-- encodeServerReport(report, jsonEncode) -> JSON { failed, skipped } of at
-- most SERVER_REPORT_MAX_LENGTH bytes, for every client: a reason
-- report.private marks never leaves the server (publicFailed). Errors when
-- the ids alone do not fit: a client must never skip a shortened list.
function Loader.encodeServerReport(report, jsonEncode)
	report = { failed = publicFailed(report), skipped = report.skipped }
	local encoded = jsonEncode({ failed = report.failed, skipped = report.skipped })
	if #encoded <= Loader.SERVER_REPORT_MAX_LENGTH then
		return encoded
	end
	encoded = jsonEncode({ failed = mapReasons(report.failed, cutReason), skipped = mapReasons(report.skipped, cutReason) })
	if #encoded <= Loader.SERVER_REPORT_MAX_LENGTH then
		return encoded
	end
	local function dropped()
		return DROPPED_REASON
	end
	encoded = jsonEncode({ failed = mapReasons(report.failed, dropped), skipped = mapReasons(report.skipped, dropped) })
	if #encoded <= Loader.SERVER_REPORT_MAX_LENGTH then
		return encoded
	end
	error(string.format("the boot report is too long even without its reasons (%d bytes, limit %d)",
		#encoded, Loader.SERVER_REPORT_MAX_LENGTH), 0)
end

-- decodeServerReport(encoded, jsonDecode) -> { failed, skipped } or nil when
-- there is no usable report. HttpService writes an empty map as [], which
-- decodes to an empty table.
function Loader.decodeServerReport(encoded, jsonDecode)
	if type(encoded) ~= "string" then
		return nil
	end
	local ok, decoded = pcall(jsonDecode, encoded)
	if not ok or type(decoded) ~= "table" then
		return nil
	end
	return {
		failed = if type(decoded.failed) == "table" then decoded.failed else {},
		skipped = if type(decoded.skipped) == "table" then decoded.skipped else {},
	}
end

-- xpcall error handler: appends a stack traceback to the error message when
-- `debug.traceback` is available (real Roblox + the Lune test harness both
-- have it), falling back to a plain tostring() if some sandboxed environment
-- doesn't provide `debug`.
local function tracebackHandler(err)
	if debug and debug.traceback then
		return debug.traceback(tostring(err), 2)
	end
	return tostring(err)
end

local function readManifests(sharedPacks, requireImpl)
	local manifests, errors = {}, {}
	for _, packFolder in ipairs(sharedPacks:GetChildren()) do
		local manifestModule = packFolder:FindFirstChild("manifest")
		if not manifestModule or not manifestModule:IsA("ModuleScript") then
			errors[packFolder.Name] = "no manifest ModuleScript"
			continue
		end
		local ok, manifest = pcall(requireImpl, manifestModule)
		if not ok then
			errors[packFolder.Name] = "manifest error: " .. tostring(manifest)
			continue
		end
		if type(manifest) ~= "table" or type(manifest.id) ~= "string" then
			errors[packFolder.Name] = "manifest must return a table with a string id"
			continue
		end
		if manifest.id ~= packFolder.Name then
			errors[packFolder.Name] = string.format("manifest id %q does not match folder name", manifest.id)
			continue
		end
		manifest = table.clone(manifest)
		manifest.deps = manifest.deps or {}
		manifest.folder = packFolder
		manifests[manifest.id] = manifest
	end
	return manifests, errors
end

local function resolveOrder(manifests)
	local skipped = {}

	-- transitively drop packs whose declared deps are not installed
	local changed = true
	while changed do
		changed = false
		for id, m in pairs(manifests) do
			if not skipped[id] then
				for _, dep in ipairs(m.deps) do
					if not manifests[dep] or skipped[dep] then
						-- Whether dep is simply absent, or exists but was itself already
						-- skipped by an earlier fixed-point pass, the reason is the same:
						-- this pack can't run because dep isn't available. Cycle detection
						-- (and the "dependency cycle" reason) happens later, in the
						-- post-Kahn indegree sweep below -- never here.
						skipped[id] = "missing dependency: " .. dep
						changed = true
						break
					end
				end
			end
		end
	end

	-- Kahn topological sort (alphabetical tie-break for determinism)
	local order, indegree, dependents = {}, {}, {}
	for id in pairs(manifests) do
		if not skipped[id] then indegree[id] = 0 end
	end
	for id, m in pairs(manifests) do
		if not skipped[id] then
			for _, dep in ipairs(m.deps) do
				indegree[id] += 1
				dependents[dep] = dependents[dep] or {}
				table.insert(dependents[dep], id)
			end
		end
	end
	local queue = {}
	for id, deg in pairs(indegree) do
		if deg == 0 then table.insert(queue, id) end
	end
	table.sort(queue)
	while #queue > 0 do
		local id = table.remove(queue, 1)
		table.insert(order, id)
		for _, dependent in ipairs(dependents[id] or {}) do
			indegree[dependent] -= 1
			if indegree[dependent] == 0 then
				local pos = #queue + 1
				for i, q in ipairs(queue) do
					if dependent < q then pos = i break end
				end
				table.insert(queue, pos, dependent)
			end
		end
	end
	for id, deg in pairs(indegree) do
		if deg > 0 and not skipped[id] then
			skipped[id] = "dependency cycle"
		end
	end
	return order, skipped
end

-- moduleNamed(parent, name): the first ModuleScript child called `name`,
-- past any other child of that name (FindFirstChild would stop at a Folder).
local function moduleNamed(parent, name)
	for _, child in ipairs(parent and parent:GetChildren() or {}) do
		if child.Name == name and child:IsA("ModuleScript") then
			return child
		end
	end
	return nil
end

-- extension(root, packId, name, defaults?) -> (module?, from?): the game's
-- module <root>.<packId>.<name> ("game"), else defaults.<name> ("pack");
-- only a ModuleScript counts. `root` is the side's Extensions folder.
function Loader.extension(root, packId, name, defaults)
	local found = moduleNamed(root and root:FindFirstChild(packId), name)
	if found ~= nil then
		return found, "game"
	end
	local shipped = moduleNamed(defaults, name)
	if shipped ~= nil then
		return shipped, "pack"
	end
	return nil, nil
end

-- extensions(root, packId, defaults?) -> { { name, module, from } }: every
-- module of both, one per name: the pack's own in their order (the game's
-- module winning a name it shares), then the game's additions in theirs.
function Loader.extensions(root, packId, defaults)
	local list, taken = {}, {}
	local own = root and root:FindFirstChild(packId)
	for _, child in ipairs(defaults and defaults:GetChildren() or {}) do
		if child:IsA("ModuleScript") and not taken[child.Name] then
			taken[child.Name] = true
			local module, from = Loader.extension(root, packId, child.Name, defaults)
			table.insert(list, { name = child.Name, module = module, from = from })
		end
	end
	for _, child in ipairs(own and own:GetChildren() or {}) do
		if child:IsA("ModuleScript") and not taken[child.Name] then
			taken[child.Name] = true
			table.insert(list, { name = child.Name, module = child, from = "game" })
		end
	end
	return list
end

function Loader.boot(opts)
	local requireImpl = opts.requireFn or require
	-- report.private[id]: why report.failed[id] may quote server-only values
	-- ("configuration" or "error"); encodeServerReport never sends such a
	-- reason to clients, and the server output prints it whole.
	-- report.notices: one line per pack that still gets ctx.settings (plan
	-- B0), or whose Settings folder its Schema leaves unread, printed once
	-- by the Kernel scripts.
	local report = { booted = {}, failed = {}, skipped = {}, private = {}, notices = {} }
	local manifests, manifestErrors = readManifests(opts.sharedPacks, requireImpl)
	for name, err in pairs(manifestErrors) do
		report.failed[name] = err
	end
	local order, skipped = resolveOrder(manifests)
	for id, reason in pairs(skipped) do
		report.skipped[id] = reason
	end

	local apis = {}
	-- Each pack's configuration is loaded once, on its own turn below or
	-- earlier through a companion handle, and shared by both.
	local configs = {}
	local function loadConfig(packId)
		local cached = configs[packId]
		if cached ~= nil then
			return cached
		end
		local m = manifests[packId]
		local configRoots = opts.configRoots or {}
		local ok, value, errors = pcall(opts.configLib.load, {
			packId = packId,
			side = opts.side,
			requireFn = requireImpl,
			schemaLib = opts.schemaLib,
			schemaModule = m.folder:FindFirstChild("Schema"),
			sharedModule = configRoots.shared and configRoots.shared:FindFirstChild(packId) or nil,
			serverModule = configRoots.server and configRoots.server:FindFirstChild(packId) or nil,
		})
		cached = { ok = ok, value = value, errors = errors }
		configs[packId] = cached
		return cached
	end
	-- One frozen handle per companion (plan B0, ruling 4).
	local companions = {}
	local function companionOf(packId)
		local handle = companions[packId]
		if handle ~= nil then
			return handle
		end
		-- No config for a pack whose pieces failed on this side or, on a
		-- client, one the server failed or skipped (nothing it declares is in
		-- force there). Otherwise its config, even for a pack this side skips
		-- or that fails later: handle.api() says whether it booted. The
		-- handle is made once, at the first call.
		local stopped = (opts.pieceFailures ~= nil and opts.pieceFailures[packId] ~= nil)
			or (opts.serverReport ~= nil and (opts.serverReport.failed[packId] ~= nil or opts.serverReport.skipped[packId] ~= nil))
		local config = nil
		if opts.configLib and not stopped then
			local loaded = loadConfig(packId)
			if loaded.ok and type(loaded.errors) == "table" and #loaded.errors == 0 then
				config = loaded.value
			end
		end
		handle = table.freeze({
			id = packId,
			version = manifests[packId].version,
			config = config,
			api = function()
				return apis[packId]
			end,
		})
		companions[packId] = handle
		return handle
	end
	for _, id in ipairs(order) do
		local m = manifests[id]
		local blockedBy
		for _, dep in ipairs(m.deps) do
			if report.failed[dep] or (report.skipped[dep] and not apis[dep]) then
				blockedBy = dep
				break
			end
		end
		if blockedBy then
			report.skipped[id] = "dependency failed: " .. blockedBy
			continue
		end

		-- 3.0 (RT-6): a pack whose Pieces declaration is invalid does not
		-- boot: its pieces can never be resolved (Pieces.collectDeclarations).
		local pieceFailure = opts.pieceFailures and opts.pieceFailures[id]
		if pieceFailure ~= nil then
			report.failed[id] = pieceFailure
			continue
		end
		-- 3.0 (RT-5): on a client, a pack that did not start on the server
		-- does not start either: it would wait for remotes nobody creates.
		local serverReason = opts.serverReport and (opts.serverReport.failed[id] or opts.serverReport.skipped[id])
		if serverReason ~= nil then
			report.failed[id] = "did not start on the server: " .. tostring(serverReason)
			continue
		end

		-- 3.0: game-owned configuration (Config.lua). A pack whose configuration
		-- is invalid fails like a pack whose init errors, so its dependents are
		-- skipped instead of booting against a half-configured dependency.
		-- The load runs in its own pcall: a schema or a Config module that
		-- makes the load throw (a self-referencing table, anything Schema.check
		-- did not foresee) fails this pack alone, never the rest of the boot.
		-- A companion handle may have loaded it already (loadConfig).
		local config = nil
		if opts.configLib then
			local loaded = loadConfig(id)
			if not loaded.ok then
				report.failed[id] = "invalid configuration: " .. tostring(loaded.value)
				report.private[id] = "configuration"
				continue
			end
			if #loaded.errors > 0 then
				report.failed[id] = "invalid configuration:\n    " .. table.concat(loaded.errors, "\n    ")
				report.private[id] = "configuration"
				continue
			end
			config = loaded.value
		end

		local module
		if opts.side == "Server" then
			module = opts.serverPacks and opts.serverPacks:FindFirstChild(id)
		else
			module = m.folder:FindFirstChild("Client")
		end
		if not module or not module:IsA("ModuleScript") then
			-- pack ships no code for this side - still counts as booted
			apis[id] = {}
			table.insert(report.booted, id)
			continue
		end

		-- A pack with a Schema reads ctx.config and gets no ctx.settings; a
		-- pack without one (a game's own pack) keeps its 2.x Settings folder,
		-- and the report says once that this is deprecated (plan B0, ruling 5).
		-- A Settings folder next to a Schema (a hand copy: T.update never
		-- takes a 2.x pack to 3.x) is not read, and the report says so.
		local settings = nil
		if m.folder:FindFirstChild("Schema") == nil then
			settings = m.folder:FindFirstChild("Settings")
			if settings ~= nil then
				table.insert(report.notices, string.format(
					"%s reads its 2.x Settings through ctx.settings, which is deprecated: an official pack stops using it when it is updated to 3.x; a game's own pack should move to a Schema and ctx.config", id))
			end
		elseif m.folder:FindFirstChild("Settings") ~= nil then
			table.insert(report.notices, string.format(
				"%s has a Schema, so its Settings folder is not read: the pack runs on Config.%s. Set there any value the game changed in Settings, then delete that folder", id, id))
		end
		local ctx = {
			packId = id,
			version = m.version,
			folder = m.folder,
			serverFolder = (opts.side == "Server") and module or nil,
			settings = settings,
			config = config,
			-- Plan B0: another installed pack's config and API (nil when it is
			-- not installed), and the game's own modules for this pack.
			companion = function(otherId)
				if type(otherId) ~= "string" or otherId == id or manifests[otherId] == nil then
					return nil
				end
				return companionOf(otherId)
			end,
			extension = function(name, defaults)
				return Loader.extension(opts.extensions, id, name, defaults)
			end,
			extensions = function(defaults)
				return Loader.extensions(opts.extensions, id, defaults)
			end,
			kernel = opts.kernelApi,
			ui = opts.ui,
			-- 3.0: this pack's own interface piece, already resolved by the Kernel.
			getPiece = opts.ui and function(name, timeout)
				return opts.ui:getPiece(id .. "." .. name, timeout)
			end or nil,
			require = function(depId)
				local declared = false
				for _, dep in ipairs(m.deps) do
					if dep == depId then declared = true break end
				end
				assert(declared, string.format(
					"[RBLXE] %s tried to require %s without declaring it in manifest.deps", id, depId))
				return apis[depId]
			end,
		}

		local ok, initOrErr = xpcall(requireImpl, tracebackHandler, module)
		if ok and type(initOrErr) ~= "function" then
			ok, initOrErr = false, "module must return function(ctx)"
		end
		if ok then
			local api
			ok, api = xpcall(initOrErr, tracebackHandler, ctx)
			if ok then
				apis[id] = api or {}
				table.insert(report.booted, id)
			else
				report.failed[id] = tostring(api)
				report.private[id] = "error"
			end
		else
			report.failed[id] = tostring(initOrErr)
			report.private[id] = "error"
		end
	end
	return report
end

function Loader.formatReport(side, report)
	local function keys(map)
		local out = {}
		for k in pairs(map) do table.insert(out, k) end
		table.sort(out)
		return table.concat(out, ",")
	end
	return string.format("[RBLXE] %s booted: %s | failed: %s | skipped: %s",
		side, table.concat(report.booted, ","), keys(report.failed), keys(report.skipped))
end

return Loader
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="ModuleScript" referent="6">
          <Properties>
            <string name="Name">Net</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Per-pack remote namespaces under RS/RBLXEssentials/Kernel/Remotes/<PackId>/.
-- Server creates on demand; clients wait for the server to create.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

local Net = {}

local function kernelFolder()
	return ReplicatedStorage:WaitForChild("RBLXEssentials"):WaitForChild("Kernel")
end

local function serverGet(packId, className, name)
	local kernel = kernelFolder()
	local root = kernel:FindFirstChild("Remotes")
	if not root then
		root = Instance.new("Folder"); root.Name = "Remotes"; root.Parent = kernel
	end
	local packFolder = root:FindFirstChild(packId)
	if not packFolder then
		packFolder = Instance.new("Folder"); packFolder.Name = packId; packFolder.Parent = root
	end
	local remote = packFolder:FindFirstChild(name)
	if remote then
		if remote.ClassName ~= className then
			error(string.format("[RBLXE Net] %s/%s already exists as %s", packId, name, remote.ClassName))
		end
		return remote
	end
	remote = Instance.new(className)
	remote.Name = name
	remote.Parent = packFolder
	return remote
end

function Net.server(packId)
	assert(RunService:IsServer(), "[RBLXE Net] Net.server is server-only")
	return {
		event = function(_, name) return serverGet(packId, "RemoteEvent", name) end,
		func = function(_, name) return serverGet(packId, "RemoteFunction", name) end,
	}
end

function Net.client(packId)
	assert(RunService:IsClient(), "[RBLXE Net] Net.client is client-only")

	-- waitFor(parent, name, deadline) -> the child, or nil once `deadline`
	-- (an os.clock time) has passed. Waits in slices of at most 10 s and
	-- warns once when it has to wait longer than one slice, instead of
	-- yielding with no word. Without a deadline it waits as long as it
	-- takes, as 2.x packs expect.
	local function waitFor(parent, name, deadline)
		local child = parent:FindFirstChild(name)
		local warned = false
		while child == nil do
			local slice = 10
			if deadline ~= nil then
				local left = deadline - os.clock()
				if left <= 0 then
					return nil
				end
				slice = math.min(slice, left)
			end
			child = parent:WaitForChild(name, slice)
			if child == nil and not warned and (deadline == nil or os.clock() < deadline) then
				warned = true
				warn(string.format(
					"[RBLXE] Net.client(%q) still waiting for %s.%s. Is the pack's server module installed and started?",
					packId, parent:GetFullName(), name))
			end
		end
		return child
	end

	-- lookup(name, timeout?) -> the remote, or nil with a warning once
	-- `timeout` seconds have passed (RT-5): one deadline for the Remotes
	-- folder, the pack's folder and the remote itself.
	local function lookup(name, timeout)
		local deadline = if type(timeout) == "number" then os.clock() + timeout else nil
		local remotes = waitFor(kernelFolder(), "Remotes", deadline)
		local packFolder = remotes and waitFor(remotes, packId, deadline)
		local remote = packFolder and waitFor(packFolder, name, deadline)
		if remote == nil then
			warn(string.format(
				"[RBLXE] Net.client(%q): remote %q did not appear within %ss; the pack's server module did not start or never creates it",
				packId, name, tostring(timeout)))
		end
		return remote
	end
	return {
		event = function(_, name, timeout) return lookup(name, timeout) end,
		func = function(_, name, timeout) return lookup(name, timeout) end,
	}
end

return Net
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="ModuleScript" referent="7">
          <Properties>
            <string name="Name">Notify</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Notification facade. Packs call Notify:Toast(...) freely; it is a no-op
-- until a backend registers (Notifications System v2 calls setBackend from
-- its server and client inits).
--
-- WHY THIS IS A FACADE AND NOT A REQUIRE: every pack in the ecosystem wants
-- to announce something, and Notifications System is optional. Without this,
-- five packs would each carry the same twenty lines of FindFirstChild +
-- pcall + degrade - and a pack that declared it in manifest.deps would make
-- an optional companion mandatory, since the plugin refuses to install a
-- pack whose declared deps are missing. Same reasoning, same shape, as
-- SFX.lua, which solved this once already for sound.
--
-- Server methods take a `player`; the client backend's do not (a client only
-- ever notifies its own player), which is why a missing method has to be a
-- no-op rather than an error.
local Notify = {}
local backend = nil

-- A missing method behaves exactly like a missing backend: the client
-- backend has no ChatTo/ToastAll/BannerAll, and a pack must not have to know
-- which side it is on. pcall because a notification is fire-and-forget - a
-- bug in the renderer must never surface as an error inside the pack that
-- called it.
local function forward(method, ...)
	if not backend then
		return
	end
	local fn = backend[method]
	if type(fn) ~= "function" then
		return
	end
	local ok, err = pcall(fn, backend, ...)
	if not ok then
		warn("[RBLXE Notify] backend:" .. method .. " failed: " .. tostring(err))
	end
end

function Notify:Toast(...)
	forward("Toast", ...)
end

function Notify:ToastAll(...)
	forward("ToastAll", ...)
end

function Notify:Chat(...)
	forward("Chat", ...)
end

function Notify:ChatTo(...)
	forward("ChatTo", ...)
end

function Notify:Banner(...)
	forward("Banner", ...)
end

function Notify:BannerAll(...)
	forward("BannerAll", ...)
end

function Notify.setBackend(b)
	backend = b
end

return Notify
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="Folder" referent="8">
          <Properties>
            <string name="Name">Packages</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <Color3 name="IconTint">
              <R>0</R>
              <G>0</G>
              <B>0</B>
            </Color3>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
          <Item class="ModuleScript" referent="9">
            <Properties>
              <string name="Name">Trove</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[--!strict

local RunService = game:GetService("RunService")

export type Trove = {
	Extend: (self: Trove) -> Trove,
	Clone: <T>(self: Trove, instance: T & Instance) -> T,
	Construct: <T, A...>(self: Trove, class: Constructable<T, A...>, A...) -> T,
	Connect: (self: Trove, signal: SignalLike | RBXScriptSignal, fn: (...any) -> ...any) -> ConnectionLike,
	BindToRenderStep: (self: Trove, name: string, priority: number, fn: (dt: number) -> ()) -> (),
	AddPromise: <T>(self: Trove, promise: T & PromiseLike) -> T,
	Add: <T>(self: Trove, object: T & Trackable, cleanupMethod: string?) -> T,
	Remove: <T>(self: Trove, object: T & Trackable) -> boolean,
	Clean: (self: Trove) -> (),
	WrapClean: (self: Trove) -> () -> (),
	AttachToInstance: (self: Trove, instance: Instance) -> RBXScriptConnection,
	Destroy: (self: Trove) -> (),
}

type TroveInternal = Trove & {
	_objects: { any },
	_cleaning: boolean,
	_findAndRemoveFromObjects: (self: TroveInternal, object: any, cleanup: boolean) -> boolean,
	_cleanupObject: (self: TroveInternal, object: any, cleanupMethod: string?) -> (),
}

--[=[
	@within Trove
	@type Trackable Instance | RBXScriptConnection | ConnectionLike | PromiseLike | thread | ((...any) -> ...any) | Destroyable | DestroyableLowercase | Disconnectable | DisconnectableLowercase
	Represents all trackable objects by Trove.
]=]
export type Trackable =
	Instance
	| RBXScriptConnection
	| ConnectionLike
	| PromiseLike
	| thread
	| ((...any) -> ...any)
	| Destroyable
	| DestroyableLowercase
	| Disconnectable
	| DisconnectableLowercase

--[=[
	@within Trove
	@interface ConnectionLike
	.Connected boolean
	.Disconnect (self) -> ()
]=]
type ConnectionLike = {
	Connected: boolean,
	Disconnect: (self: ConnectionLike) -> (),
}

--[=[
	@within Trove
	@interface SignalLike
	.Connect (self, callback: (...any) -> ...any) -> ConnectionLike
	.Once (self, callback: (...any) -> ...any) -> ConnectionLike
]=]
type SignalLike = {
	Connect: (self: SignalLike, callback: (...any) -> ...any) -> ConnectionLike,
	Once: (self: SignalLike, callback: (...any) -> ...any) -> ConnectionLike,
}

--[=[
	@within Trove
	@interface PromiseLike
	.getStatus (self) -> string
	.finally (self, callback: (...any) -> ...any) -> PromiseLike
	.cancel (self) -> ()
]=]
type PromiseLike = {
	getStatus: (self: PromiseLike) -> string,
	finally: (self: PromiseLike, callback: (...any) -> ...any) -> PromiseLike,
	cancel: (self: PromiseLike) -> (),
}

--[=[
	@within Trove
	@type Constructable { new: (A...) -> T } | (A...) -> T
]=]
type Constructable<T, A...> = { new: (A...) -> T } | (A...) -> T

--[=[
	@within Trove
	@interface Destroyable
	.disconnect (self) -> ()
]=]
type Destroyable = {
	Destroy: (self: Destroyable) -> (),
}

--[=[
	@within Trove
	@interface DestroyableLowercase
	.disconnect (self) -> ()
]=]
type DestroyableLowercase = {
	destroy: (self: DestroyableLowercase) -> (),
}

--[=[
	@within Trove
	@interface Disconnectable
	.disconnect (self) -> ()
]=]
type Disconnectable = {
	Disconnect: (self: Disconnectable) -> (),
}

--[=[
	@within Trove
	@interface DisconnectableLowercase
	.disconnect (self) -> ()
]=]
type DisconnectableLowercase = {
	disconnect: (self: DisconnectableLowercase) -> (),
}

local FN_MARKER = newproxy()
local THREAD_MARKER = newproxy()
local GENERIC_OBJECT_CLEANUP_METHODS = table.freeze({ "Destroy", "Disconnect", "destroy", "disconnect" })

local function GetObjectCleanupFunction(object: any, cleanupMethod: string?)
	local t = typeof(object)

	if t == "function" then
		return FN_MARKER
	elseif t == "thread" then
		return THREAD_MARKER
	end

	if cleanupMethod then
		return cleanupMethod
	end

	if t == "Instance" then
		return "Destroy"
	elseif t == "RBXScriptConnection" then
		return "Disconnect"
	elseif t == "table" then
		for _, genericCleanupMethod in GENERIC_OBJECT_CLEANUP_METHODS do
			if typeof(object[genericCleanupMethod]) == "function" then
				return genericCleanupMethod
			end
		end
	end

	error(`failed to get cleanup function for object {t}: {object}`, 3)
end

local function AssertPromiseLike(object: any)
	if
		typeof(object) ~= "table"
		or typeof(object.getStatus) ~= "function"
		or typeof(object.finally) ~= "function"
		or typeof(object.cancel) ~= "function"
	then
		error("did not receive a promise as an argument", 3)
	end
end

--[=[
	@class Trove
	A Trove is helpful for tracking any sort of object during
	runtime that needs to get cleaned up at some point.
]=]
local Trove = {}
Trove.__index = Trove

--[=[
	@return Trove
	Constructs a Trove object.

	```lua
	local trove = Trove.new()
	```
]=]
function Trove.new(): Trove
	local self = setmetatable({}, Trove)

	self._objects = {}
	self._cleaning = false

	return (self :: any) :: Trove
end

--[=[
	@method Add
	@within Trove
	@param object any -- Object to track
	@param cleanupMethod string? -- Optional cleanup name override
	@return object: any
	Adds an object to the trove. Once the trove is cleaned or
	destroyed, the object will also be cleaned up.

	The following types are accepted (e.g. `typeof(object)`):

	| Type | Cleanup |
	| ---- | ------- |
	| `Instance` | `object:Destroy()` |
	| `RBXScriptConnection` | `object:Disconnect()` |
	| `function` | `object()` |
	| `thread` | `task.cancel(object)` |
	| `table` | `object:Destroy()` _or_ `object:Disconnect()` _or_ `object:destroy()` _or_ `object:disconnect()` |
	| `table` with `cleanupMethod` | `object:<cleanupMethod>()` |

	Returns the object added.

	```lua
	-- Add a part to the trove, then destroy the trove,
	-- which will also destroy the part:
	local part = Instance.new("Part")
	trove:Add(part)
	trove:Destroy()

	-- Add a function to the trove:
	trove:Add(function()
		print("Cleanup!")
	end)
	trove:Destroy()

	-- Standard cleanup from table:
	local tbl = {}
	function tbl:Destroy()
		print("Cleanup")
	end
	trove:Add(tbl)

	-- Custom cleanup from table:
	local tbl = {}
	function tbl:DoSomething()
		print("Do something on cleanup")
	end
	trove:Add(tbl, "DoSomething")
	```
]=]
function Trove.Add(self: TroveInternal, object: Trackable, cleanupMethod: string?): any
	if self._cleaning then
		error("cannot call trove:Add() while cleaning", 2)
	end

	local cleanup = GetObjectCleanupFunction(object, cleanupMethod)
	table.insert(self._objects, { object, cleanup })

	return object
end

--[=[
	@method Clone
	@within Trove
	@return Instance
	Clones the given instance and adds it to the trove. Shorthand for
	`trove:Add(instance:Clone())`.

	```lua
	local clonedPart = trove:Clone(somePart)
	```
]=]
function Trove.Clone(self: TroveInternal, instance: Instance): Instance
	if self._cleaning then
		error("cannot call trove:Clone() while cleaning", 2)
	end

	return self:Add(instance:Clone())
end

--[=[
	@method Construct
	@within Trove
	@param class { new(Args...) -> T } | (Args...) -> T
	@param ... Args...
	@return T
	Constructs a new object from either the
	table or function given.

	If a table is given, the table's `new`
	function will be called with the given
	arguments.

	If a function is given, the function will
	be called with the given arguments.

	The result from either of the two options
	will be added to the trove.

	This is shorthand for `trove:Add(SomeClass.new(...))`
	and `trove:Add(SomeFunction(...))`.

	```lua
	local Signal = require(somewhere.Signal)

	-- All of these are identical:
	local s = trove:Construct(Signal)
	local s = trove:Construct(Signal.new)
	local s = trove:Construct(function() return Signal.new() end)
	local s = trove:Add(Signal.new())

	-- Even Roblox instances can be created:
	local part = trove:Construct(Instance, "Part")
	```
]=]
function Trove.Construct<T, A...>(self: TroveInternal, class: Constructable<T, A...>, ...: A...)
	if self._cleaning then
		error("Cannot call trove:Construct() while cleaning", 2)
	end

	local object = nil
	local t = type(class)
	if t == "table" then
		object = (class :: any).new(...)
	elseif t == "function" then
		object = (class :: any)(...)
	end

	return self:Add(object)
end

--[=[
	@method Connect
	@within Trove
	@param signal RBXScriptSignal
	@param fn (...: any) -> ()
	@return RBXScriptConnection
	Connects the function to the signal, adds the connection
	to the trove, and then returns the connection.

	This is shorthand for `trove:Add(signal:Connect(fn))`.

	```lua
	trove:Connect(workspace.ChildAdded, function(instance)
		print(instance.Name .. " added to workspace")
	end)
	```
]=]
function Trove.Connect(self: TroveInternal, signal: SignalLike, fn: (...any) -> ...any)
	if self._cleaning then
		error("Cannot call trove:Connect() while cleaning", 2)
	end

	return self:Add(signal:Connect(fn))
end

--[=[
	@method BindToRenderStep
	@within Trove
	@param name string
	@param priority number
	@param fn (dt: number) -> ()
	Calls `RunService:BindToRenderStep` and registers a function in the
	trove that will call `RunService:UnbindFromRenderStep` on cleanup.

	```lua
	trove:BindToRenderStep("Test", Enum.RenderPriority.Last.Value, function(dt)
		-- Do something
	end)
	```
]=]
function Trove.BindToRenderStep(self: TroveInternal, name: string, priority: number, fn: (dt: number) -> ())
	if self._cleaning then
		error("cannot call trove:BindToRenderStep() while cleaning", 2)
	end

	RunService:BindToRenderStep(name, priority, fn)

	self:Add(function()
		RunService:UnbindFromRenderStep(name)
	end)
end

--[=[
	@method AddPromise
	@within Trove
	@param promise Promise
	@return Promise
	Gives the promise to the trove, which will cancel the promise if the trove is cleaned up or if the promise
	is removed. The exact promise is returned, thus allowing chaining.

	```lua
	trove:AddPromise(doSomethingThatReturnsAPromise())
		:andThen(function()
			print("Done")
		end)
	-- Will cancel the above promise (assuming it didn't resolve immediately)
	trove:Clean()

	local p = trove:AddPromise(doSomethingThatReturnsAPromise())
	-- Will also cancel the promise
	trove:Remove(p)
	```

	:::caution Promise v4 Only
	This is only compatible with the [roblox-lua-promise](https://eryn.io/roblox-lua-promise/) library, version 4.
	:::
]=]
function Trove.AddPromise(self: TroveInternal, promise: PromiseLike)
	if self._cleaning then
		error("cannot call trove:AddPromise() while cleaning", 2)
	end
	AssertPromiseLike(promise)

	if promise:getStatus() == "Started" then
		promise:finally(function()
			if self._cleaning then
				return
			end
			self:_findAndRemoveFromObjects(promise, false)
		end)

		self:Add(promise, "cancel")
	end

	return promise
end

--[=[
	@method Remove
	@within Trove
	@param object any
	Removes the object from the Trove and cleans it up.

	```lua
	local part = Instance.new("Part")
	trove:Add(part)
	trove:Remove(part)
	```
]=]
function Trove.Remove(self: TroveInternal, object: Trackable): boolean
	if self._cleaning then
		error("cannot call trove:Remove() while cleaning", 2)
	end

	return self:_findAndRemoveFromObjects(object, true)
end

--[=[
	@method Extend
	@within Trove
	@return Trove
	Creates and adds another trove to itself. This is just shorthand
	for `trove:Construct(Trove)`. This is useful for contexts where
	the trove object is present, but the class itself isn't.

	:::note
	This does _not_ clone the trove. In other words, the objects in the
	trove are not given to the new constructed trove. This is simply to
	construct a new Trove and add it as an object to track.
	:::

	```lua
	local trove = Trove.new()
	local subTrove = trove:Extend()

	trove:Clean() -- Cleans up the subTrove too
	```
]=]
function Trove.Extend(self: TroveInternal)
	if self._cleaning then
		error("cannot call trove:Extend() while cleaning", 2)
	end

	return self:Construct(Trove)
end

--[=[
	@method Clean
	@within Trove
	Cleans up all objects in the trove. This is
	similar to calling `Remove` on each object
	within the trove. The ordering of the objects
	removed is _not_ guaranteed.

	```lua
	trove:Clean()
	```
]=]
function Trove.Clean(self: TroveInternal)
	if self._cleaning then
		return
	end

	self._cleaning = true

	for _, obj in self._objects do
		self:_cleanupObject(obj[1], obj[2])
	end

	table.clear(self._objects)
	self._cleaning = false
end

--[=[
	@method WrapClean
	@within Trove
	Returns a function that wraps the trove's `Clean()`
	method. Calling the returned function will clean up
	the trove.

	This is often useful in contexts where functions
	are the primary mode for cleaning up an environment,
	such as in many "observer" patterns.

	```lua
	local cleanup = trove:WrapClean()

	-- Sometime later...
	cleanup()
	```

	```lua
	-- Common observer pattern example:
	someObserver(function()
		local trove = Trove.new()
		-- Foo
		return trove:WrapClean()
	end)
	```
]=]
function Trove.WrapClean(self: TroveInternal)
	return function()
		self:Clean()
	end
end

function Trove._findAndRemoveFromObjects(self: TroveInternal, object: any, cleanup: boolean): boolean
	local objects = self._objects

	for i, obj in objects do
		if obj[1] == object then
			local n = #objects
			objects[i] = objects[n]
			objects[n] = nil

			if cleanup then
				self:_cleanupObject(obj[1], obj[2])
			end

			return true
		end
	end

	return false
end

function Trove._cleanupObject(_self: TroveInternal, object: any, cleanupMethod: string?)
	if cleanupMethod == FN_MARKER then
		task.spawn(object)
	elseif cleanupMethod == THREAD_MARKER then
		pcall(task.cancel, object)
	else
		object[cleanupMethod](object)
	end
end

--[=[
	@method AttachToInstance
	@within Trove
	@param instance Instance
	@return RBXScriptConnection
	Attaches the trove to a Roblox instance. Once this
	instance is removed from the game (parent or ancestor's
	parent set to `nil`), the trove will automatically
	clean up.

	This inverses the ownership of the Trove object, and should
	only be used when necessary. In other words, the attached
	instance dictates when the trove is cleaned up, rather than
	the trove dictating the cleanup of the instance.

	:::caution
	Will throw an error if `instance` is not a descendant
	of the game hierarchy.
	:::

	```lua
	trove:AttachToInstance(somePart)
	trove:Add(function()
		print("Cleaned")
	end)

	-- Destroying the part will cause the trove to clean up, thus "Cleaned" printed:
	somePart:Destroy()
	```
]=]
function Trove.AttachToInstance(self: TroveInternal, instance: Instance)
	if self._cleaning then
		error("cannot call trove:AttachToInstance() while cleaning", 2)
	elseif not instance:IsDescendantOf(game) then
		error("instance is not a descendant of the game hierarchy", 2)
	end

	return self:Connect(instance.Destroying, function()
		self:Destroy()
	end)
end

--[=[
	@method Destroy
	@within Trove
	Alias for `trove:Clean()`.

	```lua
	trove:Destroy()
	```
]=]
function Trove.Destroy(self: TroveInternal)
	self:Clean()
end

return {
	new = Trove.new,
}
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
        </Item>
        <Item class="ModuleScript" referent="10">
          <Properties>
            <string name="Name">SFX</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Sound facade. Packs call SFX:Play(name) freely; it is a no-op until a sound
-- backend registers (Sound System v2 calls setBackend from its client init).
local SFX = {}
local backend = nil

function SFX:Play(name)
	if backend then
		backend:Play(name)
	end
end

function SFX:PlayOverlap(name)
	if backend then
		backend:PlayOverlap(name)
	end
end

function SFX.setBackend(b)
	backend = b
end

return SFX
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="ModuleScript" referent="11">
          <Properties>
            <string name="Name">Schema</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Schema.lua - declarative configuration schemas (RBLX Essentials 3.0).
--
-- A pack describes the options the GAME may set in `Packs/<PackId>/Schema`,
-- a ModuleScript returning `function(S) return S.config({ ... }) end`, where
-- `S` is this module. One schema serves three readers:
--   * the Kernel at boot: defaults plus validation of the game's Config modules;
--   * Tools in Studio: the same validation, before anyone presses Play;
--   * the reference generator: every field carries a `doc`.
--
-- Values are plain Luau data. The only merge rule: `config`, `record` and
-- `map` merge key by key; a `list` and every scalar are replaced whole (list
-- items still receive their own record defaults).
--
-- Plan A3:
--   * a `server = true` option, and everything under it, has no `default`:
--     this module sits in ReplicatedStorage, so a default would reach every
--     client (RT-10). Such an option is required or S.optional, and the game
--     sets it in the server Config module; a server list starts empty;
--   * any node may carry `check = function(value) -> { { field?, message } }`
--     with a `checkDoc` that states the rule: a constraint over several
--     fields ("Target is required when Type is Stat"), run by validate once
--     the value passed every type check below it.
--
-- Plan B0 (phase B, before the Kernel 3.0.0 API freeze):
--   * S.color: a Color3 (typeof) with finite channels, written in a Config
--     module as Color3.fromRGB(r, g, b);
--   * S.tree: a nested table of text keys whose values are finite numbers,
--     text, true/false or tables of the same kind (at most TREE_DEPTH
--     levels, never a table inside itself), such as a starting profile. It
--     is a value, not a group: a game's tree replaces the default whole;
--   * pinned = true on an option outside lists and maps (never the root):
--     T.migrate refuses a game module whose value there differs from the
--     migrated one, and force never lifts it (a DataStore version, where
--     another value starts every player on an empty profile). The Kernel
--     only checks the flag and lists it in describe.
--
-- Pure: no `game`, no Instances, no yields.
local Schema = {}

-- The kinds whose value has no default of its own when the schema gives
-- none (describe's `required`): every kind but the groups and collections.
local SCALAR = {
	number = true, string = true, boolean = true, enum = true,
	id = true, dataPath = true, utcDate = true, color = true, tree = true,
}
local KNOWN = {
	number = true, string = true, boolean = true, enum = true, id = true,
	dataPath = true, utcDate = true, color = true, tree = true, list = true,
	map = true, record = true, config = true, optional = true,
}
-- How deep an S.tree may nest (plan B0).
Schema.TREE_DEPTH = 32
local ID_NAMES = { asset = "an asset id", product = "a developer product id", gamePass = "a game pass id" }
local DAYS_IN_MONTH = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

-- ── constructors ─────────────────────────────────────────────────────

local function build(kind, opts, extra)
	local node = { kind = kind }
	if opts ~= nil then
		assert(type(opts) == "table", "schema options must be a table")
		for key, value in pairs(opts) do
			node[key] = value
		end
	end
	if extra ~= nil then
		for key, value in pairs(extra) do
			node[key] = value
		end
	end
	return node
end

function Schema.number(opts) return build("number", opts) end
function Schema.integer(opts) return build("number", opts, { integer = true }) end
function Schema.string(opts) return build("string", opts) end
function Schema.boolean(opts) return build("boolean", opts) end
function Schema.enum(values, opts) return build("enum", opts, { values = values }) end
function Schema.assetId(opts) return build("id", opts, { idKind = "asset" }) end
function Schema.productId(opts) return build("id", opts, { idKind = "product" }) end
function Schema.gamePassId(opts) return build("id", opts, { idKind = "gamePass" }) end
function Schema.dataPath(opts) return build("dataPath", opts) end
function Schema.utcDate(opts) return build("utcDate", opts) end
function Schema.color(opts) return build("color", opts) end
function Schema.tree(opts) return build("tree", opts) end
function Schema.list(item, opts) return build("list", opts, { item = item }) end
function Schema.map(value, opts) return build("map", opts, { value = value }) end
function Schema.record(fields, opts) return build("record", opts, { fields = fields }) end
function Schema.config(fields, opts) return build("config", opts, { fields = fields }) end
function Schema.optional(inner) return { kind = "optional", inner = inner } end

-- ── helpers ──────────────────────────────────────────────────────────

local function unwrap(node)
	if type(node) == "table" and node.kind == "optional" then
		return node.inner
	end
	return node
end

local function copy(value)
	if type(value) ~= "table" then
		return value
	end
	local out = {}
	for key, item in pairs(value) do
		out[key] = copy(item)
	end
	return out
end
Schema.copy = copy

local function sortedKeys(t)
	local keys = {}
	for key in pairs(t) do
		table.insert(keys, key)
	end
	table.sort(keys, function(a, b)
		return tostring(a) < tostring(b)
	end)
	return keys
end

local function childPath(path, key)
	if type(key) == "number" then
		return ("%s[%d]"):format(path, key)
	end
	if type(key) == "string" and key:match("^[%a_][%w_]*$") then
		return path == "" and key or (path .. "." .. key)
	end
	return ("%s[%q]"):format(path, tostring(key))
end
Schema.childPath = childPath

local function isArray(t)
	local count = 0
	for key in pairs(t) do
		if type(key) ~= "number" or key < 1 or key % 1 ~= 0 then
			return false
		end
		count += 1
	end
	for i = 1, count do
		if t[i] == nil then
			return false
		end
	end
	return true
end

local function isDataPath(text)
	if type(text) ~= "string" or text == "" then
		return false
	end
	for segment in (text .. "."):gmatch("(.-)%.") do
		if not segment:match("^[%a_][%w_]*$") then
			return false
		end
	end
	return true
end

function Schema.parseUtcDate(text)
	if type(text) ~= "string" then
		return nil
	end
	local y, m, d = text:match("^(%d%d%d%d)%-(%d%d)%-(%d%d)$")
	if y == nil then
		return nil
	end
	local year, month, day = tonumber(y), tonumber(m), tonumber(d)
	if month < 1 or month > 12 then
		return nil
	end
	local days = DAYS_IN_MONTH[month]
	if month == 2 and ((year % 4 == 0 and year % 100 ~= 0) or year % 400 == 0) then
		days = 29
	end
	if day < 1 or day > days then
		return nil
	end
	return year, month, day
end

local function distance(a, b)
	local la, lb = #a, #b
	if la == 0 then return lb end
	if lb == 0 then return la end
	local previous = {}
	for j = 0, lb do
		previous[j] = j
	end
	for i = 1, la do
		local current = { [0] = i }
		local ca = a:sub(i, i):lower()
		for j = 1, lb do
			local cost = (ca == b:sub(j, j):lower()) and 0 or 1
			current[j] = math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost)
		end
		previous = current
	end
	return previous[lb]
end

local function suggest(key, fields)
	local best, bestDistance = nil, nil
	for _, name in ipairs(sortedKeys(fields)) do
		local d = distance(key, name)
		if d <= 2 and (bestDistance == nil or d < bestDistance) then
			best, bestDistance = name, d
		end
	end
	return best
end

-- ── validation ───────────────────────────────────────────────────────

local function push(problems, path, message)
	table.insert(problems, { path = path, message = message })
end

-- validateTree(value, path, problems, seen, depth): S.tree's rule. Every
-- bad entry is reported at its own path; a key that is not text is shown
-- with tostring (childPath's %d would throw on 1.5).
local function validateTree(value, path, problems, seen, depth)
	if type(value) ~= "table" then
		return push(problems, path, "must be a table of text keys")
	end
	if seen[value] then
		return push(problems, path, "contains itself")
	end
	if depth > Schema.TREE_DEPTH then
		return push(problems, path, ("is nested deeper than %d levels"):format(Schema.TREE_DEPTH))
	end
	seen[value] = true
	for _, key in ipairs(sortedKeys(value)) do
		local item = value[key]
		local at = if type(key) == "string" then childPath(path, key) else ("%s[%s]"):format(path, tostring(key))
		if type(key) ~= "string" then
			push(problems, at, "keys must be text")
		elseif type(item) == "number" then
			if item ~= item or item == math.huge or item == -math.huge then
				push(problems, at, "must be a finite number")
			end
		elseif type(item) == "table" then
			validateTree(item, at, problems, seen, depth + 1)
		elseif type(item) ~= "string" and type(item) ~= "boolean" then
			push(problems, at, "must be a number, text, true/false or a table")
		end
	end
	seen[value] = nil
end

local validateNode

-- runCheck(node, value, path, problems): the node's own `check`. Each item it
-- returns is { field?, message }: `field` is a key, or a list of keys, under
-- the node's path. Inside a pcall, so a rule that throws is a problem.
local function runCheck(node, value, path, problems)
	local ok, found = pcall(node.check, value)
	if not ok then
		return push(problems, path, ("could not be checked: %s"):format(tostring(found)))
	end
	if type(found) ~= "table" then
		return
	end
	for _, item in ipairs(found) do
		if type(item) == "table" and type(item.message) == "string" then
			local at = path
			local field = item.field
			if type(field) == "table" then
				for _, key in ipairs(field) do
					at = childPath(at, key)
				end
			elseif field ~= nil then
				at = childPath(at, field)
			end
			push(problems, at, item.message)
		end
	end
end

local validateShape
validateNode = function(node, value, path, problems, opts)
	if node.kind == "optional" then
		if value == nil then
			return
		end
		return validateNode(node.inner, value, path, problems, opts)
	end
	-- A node's own rule runs only over a value that passed every type check
	-- below it: a rule over fields that are already wrong is noise.
	local before = #problems
	validateShape(node, value, path, problems, opts)
	if type(node.check) == "function" and #problems == before then
		runCheck(node, value, path, problems)
	end
end

validateShape = function(node, value, path, problems, opts)
	if value == nil then
		return push(problems, path, "is required")
	end
	local kind = node.kind
	if kind == "number" then
		if type(value) ~= "number" or value ~= value then
			return push(problems, path, "must be a number")
		end
		if node.integer and value % 1 ~= 0 then
			return push(problems, path, "must be a whole number")
		end
		if node.min ~= nil and value < node.min then
			return push(problems, path, ("must be >= %s"):format(tostring(node.min)))
		end
		if node.max ~= nil and value > node.max then
			return push(problems, path, ("must be <= %s"):format(tostring(node.max)))
		end
	elseif kind == "string" then
		if type(value) ~= "string" then
			return push(problems, path, "must be text")
		end
		if node.minLength ~= nil and #value < node.minLength then
			if node.minLength == 1 then
				return push(problems, path, "must not be empty")
			end
			return push(problems, path, ("must have at least %d characters"):format(node.minLength))
		end
		if node.maxLength ~= nil and #value > node.maxLength then
			return push(problems, path, ("must have at most %d characters"):format(node.maxLength))
		end
		if node.pattern ~= nil then
			-- pcall: validate can run on a schema Schema.check never saw, and a
			-- malformed pattern must be reported, never thrown.
			local ok, matched = pcall(string.match, value, node.pattern)
			if not ok then
				return push(problems, path, ("cannot be checked against pattern %s: %s"):format(tostring(node.pattern), tostring(matched)))
			end
			if matched == nil then
				return push(problems, path, ("must match %s"):format(node.patternDoc or node.pattern))
			end
		end
	elseif kind == "boolean" then
		if type(value) ~= "boolean" then
			return push(problems, path, "must be true or false")
		end
	elseif kind == "enum" then
		if type(node.values) ~= "table" or type(value) ~= "string" or table.find(node.values, value) == nil then
			return push(problems, path, ("must be one of: %s"):format(table.concat(node.values or {}, ", ")))
		end
	elseif kind == "id" then
		if type(value) ~= "number" or value % 1 ~= 0 or value < 0 then
			return push(problems, path, ("must be %s: a whole number, 0 for none"):format(ID_NAMES[node.idKind] or "an id"))
		end
	elseif kind == "dataPath" then
		if not isDataPath(value) then
			return push(problems, path, "must be a data path like Stats.Cash")
		end
	elseif kind == "utcDate" then
		if Schema.parseUtcDate(value) == nil then
			return push(problems, path, "must be a UTC date written YYYY-MM-DD")
		end
	elseif kind == "color" then
		if typeof(value) ~= "Color3" then
			return push(problems, path, "must be a Color3 (Color3.fromRGB(r, g, b))")
		end
		-- LuaText cannot write a NaN or infinite channel, so T.config and
		-- T.migrate would fail later on a value the Kernel took.
		for _, channel in ipairs({ value.R, value.G, value.B }) do
			if channel ~= channel or channel == math.huge or channel == -math.huge then
				return push(problems, path, "must have finite channels")
			end
		end
	elseif kind == "tree" then
		validateTree(value, path, problems, {}, 1)
	elseif kind == "list" then
		if type(value) ~= "table" or not isArray(value) then
			return push(problems, path, "must be a list")
		end
		if node.minItems ~= nil and #value < node.minItems then
			push(problems, path, ("must have at least %d entries"):format(node.minItems))
		end
		if node.maxItems ~= nil and #value > node.maxItems then
			push(problems, path, ("must have at most %d entries"):format(node.maxItems))
		end
		for index, item in ipairs(value) do
			validateNode(node.item, item, childPath(path, index), problems, opts)
		end
	elseif kind == "map" then
		if type(value) ~= "table" then
			return push(problems, path, "must be a table")
		end
		for _, key in ipairs(sortedKeys(value)) do
			if type(key) ~= "string" then
				push(problems, path, "keys must be text")
			else
				validateNode(node.value, value[key], childPath(path, key), problems, opts)
			end
		end
	elseif kind == "record" or kind == "config" then
		if type(value) ~= "table" then
			return push(problems, path, "must be a table")
		end
		for _, key in ipairs(sortedKeys(value)) do
			if type(key) ~= "string" or node.fields[key] == nil then
				local hint = type(key) == "string" and suggest(key, node.fields) or nil
				push(problems, childPath(path, key),
					hint and ("is not a known option (did you mean %s?)"):format(hint) or "is not a known option")
			end
		end
		for _, name in ipairs(sortedKeys(node.fields)) do
			local field = node.fields[name]
			if not (kind == "config" and opts.skipServer and unwrap(field).server == true) then
				validateNode(field, value[name], childPath(path, name), problems, opts)
			end
		end
	end
end

function Schema.validate(root, value, rootPath, opts)
	local problems = {}
	validateNode(root, value, rootPath or "", problems, opts or {})
	return problems
end

function Schema.formatErrors(problems)
	local out = {}
	for _, problem in ipairs(problems) do
		table.insert(out, ("%s: %s"):format(problem.path, problem.message))
	end
	return out
end

-- ── defaults and merge ───────────────────────────────────────────────

function Schema.defaults(node)
	local kind = node.kind
	if kind == "optional" then
		if node.inner.default ~= nil then
			return Schema.defaults(node.inner)
		end
		return nil
	elseif kind == "record" or kind == "config" then
		local out = {}
		for name, field in pairs(node.fields) do
			out[name] = Schema.defaults(field)
		end
		return out
	elseif kind == "list" or kind == "map" then
		return Schema.merge(node, nil, node.default or {})
	end
	return copy(node.default)
end

function Schema.merge(node, base, override)
	if override == nil then
		return copy(base)
	end
	local n = unwrap(node)
	if type(override) ~= "table" then
		return copy(override)
	end
	if n.kind == "list" then
		local out = {}
		for index, item in ipairs(override) do
			out[index] = Schema.merge(n.item, Schema.defaults(n.item), item)
		end
		for key, item in pairs(override) do
			if out[key] == nil then
				out[key] = copy(item) -- kept so validation can reject a non-list
			end
		end
		return out
	end
	if n.kind ~= "record" and n.kind ~= "config" and n.kind ~= "map" then
		return copy(override)
	end
	local out = type(base) == "table" and copy(base) or {}
	for key, item in pairs(override) do
		local child = if n.kind == "map" then n.value else n.fields[key]
		if child == nil then
			out[key] = copy(item) -- unknown option: kept so validation reports it
		else
			local current = out[key]
			if current == nil then
				current = Schema.defaults(child)
			end
			out[key] = Schema.merge(child, current, item)
		end
	end
	return out
end

-- ── server-only options ──────────────────────────────────────────────

function Schema.serverFields(root)
	local set = {}
	for name, field in pairs(root.fields) do
		if unwrap(field).server == true then
			set[name] = true
		end
	end
	return set
end

function Schema.stripServer(root, value)
	local out = copy(value)
	for name in pairs(Schema.serverFields(root)) do
		out[name] = nil
	end
	return out
end

-- ── patterns ─────────────────────────────────────────────────────────

-- Luau rejects a malformed pattern only when string.match reaches the bad
-- item, so a probe on one subject lets most of them through ("a[" never
-- fails on "") and they throw later, on the game's value. patternError
-- walks the whole pattern once with the matcher's own rules (lstrlib) and
-- returns the reason the first bad item gives, or nil when every item is
-- well formed.
local MAX_CAPTURES = 32 -- LUA_MAXCAPTURES

-- setEnd(pattern, i) -> the index after the ']' that closes a set whose
-- first character is at i, or nil. As in the matcher, the first character
-- after '[' or '[^' always belongs to the set, so "[]]" and "[^]]" are sets
-- holding ']', and a '%' inside a set escapes the character after it.
local function setEnd(pattern, i)
	local n = #pattern
	if string.sub(pattern, i, i) == "^" then
		i += 1
	end
	repeat
		if i > n then
			return nil
		end
		local c = string.sub(pattern, i, i)
		i += 1
		if c == "%" and i <= n then
			i += 1
		end
	until string.sub(pattern, i, i) == "]"
	return i + 1
end

function Schema.patternError(pattern)
	if type(pattern) ~= "string" then
		return "pattern must be text"
	end
	local n = #pattern
	local i = if string.sub(pattern, 1, 1) == "^" then 2 else 1
	local closed = {} -- closed[k] becomes true when capture k gets its ')'
	local open = {} -- captures still open, innermost last
	while i <= n do
		local c = string.sub(pattern, i, i)
		if c == "(" then
			table.insert(closed, false)
			if #closed > MAX_CAPTURES then
				return "too many captures"
			end
			table.insert(open, #closed)
			i += 1
		elseif c == ")" then
			local index = table.remove(open)
			if index == nil then
				return "invalid pattern capture"
			end
			closed[index] = true
			i += 1
		elseif c == "[" then
			local after = setEnd(pattern, i + 1)
			if after == nil then
				return "missing ']'"
			end
			i = after
		elseif c == "%" then
			if i == n then
				return "ends with '%'"
			end
			local nextChar = string.sub(pattern, i + 1, i + 1)
			if nextChar == "b" then
				if i + 3 > n then
					return "missing arguments to '%b'"
				end
				i += 4
			elseif nextChar == "f" then
				if string.sub(pattern, i + 2, i + 2) ~= "[" then
					return "missing '[' after '%f'"
				end
				local after = setEnd(pattern, i + 3)
				if after == nil then
					return "missing ']'"
				end
				i = after
			elseif string.find(nextChar, "^%d$") then
				if closed[tonumber(nextChar)] ~= true then
					return "invalid capture index %" .. nextChar
				end
				i += 2
			else
				i += 2
			end
		else
			i += 1
		end
	end
	if #open > 0 then
		return "unfinished capture"
	end
	return nil
end

-- ── schema definition check ──────────────────────────────────────────

local function isCount(value)
	return type(value) == "number" and value >= 0 and value % 1 == 0
end

-- The option values validation relies on. A wrong type here would make
-- validation misbehave (a number compared with a string, a boolean
-- concatenated into a message) and a malformed pattern would only fail on
-- the game's value, so the schema is rejected instead.
local function checkOptions(node, path, errors)
	for _, option in ipairs({ "min", "max" }) do
		if node[option] ~= nil and (type(node[option]) ~= "number" or node[option] ~= node[option]) then
			table.insert(errors, ("%s: %s must be a number"):format(path, option))
		end
	end
	for _, option in ipairs({ "minLength", "maxLength", "minItems", "maxItems" }) do
		if node[option] ~= nil and not isCount(node[option]) then
			table.insert(errors, ("%s: %s must be a whole number >= 0"):format(path, option))
		end
	end
	if node.pattern ~= nil then
		if type(node.pattern) ~= "string" then
			table.insert(errors, ("%s: pattern must be text"):format(path))
		else
			local reason = Schema.patternError(node.pattern)
			if reason ~= nil then
				table.insert(errors, ("%s: pattern is not a valid Luau pattern (%s)"):format(path, reason))
			end
		end
	end
	if node.kind == "enum" then
		if type(node.values) ~= "table" or not isArray(node.values) then
			table.insert(errors, ("%s: enum needs a list of text values"):format(path))
		elseif #node.values == 0 then
			table.insert(errors, ("%s: enum needs at least one value"):format(path))
		else
			for _, value in ipairs(node.values) do
				if type(value) ~= "string" then
					table.insert(errors, ("%s: enum values must be text"):format(path))
					break
				end
			end
		end
	end
	if node.check ~= nil then
		local where = if path == "" then "the schema" else path
		if type(node.check) ~= "function" then
			table.insert(errors, ("%s: check must be a function"):format(where))
		elseif type(node.checkDoc) ~= "string" or node.checkDoc == "" then
			table.insert(errors, ("%s: check needs a checkDoc that says its rule"):format(where))
		end
	end
	if node.pinned ~= nil and type(node.pinned) ~= "boolean" then
		table.insert(errors, ("%s: pinned must be true or false"):format(if path == "" then "the schema" else path))
	end
end

-- Validates what the node gives the game when the game leaves it out: its
-- default, with list items and map values filled in from their own
-- defaults, exactly as Config.load merges it. On a group (only reached for
-- an S.optional group, see checkNode) the default is the switch that makes
-- the group present, built by Schema.defaults from its fields' defaults and
-- never from the switch's values: the switch must be `{}`, since values in
-- it would be dropped without a word, and the group it switches on must be
-- valid. In a pcall, because a default the merge cannot copy (a table that
-- contains itself) must become an error in the list, not a throw.
local function checkDefault(node, path, errors)
	local problems = {}
	local ok, err = pcall(function()
		if node.kind == "record" or node.kind == "config" then
			if type(node.default) ~= "table" then
				validateNode(node, node.default, path, problems, {})
			else
				if next(node.default) ~= nil then
					push(problems, path, "an optional group's default only switches it on, its values are not used;"
						.. " give each field its own default and use default = {}")
				end
				validateNode(node, Schema.defaults(node), path, problems, {})
			end
		else
			validateNode(node, Schema.defaults(node), path, problems, {})
		end
	end)
	if not ok then
		table.insert(errors, ("default of %s: cannot be checked (%s)"):format(path, tostring(err)))
		return
	end
	local seen = {}
	for _, problem in ipairs(problems) do
		local line = ("default of %s: %s"):format(problem.path, problem.message)
		if not seen[line] then
			seen[line] = true
			table.insert(errors, line)
		end
	end
end

-- `server` is true under a server-only option: nothing there may carry a
-- default (RT-10). `collection` is true under a list item or a map value:
-- nothing there may be pinned (plan B0), since T.migrate compares a pinned
-- option at one path.
local function checkNode(node, path, errors, topLevel, optional, server, collection)
	if type(node) ~= "table" or type(node.kind) ~= "string" or not KNOWN[node.kind] then
		table.insert(errors, ("%s is not a schema node"):format(path))
		return
	end
	if node.kind == "optional" then
		return checkNode(node.inner, path, errors, topLevel, true, server, collection)
	end
	local kind = node.kind
	local before = #errors
	if node.server == true and not topLevel then
		table.insert(errors, ("%s: server = true is only allowed on top-level options"):format(path))
	end
	if node.pinned == true and collection then
		table.insert(errors, ("%s: pinned is only allowed outside lists and maps"):format(path))
	elseif node.pinned == true and path == "" then
		-- The root has no describe row, so T.migrate would never see the flag.
		table.insert(errors, "the schema: pinned is only allowed on options")
	end
	local serverOnly = server == true or (topLevel and node.server == true)
	checkOptions(node, path, errors)
	if kind == "list" then
		checkNode(node.item, path .. "[]", errors, false, nil, serverOnly, true)
	elseif kind == "map" then
		checkNode(node.value, path .. ".<key>", errors, false, nil, serverOnly, true)
	elseif kind == "record" or kind == "config" then
		if type(node.fields) ~= "table" then
			table.insert(errors, ("%s: needs a table of fields"):format(path))
		else
			for _, name in ipairs(sortedKeys(node.fields)) do
				local field = node.fields[name]
				local fieldPath = childPath(path, name)
				local inner = unwrap(field)
				if type(inner) ~= "table" or type(inner.doc) ~= "string" or inner.doc == "" then
					table.insert(errors, ("%s needs a doc"):format(fieldPath))
				end
				checkNode(field, fieldPath, errors, kind == "config", nil, serverOnly, collection)
			end
		end
	end
	if node.default == nil then
		return
	end
	if serverOnly then
		table.insert(errors, ("%s: a server-only option has no default: the Schema reaches every client, and so would its default. Leave it out (S.optional, or required) and set the value in the server Config module")
			:format(path))
		return
	end
	if (kind == "record" or kind == "config") and not optional then
		-- Schema.defaults builds a group from its fields and reads a group's
		-- default only when the group is S.optional, as the switch that makes
		-- it present. Anywhere else the default has no effect at all.
		table.insert(errors, ("%s: default has no effect on a group that is not optional, give each field its own default")
			:format(path == "" and "the schema" or path))
	elseif #errors == before then
		-- Only on a sound node: a bad option or child is exactly what would
		-- make validating the default throw or report noise.
		checkDefault(node, path, errors)
	end
end

function Schema.check(root)
	if type(root) ~= "table" or root.kind ~= "config" then
		return { "the schema must be S.config({...})" }
	end
	local errors = {}
	checkNode(root, "", errors, false)
	return errors
end

-- ── describe (reference documentation) ───────────────────────────────

local function typeName(node)
	local kind = node.kind
	if kind == "number" then
		local parts = { node.integer and "whole number" or "number" }
		if node.min ~= nil then table.insert(parts, ">= " .. tostring(node.min)) end
		if node.max ~= nil then table.insert(parts, "<= " .. tostring(node.max)) end
		return table.concat(parts, ", ")
	elseif kind == "string" then
		return "text"
	elseif kind == "boolean" then
		return "true/false"
	elseif kind == "enum" then
		return "one of " .. table.concat(node.values or {}, " | ")
	elseif kind == "id" then
		return ID_NAMES[node.idKind] or "an id"
	elseif kind == "dataPath" then
		return "data path (e.g. Stats.Cash)"
	elseif kind == "utcDate" then
		return "UTC date YYYY-MM-DD"
	elseif kind == "color" then
		return "color (Color3)"
	elseif kind == "tree" then
		return "tree (text keys; numbers, text, true/false or nested tables)"
	elseif kind == "record" then
		return "group"
	end
	return kind
end

-- LuaText's number rule: a whole number as %d, else the shortest %.<p>g
-- that reads back exactly (a float32 channel needs up to 17 digits).
local function exactNumber(value)
	if value == math.floor(value) and math.abs(value) < 2 ^ 53 then
		return ("%d"):format(value)
	end
	for precision = 1, 17 do
		local text = ("%." .. precision .. "g"):format(value)
		if tonumber(text) == value then
			return text
		end
	end
	return ("%.17g"):format(value)
end

local function show(value)
	if value == nil then
		return ""
	end
	if typeof(value) == "Color3" then
		-- LuaText's rule (plan B0, planning decision 9): fromRGB only when
		-- every channel is exactly a whole 1/255 step as fromRGB makes it (a
		-- float32), else Color3.new with each channel's exact value.
		local channels, steps = { value.R, value.G, value.B }, {}
		for index, channel in ipairs(channels) do
			local step = math.round(channel * 255)
			if steps ~= nil and step >= 0 and step <= 255 and string.unpack("<f", string.pack("<f", step / 255)) == channel then
				steps[index] = step
			else
				steps = nil
			end
		end
		if steps ~= nil then
			return ("Color3.fromRGB(%d, %d, %d)"):format(steps[1], steps[2], steps[3])
		end
		return ("Color3.new(%s, %s, %s)"):format(exactNumber(channels[1]), exactNumber(channels[2]), exactNumber(channels[3]))
	end
	if type(value) == "string" then
		return ("%q"):format(value)
	end
	if type(value) == "table" then
		local count = 0
		for _ in pairs(value) do
			count += 1
		end
		return count == 0 and "{}" or ("{%d entries}"):format(count)
	end
	return tostring(value)
end

-- The limits a reader needs that `typeName` does not already say: text
-- length and pattern, and list sizes. Worded like the validation messages.
local function plural(count, one, many)
	return ("%d %s"):format(count, count == 1 and one or many)
end

local function constraintsOf(node)
	local out = {}
	if node.kind == "string" then
		if node.minLength == 1 then
			table.insert(out, "not empty")
		elseif node.minLength ~= nil then
			table.insert(out, "at least " .. plural(node.minLength, "character", "characters"))
		end
		if node.maxLength ~= nil then
			table.insert(out, "at most " .. plural(node.maxLength, "character", "characters"))
		end
		if node.pattern ~= nil then
			table.insert(out, "matches " .. tostring(node.patternDoc or node.pattern))
		end
	elseif node.kind == "list" then
		if node.minItems ~= nil then
			table.insert(out, "at least " .. plural(node.minItems, "entry", "entries"))
		end
		if node.maxItems ~= nil then
			table.insert(out, "at most " .. plural(node.maxItems, "entry", "entries"))
		end
	end
	if type(node.checkDoc) == "string" and node.checkDoc ~= "" then
		table.insert(out, node.checkDoc)
	end
	return out
end

-- describe(root) -> rows, one per option, in path order:
--   { path, type, default, doc, server, required,     -- display fields
--     optional, value, example, constraints,          -- for templates and Tools
--     pinned }                                        -- plan B0, for T.migrate
-- `default` is the display text the reference prints. `value` is the
-- default itself, a fresh copy, with the defaults of nested fields filled in
-- (Schema.defaults), nil when there is none. `example` is a copy of the
-- option's `example`. `constraints` lists the limits `type` does not say.
function Schema.describe(root)
	local rows = {}
	-- A list item or a map value is a structural node, not required to carry
	-- its own doc (Schema.check does not demand one there). Its row falls
	-- back to the list/map's own doc; an explicit doc on the item still wins.
	local function walk(node, path, server, parentDoc)
		local optional = node.kind == "optional"
		local n = unwrap(node)
		local isServer = server or n.server == true
		if path ~= "" then
			local doc = n.doc
			if doc == nil or doc == "" then
				doc = parentDoc
			end
			table.insert(rows, {
				path = path,
				type = typeName(n),
				default = show(n.default),
				doc = doc or "",
				server = isServer,
				required = (not optional) and n.default == nil and SCALAR[n.kind] == true,
				optional = optional,
				value = Schema.defaults(node),
				example = copy(n.example),
				constraints = constraintsOf(n),
				pinned = n.pinned == true,
			})
		end
		if n.kind == "record" or n.kind == "config" then
			for _, name in ipairs(sortedKeys(n.fields)) do
				walk(n.fields[name], childPath(path, name), isServer, nil)
			end
		elseif n.kind == "list" then
			walk(n.item, path .. "[]", isServer, n.doc)
		elseif n.kind == "map" then
			walk(n.value, path .. ".<key>", isServer, n.doc)
		end
	end
	walk(root, "", false, nil)
	return rows
end

-- ── freeze ───────────────────────────────────────────────────────────

function Schema.freeze(value)
	if type(value) ~= "table" or table.isfrozen(value) then
		return value
	end
	for _, item in pairs(value) do
		Schema.freeze(item)
	end
	return table.freeze(value)
end

return Schema
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="ModuleScript" referent="12">
          <Properties>
            <string name="Name">Signal</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Minimal signal (connect/fire/once/wait). Handlers run via task.spawn so a
-- slow or erroring handler never blocks the firer.
local Signal = {}
Signal.__index = Signal

local Connection = {}
Connection.__index = Connection

function Connection:Disconnect()
	if not self.Connected then return end
	self.Connected = false
	local conns = self._signal._connections
	for i, c in ipairs(conns) do
		if c == self then table.remove(conns, i) break end
	end
end

function Signal.new()
	return setmetatable({ _connections = {} }, Signal)
end

function Signal:Connect(fn)
	local conn = setmetatable({ _signal = self, _fn = fn, Connected = true }, Connection)
	table.insert(self._connections, conn)
	return conn
end

function Signal:Once(fn)
	local conn
	conn = self:Connect(function(...)
		conn:Disconnect()
		fn(...)
	end)
	return conn
end

function Signal:Fire(...)
	for _, conn in ipairs(table.clone(self._connections)) do
		if conn.Connected then
			task.spawn(conn._fn, ...)
		end
	end
end

function Signal:Wait()
	local thread = coroutine.running()
	self:Once(function(...)
		task.spawn(thread, ...)
	end)
	return coroutine.yield()
end

function Signal:Destroy()
	for _, conn in ipairs(table.clone(self._connections)) do
		conn:Disconnect()
	end
end

return Signal
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
        <Item class="Folder" referent="13">
          <Properties>
            <string name="Name">UI</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <Color3 name="IconTint">
              <R>0</R>
              <G>0</G>
              <B>0</B>
            </Color3>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
          <Item class="ModuleScript" referent="14">
            <Properties>
              <string name="Name">MenuSystem</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[-- Runtime menu system. Replaces v1's install-time MenusGUI merge
-- (GUIManager + ToggleListener + GUIBridge) with runtime registration.
local CollectionService = game:GetService("CollectionService")
local ContentProvider = game:GetService("ContentProvider")
local TweenService = game:GetService("TweenService")
local Players = game:GetService("Players")

local SFX = require(script.Parent.Parent.SFX)
local buildShell = require(script.Parent.Shell)
local PanelAnimations = require(script.Parent.PanelAnimations)

local TOOLTIP_OFFSET_X = 15
local TOOLTIP_OFFSET_Y = 78
local TOOLTIP_THROTTLE_INTERVAL = 0.016
local ICON_HOVER_SCALE = UDim2.new(1.05, 0, 1.05, 0)
local ICON_DEFAULT_SCALE = UDim2.new(1, 0, 1, 0)
local ICON_HOVER_TWEEN_TIME = 0.1
local ICON_LEAVE_TWEEN_TIME = 0.3
local TOGGLE_COLOR_ON = Color3.fromRGB(85, 255, 0)
local TOGGLE_COLOR_OFF = Color3.fromRGB(255, 50, 50)

-- AdoptPriority is buyer-editable (Studio attribute), so it may arrive as a
-- non-numeric type (e.g. a String) instead of the expected number. Both call
-- sites coerce through this helper rather than trusting the raw attribute -
-- a non-numeric value is treated as priority 0 instead of crashing the
-- table.sort comparator / the <= comparison in _adoptCandidate.
local function readAdoptPriority(inst)
	return tonumber(inst:GetAttribute("AdoptPriority")) or 0
end

-- Deterministic adoption order: highest AdoptPriority first, ties broken by
-- original GetTagged() encounter order (not Luau's unstable table.sort) so a
-- lower-priority duplicate is NEVER reparented during a sweep - it always
-- loses to a higher-priority sibling already processed first, regardless of
-- CollectionService's return order.
local function sortByAdoptPriority(list)
	local decorated = {}
	for i, inst in ipairs(list) do
		decorated[i] = { inst = inst, priority = readAdoptPriority(inst), index = i }
	end
	table.sort(decorated, function(a, b)
		if a.priority ~= b.priority then
			return a.priority > b.priority
		end
		return a.index < b.index
	end)
	local out = {}
	for i, d in ipairs(decorated) do
		out[i] = d.inst
	end
	return out
end

-- Async (task.spawn) image warm-up shared by both panel-acquisition paths:
-- registerPanel's clone (below) and the panel branch of adoption
-- (_adoptCandidate, "parity restoration" fix - adopted panels used to skip
-- this entirely, causing first-open texture pop-in for every StarterGui-
-- shipped panel post-edit-time-GUI-migration). Interactables are NOT
-- preloaded (registerPanel never did for addInteractable's clones either -
-- this only restores parity with registerPanel's own existing behavior, not
-- a new scope).
local function preloadPanelImages(panel)
	task.spawn(function()
		local images = {}
		for _, desc in ipairs(panel:GetDescendants()) do
			if desc:IsA("ImageLabel") or desc:IsA("ImageButton") then
				table.insert(images, desc)
			end
		end
		if #images > 0 then
			ContentProvider:PreloadAsync(images)
		end
	end)
end

local MenuSystem = {}
MenuSystem.__index = MenuSystem

function MenuSystem.new(playerGui, opts)
	local self = setmetatable({}, MenuSystem)
	self._playerGui = playerGui
	-- 3.0: the Kernel's piece runtime (UI/Pieces.lua). When present, every
	-- adoption candidate is offered to it first; nil keeps 2.x behavior.
	self._pieces = opts and opts.pieces or nil
	self._mouse = Players.LocalPlayer:GetMouse()
	self.gui = buildShell(playerGui)
	self._menus = self.gui.Menus
	self._interactables = self.gui.Interactables.Container
	self._tooltip = self.gui.Tooltip
	self._handlers = {}
	self._panels = {}
	self._panelPriority = {}
	self._panelScrollers = {}
	self._interactableRegistry = {}
	self._interactablePriority = {}
	self._animations = {}
	self._wired = {}
	self._toggled = {}

	for name, fn in pairs(PanelAnimations) do
		self._animations[name] = fn
	end

	for _, desc in ipairs(self.gui:GetDescendants()) do
		self:_wireDescendant(desc)
	end
	self.gui.DescendantAdded:Connect(function(desc)
		self:_wireDescendant(desc)
	end)

	for _, button in ipairs(CollectionService:GetTagged("UI_Toggle")) do
		self:_wireToggle(button)
	end
	CollectionService:GetInstanceAddedSignal("UI_Toggle"):Connect(function(button)
		self:_wireToggle(button)
	end)

	-- Edit-time GUI adoption (StarterGui-shipped panels/interactables). Must
	-- run after the shell + wiring above exist so reparenting into Menus /
	-- Interactables.Container flows through the DescendantAdded wiring path
	-- automatically (no separate wiring code needed for adopted instances).
	-- self:_safeAdopt pcall-wraps each candidate: MenuSystem.new runs BEFORE
	-- Loader.boot in KernelClient, so an uncaught error here would take down
	-- the whole client ecosystem, not just adoption - one bad tag must never
	-- do that.
	for _, inst in ipairs(sortByAdoptPriority(CollectionService:GetTagged("UI_Panel"))) do
		self:_safeAdopt(inst, "Panel")
	end
	CollectionService:GetInstanceAddedSignal("UI_Panel"):Connect(function(inst)
		self:_safeAdopt(inst, "Panel")
	end)

	for _, inst in ipairs(sortByAdoptPriority(CollectionService:GetTagged("UI_Interactable"))) do
		self:_safeAdopt(inst, "Interactable")
	end
	CollectionService:GetInstanceAddedSignal("UI_Interactable"):Connect(function(inst)
		self:_safeAdopt(inst, "Interactable")
	end)

	return self
end

-- ── handlers ─────────────────────────────────────────────────────────

function MenuSystem:registerHandlers(handlers)
	for action, fn in pairs(handlers) do
		self._handlers[action] = fn
	end
end

function MenuSystem:dispatch(action, button)
	local fn = self._handlers[action]
	if fn then
		fn(button)
	else
		warn("[RBLXE UI] No handler registered for action:", action)
	end
end

function MenuSystem:registerAnimation(name, fn)
	self._animations[name] = fn
end

-- ── panels ───────────────────────────────────────────────────────────

function MenuSystem:registerPanel(template)
	local panel = template:Clone()
	panel.Visible = false
	panel.Parent = self._menus
	self._panels[panel.Name] = panel
	local scrollers = {}
	for _, desc in ipairs(panel:GetDescendants()) do
		if desc:IsA("ScrollingFrame") then
			table.insert(scrollers, desc)
		end
	end
	self._panelScrollers[panel.Name] = scrollers
	preloadPanelImages(panel)
	return panel
end

function MenuSystem:getPanel(name)
	return self._panels[name]
end

--- The HUD button that actually opens `panelName` - the one this system
--- REGISTERED, not merely one that carries the attribute.
---
--- Packs need this to put a notification badge on their own button, and until
--- 2026-08-25 every one of them scanned the shell for the first GuiButton with
--- a matching `TargetPanel`. That is wrong whenever two packs ship a fallback
--- button for the same panel: the loser of the priority contest is hidden but
--- LEFT IN THE CONTAINER when it was adopted before the winner arrived (see
--- `_adoptCandidate`'s "deposed" branch), so the scan could - and did, for
--- Easy Pet System's Pets button - return an invisible button and light a
--- badge nobody could see. Which of the two a scan hits depends on sweep
--- order, so the packs that appeared to work were only lucky.
function MenuSystem:getInteractable(panelName)
	return self._interactableRegistry["TogglePanel:" .. tostring(panelName)]
end

--- A 3.0 interface piece, already resolved by the Kernel: the game's Interface
--- override when it satisfies its contract, otherwise the pack's default.
--- `pieceId` is "<PackId>.<Name>" (packs use ctx.getPiece("<Name>")). Yields
--- up to `timeout` seconds (default 10) for it to reach PlayerGui. A Panel or
--- HudButton piece (tagged UI_Panel / UI_Interactable) is only useful once
--- this menu adopted it; if it did not, the piece is still returned but a
--- warning says why the menu cannot open it, instead of failing silently.
function MenuSystem:getPiece(pieceId, timeout)
	if self._pieces == nil then
		return nil
	end
	local piece = self._pieces:get(pieceId, timeout)
	if piece ~= nil then
		local tag = (CollectionService:HasTag(piece, "UI_Panel") and "UI_Panel")
			or (CollectionService:HasTag(piece, "UI_Interactable") and "UI_Interactable")
			or nil
		-- M-d: the kind in the server's decision marks a menu piece even when
		-- it lacks its tag (a default that fails its contract).
		local kind = if self._pieces.kindOf ~= nil then self._pieces:kindOf(pieceId) else nil
		local menuPiece = tag ~= nil or kind == "Panel" or kind == "HudButton"
		if menuPiece and not self:_holds(piece) then
			-- A piece that has just arrived is adopted from its own tag signal:
			-- give that one frame before warning.
			task.wait()
			if not self:_holds(piece) then
				warn(("[RBLXE] UI: piece %s (%s) was not adopted by the menu; nothing can open it"):format(pieceId, tag or kind))
			end
		end
	end
	return piece
end

-- Whether `inst` holds a registry slot (an adopted or registered panel or
-- interactable), by identity.
function MenuSystem:_holds(inst)
	for _, registry in ipairs({ self._panels, self._interactableRegistry }) do
		for _, registered in pairs(registry) do
			if registered == inst then
				return true
			end
		end
	end
	return false
end

function MenuSystem:openPanel(name)
	local menu = self._panels[name]
	if not menu or menu.Visible then return end
	SFX:Play("Press")
	menu.Visible = true
	local animFn = self._animations[menu:GetAttribute("Animation") or "Bounce"]
	if animFn then animFn(menu) end
	for _, sf in ipairs(self._panelScrollers[name] or {}) do
		sf.CanvasPosition = Vector2.zero
	end
	if menu:GetAttribute("Exclusive") ~= false then
		for otherName, otherMenu in pairs(self._panels) do
			if otherName ~= name and otherMenu.Visible and otherMenu:GetAttribute("Exclusive") ~= false then
				otherMenu.Visible = false
			end
		end
	end
end

function MenuSystem:closePanel(name)
	local menu = self._panels[name]
	if menu then menu.Visible = false end
end

function MenuSystem:togglePanel(name)
	local menu = self._panels[name]
	if not menu then return end
	if menu.Visible then
		SFX:Play("Press")
		menu.Visible = false
	else
		self:openPanel(name)
	end
end

function MenuSystem:addInteractable(template)
	local button = template:Clone()
	button.Parent = self._interactables
	return button
end

-- ── adoption (edit-time GUI: StarterGui-shipped panels/interactables) ──

-- interactableKey(inst) -> the identity two packs' HUD buttons are deduped
-- by. A button that toggles a panel IS that panel's button, whatever the
-- instance happens to be called, so the key is the panel it opens.
--
-- It used to be `inst.Name`, which only ever worked by coincidence: General
-- UI Kit and Easy Pet System both shipped a fallback "Shop" button and both
-- happened to name it after the panel. Renaming General UI Kit's buttons to
-- "Shop Button" etc. (2026-08-21) broke that coincidence instantly - the two
-- stopped colliding, both got adopted, and the HUD would have shown two Shop
-- buttons side by side, each opening the same panel. Keying off what the
-- button DOES cannot be broken by a rename.
--
-- Anything that is not a panel toggle (a pack's own custom Action, or a
-- decorative interactable with none) falls back to the name: there is
-- nothing better to compare, and two of those are not obviously duplicates.
local function interactableKey(inst)
	if inst:GetAttribute("Action") == "TogglePanel" then
		local target = inst:GetAttribute("TargetPanel")
		if type(target) == "string" and target ~= "" then
			return "TogglePanel:" .. target
		end
	end
	return inst.Name
end

local ADOPT_KIND = {
	Panel = { tag = "UI_Panel", container = "_menus", registry = "_panels", priorities = "_panelPriority" },
	Interactable = { tag = "UI_Interactable", container = "_interactables", registry = "_interactableRegistry", priorities = "_interactablePriority" },
}

-- Entry point for both the sweep (GetTagged) and late-arrival
-- (GetInstanceAddedSignal) paths. Exposed (not local-only) so specs can
-- drive it directly where there is no natural way to simulate a scenario
-- through the tag-add signal (e.g. reentrancy guard).
function MenuSystem:_adoptCandidate(inst, kind)
	local cfg = ADOPT_KIND[kind]
	if not cfg then return end
	-- A UI_Panel/UI_Interactable tag on a non-GuiObject (Folder, ScreenGui,
	-- UIStroke, ...) is not a valid candidate - bail before touching any
	-- GuiObject-only property (Visible, below) that would error on it.
	if not inst:IsA("GuiObject") then return end
	-- Only adopt from the local player's own PlayerGui tree, and never
	-- re-adopt something already living inside our own shell (avoids
	-- re-registration loops for anything CollectionService reports again).
	if not inst:IsDescendantOf(self._playerGui) or inst:IsDescendantOf(self.gui) then
		return
	end

	-- 3.0 pieces: a copy the Kernel did not choose (the default behind a valid
	-- Interface override, or the reverse, or a clone a pack made) is never
	-- adopted. Instances without RBLXE_Piece are always admitted, so 2.x GUIs
	-- keep the priority path below.
	if self._pieces ~= nil and not self._pieces:admit(inst) then
		return
	end

	local registry = self[cfg.registry]
	local priorities = self[cfg.priorities]
	local name = (kind == "Panel" and inst:GetAttribute("PanelId")) or interactableKey(inst)
	local priority = readAdoptPriority(inst)
	local existingPriority = priorities[name]
	local incumbent = registry[name]
	local chosen = self._pieces ~= nil and self._pieces:chose(inst)

	if chosen then
		-- The Kernel already decided this piece: it takes the slot whatever
		-- the AdoptPriority of a 2.x copy, which is deposed (hidden) instead.
		-- Two chosen pieces on one key is a declaration conflict: the first
		-- keeps the slot and both are named.
		local pieceId = inst:GetAttribute("RBLXE_Piece")
		if incumbent ~= nil and incumbent ~= inst and self._pieces:chose(incumbent) then
			inst.Visible = false
			warn(("[RBLXE] UI: pieces %s and %s both use %s '%s'; %s keeps it, %s is left unadopted")
				:format(tostring(incumbent:GetAttribute("RBLXE_Piece")), tostring(pieceId), cfg.tag, tostring(name),
					tostring(incumbent:GetAttribute("RBLXE_Piece")), tostring(pieceId)))
			return
		end
		if incumbent ~= nil and incumbent ~= inst then
			warn(("[RBLXE] UI: %s '%s' %s deposed by the 3.0 piece %s")
				:format(cfg.tag, tostring(name), incumbent:GetFullName(), tostring(pieceId)))
		end
		priority = math.huge
	elseif incumbent ~= nil and self._pieces ~= nil and self._pieces:chose(incumbent) then
		-- A 2.x copy arriving after the piece: the slot stays with the piece.
		inst.Visible = false
		warn(("[RBLXE] UI: %s '%s' %s left unadopted: the slot belongs to the 3.0 piece %s")
			:format(cfg.tag, tostring(name), inst:GetFullName(), tostring(incumbent:GetAttribute("RBLXE_Piece"))))
		return
	elseif existingPriority ~= nil and priority <= existingPriority then
		-- Loses to the incumbent (strictly lower, or a tie): left in place,
		-- unadopted, hidden so a dangling duplicate is never visible/clickable.
		inst.Visible = false
		if incumbent ~= nil and incumbent.Parent == nil then
			warn(("[RBLXE] duplicate %s '%s' left unadopted (priority): the incumbent was destroyed"):format(cfg.tag, name))
		else
			warn(("[RBLXE] duplicate %s '%s' left unadopted (priority)"):format(cfg.tag, name))
		end
		return
	end

	-- A higher-priority late arrival swaps the registration: the previously
	-- registered instance (if any) is deposed - hide it so it doesn't stay
	-- visible/reachable (an open panel, or a still-clickable interactable)
	-- after losing its registry slot, symmetric with the sweep-loser path.
	local previous = registry[name]
	if previous and previous ~= inst then
		previous.Visible = false
	end

	inst.Parent = self[cfg.container]
	if kind == "Panel" then
		inst.Visible = false -- panels default closed; interactables stay visible
	end
	registry[name] = inst
	priorities[name] = priority

	if kind == "Panel" then
		local scrollers = {}
		for _, desc in ipairs(inst:GetDescendants()) do
			if desc:IsA("ScrollingFrame") then
				table.insert(scrollers, desc)
			end
		end
		self._panelScrollers[name] = scrollers
		-- Parity restoration (M3 review fix): registerPanel always warmed up
		-- its clone's images; adopted panels must get the identical treatment
		-- - otherwise every StarterGui-shipped panel (GUK's 13, EPS's own)
		-- loses this warm-up entirely post edit-time-GUI-migration, causing
		-- first-open texture pop-in that registerPanel-based panels never had.
		preloadPanelImages(inst)
	end
end

-- Safety net around _adoptCandidate: MenuSystem.new runs before Loader.boot,
-- so any uncaught error here would kill client boot entirely. A malformed
-- candidate (or anything else unexpected) is logged and skipped instead.
function MenuSystem:_safeAdopt(inst, kind)
	local ok, err = pcall(self._adoptCandidate, self, inst, kind)
	if not ok then
		warn(("[RBLXE] adoption failed for '%s': %s"):format(inst.Name, tostring(err)))
	end
end

function MenuSystem:_findAncestorPanel(instance)
	local current = instance.Parent
	while current and current ~= self.gui do
		-- Identity lookup, not a Name-keyed probe: adopted panels register
		-- under their PanelId attribute, which may differ from the
		-- instance's own Name - self._panels[current.Name] would miss those.
		for _, panel in pairs(self._panels) do
			if panel == current then
				return current
			end
		end
		current = current.Parent
	end
	return nil
end

-- Action routing. Real clicks call this from _wireButton; tests call it
-- directly because Activated cannot be fired programmatically.
function MenuSystem:_onButtonActivated(button)
	local action = button:GetAttribute("Action")
	if not action or action == "" then return end
	if action == "TogglePanel" then
		self:togglePanel(button:GetAttribute("TargetPanel") or "")
	elseif action == "ClosePanel" then
		local target = button:GetAttribute("TargetPanel") or ""
		if target ~= "" then
			self:closePanel(target)
		else
			local ancestor = self:_findAncestorPanel(button)
			if ancestor then ancestor.Visible = false end
		end
	else
		self:dispatch(action, button)
	end
end

-- ── wiring (Task 8 fills these in) ───────────────────────────────────

function MenuSystem:_wireDescendant(desc)
	if desc:IsA("GuiButton") then
		self:_wireButton(desc)
	elseif desc:IsA("GuiObject") then
		self:_wireDecoration(desc)
	end
end

function MenuSystem:_wireButton(button)
	if self._wired[button] then return end
	self._wired[button] = true
	if CollectionService:HasTag(button, "UI_Toggle") then return end
	-- A blocker is a GuiButton only so that it SINKS input - the invisible
	-- full-screen sheet a modal panel puts behind itself so clicks never
	-- reach what it covers. It is not something the player presses, so it
	-- gets no press sound, no hover sound, no icon tween and no tooltip.
	-- Reported by the user against Roulette System's Spin: "cada vez que
	-- clico el fondo del menu Spin suena el SFX de click". Declared with a
	-- tag rather than inferred: 100 GuiButtons across the shipped v2 assets
	-- carry neither a tag nor an Action (Teleport zones, Claim buttons,
	-- Equip/Merge/Delete, the music player's Next/Mute - all wired by pack
	-- code and all of them SHOULD click), so there is no property of a
	-- blocker to detect. It still sinks input exactly as before: absorbing
	-- clicks is what a GuiButton does, not something this wiring conferred.
	if CollectionService:HasTag(button, "UI_Blocker") then return end

	button.Activated:Connect(function()
		SFX:Play(button:GetAttribute("BuySound") and "Buy_1" or "Press")
		self:_onButtonActivated(button)
	end)

	local icon = button:FindFirstChild("Icon")
	button.MouseEnter:Connect(function()
		SFX:Play("Hover")
		if icon then
			icon:TweenSize(ICON_HOVER_SCALE, Enum.EasingDirection.Out, Enum.EasingStyle.Quint, ICON_HOVER_TWEEN_TIME, true)
		end
		if button:GetAttribute("ShowTooltip") then
			self._tooltip.Visible = true
			self._tooltip.ButtonName.Text = button:GetAttribute("TooltipText") or button.Name
		end
	end)
	local lastTooltipMove = 0
	button.MouseMoved:Connect(function()
		if button:GetAttribute("ShowTooltip") then
			local now = tick()
			if now - lastTooltipMove < TOOLTIP_THROTTLE_INTERVAL then return end
			lastTooltipMove = now
			self._tooltip.Position = UDim2.fromOffset(
				self._mouse.X + TOOLTIP_OFFSET_X, self._mouse.Y + TOOLTIP_OFFSET_Y)
		end
	end)
	button.MouseLeave:Connect(function()
		if icon then
			icon:TweenSize(ICON_DEFAULT_SCALE, Enum.EasingDirection.Out, Enum.EasingStyle.Quint, ICON_LEAVE_TWEEN_TIME, true)
		end
		if button:GetAttribute("ShowTooltip") then
			self._tooltip.Visible = false
		end
	end)
end

function MenuSystem:_wireDecoration(element)
	if self._wired[element] then return end
	local animation = element:GetAttribute("Animation")
	if not animation then return end
	if element.Parent == self._menus then return end -- panels use Animation for their open-anim
	self._wired[element] = true
	if animation == "Rotate" then
		local speed = element:GetAttribute("Speed") or 15
		TweenService:Create(element,
			TweenInfo.new(speed, Enum.EasingStyle.Linear, Enum.EasingDirection.Out, -1),
			{ Rotation = 360 }):Play()
	elseif animation == "HoverBob" then
		local basePos = element.Position
		element.MouseEnter:Connect(function()
			element:TweenPosition(basePos - UDim2.fromScale(0, 0.03),
				Enum.EasingDirection.Out, Enum.EasingStyle.Quint, 0.2, true)
		end)
		element.MouseLeave:Connect(function()
			element:TweenPosition(basePos,
				Enum.EasingDirection.Out, Enum.EasingStyle.Quint, 0.2, true)
		end)
	end
end

function MenuSystem:_wireToggle(button)
	if not button:IsA("GuiButton") then return end
	if not button:IsDescendantOf(self._playerGui) then return end -- ignore RS/asset templates
	if self._toggled[button] then return end
	local state = { isEnabled = true }
	self._toggled[button] = state
	local function setVisual()
		button.BackgroundColor3 = state.isEnabled and TOGGLE_COLOR_ON or TOGGLE_COLOR_OFF
		local status = button:FindFirstChild("Status")
		if status then status.Text = state.isEnabled and "ON" or "OFF" end
	end
	setVisual()
	button.MouseButton1Click:Connect(function()
		state.isEnabled = not state.isEnabled
		setVisual()
		local action = button:GetAttribute("Action")
		if action then self:dispatch(action, button) end
	end)
end

return MenuSystem
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="ModuleScript" referent="15">
            <Properties>
              <string name="Name">PanelAnimations</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[-- PanelAnimations loader
-- Each child ModuleScript is an animation: its name maps to the Animation
-- attribute on UI_Panel, and it must return function(menu: GuiObject).
local Animations = {}

for _, child in ipairs(script:GetChildren()) do
	if child:IsA("ModuleScript") then
		local ok, fn = pcall(require, child)
		if ok and type(fn) == "function" then
			Animations[child.Name] = fn
		end
	end
end

return Animations
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
            <Item class="ModuleScript" referent="16">
              <Properties>
                <string name="Name">Bounce</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Bounce animation: drops from slightly above with Back easing and a small random rotation.
--
-- Works on ANY GuiObject. It used to bail out on anything that was not a
-- CanvasGroup - a guard with nothing behind it, since the animation only ever
-- touches Position and Rotation and never GroupTransparency. Two of General
-- UI Kit's thirteen shipped panels are plain Frames (TradeRequest, Spin), and
-- both ask for Bounce, so both opened with a hard cut and no animation at all
-- while every CanvasGroup panel bounced. Found 2026-08-21 via the plugin's
-- new MENUS Preview button; the guard is removed rather than the panels
-- converted, because a CanvasGroup rasterizes its descendants into a canvas
-- its own size and both panels have content that deliberately overhangs
-- (TradeRequest's Icon at x=-0.07/y=-0.22, Spin's CoinsEffect spawn line at
-- y=-0.1) - converting them would have cropped it.
local TweenService = game:GetService("TweenService")

local DURATION   = 0.5
local OFFSET_Y   = 0.02  -- how far above the resting position the panel starts

return function(menu: GuiObject)
	local origPos = menu.Position
	menu.Position = UDim2.new(origPos.X.Scale, origPos.X.Offset, origPos.Y.Scale - OFFSET_Y, origPos.Y.Offset)
	menu.Rotation = math.random(2) == 1 and 1 or -1

	menu:TweenPosition(
		origPos,
		Enum.EasingDirection.Out, Enum.EasingStyle.Back, DURATION, true
	)
	TweenService:Create(
		menu,
		TweenInfo.new(DURATION, Enum.EasingStyle.Quint, Enum.EasingDirection.Out),
		{ Rotation = 0 }
	):Play()
end
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
          </Item>
          <Item class="ModuleScript" referent="17">
            <Properties>
              <string name="Name">Pieces</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[-- Pieces.lua - interface pieces (RBLX Essentials 3.0).
--
-- A pack declares the pieces of interface it drives in `Packs/<PackId>/Pieces`
-- (see Contracts.lua). Each piece has one DEFAULT copy, shipped by the pack
-- under StarterGui.RBLXEssentials.<PackId>, and may have one OVERRIDE, owned
-- by the game, under StarterGui.RBLXEssentials.Interface (a theme's piece or
-- a fork). Piece roots carry RBLXE_Piece = "<PackId>.<Name>".
--
-- The server decides once, at boot (`plan`), which copy each piece uses: a
-- valid override, else the default. Each decision is published as the
-- relative path of the chosen instance under the RBLXEssentials root (for
-- example "Interface/ThemeGui/Panel" or "Demo/DemoGui/Panel"), together with
-- the path of every other candidate copy the server saw for that id (the
-- refused ones), reaching every client in the RBLXE_PieceWinners attribute
-- (`encodeDecisions`/`decodeDecisions`). The client (`runtime`) admits only
-- the first instance of a piece whose own path under its nearest
-- RBLXEssentials ancestor matches the winner, and retires the copies that
-- arrive at a refused path or as a second copy at the winner path, so no pack
-- ever holds a copy that is later replaced (the 434 failure). Any other
-- instance carrying RBLXE_Piece (a clone a pack makes at runtime: a toast, a
-- billboard per adornee, a registerPanel copy) is not admitted but is left
-- alone: clones belong to the pack that made them.
--
-- The server makes StarterGui.RBLXEssentials survive character respawns
-- before `plan` runs (UI/RootPersistence.lua), so a piece admitted here
-- stays the same instance for the whole session.
--
-- Pure: every Instance, require function and scheduler comes in as an argument.
local Pieces = {}

Pieces.PIECE_ATTRIBUTE = "RBLXE_Piece"
Pieces.SOURCE_ATTRIBUTE = "RBLXE_Source"
Pieces.WINNERS_ATTRIBUTE = "RBLXE_PieceWinners"
Pieces.LEGACY = "legacy"
Pieces.INTERFACE = "Interface"
Pieces.ROOT = "RBLXEssentials"
-- StarterGui.RBLXEssentials.Interface.Custom holds what the 2.1 to 3.0
-- migration kept without managing it (T.migrate: retired panels and
-- buttons). Nothing there is a candidate for any piece, here or in Tools.
Pieces.CUSTOM = "Custom"
-- How long getPiece waits for PlayerGui.RBLXEssentials (it arrives with the
-- first character) before its own timeout starts counting (RT-4).
Pieces.ROOT_WAIT = 120

local function pieceIdOf(inst)
	local id = inst:GetAttribute(Pieces.PIECE_ATTRIBUTE)
	if type(id) == "string" and id ~= "" then
		return id
	end
	return nil
end

local function sortedKeys(t)
	local keys = {}
	for key in pairs(t) do
		table.insert(keys, key)
	end
	table.sort(keys)
	return keys
end

-- ── declarations ─────────────────────────────────────────────────────

-- collectDeclarations(...) -> (declarations, warnings, failures). `failures`
-- maps the id of a pack whose Pieces module errors or is invalid to the
-- reason its boot fails with (RT-6): its pieces can never be resolved, so
-- the Loader fails it instead of letting it drive an interface nobody sees.
function Pieces.collectDeclarations(packsFolder, requireFn, contracts)
	local declarations, warnings, failures = {}, {}, {}
	for _, packFolder in ipairs(packsFolder:GetChildren()) do
		local module = packFolder:FindFirstChild("Pieces")
		if module ~= nil and module:IsA("ModuleScript") then
			local ok, specs = pcall(requireFn, module)
			if not ok then
				local message = ("%s.Pieces errored: %s"):format(packFolder.Name, tostring(specs))
				table.insert(warnings, message)
				failures[packFolder.Name] = "invalid Pieces: " .. message
			else
				local errors = contracts.validateSpecs(packFolder.Name, specs)
				if #errors > 0 then
					for _, message in ipairs(errors) do
						table.insert(warnings, message)
					end
					failures[packFolder.Name] = "invalid Pieces:\n    " .. table.concat(errors, "\n    ")
				else
					declarations[packFolder.Name] = specs
				end
			end
		end
	end
	table.sort(warnings)
	return declarations, warnings, failures
end

-- ── server plan ──────────────────────────────────────────────────────

-- byId keeps the first copy of each id (sorted by full name); all keeps
-- every copy, so the plan can publish the paths of the ones it refuses.
local function index(list, origin, warnings, all)
	table.sort(list, function(a, b)
		return a:GetFullName() < b:GetFullName()
	end)
	local byId = {}
	for _, inst in ipairs(list) do
		local id = pieceIdOf(inst)
		all[id] = all[id] or {}
		table.insert(all[id], inst)
		if byId[id] ~= nil then
			table.insert(warnings, ("%s: more than one %s piece; using %s"):format(id, origin, byId[id]:GetFullName()))
		else
			byId[id] = inst
		end
	end
	return byId
end

-- The attribute that ties each piece kind to MenuSystem: a Panel is
-- registered under its PanelId, a HudButton opens its TargetPanel. An
-- Interface override must keep the default copy's value, or the button that
-- opens the panel (and every pack that asks for it) would miss it.
local IDENTITY = { Panel = "PanelId", HudButton = "TargetPanel" }

local function nonEmptyText(value)
	if type(value) == "string" and value ~= "" then
		return value
	end
	return nil
end

local function quoted(value)
	if type(value) == "string" then
		return ("%q"):format(value)
	end
	return tostring(value)
end

-- The path of `inst` under `root`, as the names of every node strictly
-- between them, joined by "/" (for example "Interface/ThemeGui/Panel").
local function relativePath(inst, root)
	local segments = {}
	local node = inst
	while node ~= nil and node ~= root do
		table.insert(segments, 1, node.Name)
		node = node.Parent
	end
	return table.concat(segments, "/")
end

-- winners maps each declared piece id to the relative path of the instance
-- chosen to satisfy it; a piece with nothing valid to use has no entry.
-- refused maps every id seen under the root, declared or not, to the paths
-- of its other copies (the default behind a valid override, a rejected
-- override, duplicates, copies of an id no pack declares): the client
-- retires exactly those, and nothing else.
function Pieces.plan(args)
	local contracts = args.contracts
	local root = args.root
	local interface = root and root:FindFirstChild(Pieces.INTERFACE)
	local custom = interface and interface:FindFirstChild(Pieces.CUSTOM)
	local defaultList, overrideList = {}, {}
	if root ~= nil then
		for _, inst in ipairs(root:GetDescendants()) do
			if pieceIdOf(inst) ~= nil and not (custom ~= nil and inst:IsDescendantOf(custom)) then
				if interface ~= nil and inst:IsDescendantOf(interface) then
					table.insert(overrideList, inst)
				else
					table.insert(defaultList, inst)
				end
			end
		end
	end

	local warnings, copies = {}, {}
	local defaults = index(defaultList, "default", warnings, copies)
	local overrides = index(overrideList, "Interface", warnings, copies)
	local declared, order, chosen, fromInterface, kinds = {}, {}, {}, {}, {}
	local detail = {}

	-- Stand-ins (Kernel 3.0.1): a piece with standsInFor = "<PackId>.<Name>"
	-- steps aside when that owner piece is declared. It gets no candidate at
	-- all, so its default and every Interface copy land in `refused` below.
	-- An owner of another kind keeps its piece and the stand-in is refused
	-- with a warning. A HudButton that opens a replaced panel is replaced
	-- with it ("a stand-in's opens follows its panel").
	local replaced = {}
	for _, packId in ipairs(sortedKeys(args.declarations)) do
		local specs = args.declarations[packId]
		for _, name in ipairs(sortedKeys(specs)) do
			local spec = specs[name]
			local ownerId = spec.standsInFor
			if type(ownerId) == "string" then
				local ownerPack, ownerName = contracts.splitId(ownerId)
				local ownerSpecs = ownerPack ~= nil and ownerPack ~= packId and args.declarations[ownerPack] or nil
				local owner = ownerSpecs ~= nil and ownerSpecs[ownerName] or nil
				if type(owner) == "table" then
					local id = packId .. "." .. name
					replaced[id] = true
					if owner.kind == spec.kind then
						table.insert(detail, ("%s stands in for %s: replaced (owner installed)"):format(id, ownerId))
					else
						table.insert(warnings, ("%s stands in for %s, a %s: a %s cannot stand in for it, refused")
							:format(id, ownerId, tostring(owner.kind), tostring(spec.kind)))
					end
				end
			end
		end
	end
	local followed = true
	while followed do
		followed = false
		for _, packId in ipairs(sortedKeys(args.declarations)) do
			local specs = args.declarations[packId]
			for _, name in ipairs(sortedKeys(specs)) do
				local id = packId .. "." .. name
				local opens = specs[name].opens
				if not replaced[id] and type(opens) == "string" and replaced[packId .. "." .. opens] then
					replaced[id] = true
					followed = true
					table.insert(detail, ("%s opens %s.%s: refused with its panel"):format(id, packId, opens))
				end
			end
		end
	end

	-- Pass 1: each piece's contract, and an override's identity (PanelId or
	-- TargetPanel) against its default.
	for _, packId in ipairs(sortedKeys(args.declarations)) do
		local specs = args.declarations[packId]
		for _, name in ipairs(sortedKeys(specs)) do
			local spec = specs[name]
			local id = packId .. "." .. name
			declared[id] = { packId = packId, spec = spec }
			if replaced[id] then
				continue
			end
			kinds[id] = spec.kind
			table.insert(order, id)
			local default = defaults[id]
			if default ~= nil then
				local problems = contracts.check(default, spec)
				if #problems > 0 then
					table.insert(warnings, ("%s: default piece does not satisfy its contract: %s"):format(id, contracts.formatProblems(problems)))
				end
			end
			chosen[id] = default
			local override = overrides[id]
			if override ~= nil then
				local reason = nil
				local problems = contracts.check(override, spec)
				if #problems > 0 then
					reason = contracts.formatProblems(problems)
				else
					local attribute = IDENTITY[spec.kind]
					local want = attribute ~= nil and default ~= nil and nonEmptyText(default:GetAttribute(attribute)) or nil
					local got = attribute ~= nil and override:GetAttribute(attribute) or nil
					if want ~= nil and got ~= want then
						reason = ("%s is %s, the default's is %s"):format(attribute, quoted(got), quoted(want))
					end
				end
				if reason == nil then
					chosen[id] = override
					fromInterface[id] = true
				else
					table.insert(warnings, ("%s: Interface piece rejected, using the default: %s"):format(id, reason))
				end
			end
		end
	end

	-- Pass 2: `opens`. The chosen HudButton must target the PanelId of the
	-- chosen copy of the panel it opens, or it would open nothing.
	for _, id in ipairs(order) do
		local entry = declared[id]
		local opens = entry.spec.opens
		local panel = opens ~= nil and chosen[entry.packId .. "." .. opens] or nil
		if panel ~= nil and chosen[id] ~= nil then
			local panelId = panel:GetAttribute("PanelId")
			local function mismatch(button)
				local target = button:GetAttribute("TargetPanel")
				if target ~= panelId then
					return ("TargetPanel is %s but %s.%s has PanelId %s"):format(quoted(target), entry.packId, opens, quoted(panelId))
				end
				return nil
			end
			local reason = mismatch(chosen[id])
			if reason ~= nil and fromInterface[id] then
				table.insert(warnings, ("%s: Interface piece rejected, using the default: %s"):format(id, reason))
				fromInterface[id] = nil
				chosen[id] = defaults[id]
				reason = chosen[id] ~= nil and mismatch(chosen[id]) or nil
			end
			if reason ~= nil then
				table.insert(warnings, ("%s: default piece does not satisfy its contract: %s"):format(id, reason))
			end
		end
	end

	local winners, refused = {}, {}
	local total, interfaceCount = #order, 0
	for _, id in ipairs(order) do
		local inst = chosen[id]
		if inst == nil then
			table.insert(warnings, ("%s: no piece available (no valid Interface piece and no default)"):format(id))
		else
			winners[id] = relativePath(inst, root)
			if fromInterface[id] then
				interfaceCount += 1
				table.insert(detail, ("%s <- Interface (%s)"):format(id, tostring(inst:GetAttribute(Pieces.SOURCE_ATTRIBUTE) or "custom")))
			end
		end
	end
	for _, id in ipairs(sortedKeys(copies)) do
		local seen = {}
		for _, inst in ipairs(copies[id]) do
			local path = relativePath(inst, root)
			if inst ~= chosen[id] and path ~= winners[id] and not seen[path] then
				seen[path] = true
				refused[id] = refused[id] or {}
				table.insert(refused[id], path)
			end
		end
		if refused[id] ~= nil then
			table.sort(refused[id])
		end
	end
	for _, id in ipairs(sortedKeys(overrides)) do
		if declared[id] == nil then
			table.insert(warnings, ("%s: Interface piece ignored, no installed pack declares it (%s)"):format(id, overrides[id]:GetFullName()))
		end
	end
	table.sort(warnings)

	local lines = {}
	if total > 0 then
		table.insert(lines, ("%d pieces: %d from Interface, %d default"):format(total, interfaceCount, total - interfaceCount))
		for _, line in ipairs(detail) do
			table.insert(lines, line)
		end
	end
	return { winners = winners, refused = refused, kinds = kinds, lines = lines, warnings = warnings }
end

-- The RBLXE_PieceWinners value: the plan's winners and refused paths as JSON.
-- `jsonEncode` is HttpService:JSONEncode in the Kernel; the server calls this
-- inside the same pcall as the plan, so a value JSON cannot encode (an
-- instance name that is not valid UTF-8, for example) falls back to LEGACY
-- instead of stopping the server script.
function Pieces.encodeDecisions(plan, jsonEncode)
	return jsonEncode({ winners = plan.winners, refused = plan.refused or {}, kinds = plan.kinds or {} })
end

-- The client side of encodeDecisions. Returns { winners, refused }, or nil
-- when the server sent no usable decision (missing, LEGACY, not JSON, or not
-- the { winners, refused } shape): every piece is then adopted as in 2.x.
-- An empty winners map encodes as "[]" and decodes to an empty table.
function Pieces.decodeDecisions(encoded, jsonDecode)
	if type(encoded) ~= "string" or encoded == Pieces.LEGACY then
		return nil
	end
	local ok, decoded = pcall(jsonDecode, encoded)
	if not ok or type(decoded) ~= "table" or type(decoded.winners) ~= "table" then
		return nil
	end
	local refused = decoded.refused
	if type(refused) ~= "table" then
		refused = {}
	end
	local kinds = decoded.kinds
	if type(kinds) ~= "table" then
		kinds = {}
	end
	return { winners = decoded.winners, refused = refused, kinds = kinds }
end

-- strays(starterGui, root) -> warnings (M-c): every RBLXE_Piece instance in
-- StarterGui outside StarterGui.RBLXEssentials. Nothing resolves or retires
-- it, so it shows on every client as it is. The server says so once at boot
-- (Kernel.server.lua) and T.validate says it in Studio. A clone a pack makes
-- at runtime never reaches StarterGui, so it never warns.
function Pieces.strays(starterGui, root)
	local warnings = {}
	if starterGui == nil then
		return warnings
	end
	for _, inst in ipairs(starterGui:GetDescendants()) do
		local id = pieceIdOf(inst)
		if id ~= nil and not (root ~= nil and (inst == root or inst:IsDescendantOf(root))) then
			table.insert(warnings, ("%s: %s is outside StarterGui.%s: the Kernel never uses it, and it shows on screen as it is")
				:format(id, inst:GetFullName(), Pieces.ROOT))
		end
	end
	table.sort(warnings)
	return warnings
end

-- ── client runtime ───────────────────────────────────────────────────

function Pieces.originOf(inst)
	local node = inst.Parent
	while node ~= nil do
		if node.Name == Pieces.INTERFACE and node.Parent ~= nil and node.Parent.Name == Pieces.ROOT then
			return "Interface"
		end
		node = node.Parent
	end
	return "Default"
end

-- The path of `inst` under its nearest ancestor named Pieces.ROOT
-- ("RBLXEssentials"), matching what the server published in `plan`'s
-- winners. Nil when `inst` has no such ancestor at all.
local function pathUnderRoot(inst)
	local segments = {}
	local node = inst
	while node ~= nil do
		local parent = node.Parent
		if parent == nil then
			return nil
		end
		table.insert(segments, 1, node.Name)
		if parent.Name == Pieces.ROOT then
			return table.concat(segments, "/")
		end
		node = parent
	end
	return nil
end

local Runtime = {}
Runtime.__index = Runtime

-- decisions is what decodeDecisions returns (or a plan result): winners maps
-- a piece id to the relative path (relativePath/pathUnderRoot) of the
-- instance chosen to satisfy it, refused maps an id to the paths of the
-- copies the server refused. decisions == nil means the server sent no
-- decision at all: 2.x adoption for every piece.
function Pieces.runtime(decisions, opts)
	opts = opts or {}
	local self = setmetatable({}, Runtime)
	self._winners = decisions and decisions.winners or nil
	self._refused = {}
	for id, paths in pairs(decisions and decisions.refused or {}) do
		if type(paths) == "table" then
			local set = {}
			for _, path in ipairs(paths) do
				set[path] = true
			end
			self._refused[id] = set
		end
	end
	self._admitted = {}
	self._decided = setmetatable({}, { __mode = "k" })
	self._kinds = decisions and decisions.kinds or {}
	self._noDecision = {}
	-- RT-4: getPiece counts its timeout only once PlayerGui.RBLXEssentials
	-- exists. attach() records the PlayerGui; without one (a spec) the root
	-- counts as arrived.
	self._playerGui = opts.playerGui
	self._rootWait = opts.rootWait or Pieces.ROOT_WAIT
	self._wait = opts.wait or function(seconds)
		return seconds
	end
	self._warn = opts.warn or function() end
	self._defer = opts.defer or function(fn)
		fn()
	end
	return self
end

-- The declared kind of a piece id ("Panel", "HudButton", ...) as the
-- server's decision carries it, or nil. MenuSystem:getPiece warns from it
-- about a menu piece it never adopted, even one that lacks its tag (M-d).
function Runtime:kindOf(pieceId)
	local kind = self._kinds[pieceId]
	return if type(kind) == "string" then kind else nil
end

-- One warning per id the server's decision does not contain (T-G, M5): no
-- installed pack declares it, or no copy of it was usable.
function Runtime:_warnNoDecision(id, where)
	if self._noDecision[id] then
		return
	end
	self._noDecision[id] = true
	self._warn(("[RBLXE] UI: piece %s has no decision from the server (no installed pack declares it, or no copy of it is usable)%s")
		:format(id, if where ~= nil then ("; %s is not used"):format(where) else ""))
end

function Runtime:_retire(inst)
	pcall(function()
		if inst:IsA("GuiObject") then
			inst.Visible = false
		elseif inst:IsA("LayerCollector") then
			inst.Enabled = false
		end
	end)
	-- Deferred: the clone may still be mid-parenting when it is refused.
	self._defer(function()
		inst:Destroy()
	end)
end

-- Decides once per instance (the answer is cached, so a later move into the
-- MenuSystem shell cannot change it) and returns whether it may be used.
-- Only copies competing for the id are retired: one at a path the server
-- refused, or a second one at the winner path. Any other instance carrying
-- RBLXE_Piece (a clone a pack made) is refused but left alone.
function Runtime:admit(inst)
	local cached = self._decided[inst]
	if cached ~= nil then
		return cached
	end
	local id = pieceIdOf(inst)
	local admitted = true
	if id ~= nil then
		if self._winners == nil then
			self._admitted[id] = self._admitted[id] or inst
		else
			local winnerPath = self._winners[id]
			local path = pathUnderRoot(inst)
			if winnerPath == nil then
				admitted = false
				self:_warnNoDecision(id, inst:GetFullName())
				local refused = self._refused[id]
				if path ~= nil and refused ~= nil and refused[path] then
					self:_retire(inst)
				end
			elseif path ~= nil and path == winnerPath then
				local incumbent = self._admitted[id]
				if incumbent == nil then
					self._admitted[id] = inst
				else
					admitted = false
					if incumbent.Parent == nil then
						self._warn(("[RBLXE] UI: piece %s was destroyed; its new copy %s is refused (pieces are admitted once per session)")
							:format(id, inst:GetFullName()))
					else
						-- M-b: never removed without a word.
						self._warn(("[RBLXE] UI: piece %s: a second copy arrived at %s and was removed; the first copy keeps the piece")
							:format(id, inst:GetFullName()))
					end
					self:_retire(inst)
				end
			else
				admitted = false
				local refused = self._refused[id]
				if path ~= nil and refused ~= nil and refused[path] then
					self:_retire(inst)
				end
			end
		end
	end
	self._decided[inst] = admitted
	return admitted
end

-- Whether `inst` is the copy the server's decision chose for its id (always
-- false in 2.x legacy mode, where nothing was decided). MenuSystem adopts
-- such a piece over any 2.x panel or button with the same key.
function Runtime:chose(inst)
	if self._winners == nil then
		return false
	end
	local id = pieceIdOf(inst)
	return id ~= nil and self._admitted[id] == inst
end

function Runtime:attach(playerGui)
	self._playerGui = playerGui
	local function consider(inst)
		if pieceIdOf(inst) ~= nil then
			self:admit(inst)
		end
	end
	for _, inst in ipairs(playerGui:GetDescendants()) do
		consider(inst)
	end
	return playerGui.DescendantAdded:Connect(consider)
end

-- get(pieceId, timeout?) -> the admitted piece, or nil. An id the server's
-- decision does not contain returns at once (M5): no copy of it will ever be
-- admitted. Otherwise the timeout (default 10 s) counts only while
-- PlayerGui.RBLXEssentials exists (RT-4): the root arrives with the first
-- character, which a slow client or a pack like DatastorePurchaseSystem can
-- delay; waiting for the root is bounded by rootWait on its own.
function Runtime:get(pieceId, timeout)
	if self._winners ~= nil and self._winners[pieceId] == nil then
		self:_warnNoDecision(pieceId, nil)
		return nil
	end
	local limit = timeout or 10
	local elapsed, waitedForRoot = 0, 0
	while true do
		local found = self._admitted[pieceId]
		if found ~= nil and found.Parent ~= nil then
			return found
		end
		local rootHere = self._playerGui == nil or self._playerGui:FindFirstChild(Pieces.ROOT) ~= nil
		if rootHere and elapsed >= limit then
			break
		end
		if not rootHere and waitedForRoot >= self._rootWait then
			self._warn(("[RBLXE] UI: piece %s: PlayerGui.%s did not arrive within %ss (the player has no character yet?)")
				:format(pieceId, Pieces.ROOT, tostring(self._rootWait)))
			return nil
		end
		local step = self._wait(0.1)
		step = if type(step) == "number" and step > 0 then step else 0.1
		if rootHere then
			elapsed += step
		else
			waitedForRoot += step
		end
	end
	self._warn(("[RBLXE] UI: piece %s did not appear within %ss"):format(pieceId, tostring(limit)))
	return nil
end

return Pieces
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="ModuleScript" referent="18">
            <Properties>
              <string name="Name">RootPersistence</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[-- RootPersistence.lua - keeps StarterGui.RBLXEssentials alive across
-- character respawns (Kernel 2.1.1).
--
-- WHY: Roblox resets PlayerGui on every character spawn. Each StarterGui
-- child is destroyed and cloned again unless it is a top-level
-- LayerCollector with ResetOnSpawn = false. The installer creates
-- StarterGui.RBLXEssentials as a Folder, which has no ResetOnSpawn, so the
-- whole tree was destroyed on the server and cloned again on every respawn
-- (the ResetOnSpawn = false of each pack ScreenGui nested inside is
-- ignored: only top-level LayerCollectors count). That server-side Destroy
-- replicates to every instance the client had moved out of the tree,
-- including every panel and HUD button MenuSystem adopted into
-- RBLXEssentialsGUI, so after the first death the menus and the HUD buttons
-- were gone. Diagnosed natively on 2026-09-23.
--
-- The server calls persist once at boot, before packs load, to turn a
-- non-ScreenGui root into a ScreenGui with ResetOnSpawn = false. The root
-- instance itself is replaced (the old Folder is destroyed), but the new one
-- keeps its name, attributes, tags and children, so every
-- PlayerGui.RBLXEssentials.<PackId>.<Gui> path stays the same: look the root
-- up by name after boot. The holder is neutral (no insets, no safe-area
-- clipping), so it adds no layout of its own, and the pack ScreenGuis nested
-- inside keep rendering as independent layers.
--
-- Pure: no `game` access. `create` is Instance.new and `enums` is Enum,
-- both injected so Lune specs can pass @lune/roblox's versions.
local RootPersistence = {}

RootPersistence.ROOT = "RBLXEssentials"

-- The nearest ancestor of `inst` (not `inst` itself) that is a GuiObject or
-- a LayerCollector, or nil when there is none.
local function nearestGuiAncestor(inst)
	local node = inst.Parent
	while node ~= nil do
		if node:IsA("GuiObject") or node:IsA("LayerCollector") then
			return node
		end
		node = node.Parent
	end
	return nil
end

-- Reports every instance under the root whose behavior changes now that the
-- root persists instead of resetting on spawn:
--   * client code (a LocalScript, or a Script with RunContext Client) now
--     runs once per session instead of on every respawn;
--   * a nested LayerCollector that asked to reset on spawn no longer does;
--   * only when the old root was not a LayerCollector (a Folder, which
--     renders nothing): a GuiObject with no GuiObject or LayerCollector
--     between it and the root now renders. Only the top of each such subtree
--     is reported, so a Frame > Folder > Frame chain gives one warning. When
--     the old root was already a ScreenGui, those objects were already
--     rendering, so they are not reported.
local function audit(root, enums, warnings, rootWasLayerCollector)
	for _, inst in ipairs(root:GetDescendants()) do
		if inst:IsA("LocalScript") or (inst:IsA("Script") and inst.RunContext == enums.RunContext.Client) then
			table.insert(warnings, ("%s: now runs once per session instead of on every respawn"):format(inst:GetFullName()))
		elseif inst:IsA("LayerCollector") then
			if inst.ResetOnSpawn == true then
				table.insert(warnings, ("%s: no longer resets on spawn"):format(inst:GetFullName()))
			end
		elseif inst:IsA("GuiObject") then
			if not rootWasLayerCollector and nearestGuiAncestor(inst) == root then
				table.insert(warnings, ("%s: now renders (it has no ScreenGui of its own)"):format(inst:GetFullName()))
			end
		end
	end
end

-- Makes StarterGui.RBLXEssentials survive respawn. Returns (root, warnings);
-- root is nil only when StarterGui has no RBLXEssentials child.
function RootPersistence.persist(starterGui, create, enums)
	local warnings = {}
	local root = starterGui:FindFirstChild(RootPersistence.ROOT)

	local matches = 0
	for _, child in ipairs(starterGui:GetChildren()) do
		if child.Name == RootPersistence.ROOT then
			matches += 1
		end
	end
	if matches > 1 and root ~= nil then
		table.insert(warnings, ("more than one StarterGui child is named %s; only %s was made persistent")
			:format(RootPersistence.ROOT, root:GetFullName()))
	end

	if root == nil then
		return nil, warnings
	end

	if root:IsA("ScreenGui") then
		-- Already converted, or the root may already be a ScreenGui if the
		-- game replaced it by hand: only make sure it survives respawn, and
		-- audit only when that is a change. Its GuiObjects already rendered.
		if root.ResetOnSpawn then
			root.ResetOnSpawn = false
			audit(root, enums, warnings, true)
		end
		table.sort(warnings)
		return root, warnings
	end

	local holder = create("ScreenGui")
	holder.Name = RootPersistence.ROOT
	holder.ResetOnSpawn = false
	holder.ScreenInsets = enums.ScreenInsets.None
	holder.ClipToDeviceSafeArea = false
	holder.SafeAreaCompatibility = enums.SafeAreaCompatibility.None
	for key, value in pairs(root:GetAttributes()) do
		holder:SetAttribute(key, value)
	end
	for _, tag in ipairs(root:GetTags()) do
		holder:AddTag(tag)
	end

	local moved = {}
	local moveOk, moveErr = pcall(function()
		for _, child in ipairs(root:GetChildren()) do
			child.Parent = holder
			table.insert(moved, child)
		end
	end)
	if not moveOk then
		-- Put back whatever already moved, so nothing is left orphaned.
		local stranded = {}
		for _, child in ipairs(moved) do
			local backOk = pcall(function()
				child.Parent = root
			end)
			if not backOk then
				table.insert(stranded, child)
			end
		end
		if #stranded == 0 then
			holder:Destroy()
		else
			-- Destroying the holder would destroy these children with it.
			for _, child in ipairs(stranded) do
				table.insert(warnings, ("%s could not be returned to %s"):format(child.Name, RootPersistence.ROOT))
			end
		end
		table.insert(warnings, ("%s: root not made persistent; menus, HUD buttons and pack interfaces may stop working after a respawn (%s)")
			:format(RootPersistence.ROOT, tostring(moveErr)))
		table.sort(warnings)
		return root, warnings
	end

	-- Parented before the Folder is destroyed, with no yield in between, so
	-- the moved children always have a root.
	holder.Parent = starterGui
	root:Destroy()

	audit(holder, enums, warnings, false)
	table.sort(warnings)
	return holder, warnings
end

return RootPersistence
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="ModuleScript" referent="19">
            <Properties>
              <string name="Name">Shell</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[-- Builds the kernel's ScreenGui shell programmatically - the kernel ships no
-- Studio-only GUI assets. Packs contribute their own panels via registerPanel.
return function(playerGui)
	local gui = Instance.new("ScreenGui")
	gui.Name = "RBLXEssentialsGUI"
	gui.ResetOnSpawn = false
	gui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
	gui.DisplayOrder = 5
	-- Parity with v1 MenusGUI: ignore topbar inset to prevent coordinate
	-- shift of scale-positioned content and mouse-follow tooltip.
	gui.IgnoreGuiInset = true

	local menus = Instance.new("Frame")
	menus.Name = "Menus"
	menus.BackgroundTransparency = 1
	menus.Size = UDim2.fromScale(1, 1)
	-- Panels draw ABOVE the HUD. This frame and the interactables layer are
	-- effective render siblings under the ScreenGui - `Interactables` below
	-- is a Folder, not a GuiObject, so it creates no stacking context of its
	-- own and `Container` is compared straight against this frame. Both used
	-- to sit at the default ZIndex 1: a tie, broken only by the order the
	-- children happen to be parented in, which put the HUD on top. Any
	-- full-screen panel then rendered UNDER the nav icons at the left HUD
	-- spot - reported against Roulette System's Spin, whose panel dims the
	-- whole screen at BackgroundTransparency 0.5 and is the first v2 panel
	-- big enough to reach that strip at all. Explicit ranks remove the tie
	-- instead of relying on parenting order. Anything a pack clones in as a
	-- sibling group (GUK's Effects/InviteFriends) keeps the default 1 and so
	-- also stays below panels; the Tooltip (50) still wins over everything.
	menus.ZIndex = 10
	menus.Parent = gui

	-- Folder, not Frame: matches v1 (EC's designed MenusGUI.Interactables) -
	-- layout-transparent, so GuiObject children (Container, and any
	-- pack-cloned sibling groups) size/position relative to the ScreenGui
	-- instead of compressing into an invented strip. Folders have no
	-- Size/Position/AnchorPoint to set.
	local interactables = Instance.new("Folder")
	interactables.Name = "Interactables"
	interactables.Parent = gui

	-- Geometry below matches GUK v2's designed Container (EC lineage;
	-- General UI Kit v2/src/StarterGui/GeneralUIKit/GeneralUIKitGUI.rbxm ->
	-- Interactables.Container pre-M1-unwrap, verified directly by a Lune
	-- probe against `git show 8b0e864:"General UI Kit v2/src/
	-- ReplicatedStorage/GeneralUIKit/Assets/Interactables.rbxm"` - see
	-- task-M1-report.md's I2 fix section for the probe output) as the
	-- kernel default for ALL packs, designed or not: since Task M1, GUK
	-- ships its 10 nav buttons directly adopted into THIS Container (no
	-- pack ever overwrites this geometry anymore - the old "GUK v2
	-- overwrites this after cloning its layout" comment this replaced is
	-- stale post-M1).
	local container = Instance.new("Frame")
	container.Name = "Container"
	container.BackgroundTransparency = 1
	container.AnchorPoint = Vector2.new(0, 0.5)
	container.Position = UDim2.fromScale(0.01, 0.5)
	container.Size = UDim2.fromScale(0.2, 0.38)
	-- Explicit even though it equals the Frame default: this is the low half
	-- of the rank documented on `menus.ZIndex` above, and a silent default is
	-- exactly what produced the tie in the first place.
	container.ZIndex = 1
	container.Parent = interactables

	local grid = Instance.new("UIGridLayout")
	grid.CellSize = UDim2.fromScale(0.24, 0.24)
	grid.CellPadding = UDim2.fromScale(0.03, 0.01)
	grid.FillDirection = Enum.FillDirection.Vertical
	grid.HorizontalAlignment = Enum.HorizontalAlignment.Left
	grid.SortOrder = Enum.SortOrder.LayoutOrder
	grid.Parent = container

	-- The designed Container parents this directly to the FRAME, not to the
	-- UIGridLayout (a UIAspectRatioConstraint parented to a UIGridLayout has
	-- no effect on anything - verified via the probe above: it does nothing
	-- there, which is why this was a real, not merely cosmetic, v1-parity
	-- bug prior to this fix).
	local aspect = Instance.new("UIAspectRatioConstraint")
	aspect.AspectRatio = 0.9341463446617126
	aspect.AspectType = Enum.AspectType.FitWithinMaxSize
	aspect.DominantAxis = Enum.DominantAxis.Height
	aspect.Parent = container

	local tooltip = Instance.new("Frame")
	tooltip.Name = "Tooltip"
	tooltip:SetAttribute("TooltipType", "Button")
	tooltip.Visible = false
	tooltip.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
	tooltip.BackgroundTransparency = 0.15
	tooltip.BorderSizePixel = 0
	tooltip.Size = UDim2.fromOffset(140, 34)
	tooltip.ZIndex = 50
	tooltip.Parent = gui

	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, 6)
	corner.Parent = tooltip

	local label = Instance.new("TextLabel")
	label.Name = "ButtonName"
	label.BackgroundTransparency = 1
	label.Size = UDim2.fromScale(1, 1)
	label.TextColor3 = Color3.fromRGB(255, 255, 255)
	label.TextScaled = true
	label.Font = Enum.Font.GothamBold
	label.Text = ""
	label.ZIndex = 51
	label.Parent = tooltip

	gui.Parent = playerGui
	return gui
end
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
        </Item>
        <Item class="ModuleScript" referent="20">
          <Properties>
            <string name="Name">Version</string>
            <BinaryString name="AttributesSerialize"></BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[-- Kernel semver. Single source of truth - the server stamps it as the
-- RBLXE_KernelVersion attribute on ReplicatedStorage.RBLXEssentials at boot,
-- and the Dev Plugin's ExporterV2 reads it through
-- `PackFormat.parseKernelVersion` to stamp the same attribute on every
-- exported RBLXE_Pack container.
--
-- BUMP THIS WITH EVERY KERNEL CHANGE. The kernel unit is shipped inside each
-- pack, and `Installer.decideKernel` replaces an installed kernel ONLY when
-- the incoming version is strictly greater - an equal version is
-- "kept-existing". So a kernel fix that does not raise this number reaches
-- nobody: reinstalling the pack silently keeps the old modules. Learned the
-- hard way on 2026-08-24, when the panels-above-HUD and UI_Blocker fixes
-- both looked like they had not worked after a reinstall (user: "he
-- reinstalado el roulette system en el place de prueba y nada, se ve por
-- detrás el fondo aún").
--
-- 2.0.1 - panels draw above the HUD (Shell ZIndex ranks); UI_Blocker tag
--         skips wiring for a modal's click-eating sheet.
-- 2.0.2 - MenuSystem:getInteractable(panelName): the HUD button a pack's
--         notification badge belongs on. Additive, so an older pack keeps
--         working against this kernel unchanged - but a pack that ASKS for it
--         needs this version present, or it falls back to scanning.
-- 2.1.0 - ctx.kernel.Notify: the notification facade, shaped like SFX. A
--         no-op until Notifications System v2 registers a backend, so every
--         pack can announce unconditionally without declaring a dependency
--         on an optional pack. MINOR, not patch: this adds API that packs
--         built against it will call, and an older kernel does not have it.
-- 2.1.1 - menus and HUD buttons survive character respawn: the server makes
--         StarterGui.RBLXEssentials a ScreenGui with ResetOnSpawn = false at
--         boot (UI/RootPersistence.lua). Before, every respawn destroyed every
--         panel and HUD button MenuSystem had adopted. PATCH: no API change.
-- 3.0.0 - RBLX Essentials 3.0 foundation (design spec 2026-09-23):
--         game-owned configuration (ctx.config from each pack's Schema and
--         the game's Config modules; Schema.lua, Config.lua), interface piece
--         contracts (Contracts.lua) and piece resolution decided on the server
--         and enforced on clients (UI/Pieces.lua, RBLXE_PieceWinners,
--         MenuSystem pieces gate, getPiece, ctx.getPiece). The respawn fix
--         (StarterGui.RBLXEssentials made a persistent ScreenGui at boot, so
--         the pieces a client adopted survive respawns) is not new in 3.0: it
--         shipped in 2.1.1 (UI/RootPersistence.lua) and 3.0 keeps it. The
--         client now waits for game.Loaded
--         before booting. Final A1 fix wave (still 3.0.0, unreleased): a
--         config load that throws fails only its pack, Schema.check rejects
--         unusable option types, a chosen piece takes its MenuSystem slot
--         over any 2.x copy, contracts check what MenuSystem needs (tags,
--         PanelId, TargetPanel, `opens`), and clients retire only the
--         StarterGui copies the server refused, never a pack's own clones.
--         A2a hardening for Tools (still 3.0.0, unreleased): Schema.check
--         walks whole patterns and checks list, map and optional-group
--         defaults; Contracts.check reports unusable specs and roots as
--         problems; Config.load reports a wrong side, packId, schemaLib or
--         module argument as an error. Callers keep their pcall for the
--         rest (Loader.lua does).
--         A2b (still 3.0.0): Schema.describe rows also carry optional,
--         value, example and constraints, for config templates and Tools.
--         A3 (still 3.0.0): Schema refuses defaults under server-only
--         options (RT-10) and takes check/checkDoc rules; getPiece counts
--         from PlayerGui.RBLXEssentials' arrival and answers an undecided id
--         at once; the piece runtime warns where it was silent (T-G, M-b,
--         M-c, M-d); Interface/Custom is never a candidate; an invalid
--         Pieces declaration fails its pack (RT-6); clients skip the packs
--         the server could not start (RBLXE_ServerReport) and Net.client
--         waits can be bounded (RT-5).
--         B0 (still 3.0.0, then frozen): Schema kinds S.color and S.tree
--         and the pinned flag; ctx.companion, ctx.extension(s) (the game's
--         Extensions zone) and no ctx.settings for a pack with a Schema
--         (a notice for the others); the Layer piece kind.
--         MAJOR: official 2.x packs are replaced together
--         with it at release; during development 2.x packs keep ctx.settings
--         and 2.x adoption.
-- 3.0.1 - piece specs may declare standsInFor = "<PackId>.<Name>": a
--         stand-in copy of a piece another pack owns (the General UI Kit
--         ships its 2.x menus this way). Pieces.plan refuses the stand-in,
--         its default and every Interface copy, when the owner piece is
--         declared, and a HudButton that opens a refused stand-in panel is
--         refused with it; without the owner the stand-in is planned like
--         any piece. An owner of another kind keeps its piece and the
--         stand-in is refused with a warning. PATCH: an older Kernel ignores
--         the field and would choose both copies, so a pack that declares
--         stand-ins needs Kernel >= 3.0.1.
return "3.0.1"
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
        </Item>
      </Item>
      <Item class="Folder" referent="21">
        <Properties>
          <string name="Name">Packs</string>
          <BinaryString name="AttributesSerialize"></BinaryString>
          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
          <Color3 name="IconTint">
            <R>0</R>
            <G>0</G>
            <B>0</B>
          </Color3>
          <bool name="DefinesCapabilities">false</bool>
          <BinaryString name="SerializedOverrides">
          </BinaryString>
          <int64 name="SourceAssetId">-1</int64>
          <BinaryString name="Tags"></BinaryString>
        </Properties>
        <Item class="Folder" referent="22">
          <Properties>
            <string name="Name">NotificationsSystem</string>
            <BinaryString name="AttributesSerialize">AQAAAAwAAABSQkxYRV9IYXNoZXMCLQUAACNyYmx4ZS1oYXNoZXMgdjEgZm52MWEzMiBsZgpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL0NsaWVudAlkZmRjZDlhMQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL0NsaWVudC9Db3VudGVyRmx5b3V0CTc0YzdlMmMzClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vQ2xpZW50L1RleHRGaWVsZHMJNGUyYjJlNjYKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9DbGllbnQvVG9hc3RlcgkxMGI5NjZjOQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL01pZ3JhdGlvbnMvQ29udGVudAkyOTgzNGFlNQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL01pZ3JhdGlvbnMvRnJvbVYyCTc2N2VlM2ZkClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vTWlncmF0aW9ucy9JbnRlcmZhY2UJZTI2M2IxNWYKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9NaWdyYXRpb25zL0tlZXAJZTczMzI3MjkKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9NaWdyYXRpb25zL1NvdXJjZXMJNzkxMWQ2OWYKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9Ob3RpZmljYXRpb25zCWYzZmMzYmM0ClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vTm90aWZ5CTE1ZWIyMzI4ClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vUGllY2VzCWQwMDg2YzFmClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vU2NoZW1hCWU0MTJmNWNlClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vbWFuaWZlc3QJYzg5ODUxNzIKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtCWNiZWU5YTM3ClNlcnZlclNjcmlwdFNlcnZpY2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9UcmlnZ2Vycy9Bbm5vdW5jZW1lbnRzCTI0YTgyNWNiClNlcnZlclNjcmlwdFNlcnZpY2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9UcmlnZ2Vycy9GcmllbmRKb2luZWQJN2QwNDg2YWYKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL1RyaWdnZXJzL0pvaW5MZWF2ZQljOWRlY2MwMApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vVHJpZ2dlcnMvUHVyY2hhc2VzCWUyZTlmNjcy</BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <Color3 name="IconTint">
              <R>0</R>
              <G>0</G>
              <B>0</B>
            </Color3>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
          <Item class="ModuleScript" referent="23">
            <Properties>
              <string name="Name">Client</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[--[[
	NotificationsSystem - client module.

	Two jobs, and nothing else:
	  1. register the CLIENT backend on `ctx.kernel.Notify`, so a pack that
	     already knows something locally (Easy Pet System seeing a pet
	     arrive, Roulette's countdown reaching zero) can announce it without
	     a server round trip;
	  2. render what the server sends over the `Show` remote.

	NO PANEL, NO HUD BUTTON: there is nothing to open. Nothing here calls
	`ui:getPanel`/`ui:addInteractable`.

	THE CARDS ARE DRAWN IN THE NotificationLayer PIECE (3.0, plan B1): the
	ScreenGui the Kernel chose (ctx.getPiece), the game's fork in
	StarterGui.RBLXEssentials.Interface when it satisfies its contract
	(Pieces.lua), otherwise this pack's own NotificationsSystemGUI. Its
	Templates are looked up by name and every card is parented to it and
	measured against it, exactly as 2.x did with its own copy.

	THE CLIENT BACKEND IS DELIBERATELY PARTIAL. It has no ToastAll, ChatTo or
	BannerAll - a client cannot notify anyone else - and the kernel facade
	treats a missing method as a no-op precisely so a pack does not have to
	know which side it is running on.

	Boot never blocks the Kernel: the piece is awaited in a thread of its
	own, and for as long as it takes. getPiece waits for
	PlayerGui.RBLXEssentials only up to the Kernel's own limit, but that
	root comes with the first character, which a game may hold back
	(DatastorePurchaseSystem spawns it once the profile loads; a menu may
	come before spawning). 2.x waited for its GUI however long that took,
	and so does this: one warning, then the piece is asked for again once
	the root is there. The owning UI trove stops everything with the shell.
]]

local Toaster = require(script.Toaster)

local TAG = "[NotificationsSystem]"
local ROOT = "RBLXEssentials"

return function(ctx)
	local Players = game:GetService("Players")
	local trove = ctx.kernel.Trove.new()
	local alive = true
	trove:Add(function() alive = false end)
	trove:AttachToInstance(ctx.ui.gui)
	local rules = require(ctx.folder.Notifications)
	local public = {}
	local assets = ctx.folder:FindFirstChild('Assets')
	local counterTemplate = assets and assets:FindFirstChild('CounterEffects')
	if counterTemplate then
		local layer = counterTemplate:Clone()
		layer.Parent = ctx.ui.gui
		trove:Add(layer)
		local Flyout = require(script.CounterFlyout)
		local renderer = Flyout.new(layer, layer.CounterGain, trove)
		public.FlyToCounter = renderer.Play
		Flyout.observe(Players.LocalPlayer, Players.LocalPlayer:WaitForChild('PlayerGui'), renderer, trove)
	end
	-- No configuration here on purpose: the texts are the server's business.
	-- What the renderer needs rides on the templates themselves, as
	-- attributes.

	task.spawn(function()
		local playerGui = Players.LocalPlayer:WaitForChild("PlayerGui")
		local layer = ctx.getPiece("NotificationLayer")
		if layer == nil and alive and playerGui:FindFirstChild(ROOT) == nil then
			warn(("%s PlayerGui.%s has not arrived yet (no character?): still waiting for it; notifications start once it does"):format(TAG, ROOT))
			while alive and playerGui:FindFirstChild(ROOT) == nil do
				playerGui.ChildAdded:Wait()
			end
			if not alive then return end
			layer = ctx.getPiece("NotificationLayer")
		end
		if not alive then return end
		local templates = layer and layer:FindFirstChild("Templates")
		if templates == nil then
			warn(("%s the NotificationLayer piece %s, so notifications are off this session"):format(TAG,
				if layer == nil then "did not appear" else ("(%s) has no Templates"):format(layer:GetFullName())))
			return
		end
		trove:AttachToInstance(layer)

		local toaster = Toaster.new(templates, layer, rules, ctx.kernel.SFX, trove)

		ctx.kernel.Notify.setBackend({
			Toast = function(_, template, data)
				toaster.Show("toast", template, data)
			end,
			Banner = function(_, data)
				-- nil, not "Banner": the toaster picks the one-line or the
				-- two-line card from what the caller actually passed.
				toaster.Show("banner", nil, data)
			end,
			Chat = function(_, text, color)
				toaster.Show("chat", nil, { Title = text, Color = color })
			end,
		})

		-- Acquired LAST, after the backend is live: the remote's WaitForChild
		-- yields, and a server notification arriving before the local packs
		-- can emit would be the only ordering that matters here.
		local net = ctx.kernel.Net.client("NotificationsSystem")
		local event = net:event("Show")
		if not alive then return end
		trove:Connect(event.OnClientEvent, function(payload)
			if typeof(payload) ~= "table" then
				return
			end
			toaster.Show(payload.kind, payload.template, payload.data)
		end)
	end)

	return public
end
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
            <Item class="ModuleScript" referent="24">
              <Properties>
                <string name="Name">CounterFlyout</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Editable native template; presentation only, never grants currency.
local Flyout={}
function Flyout.delta(previous,current,ready)
 if not ready or type(previous)~='number' or type(current)~='number' or current~=current or math.abs(current)==math.huge then return 0 end
 return math.max(0,current-previous)
end
function Flyout.new(layer,template,trove)
 local active={};local alive=true;local random=Random.new()
 trove:Add(function()alive=false;for _,a in ipairs(active)do a.card:Destroy()end;table.clear(active)end)
 local api={}
 function api.Play(target,amount,image,onArrive)
  if not alive or not target or not target:IsDescendantOf(game)or type(amount)~='number'or amount<=0 or amount~=amount or amount==math.huge then return false end
  -- Bound the number of simultaneous visuals without dropping their totals.
  for _,a in ipairs(active)do if not onArrive and not a.onArrive and a.target==target and a.elapsed<.12 and a.image==image then a.amount+=amount;a.card.Amount.Text='+'..tostring(math.floor(a.amount));return true end end
  if #active>=24 then return false end
  local card=template:Clone();card.Name='CounterGain';card.Visible=false
  card.Amount.Text='+'..tostring(math.floor(amount));if type(image)=='string'and image~=''then card.Icon.Image=image end
  card.Pulse.Scale=0;card.Parent=layer
  local origin=Vector2.new(random:NextNumber(.43,.57),random:NextNumber(.38,.54));card.Position=UDim2.fromScale(origin.X,origin.Y);card.Visible=true
  table.insert(active,{card=card,target=target,origin=origin,elapsed=0,amount=amount,image=image,onArrive=onArrive})
  return true
 end
 trove:Connect(game:GetService('RunService').RenderStepped,function(dt)
  for i=#active,1,-1 do
   local a=active[i];a.elapsed+=dt;local t=math.clamp((a.elapsed-.3)/.65,0,1);local u=t*t
   local size=layer.AbsoluteSize;local target=a.target
   if not target.Parent or size.X<=0 or size.Y<=0 then a.card:Destroy();table.remove(active,i);continue end
   local dest=(target.AbsolutePosition+target.AbsoluteSize*.5-layer.AbsolutePosition)/size
   local control=(a.origin+dest)*.5+Vector2.new(0,-.1)
   local pos=a.origin*(1-u)^2+control*(2*(1-u)*u)+dest*u
   a.card.Position=UDim2.fromScale(pos.X,pos.Y);a.card.Pulse.Scale=math.clamp(a.elapsed/.14,0,1)*(1-.7*t)
   local fade=math.clamp((t-.8)/.2,0,1);a.card.Icon.ImageTransparency=fade;a.card.Amount.TextTransparency=fade
   local stroke=a.card.Amount:FindFirstChildOfClass('UIStroke');if stroke then stroke.Transparency=fade end
   if t>=1 then a.card:Destroy();table.remove(active,i);if a.onArrive then task.spawn(a.onArrive,a.amount)end end
  end
 end)
 return api
end
function Flyout.observe(player,gui,api,trove)
 local cs=game:GetService('CollectionService');local watched={};local alive=true
 trove:Add(function()alive=false;for _,s in pairs(watched)do if s.connection then s.connection:Disconnect()end end end)
 local function visible(n)
  while n and n~=gui do if n:IsA('GuiObject')and not n.Visible then return false end;if n:IsA('ScreenGui')and not n.Enabled then return false end;n=n.Parent end
  return n==gui
 end
 local function refresh()
  if not alive then return end
  local paths={}
  for _,target in ipairs(cs:GetTagged('UI_CounterFeedback'))do if target:IsA('GuiObject')and target:IsDescendantOf(gui)then
   local path=target:GetAttribute('DataPath');if type(path)=='string'then paths[path]=paths[path]or{};table.insert(paths[path],target)end
  end end
  for path,targets in pairs(paths)do
   local data=player:FindFirstChild('PlayerData');local value=data
   for segment in path:gmatch('[^.]+')do value=value and value:FindFirstChild(segment)end
   if value and not(value:IsA('NumberValue')or value:IsA('IntValue'))then value=nil end
   local s=watched[path];if not s then s={};watched[path]=s end;s.targets=targets
   local ready=data and data:FindFirstChild('DataReady');local isReady=not ready or ready.Value==true
   if s.value~=value or not isReady or (value and not s.connection) then
    if s.connection then s.connection:Disconnect();s.connection=nil end;s.value=value;s.previous=nil
    if value and isReady then
     s.previous=value.Value
     s.connection=value.Changed:Connect(function(current)
      if not alive then return end
      local amount=Flyout.delta(s.previous,current,not ready or ready.Value==true);s.previous=current
      if amount>0 then for _,target in ipairs(s.targets)do if visible(target)then api.Play(target,amount,target:GetAttribute('CounterImage'));break end end end
     end)
    end
   end
  end
 end
 local queued=false
 local function schedule()if queued or not alive then return end;queued=true;task.defer(function()queued=false;refresh()end)end
 trove:Connect(player.DescendantAdded,schedule);trove:Connect(player.DescendantRemoving,schedule)
 trove:Connect(cs:GetInstanceAddedSignal('UI_CounterFeedback'),schedule);trove:Connect(cs:GetInstanceRemovedSignal('UI_CounterFeedback'),schedule)
 -- DataReady may be delivered before or after the numeric value.
 local readyBound={}
 local function bindReady(n)if n.Name=='DataReady'and n:IsA('BoolValue')and not readyBound[n]then readyBound[n]=true;trove:Connect(n.Changed,schedule)end end
 for _,n in ipairs(player:GetDescendants())do bindReady(n)end;trove:Connect(player.DescendantAdded,bindReady)
 refresh()
end
return Flyout
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="25">
              <Properties>
                <string name="Name">TextFields</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Optional native text slots for buyer-authored templates. No game-specific names.
local TextFields = {}

function TextFields.fill(card, data)
	local fields = type(data) == "table" and type(data.Fields) == "table" and data.Fields or {}
	for _, node in ipairs(card:GetDescendants()) do
		local key = node:GetAttribute("NotificationField")
		if node:IsA("TextLabel") and type(key) == "string" and key ~= "" then
			local value = fields[key]
			local usable = type(value) == "string"
				or (type(value) == "number" and value == value and math.abs(value) < math.huge)
			-- Missing/invalid data must never expose the preview's sample value.
			node.Text = usable and tostring(value) or ""
			if node:GetAttribute('HideIfEmpty') == true then node.Visible = usable and tostring(value) ~= '' end
		end
	end
end

return TextFields
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="26">
              <Properties>
                <string name="Name">Toaster</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[--[[
	Toaster.lua - renders notifications. ONE STACK PER `StackGroup`, not per
	template: templates carrying the same group name share a column and sit
	below each other in it (user, 2026-08-26). A template with no group gets
	a stack to itself.

	NOTHING WAITS. `MaxOnScreen` caps what is VISIBLE, and a notification
	arriving at the cap dismisses the oldest of its kind rather than queueing
	(user, 2026-08-26). There was a queue here until then, and it was the
	wrong shape: a held-back card describes a moment already gone, and a
	burst drained at one card per Duration.

	The first version of this grouped by POSITION, and the user threw it out
	for the right reason: dragging a template would silently change which
	other templates it shared a column with. The group is written on the
	frame, so the answer is readable rather than inferred.

	Two consequences worth knowing. A stack now holds cards of DIFFERENT
	HEIGHTS, so placement accumulates their real sizes instead of stepping by
	one; and the stack's direction and origin come from the card NEAREST THE
	ANCHOR, not from each card's own template, or two templates sharing a
	spot with different StackDirection attributes would pull it apart.
	`MaxOnScreen` stays per template: it is a cap on how much of one KIND of
	notification you see, not on the stack - and so is the eviction it now
	drives, which only ever removes a card of the SAME template.

	INSTANCE-SCOPED and DOT-CALL, the same two conventions as Easy Pet
	System's HatchToast: `Toaster.new(...)` returns a table of closures over
	its own state, and every method is defined with dot syntax
	(`function toaster.Show(...)`, no `self`). A colon call would silently
	pass the toaster itself as the first argument.

	THE TEMPLATES ARE HANDED IN, never scanned for. `Client/init.lua` walks
	the PlayerGui once with a bounded WaitForChild chain and passes the
	Templates folder here. HatchToast's declared fix 1 is the same decision,
	for the same reason: a descendant scan on every call is both slower and
	wrong the moment a buyer adds a frame with a colliding name.

	EVERY FIELD IS OPTIONAL. `Title`, `Subtitle` and `Image` are filled only
	if the template has a child by that name. A buyer who deletes the
	subtitle from their redesigned card gets a card with no subtitle, not an
	error - their redesign must not be able to break the pack.

	Timings are HatchToast's verbatim (0.4 s Quint Out in, 0.35 s Quint In
	out) so the whole ecosystem moves alike.
]]

local Toaster = {}
local TextFields = require(script.Parent.TextFields)

-- The space between two stacked cards, as a fraction of screen height. No
-- floor: a floor is a fixed number wearing a disguise, and it would make the
-- gap proportionally BIGGER on a small screen, which is the opposite of what
-- scaling is for.
local GAP_SCALE = 16 / 1080
-- How far past the edge a sliding card starts, on top of its own size.
local SLIDE_MARGIN = 40
local REFLOW = TweenInfo.new(0.15, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
local TWEEN_IN = TweenInfo.new(0.4, Enum.EasingStyle.Quint, Enum.EasingDirection.Out)
local TWEEN_OUT = TweenInfo.new(0.35, Enum.EasingStyle.Quint, Enum.EasingDirection.In)

local DEFAULTS = {
	Duration = 5,
	MaxOnScreen = 4,
	Animation = "Slide",
	SlideFrom = "Auto",
}

local TAG = "[NotificationsSystem]"

function Toaster.new(templatesFolder, screenGui, rules, SFX, trove)
	local Players = game:GetService("Players")
	local TextChatService = game:GetService("TextChatService")
	local TweenService = game:GetService("TweenService")

	local toaster = {}
	local alive = true
	trove:Add(function() alive = false end)

	-- stacks[groupKey] = { entries = { entry, ... } }, anchor first
	--   entry = { card = , name = , template = , dismissed = }
	-- No size on the entry: `place` measures the template every time, so a
	-- window that changes shape cannot leave a stack laid out for the old one.
	local stacks = {}
	local warned = {}

	--- One warning per distinct cause, ever. A missing template that fires
	--- sixty times a minute would otherwise bury the output window.
	local function warnOnce(key, message)
		if warned[key] then
			return
		end
		warned[key] = true
		warn(TAG .. " " .. message)
	end

	local function attr(template, name)
		local v = template:GetAttribute(name)
		if v == nil then
			return DEFAULTS[name]
		end
		return v
	end

	--- What this ONE notification should use for `name`: the caller's
	--- override if they passed a usable one, otherwise the template's
	--- attribute, otherwise the pack default.
	local function setting(template, data, name)
		local override = rules.override(name, data)
		if override ~= nil then
			return override
		end
		return attr(template, name)
	end

	-- ── chat ─────────────────────────────────────────────────────────────
	local function showChat(data)
		local text = data and data.Title
		if type(text) ~= "string" or text == "" then
			return
		end
		local channels = TextChatService:FindFirstChild("TextChannels")
		local general = channels and channels:FindFirstChild("RBXGeneral")
		if not general then
			-- Legacy chat, or TextChatService not ready. Not an error: the
			-- place simply has no channel to write to.
			warnOnce("chat", "TextChannels.RBXGeneral is missing (legacy chat?), so chat notifications are off this session")
			return
		end
		if data.Color then
			local c = data.Color
			text = ('<font color="#%02X%02X%02X">%s</font>'):format(
				math.floor(c.R * 255 + 0.5),
				math.floor(c.G * 255 + 0.5),
				math.floor(c.B * 255 + 0.5),
				text
			)
		end
		local ok, err = pcall(function()
			general:DisplaySystemMessage(text)
		end)
		if not ok then
			warnOnce("chatfail", "DisplaySystemMessage failed: " .. tostring(err))
		end
	end

	-- ── placement ────────────────────────────────────────────────────────
	local function anchorOf(template)
		return template.Position.X.Scale, template.Position.Y.Scale
	end

	--- The stack this template belongs to, created on first use.
	local function stackFor(template)
		local key = rules.stackGroup(template.Name, template:GetAttribute("StackGroup"))
		local stack = stacks[key]
		if not stack then
			stack = { entries = {} }
			stacks[key] = stack
		end
		return stack
	end

	--- The template's direction, and ONLY the template's: `StackDirection` is
	--- deliberately not per-call. See `Notifications.OVERRIDES` for why - in
	--- short, direction belongs to a column, not to a card.
	local function directionOf(template)
		local x, y = anchorOf(template)
		local explicit = template:GetAttribute("StackDirection")
		if type(explicit) == "string" and explicit ~= "" then
			return rules.stackDirection(x, y, explicit)
		end
		return rules.stackDirection(x, y)
	end

	--- The box this template's card will occupy, WORKED OUT from what the
	--- template declares against the screen as it is right now.
	---
	--- It no longer reads `AbsoluteSize` for that, and the difference is a
	--- real bug: AbsoluteSize is a measurement from the last frame the
	--- template was laid out, and the triggers fire on join, exactly while a
	--- Studio viewport is still settling. The gap came from the current
	--- screen and the heights from the old one, so the cards stepped by
	--- roughly 0.44 of their height and overlapped (seen in game
	--- 2026-08-30). `rules.fitBox` carries the rest of the reasoning.
	---
	--- AutomaticSize is the one thing that cannot be worked out - a card that
	--- sizes itself to its own text has no declared width to resolve - so
	--- that axis, and only that axis, still asks the instance.
	local function measure(template)
		local screen = screenGui.AbsoluteSize
		local w = template.Size.X.Scale * screen.X + template.Size.X.Offset
		local h = template.Size.Y.Scale * screen.Y + template.Size.Y.Offset
		local aspect = template:FindFirstChildOfClass("UIAspectRatioConstraint")
		w, h = rules.fitBox(w, h, aspect and aspect.AspectRatio or nil)

		local auto = template.AutomaticSize
		local measured = template.AbsoluteSize
		if (auto == Enum.AutomaticSize.X or auto == Enum.AutomaticSize.XY) and measured.X > 0 then
			w = measured.X
		end
		if (auto == Enum.AutomaticSize.Y or auto == Enum.AutomaticSize.XY) and measured.Y > 0 then
			h = measured.Y
		end
		return w, h
	end

	local function gapPx()
		return screenGui.AbsoluteSize.Y * GAP_SCALE
	end

	--- Places entry number `index` of `stack`. The stack's direction and its
	--- base position both come from the card nearest the anchor, so the whole
	--- column moves as one thing rather than as N templates that happen to
	--- overlap.
	local function place(stack, index, animate)
		local entry = stack.entries[index]
		local lead = stack.entries[1] or entry
		local anchorTemplate = lead.template
		-- The LEAD card's direction: a column moves as one thing, and the
		-- card nearest the anchor is the one that defines it. Templates
		-- sharing a StackGroup may carry different StackDirection
		-- attributes, and the lead's is the one that wins.
		local direction = directionOf(anchorTemplate)
		-- MEASURED NOW, not remembered from the frame each card arrived on.
		-- A size stored at Show time is stale the moment the window changes
		-- shape, and every card already on screen keeps stepping by the old
		-- number for as long as it lives. The templates are all scale, so
		-- asking again costs arithmetic and nothing else.
		local ahead = {}
		for i = 1, index - 1 do
			local w, h = measure(stack.entries[i].template)
			ahead[i] = { width = w, height = h }
		end
		local dx, dy = rules.stackOffset(direction, ahead, gapPx())
		-- The step is measured in pixels, because that is what AbsoluteSize
		-- gives, but it is APPLIED IN SCALE. Two reasons. The templates are
		-- all scale, so a pixel offset on top of them is the one thing that
		-- would not follow the screen; and a window resized while cards are
		-- on screen leaves a pixel offset stale, which slides a live stack
		-- out of line with the anchor it is hanging from.
		local screen = screenGui.AbsoluteSize
		local base = anchorTemplate.Position
		local target = UDim2.new(
			base.X.Scale + ((screen.X > 0) and (dx / screen.X) or 0),
			base.X.Offset,
			base.Y.Scale + ((screen.Y > 0) and (dy / screen.Y) or 0),
			base.Y.Offset
		)
		if animate then
			TweenService:Create(entry.card, REFLOW, { Position = target }):Play()
		else
			entry.card.Position = target
		end
		return target, direction
	end

	local function reflow(stack)
		for i = 1, #stack.entries do
			place(stack, i, true)
		end
	end

	-- ── the card ─────────────────────────────────────────────────────────
	local function fill(card, template, data)
		TextFields.fill(card, data)
		-- Optional palette for an authored badge; untouched for other templates.
		local colors = data.Colors
		if type(colors) == 'table' and typeof(colors[1]) == 'Color3' and typeof(colors[2]) == 'Color3' and typeof(colors[3]) == 'Color3' then
			local gradient = card:FindFirstChild('Gradient')
			if gradient and gradient:IsA('UIGradient') then gradient.Color = ColorSequence.new(colors[1], colors[2]) end
			for _, name in {'Outline', 'DropShadow'} do
				local edge = card:FindFirstChild(name)
				if edge and (edge:IsA('UIStroke') or edge:IsA('UIShadow')) then edge.Color = colors[3] end
			end
		end
		local title = card:FindFirstChild("Title")
		if title and title:IsA("TextLabel") then
			title.Text = tostring(data.Title or "")
		end
		local subtitle = card:FindFirstChild("Subtitle")
		if subtitle and subtitle:IsA("TextLabel") then
			subtitle.Text = tostring(data.Subtitle or "")
		end
		-- The `Image` field is a FRAME with the picture inside it: a plate
		-- and a ring that clip whatever is drawn in. Resolve the label one
		-- level down, but accept a bare ImageLabel named `Image` too, so a
		-- buyer whose redesign kept the old flat shape still works.
		local slot = card:FindFirstChild("Image")
		local image = slot
		if slot and not slot:IsA("ImageLabel") then
			image = slot:FindFirstChildWhichIsA("ImageLabel", true)
		end
		if image and image:IsA("ImageLabel") then
			if type(data.Image) == "string" and data.Image ~= "" then
				image.Image = data.Image
			elseif data.ImageUserId then
				image.Image = ""
				-- A thumbnail is a web call. It gets its own thread so the
				-- card shows immediately and fills in when the image lands;
				-- a slow endpoint must not delay the notification.
				task.spawn(function()
					local ok, url = pcall(function()
						return Players:GetUserThumbnailAsync(
							data.ImageUserId,
							Enum.ThumbnailType.HeadShot,
							Enum.ThumbnailSize.Size100x100
						)
					end)
					if ok and url and image.Parent then
						image.Image = url
					end
				end)
			else
				image.Image = ""
			end
		end
	end

	--- Every transparency a card draws with, paired with the value it should
	--- rest at. A fade that only touches TextLabels leaves everything else
	--- solid; that was invisible while the card itself was the only opaque
	--- thing, and stopped being invisible when the image slot became a
	--- plate with a ring. A solid disc hanging in mid-air during a fade is
	--- exactly the kind of thing nobody files a bug about.
	local function fadeParts(card)
		local parts = {}
		local function add(inst, prop)
			table.insert(parts, { inst = inst, prop = prop, value = inst[prop] })
		end
		for _, d in ipairs(card:GetDescendants()) do
			if d:IsA("GuiObject") then
				add(d, "BackgroundTransparency")
				if d:IsA("TextLabel") or d:IsA("TextButton") then
					add(d, "TextTransparency")
				end
				if d:IsA("ImageLabel") or d:IsA("ImageButton") then
					add(d, "ImageTransparency")
				end
			elseif d:IsA("UIStroke") or d:IsA("UIShadow") then
				add(d, "Transparency")
			end
		end
		return parts
	end

	local function offscreen(card, edge, target)
		local screen = screenGui.AbsoluteSize
		local w, h = measure(card)
		local x, y = rules.offscreenPosition(edge, target.X.Scale, target.Y.Scale,
			w / math.max(1, screen.X), h / math.max(1, screen.Y), card.AnchorPoint.X, card.AnchorPoint.Y, .025)
		return UDim2.fromScale(x, y)
	end
	local function animateIn(card, template, target, direction, animation, slideFrom)
		if template:GetAttribute('SlideAcrossScreen') == true then
			card.Position = offscreen(card, slideFrom, target)
			local tween = TweenService:Create(card, TWEEN_IN, {Position = target})
			tween:Play()
			return tween
		end
		if animation == "Fade" then
			local parts = fadeParts(card)
			card.BackgroundTransparency = 1
			for _, part in ipairs(parts) do
				part.inst[part.prop] = 1
			end
			TweenService:Create(card, TWEEN_IN, { BackgroundTransparency = template.BackgroundTransparency }):Play()
			for _, part in ipairs(parts) do
				TweenService:Create(part.inst, TWEEN_IN, { [part.prop] = part.value }):Play()
			end
		elseif animation == "Pop" then
			-- Writing Size on an axis the card sizes automatically is simply
			-- overridden, so pop only the axes we actually own. A card that
			-- owns neither (AutomaticSize.XY) just appears.
			local auto = card.AutomaticSize
			local autoX = auto == Enum.AutomaticSize.X or auto == Enum.AutomaticSize.XY
			local autoY = auto == Enum.AutomaticSize.Y or auto == Enum.AutomaticSize.XY
			if not (autoX and autoY) then
				local full = card.Size
				local sx = autoX and 1 or 0.85
				local sy = autoY and 1 or 0.85
				card.Size = UDim2.new(full.X.Scale * sx, full.X.Offset * sx, full.Y.Scale * sy, full.Y.Offset * sy)
				TweenService:Create(card, TWEEN_IN, { Size = full }):Play()
			end
		else
			-- Slide: start off-screen past one edge and travel to the
			-- template's own position. WHICH edge is the template's own
			-- `SlideFrom` attribute; `Auto` derives it from the stack's
			-- direction, which is what this did before the attribute
			-- existed. Only the entry changes - `target` is untouched.
			-- AbsoluteSize, not Size: a card that sizes itself (the Banner's
			-- auto width) carries only its MINIMUM in Size.X.Offset, and the
			-- slide would start from the wrong place. Same fallback as
			-- `place` uses for an instance that has never rendered.
			local abs = card.AbsoluteSize
			local screen = screenGui.AbsoluteSize
			local w = (abs.X > 0) and abs.X or (card.Size.X.Scale * screen.X + card.Size.X.Offset)
			local h = (abs.Y > 0) and abs.Y or (card.Size.Y.Scale * screen.Y + card.Size.Y.Offset)
			-- The template's own anchor, so Auto answers "from the edge this
			-- card hangs nearest" rather than "from wherever the column
			-- happens to grow".
			local ax, ay = anchorOf(template)
			local edge = rules.entryEdge(direction, slideFrom, ax, ay)
			local dx, dy = rules.entryOffset(edge, w, h, SLIDE_MARGIN)
			-- In scale too, for the same reason as the stack step: nothing
			-- about a card's position should be a pixel count.
			local vp = screenGui.AbsoluteSize
			card.Position = UDim2.new(
				target.X.Scale + ((vp.X > 0) and (dx / vp.X) or 0),
				target.X.Offset,
				target.Y.Scale + ((vp.Y > 0) and (dy / vp.Y) or 0),
				target.Y.Offset
			)
			TweenService:Create(card, TWEEN_IN, { Position = target }):Play()
		end
	end

	--- Takes a card off screen: out of the stack now, faded and destroyed a
	--- moment later.
	---
	--- ONCE ONLY. A card can now be dismissed EARLY to make room for a newer
	--- one, and its Duration timer is still pending when that happens -- so
	--- without this flag the timer fires on an entry already gone and
	--- reflows the stack a second time for no reason. `card.Parent` is not
	--- enough of a guard: the card stays parented through the fade.
	local function dismiss(entry, stack)
		if entry.dismissed then
			return
		end
		entry.dismissed = true
		local card = entry.card
		for i, e in ipairs(stack.entries) do
			if e == entry then
				table.remove(stack.entries, i)
				break
			end
		end
		if entry.entrance then entry.entrance:Cancel() end
		local exitTo = entry.template:GetAttribute('ExitTo')
		if exitTo == 'Left' or exitTo == 'Right' or exitTo == 'Top' or exitTo == 'Bottom' then
			TweenService:Create(card, TWEEN_OUT, {Position = offscreen(card, exitTo, card.Position)}):Play()
		else
			TweenService:Create(card, TWEEN_OUT, { BackgroundTransparency = 1 }):Play()
			for _, part in ipairs(fadeParts(card)) do
				TweenService:Create(part.inst, TWEEN_OUT, { [part.prop] = 1 }):Play()
			end
		end
		task.delay(TWEEN_OUT.Time, function()
			card:Destroy()
			if alive then trove:Remove(card) end
		end)
		reflow(stack)
	end

	-- ── public ───────────────────────────────────────────────────────────

	--- kind: "toast" | "banner" | "chat".
	--- Banner is a toast on one of the banner templates; the split exists so
	--- a caller can say "banner" without knowing which. Naming a template
	--- explicitly always wins.
	function toaster.Show(kind, template, data)
		if not alive then return end
		data = data or {}
		if kind == "chat" then
			showChat(data)
			return
		end

		local name = template
		if kind == "banner" then
			name = template
				or rules.bannerTemplate(data, function(candidate)
					local t = templatesFolder:FindFirstChild(candidate)
					return t ~= nil and t:IsA("GuiObject")
				end)
		end
		if type(name) ~= "string" or name == "" then
			return
		end

		local source = templatesFolder:FindFirstChild(name)
		if not source or not source:IsA("GuiObject") then
			warnOnce(
				"template:" .. name,
				("no template named '%s' in NotificationsSystemGUI.Templates, so that notification is being dropped"):format(name)
			)
			return
		end

		local stack = stackFor(source)
		-- MaxOnScreen counts this TEMPLATE's cards, not the stack's. It is a
		-- cap on how much of one kind you see at once; a shared stack is
		-- still allowed to hold four toasts and a friend-joined card.
		local mine = 0
		for _, e in ipairs(stack.entries) do
			if e.name == name then
				mine += 1
			end
		end
		-- AT THE CAP, THE OLDEST MAKES WAY (user, 2026-08-26). This used to
		-- queue the newcomer until a slot opened, which meant a notification
		-- could arrive describing a moment already gone -- and under a burst
		-- the queue drained one card per Duration, so the tenth showed up
		-- half a minute late. The newest thing that happened is the thing
		-- worth showing.
		--
		-- OLDEST FIRST, and in this stack that is the first entry with this
		-- name: cards are appended, so the front of the list is both the
		-- earliest and the one nearest the anchor. It is also the one the
		-- player has had the longest to read.
		for _ = 1, rules.evict(mine, setting(source, data, "MaxOnScreen")) do
			local oldest
			for _, e in ipairs(stack.entries) do
				if e.name == name then
					oldest = e
					break
				end
			end
			if not oldest then
				break
			end
			dismiss(oldest, stack)
		end

		local card = source:Clone()
		card.Name = name .. "Card"
		card.Visible = true
		fill(card, source, data)
		card.Parent = screenGui
		trove:Add(card)

		-- No `w`/`h` on the entry any more: a size kept here is a size that
		-- can go out of date, and `place` measures the template it already
		-- holds a reference to.
		local entry = {
			card = card,
			name = name,
			template = source,
		}
		table.insert(stack.entries, entry)
		local target, direction = place(stack, #stack.entries, false)
		entry.entrance = animateIn(
			card,
			source,
			target,
			direction,
			setting(source, data, "Animation"),
			setting(source, data, "SlideFrom")
		)

		local sound = setting(source, data, "Sound")
		if type(sound) == "string" and sound ~= "" then
			SFX:Play(sound)
		end

		-- THE TIMER BAR (3.0.1). A card with a `Timer` Frame holding a
		-- `Fill` shows how long it stays: the Fill's width goes from the
		-- whole bar to nothing over this card's Duration, linearly, from the
		-- moment it is shown. A card without one is untouched.
		local timer = card:FindFirstChild("Timer")
		local timerFill = timer and timer:FindFirstChild("Fill")
		local duration = setting(source, data, "Duration")
		if timerFill and timerFill:IsA("GuiObject") and type(duration) == "number" and duration > 0 then
			local size = timerFill.Size
			timerFill.Size = UDim2.new(1, size.X.Offset, size.Y.Scale, size.Y.Offset)
			TweenService:Create(timerFill, TweenInfo.new(duration, Enum.EasingStyle.Linear), {
				Size = UDim2.new(0, size.X.Offset, size.Y.Scale, size.Y.Offset),
			}):Play()
		end

		task.delay(setting(source, data, "Duration"), function()
			if card.Parent then
				dismiss(entry, stack)
			end
		end)
	end

	-- A SCREEN THAT CHANGES SHAPE RE-PLACES EVERY LIVE CARD. The step between
	-- two cards is a fraction of the screen height, so a stack laid out for
	-- the old shape drifts out of line with the anchor it hangs from - which
	-- is what a player sees when they resize a window, and what a developer
	-- sees the whole time a Studio viewport is settling. Instantly, not
	-- tweened: a resize is not an animation, and a card sliding to catch up
	-- with a window reads as a bug.
	trove:Add(screenGui:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
		for _, stack in pairs(stacks) do
			for i = 1, #stack.entries do
				place(stack, i, false)
			end
		end
	end))

	return toaster
end

return Toaster
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
          </Item>
          <Item class="Folder" referent="27">
            <Properties>
              <string name="Name">Migrations</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <Color3 name="IconTint">
                <R>0</R>
                <G>0</G>
                <B>0</B>
              </Color3>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
            <Item class="ModuleScript" referent="28">
              <Properties>
                <string name="Name">Content</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Migrations/Content - generated by node tools/v3/b-release/run.mjs fingerprints NotificationsSystem (plan B0)
-- from tools/v3/b-release/packs/NotificationsSystem.json and fingerprints computed in Studio.
-- Do not edit it: change the descriptor and run that command again.
--   each entry: a subtree of buyer content, and "<PackId>@<version> <element>"
--   of every published 2.x copy with its fingerprint (Migrate.contentFingerprint).
return {
	{
		path = "ReplicatedStorage/Packs/NotificationsSystem/Assets/CounterEffects",
		published = {
			["NotificationsSystem@2.1.0 ReplicatedStorage/Packs/NotificationsSystem/Assets/CounterEffects"] = "f2:e4023159:b4ed69c0",
			["NotificationsSystem@2.1.1 ReplicatedStorage/Packs/NotificationsSystem/Assets/CounterEffects"] = "f2:e4023159:b4ed69c0",
			["NotificationsSystem@3.0.0 ReplicatedStorage/Packs/NotificationsSystem/Assets/CounterEffects"] = "f2:e4023159:b4ed69c0",
		},
	},
}
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="29">
              <Properties>
                <string name="Name">FromV2</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Migrations/FromV2 - Notifications System 2.x to the 3.0 configuration
-- (plan B1). T.migrate reads the two 2.x sources Migrations/Sources names
-- into plain data (plugins/Official/Tools/Core/Tree.lua: node = { name,
-- class, value?, attributes, children, deep? }) and calls FromV2(trees,
-- ctx), trees = { Settings = node?, Triggers = node? } (a source the game
-- deleted is absent), ctx = { packId, fromVersion, find }. Pure: data in,
-- data out; no game, no Instances, no script.
--
-- Returns (config, notes, sources, refusals). config holds Announcements
-- (Messages always, the rest when 2.x ran a value of its own) and all four
-- Triggers switches; T.migrate writes only what differs from the Schema's
-- defaults. notes = { { path, message, fix?, action?, carried? } } says what 2.x did
-- with each value that is not carried as it stood; the note of a trigger of
-- the game's own gives its own fix, which T.migrate reports in place of its
-- generic one (B3b acceptance R1), and the one of same-name triggers, which
-- asks the user which to keep, is marked action = true (migration-action,
-- B3b acceptance R2); sources = { [option path] = 2.x path }
-- names where each carried value came from ("Announcements.Messages[2]" =
-- "Settings.Announcements.Message7"). 2.x booted on every value there is,
-- so refusals is always empty.
--
-- It mirrors Notifications System 2.x exactly: Config.lua, the trigger loop
-- of the server module and the Announcements trigger's use of both (the
-- same in 2.0.0, 2.1.0 and 2.1.1). tests/fromv2.spec.luau runs those
-- modules from every published release on the same trees, and the 3.0
-- server on what this returns, and compares which triggers start and what
-- the rotation announces, when and where:
--   * Announcements is the first child of Settings with that name, of any
--     class (FindFirstChild); a later one is never read;
--   * IntervalMinutes is the first child with that name when it is a
--     NumberValue or an IntValue, otherwise 5 (a StringValue first shadows a
--     later NumberValue). Carried as it is: the rotation waits
--     max(30 seconds, minutes x 60) in 2.x and in 3.0, so anything under half
--     a minute stays every 30 seconds. NaN and minus infinity ran every 30
--     seconds, as 0 does: carried as 0, noted. Plus infinity never
--     announced: Triggers.Announcements is written off, noted;
--   * Surface: only a StringValue whose text is exactly "Banner" showed
--     banners; anything else ("banner", "Banner ", "", another class) sent
--     chat lines: carried as "Chat", noted;
--   * Shuffle: a BoolValue's value, otherwise false;
--   * Messages: the StringValue children named Message<digits> (the name is
--     case-sensitive) whose text has a character that is not a space, in
--     the order of that number, each exactly as written ({tokens} included:
--     2.x never replaced them). Children with the same number keep tree
--     order (2.x left their order to an unstable sort), noted. Everything
--     else under Announcements, and every other child of Settings, 2.x never
--     read: noted. No messages (or no Settings, or no Announcements) is
--     written as an empty list, so the three default messages never start
--     in a game whose 2.x rotation announced nothing;
--   * Triggers.<Name>, for the four shipped triggers: on when a direct
--     ModuleScript child of the 2.x Triggers folder has that name and an
--     Enabled attribute that is not the boolean false (absent, "false" or 0
--     meant on); off when there is none (the game deleted it, or it is not a
--     ModuleScript) or every one is false. Two with one name both ran in
--     2.x: noted (3.0 runs one). Without a Triggers folder no trigger ran:
--     all four off, noted;
--   * a module of the game's own in Triggers: T.migrate carries it (its
--     Enabled attribute, still its switch, included) into
--     ServerScriptService.RBLXEssentials.Extensions.NotificationsSystem;
--     noted once per name, with what changes for it: its ctx has no
--     settings, and the pack's folder has no Config or Settings. T.migrate
--     carries only the first child of each name (a later one stays in the
--     migration backup: extension-exists), and 3.0 runs it when it is a
--     ModuleScript whose Enabled is not false, where 2.x started every
--     ModuleScript of that name that was on: the note says so, and says
--     when the trigger stops running (the first is off, a later one on).
--     Since plan B3a T.migrate refuses same-name children there first
--     (migrate-keep-duplicate), so that note's fix asks the user which one
--     to keep (B3b acceptance R1). B3b acceptance R3 premortem: the note
--     names the module it is about (`carried`), so T.migrate ends its line
--     in the report with what it found in it once carried, and the first
--     sentence of a single trigger whose Enabled is false (the line the
--     report gives) says it is switched off, as the game had it, so Play
--     does not prove it.
local SHIPPED = { "Announcements", "FriendJoined", "JoinLeave", "Purchases" }
local SHIPPED_SET = { Announcements = true, FriendJoined = true, JoinLeave = true, Purchases = true }
local KNOWN = { IntervalMinutes = true, Surface = true, Shuffle = true }

-- first(node, name) -> the first child with that name (FindFirstChild).
local function first(node, name)
	for _, child in ipairs(node and node.children or {}) do
		if child.name == name then
			return child
		end
	end
	return nil
end

local function shown(node)
	if node.value == nil then
		return ("a %s"):format(node.class)
	elseif type(node.value) == "string" then
		return ("a %s %q"):format(node.class, node.value)
	end
	return ("a %s %s"):format(node.class, tostring(node.value))
end

return function(trees, ctx)
	trees = trees or {}
	local config, notes, sources = {}, {}, {}
	local function note(path, message, fix, action, carried)
		table.insert(notes, { path = path, message = message, fix = fix, action = action, carried = carried })
	end
	local announcements = { Messages = {} }
	config.Announcements = announcements
	local switches = {}
	config.Triggers = switches
	local neverAnnounces = false

	-- ── Settings ──
	local settings = trees.Settings
	local root = if settings ~= nil then settings.name else "Settings"
	local an = first(settings, "Announcements")
	if settings == nil then
		note(root, "is missing, so 2.x announced nothing (its Config read no message): Announcements.Messages is written empty")
	else
		local seen = false
		for _, child in ipairs(settings.children) do
			if child.name ~= "Announcements" then
				note(root .. "." .. child.name, "is not a Notifications System 2.x setting, so 2.x never read it")
			elseif seen then
				note(root .. ".Announcements", ("is a second child named Announcements (%s): 2.x read only the first one, and so does this"):format(child.class))
			end
			seen = seen or child.name == "Announcements"
		end
		if an == nil then
			note(root, "has no Announcements, so 2.x announced nothing: Announcements.Messages is written empty")
		end
	end
	if an ~= nil then
		local path = root .. ".Announcements"
		-- A setting's first child wins; a later one of that name is shadowed.
		local counts = {}
		for _, child in ipairs(an.children) do
			if KNOWN[child.name] then
				counts[child.name] = (counts[child.name] or 0) + 1
				if counts[child.name] == 2 then
					note(path .. "." .. child.name, ("is a second child named %s: 2.x read only the first one, and so does this"):format(child.name))
				end
			end
		end

		local interval = first(an, "IntervalMinutes")
		if interval ~= nil and (interval.class == "NumberValue" or interval.class == "IntValue") and type(interval.value) == "number" then
			local value = interval.value
			sources["Announcements.IntervalMinutes"] = path .. ".IntervalMinutes"
			if value ~= value or value == -math.huge then
				announcements.IntervalMinutes = 0
				note(path .. ".IntervalMinutes", ("is %s: 2.x ran the rotation every 30 seconds with it, which is what 0 does: carried as 0"):format(tostring(value)))
			elseif value == math.huge then
				neverAnnounces = true
				note(path .. ".IntervalMinutes", "is infinite: 2.x waited forever before the first announcement, so the rotation never ran: Triggers.Announcements is written off, and IntervalMinutes keeps its default")
			else
				announcements.IntervalMinutes = value
			end
		elseif interval ~= nil then
			note(path .. ".IntervalMinutes", ("is %s, which 2.x's Config skipped: 2.x waited 5 minutes, the default"):format(shown(interval)))
		end

		local surface = first(an, "Surface")
		if surface ~= nil and surface.class == "StringValue" then
			sources["Announcements.Surface"] = path .. ".Surface"
			if surface.value == "Banner" then
				announcements.Surface = "Banner"
			else
				announcements.Surface = "Chat"
				if surface.value ~= "Chat" then
					note(path .. ".Surface", ("is %q: 2.x showed banners only for the exact text \"Banner\" and sent anything else to the chat: carried as \"Chat\""):format(tostring(surface.value)))
				end
			end
		elseif surface ~= nil then
			note(path .. ".Surface", ("is %s, which 2.x's Config skipped: 2.x used the chat, the default"):format(shown(surface)))
		end

		local shuffle = first(an, "Shuffle")
		if shuffle ~= nil and shuffle.class == "BoolValue" then
			sources["Announcements.Shuffle"] = path .. ".Shuffle"
			announcements.Shuffle = shuffle.value == true
		elseif shuffle ~= nil then
			note(path .. ".Shuffle", ("is %s, which 2.x's Config skipped: 2.x went in order, the default"):format(shown(shuffle)))
		end

		local found = {}
		for index, child in ipairs(an.children) do
			local number = tonumber(string.match(child.name, "^Message(%d+)$"))
			if number ~= nil and child.class == "StringValue" then
				local text = if type(child.value) == "string" then child.value else ""
				if string.match(text, "%S") ~= nil then
					table.insert(found, { number = number, index = index, name = child.name, text = text })
				else
					note(path .. "." .. child.name, "is blank, so 2.x skipped it")
				end
			elseif number ~= nil then
				note(path .. "." .. child.name, ("is %s, not a StringValue, so 2.x never showed it"):format(shown(child)))
			elseif not KNOWN[child.name] then
				note(path .. "." .. child.name, "is not a Notifications System 2.x setting (a message is a StringValue named Message<number>), so 2.x never read it")
			end
		end
		table.sort(found, function(a, b)
			if a.number ~= b.number then
				return a.number < b.number
			end
			return a.index < b.index
		end)
		for position, entry in ipairs(found) do
			table.insert(announcements.Messages, entry.text)
			sources[("Announcements.Messages[%d]"):format(position)] = path .. "." .. entry.name
			local previous = found[position - 1]
			if previous ~= nil and previous.number == entry.number then
				note(path .. "." .. entry.name, ("has the number %d, like %s.%s: 2.x showed both, in an order it left to an unstable sort; both are carried, in tree order"):format(
					entry.number, path, previous.name))
			end
		end
	end

	-- ── Triggers ──
	local triggers = trees.Triggers
	if triggers == nil then
		for _, name in ipairs(SHIPPED) do
			switches[name] = false
		end
		note("Triggers", "is missing, so 2.x started no trigger: all four switches are written off")
	else
		local path = triggers.name
		for _, name in ipairs(SHIPPED) do
			local modules = {}
			for _, child in ipairs(triggers.children) do
				if child.name == name and child.class == "ModuleScript" then
					table.insert(modules, child)
				end
			end
			if #modules == 0 then
				switches[name] = false
				note(path .. "." .. name, ("is not a ModuleScript in Triggers (the game deleted or replaced it), so 2.x never started it: Triggers.%s is written off"):format(name))
			else
				local on = false
				for _, module in ipairs(modules) do
					local enabled = module.attributes and module.attributes.Enabled
					on = on or enabled ~= false
					if enabled ~= nil and type(enabled) ~= "boolean" then
						note(path .. "." .. name, ("has the Enabled attribute %s (%s): 2.x turned a trigger off only with the boolean false, so it ran"):format(
							tostring(enabled), type(enabled)))
					end
				end
				switches[name] = on
				sources["Triggers." .. name] = path .. "." .. name
				if #modules > 1 then
					note(path .. "." .. name, ("is %d ModuleScripts with that name: 2.x started each one that was on, so its notifications came more than once; 3.0 runs %s once"):format(
						#modules, name))
				end
			end
		end
		-- The game's own children, grouped by name in tree order.
		local names, byName = {}, {}
		for _, child in ipairs(triggers.children) do
			if not SHIPPED_SET[child.name] then
				if byName[child.name] == nil then
					byName[child.name] = {}
					table.insert(names, child.name)
				end
				table.insert(byName[child.name], child)
			end
		end
		local function runs(child)
			return child.class == "ModuleScript" and (child.attributes and child.attributes.Enabled) ~= false
		end
		for _, name in ipairs(names) do
			local group = byName[name]
			local modules, ran = 0, 0
			for _, child in ipairs(group) do
				if child.class == "ModuleScript" then
					modules += 1
					if runs(child) then
						ran += 1
					end
				end
			end
			if modules > 0 then
				-- B3b acceptance R3 premortem: the first sentence is the note's
				-- line in the report (T.migrate's brief), so a single trigger
				-- that is off says so there.
				local off = #group == 1 and not runs(group[1])
				local message = if off
					then "is a trigger of the game's own, switched off, as the game had it, so Play does not prove it: T.migrate carries it, with its Enabled attribute false (still its switch), into ServerScriptService.RBLXEssentials.Extensions.NotificationsSystem. The 3.0 server starts it only when that attribute is not false, as 2.x did. Its ctx has no settings in 3.0, and the pack's folder no longer has Config or Settings: if it reads ctx.settings, ctx.folder.Config or ctx.folder.Settings, make it read ctx.config"
					else "is a trigger of the game's own: T.migrate carries it, with its Enabled attribute (still its switch), into ServerScriptService.RBLXEssentials.Extensions.NotificationsSystem. The 3.0 server starts it when that attribute is not false. Its ctx has no settings in 3.0, and the pack's folder no longer has Config or Settings: if it reads ctx.settings, ctx.folder.Config or ctx.folder.Settings, make it read ctx.config"
				-- T.migrate checks each module it carries to Extensions for
				-- ctx.settings, ctx.folder.Config and ctx.folder.Settings
				-- (reads-ctx-settings), and for script.Parent, through which a
				-- trigger reached its old neighbours (reads-script-parent).
				local named = "reads-ctx-settings or reads-script-parent names this trigger's module (T.migrate looks in it for ctx.settings, ctx.folder.Config and ctx.folder.Settings, and for a read of its own Parent, through which it reached its old neighbours: the Triggers folder and the pack's modules)"
				local fix = ("Nothing to do unless %s: then ask the user, and change it as that issue's fix says. Check it in Play (extension-carried)"):format(named)
				if #group > 1 then
					message ..= (". There are %d children named %s: 2.x started each ModuleScript among them that was on (%d); T.migrate carries only the first, the others stay in the migration backup (extension-exists), and 3.0 runs at most that one"):format(
						#group, name, ran)
					-- B3b acceptance R1: what to do. Since plan B3a, T.migrate
					-- refuses same-name children in Triggers (migrate-keep-duplicate,
					-- never forced) before it carries any: the game keeps one.
					local stops = ran > 0 and not runs(group[1])
					if stops then
						message ..= ", which is off or not a ModuleScript: this trigger stops running in 3.0"
					end
					fix = ("Ask the user which %s the game wants: T.migrate refuses %d children named %s in Triggers (migrate-keep-duplicate) before it carries any. Keep only that one there (merge the others into it, or rename them), then run T.migrate() again.%s Once it is carried, if %s, ask the user, then change it as that issue's fix says. Check it in Play (extension-carried)"):format(
						name, #group, name,
						if stops then " The first is off or not a ModuleScript and 2.x ran a later one: if the game still wants this trigger, keep the one that ran (a ModuleScript whose Enabled is not false), or it stops running in 3.0." else "",
						named)
				end
				-- B3b acceptance R2: asking the user which one to keep is an
				-- action (migration-action); a single trigger needs nothing
				-- unless a reads- issue names it.
				note(path .. "." .. name, message, fix, if #group > 1 then true else nil, name)
			end
		end
	end
	if neverAnnounces then
		switches.Announcements = false
	end
	return config, notes, sources, {}
end
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="30">
              <Properties>
                <string name="Name">Interface</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Migrations/Interface - generated by node tools/v3/b-release/run.mjs fingerprints NotificationsSystem (plan B0)
-- from tools/v3/b-release/packs/NotificationsSystem.json and fingerprints computed in Studio.
-- Do not edit it: change the descriptor and run that command again.
--   derived: per piece, the properties and attributes a 2.x action wrote
--     from Settings, never counted as an edit (or a function of the
--     configuration that returns them);
--   conditional: for such a function, every rule it may return and the
--     published values of what they name (Migrate.conditionalValues);
--   published: per piece, "<PackId>@<version> <element>" of every published
--     2.x copy and its fingerprint (Migrate.pieceFingerprint);
--   foreign: this pack's own 2.x copies of other packs' pieces, each on its
--     owner piece's slot (key); standIn, when present, is this pack's own
--     piece that stands in for that owner piece (Kernel 3.0.1 standsInFor).
return {
	conditional = {},
	derived = {},
	foreign = {},
	published = {
		NotificationLayer = {
			["NotificationsSystem@2.0.0 StarterGui/NotificationsSystem/NotificationsSystemGUI"] = "f2:e4023159:8b981cd6",
			["NotificationsSystem@2.1.0 StarterGui/NotificationsSystem/NotificationsSystemGUI"] = "f2:e4023159:8b981cd6",
			["NotificationsSystem@2.1.1 StarterGui/NotificationsSystem/NotificationsSystemGUI"] = "f2:e4023159:8b981cd6",
		},
	},
}
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="31">
              <Properties>
                <string name="Name">Keep</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Migrations/Keep - what T.migrate must look at in the 2.x pack's own code
-- (plan B1). Everything below "return {" is generated from the published
-- 2.x releases by tools/v3/keep-gen.luau (plan B0, ruling 11): run it again
-- after a 2.x release, and with --check to compare.
--
-- folders: the server module's Triggers folder. A ModuleScript there that
--   no 2.x release shipped is a trigger of the game's own: T.migrate copies
--   it, with its Enabled attribute (still its switch in 3.0) and whatever
--   is inside it, into ServerScriptService.RBLXEssentials.Extensions.
--   NotificationsSystem (the game's zone, which the 3.0 server runs its
--   triggers from after the shipped ones) and says so. Only the first
--   child of each name is placed there; a later one stays in the migration
--   backup (extension-exists), and FromV2's note says what that changes.
-- shipped: every script a 2.x release shipped under the pack's own roots
--   (ReplicatedStorage/Packs/NotificationsSystem, ServerScriptService/Packs/
--   NotificationsSystem; the StarterGui folder ships none), keyed
--   "<service key>/<path under that service's RBLXEssentials>", with the
--   SourceHash (plugins/Official/src/Shared/SourceHash.lua) of every
--   published version of it. A game that edited one (a trigger's wording,
--   which 2.x told buyers to edit in the file; a rule in Notifications or
--   the renderer) makes T.migrate refuse without force
--   (migrate-custom-modified) and name the lines it changed. Move the
--   wording into Config.NotificationsSystem first; with force, the 3.0
--   version replaces it, the edited copy stays in the protected migration
--   backup and, for a trigger, becomes the game's own module of that name
--   in Extensions.NotificationsSystem, which runs instead of the shipped
--   one (its switch is still the config's). Not an edited Announcements:
--   2.x's requires 2.x's Config module and reads ctx.settings, which 3.0
--   does not have, so it cannot start; the 3.0 server then runs the shipped
--   Announcements on Config.NotificationsSystem and warns that the edit is
--   lost. Make such a change in a copy of the 3.0 Announcements instead.
-- lines: for each published SourceHash, SourceHash.fnv1a32 of each line of
--   that source, trimmed, blank lines left out, in order. T.migrate names
--   the lines a game changed with them.
return {
	folders = {
		"ServerScriptService/Packs/NotificationsSystem/Triggers",
	},
	shipped = {
		-- 2.0.0; 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Client"] = { "3a96255d", "58f39077" },
		-- 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Client/AwaitGui"] = { "e2838c36" },
		-- 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Client/CounterFlyout"] = { "74c7e2c3" },
		-- 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Client/TextFields"] = { "4e2b2e66" },
		-- 2.0.0; 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Client/Toaster"] = { "aefd4f15", "6ccdd88c" },
		-- 2.0.0, 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Config"] = { "8ba55bf6" },
		-- 2.0.0; 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Notifications"] = { "a6628e17", "f3fc3bc4" },
		-- 2.0.0, 2.1.0, 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/Notify"] = { "15eb2328" },
		-- 2.0.0; 2.1.0; 2.1.1
		["ReplicatedStorage/Packs/NotificationsSystem/manifest"] = { "42ab170e", "7a0da48b", "1525d4e2" },
		-- 2.0.0, 2.1.0, 2.1.1
		["ServerScriptService/Packs/NotificationsSystem"] = { "073ffecc" },
		-- 2.0.0, 2.1.0, 2.1.1
		["ServerScriptService/Packs/NotificationsSystem/Triggers/Announcements"] = { "017b7136" },
		-- 2.0.0, 2.1.0, 2.1.1
		["ServerScriptService/Packs/NotificationsSystem/Triggers/FriendJoined"] = { "c52d889b" },
		-- 2.0.0, 2.1.0, 2.1.1
		["ServerScriptService/Packs/NotificationsSystem/Triggers/JoinLeave"] = { "3558556f" },
		-- 2.0.0, 2.1.0, 2.1.1
		["ServerScriptService/Packs/NotificationsSystem/Triggers/Purchases"] = { "f6571dd2" },
	},
	lines = {
		["017b7136"] = "c29f3550 f14d18e5 20cd1d0f 18183185 caeb1e46 fd5db6a1 5d1fed30 b67512ed 20cd1d0f 46378ae0 e3025651 75618b31 46ecac2f fba63aa2 5801d757 64fc6099 3909bd2b 6bf80be9 eae87df3 b921cf32 85ee37bf 6a8e75aa 6e2272b5 f5f56493 6f73a0a3 4142fd39 5fe1f84c a6ba117b 6cf2944f cb124246 e6e68dee 85ee37bf 6a8e75aa 77d2423b be05c153 923bd8e2 339ef78a 170cf500 bdbf5bf0 19ab6066 6a8e75aa 6a8e75aa 6a8e75aa 4142fd39 6a8e75aa e0631b63",
		["073ffecc"] = "11c35325 bbd7dc2e a98ab32d 671e81ae 4078bfa4 f85d41eb 80e3da8f 28db1518 10118da2 4545501d e278e528 e9bc6446 d654f462 85cbf262 1277babc 0b8f46f8 2e8fc6e6 9621498b 3aa216e4 3006c30f 1a6c5be4 0efe1257 11150029 84ff396c d9d17355 865cc7c5 3da4afd9 6a8e75aa 2630d305 e9669604 657ef143 f11def3e e6071993 ffe413f1 6a8e75aa 444301f2 d00b6b22 e0f1f424 444301f2 bcf24a2b e6071993 d8428b5b 6a8e75aa 444301f2 b66c2145 c149c7f6 444301f2 528cd863 67c68357 20a3e4de 8b9acf34 26eb77af 444301f2 1febde5e e6071993 6e11e37c 6a8e75aa 444301f2 fc562313 2eabcdb4 75a0e994 46d37dac 427109c0 93a13ea8 84bc7774 a221944a b35fa865 f3b475c3 ff6fa03a 6cfc999e b1727e44 6a8e75aa 2a11d43d 8dcbc7b6 bb4aab29 b1727e44 6a8e75aa 0bd43690 bfa75ae8 b1727e44 6a8e75aa 1401a6e8 b4323d6c 604aa5fb bdbf5bf0 1f45b65c 6a8e75aa 6a8e75aa 6a8e75aa b91fa8b7 b897b64d 5cf5adce 2cf990ce 04d77e57 5b503ded 6a8e75aa",
		["1525d4e2"] = "67747202 04469bf8 396d6cb6 3cc7ce36 d7e8c539 62f68616 19a2b6b4 be5684b2 36c6973c e7da21b9 46088491 c30f3f58 f7bd09fb 5833bf0f 17697943 84943509 f80c48a8",
		["15eb2328"] = "11c35325 cbe5e3d9 cf1dc6a3 b8003925 31508f4a d6869480 61cd9b5b 582b9ff6 2d5a595f 536db679 a1dc5838 dc48e1c6 795cd40f e3408731 421a9f20 60cba800 e22b3992 44a2842a 835aca2d 9d0a57b9 173f94db 43ca4aad b1381cd1 3006c30f 41e1255b f109fe60 3b4dbdaa 3fadeb46 01166138 c453f8d7 6a8e75aa 1b70d51f 1ec34d0a 6a8e75aa ec32d73b 2dd5da56 6a8e75aa 0366dc34 797a7d21 6a8e75aa 21df4713 609d467e 6a8e75aa 0e756a3e e435d2d9 6a8e75aa 023ea344",
		["3558556f"] = "f96ffb05 e9f8dee6 20cd1d0f 6233b896 3ffd14aa 206979df 855a4b1b 20cd1d0f 46378ae0 3e7dceeb 3d157ee7 4119dab4 696df615 aec50270 862c3d2c fa04ef58 64fc6099 6bf80be9 4034c788 c8c52a66 4142fd39 720c0d79 f226967b 4142fd39 6a8e75aa 9e4b7e14",
		["3a96255d"] = "11c35325 3d617f22 6d645774 30d86006 c07b76f4 bd0cddc7 b918ee4f 212c4eb8 4591cbdd 8f8b9f03 f0f0e3d2 7ecfa668 566aac1e 716031da d004e96d 2d9646e3 bfa49450 05609115 fb842300 fd123120 3006c30f d2be53d8 1a6c5be4 94ea55df 0efe1257 3e7dceeb 5a0cb120 64fc6099 ed7af9d6 81880ea6 fd25c734 5fe1f84c 190c0905 376c1993 416d8a00 d9bcea1f 99325762 4d1db5ff 7059a0b2 85ee37bf 6a8e75aa 6df90904 68403eea 657ef143 bacbd175 a1998124 444301f2 81857250 46316796 b3d5a6ab 31070ce6 444301f2 8b9acf34 0b8f2447 444301f2 fc562313 49c69519 783c425c 3465cf76 e48ff238 c826602b f0ffbfd0 85ee37bf 6a8e75aa 4a19c9b5 4142fd39 4142fd39 5b503ded 6a8e75aa",
		["42ab170e"] = "67747202 04469bf8 836bce0a 3cc7ce36 d7e8c539 62f68616 19a2b6b4 be5684b2 36c6973c e7da21b9 46088491 c30f3f58 f7bd09fb 5833bf0f 17697943 84943509 f80c48a8",
		["4e2b2e66"] = "ec0519ea 09172b7b c60738e1 d40715e9 18460c0b 166b7a54 ab3fe60d 6098993e ff3fccaa 31a91c9d 430921aa 26fc5fc1 5543c658 6a8e75aa 6a8e75aa 6a8e75aa d96d64d3",
		["58f39077"] = "11c35325 3d617f22 6d645774 30d86006 c07b76f4 bd0cddc7 b918ee4f 212c4eb8 4591cbdd 8f8b9f03 f0f0e3d2 7ecfa668 566aac1e 716031da d004e96d 2d9646e3 7b778445 1d9d9f70 3006c30f d2be53d8 ccb8e40a 0efe1257 3e7dceeb 5a0cb120 8a8b324a 2f7fc0e6 098a9cbb 64fc6099 64c8186e 25820928 cf54a7a6 356f6c73 f7149a7c 5cc6dd7f ed2875bc a5d40bc2 3eb7e4ff 7ba7e814 2cf64e65 6a8e75aa ed7af9d6 81880ea6 fd25c734 20df457b 25f46fec 1c8ae4a4 240b9c53 6df90904 68403eea 657ef143 bacbd175 a1998124 444301f2 81857250 46316796 b3d5a6ab 31070ce6 444301f2 8b9acf34 0b8f2447 444301f2 fc562313 49c69519 783c425c 3465cf76 e48ff238 c717536c 79267634 031dc9ae f0ffbfd0 85ee37bf 6a8e75aa 4a19c9b5 4142fd39 4142fd39 ac0690e8 6a8e75aa",
		["6ccdd88c"] = "11c35325 5d2eac43 3d99b319 c2887679 827822e6 f387a011 ea086b5c dce37cd1 d463f65f a1f2f69a d6511425 d1c6e2bd 229a201a 77911509 7a9c4cf0 e0f0ff3f de9b8a6c 4e1392c1 bcb822c3 a6a12ca3 f96b60aa 112829e9 461cca40 dcd9729b 63765586 5a219514 c4837678 dba28e47 cd0499ed ddb2d4a6 ffd96ffa 07fcfaf8 bf0f6f62 c2c2e1de e2fb6bb8 4cc3f57c 37909cd5 2191bef8 3006c30f 7679a729 56730c76 fda0718c 129f566d d59e094c 9efb1709 46bdacb9 c0da6dfe 149edfe9 fae34757 5c000ea5 de7dd1ab a20d0948 4b825063 2d258c8d 3108bbd3 8c27cde6 f80c48a8 1a6c5be4 87c8ac92 3e7dceeb 0b5ff32f e4cae9fb e4b92849 8a8b324a 2f7fc0e6 f74cde5b b2ef6a3a 8dbf3eaf ee10d87a 1e33519e f3f72b22 91b6d357 90dd35e9 2da56b90 82367ac5 85ee37bf 6a8e75aa ae92bc10 3273b3c9 6a8e75aa f0db4683 b1579acb ab769554 6d618dde 6a8e75aa 6c7479e1 6a8e75aa 3ee4e2fd 5bf1027b 3f958aa5 c990b5c4 b5e04f78 3af5c21b 3da14725 6a8e75aa 330168c2 6a8e75aa 81efec4f b2ad489c 2a831227 005817f9 85ee37bf 6a8e75aa a667d988 21beacb6 b6109f32 edb3622c b2727185 752b5768 85ee37bf 6a8e75aa 5b3ed71a a217c7e7 f8c3d214 b7c5d24d 6b3f920a a8ddf17d bde64e3e 2c0c9a84 6a8e75aa 5d171fa1 030808ef 4142fd39 8dcbc7b6 a07d3220 6a8e75aa 6a8e75aa e4a7f5ea 30608f55 9b4ee93c 6a8e75aa 7cb4fc52 3b4ed4be e64fb58c 65c8bceb b81e5f26 9a3a0e4d 1c482d04 6a8e75aa 6c8df227 6a8e75aa 1caa6c4b d22f1b6a a42b96ec ac135745 b63ebf35 e2ace3b9 43c11217 d6358bb9 6a8e75aa 3be9c5bd 6a8e75aa bde68d66 c05b9d60 c4e4dc86 05275dba 1e45e89e 75ca1379 7adfd4c5 58adc170 835cdebd df28b857 c4e4dc86 26b98fc3 8e2458e2 23cf7f13 1b7f50a1 1b0cbc72 1927736a 0e61834c 84ea8440 4337c762 7813651a dea6138f 97ff28bd cc1655ad 6a8e75aa d96bd593 b621a8d5 6a8e75aa f7a7bb8e 6a8e75aa ee24088f a9c9d7bc 6a8e75aa 4a7609f5 ab5cd0ac fa4e6170 fd0bb8c9 7d5562d7 dfd13da9 49d8b517 f2f10762 c6bb57b6 19ad9f45 ebbb96e9 100dff79 bf6c6478 fb4d976f 573cf1eb e8afa6c2 e74950a2 173c1929 7af73da6 6d1d7fca 51e818a2 62024962 6a8e75aa e49e7c1a 8512b1ab 3e3d7730 9ae522f9 a29b87cc 74fffd6d ed2b06e7 1b0cbc72 949aa68a 388007b7 21c3ae4f e7604ffd bb75ad2b 945b5a12 2c0c9a84 59e7f008 88863729 bdbf5bf0 69b2cc46 6a8e75aa 5e6b720d 6a8e75aa dffce564 930c7a73 62cc7d46 6a8e75aa 6a8e75aa 0a7211c6 4a7fed6e 4dfc4cf7 65417cc3 cf2dfd61 3c960a99 04b86bdd a73b29cb 0bb9c083 074cc107 c62c20ce 6a8e75aa 6a8e75aa 58d3359b 29261e89 1d42b909 6a8e75aa b6a1296f 30fd243f 2bc94a99 6a8e75aa 2cb5d30e 314f6dd8 c23a6319 b241b81f 1dc0f27a 225432b6 5fe12624 af8bf40e 6a8e75aa aa14c693 d1b4b7b7 25ca5ab5 cec1e08b b49ee85a 501de75a 2942085e 84633cdd 5fe1f84c 328e964b 92b26588 33b29790 646745c6 7aedb53a 2c0c9a84 4142fd39 1af48bb9 87bcb4e7 6a8e75aa 4142fd39 bdbf5bf0 b49ee85a 6a8e75aa 6a8e75aa 6a8e75aa e615af52 f16d3398 c888772d 2de3f7e8 3f422822 4a135cc8 c72f8a19 a29f7397 b89ec39f a9d177e0 6a8e75aa 5362702d ada0614d 0705b00d 9b3b4532 f9616c3e 6a8e75aa aae9ac12 22971838 6a8e75aa 7360d08f d8888e8d 6a8e75aa 6a8e75aa 63ec09dd 6a8e75aa 734e0034 1b0cbc72 6909b5b1 b5fba1d5 c12fb784 2067f152 6a8e75aa dbcd3418 141f75e2 b73fefcb 600df0c5 d249312f 21e33004 6a8e75aa d794e923 1e69fc38 eeb3e575 bd2dde43 e2d41384 6a8e75aa 5a04c7d9 bd2dde43 c63fd336 6a8e75aa 8f18f723 55c6c1b5 c46f818f 04e2dec5 c634a5d6 c3647904 e7e250a6 63bf5ca9 61dcd9b3 6a8b396d 417a4d31 d72ca3e9 64a60e2b 6a8e75aa bdbf5bf0 082bacae 7b32721d 54bfdef0 f134c78e feffb694 5176895d a7cbe1e9 a43b562e bbf0bb2f d726d127 1b0cbc72 43085c38 240558a4 fb295baf 231b9a5a a692f61a 48f9babd 96b042f6 3571f177 e7e9a102 7eee3d58 ba82a6d4 2fd56328 2352c127 a7c4654d 1d78869f 612c7f82 2c0c9a84 7bbc63c9 6a8e75aa 6a8e75aa 7368e60f 239689fe c4e4dc86 b8eeea20 9827a213 bf129bc3 c740fd98 f0235f51 636141af 392d28e0 85ee37bf 6a8e75aa bfb27e29 6c96c7a7 777fd2c5 78937b64 7d8a9b17 c9648178 6a8e75aa 6a8e75aa 5668b6df 189148ac ce45d70f 4648a641 bdbf5bf0 6fba0711 634d2e20 c7279ec4 6a8e75aa 6a8e75aa 1323ca3f bad12ee4 3da9966a 4142fd39 eaf84113 6a8e75aa 851165c4 9198bd4b 43944d4e 0076b566 e256a22d 9f6e2037 79267634 3a86e1c9 812d728f 3f47251d 85ee37bf 6a8e75aa e9700f86 cfe652f7 1b015805 0131e66b ea203403 5cd6ce9e 4142fd39 6a8e75aa c08c39cd 85ee37bf 6a8e75aa 28d2f450 e2d0360a f0175d10 21102f2c 16cad59a 2c0c9a84 85ee37bf 6a8e75aa 1efd4196 bf1d6861 03678da5 bb9b7867 1ea1b8bc 9e5bd0cf ef5a476e d84050b5 6a8e75aa 6a8e75aa f43474f5 7544f05f 96994f27 cb70bd30 1533950b 70f58b16 20cd1d0f 42669652 4ea37dd2 c3b16004 07b2f2d3 653c27ab 8974925f 9e5bd0cf ef5a476e db23af5e c9648178 6a8e75aa 6a8e75aa fe6db9ed c9648178 6a8e75aa 5fa59f65 6a8e75aa a8bc87fa 55d99364 a5a0ad10 2f7826ce 45f99c03 233d60bd c37873d8 f9736cb7 649c81a6 c8f0fc7e 91008246 4adba7f8 37ab302f f80c48a8 6378025b 7a2e9501 58f3023e c8f1d009 bb1f0b1c b1f6b56c ffd0b332 66d8856b a74bc25e 2c0c9a84 9a0e9a7d 12e6a78f a3aaa4be 6a8e75aa 8661ccbe 8d0adaf1 a12ef9ec 6a8e75aa 4142fd39 6a8e75aa 594a4997 bb232f38 b54f338b 95f4ad9a a274ace0 ecc37769 03e3e792 0e4d014e 50b83c0c 930c7a73 fc62586d 6a8e75aa 6a8e75aa cc746030 97fadeef 6a8e75aa db96168f",
		["74c7e2c3"] = "6164ac57 18b7b402 60019f3a e51f8c72 b2a9c75b 6a8e75aa 8d64b15e a2f0e64d 233efddf 3394e513 628bff10 ec4408d0 4de5808c 1afcfe2a c99eaef3 0e3ebf88 643912ce de8081ba aead26b4 2a4148e8 bc04c08d 6a8e75aa 0f00f9f9 ae2385a1 d396715b 588ccd4b 1a86e376 6c7029b2 60e7a695 ca4ca09a 94151011 bbd048f8 9ea2a738 6074387f 6a8e75aa 4142fd39 20f0d1ef 6a8e75aa 8d3ca4dd 87ad42fb 59fcf4bb 25f4ffbb 28bc4786 4643c3f6 6a8e75aa f6749470 79267634 77050a17 e7fb1b1b f0379fdd 860fdadb f0f56afd 15b30e2d 1c26e7f7 a4bf5d1c abdf218a ee403839 e98f1a1a d62a9257 72169030 cc74cbbe d9d44ef2 79267634 6122d32a ada014ce 4142fd39 6a8e75aa 6a8e75aa 6a8e75aa 6a8e75aa 9189a64f 9a074428 75a259ab ef9e8b5a b76fd949 7dc857f4 50823e6b 76291f2a f94d7a07 6a8e75aa 5783616e",
		["7a0da48b"] = "67747202 04469bf8 a849de35 3cc7ce36 d7e8c539 62f68616 19a2b6b4 be5684b2 36c6973c e7da21b9 46088491 c30f3f58 f7bd09fb 5833bf0f 17697943 84943509 f80c48a8",
		["8ba55bf6"] = "11c35325 d360276c 778e76d8 3431f5a3 fea486ec 61cc3063 7d99c0b0 dc69ff95 90a5fb30 1b97bdef 40488e7f f5d95572 81255b0f 21d4d999 640fb19d 4d516fce 3006c30f a56cf3cb 14cf2665 c474b703 77b6c302 6a8e75aa 62eb3766 6a8e75aa 3f65ceeb 14cf2665 0075ebc2 77b6c302 6a8e75aa 62eb3766 6a8e75aa 3e16682e 14cf2665 7b6521b2 77b6c302 6a8e75aa 62eb3766 6a8e75aa 26c06b44 5b41c476 2ceef6bd 6da1d907 74b6ff10 e9bea8a3 41c56509 a6afa106 a56e7291 076ed58b 3fdbbb47 37b8a9fd 6a8e75aa 6a8e75aa 6a8e75aa e444b7a5 c576c6e6 4142fd39 119afc59 c6481596 82182ed2 6a8e75aa d6248a47 6a8e75aa f4cc7e3d 2c172fb1 67747202 d11c78b5 1788a349 f885bc07 98f9f749 0dca06f8 ff5627cc f80c48a8 6a8e75aa",
		["a6628e17"] = "11c35325 96d8b9c4 78c0134b 7602c005 31b926f5 9e2a849e 644cec0d 8ad382d3 130b6734 3006c30f f377c659 d34e2bce 8825a94f e2a9fcde 43429c4e 6a8e75aa 10068fdc c1b7756e 939e680d 21bd6e3e 21fa7de9 ba4816d2 5587a92e 20cd1d0f 170f917b 1ec63145 63e0cb16 032e856f 80df425e cb8fbbca 0b93377e 6a8e75aa 1c4d147e 87f06595 fc46116d dd601dba 3cd13207 a5a78af1 65f9fc98 f287a8fc c4e4dc86 74552ce9 84640e61 428b9856 4f1d7084 f18ae93c a30cec4d 1e849735 36dc8b4d 6a8e75aa d626b0a1 1680f34a 8986f116 6a8e75aa b3ccaf7f 0f7182af 0426034f 7fdd5e74 6a8e75aa b034b297 4142fd39 d6248a47 6a8e75aa 4bd2bce5 c20f0325 7342ada8 7f4dce72 098a9cce 9e71f4ca 599b8bc4 6bf750d1 6a8e75aa 51121878 95bd7df2 31eb2ec3 cadd3adc 2e599ab6 6a8e75aa 6b74a7cd 6a8e75aa 47347eaf 84471ab9 c4e4dc86 a0d23428 526d6714 2c297044 c4e4dc86 013d75df 2e3c989b ed33c4c7 4e1845e8 b9c6608c faf41b24 cff7acc4 a379edf6 3ca75152 f9a990e7 2aea535f d85ac7bf 2fd099f2 444301f2 d0c0e052 cad5cb75 444301f2 ea910fe6 74d6db37 444301f2 1d31d00f 92056114 444301f2 00829994 b96b8b5f 444301f2 f80c48a8 f4738862 83bc2272 95652726 c4e4dc86 a1ae5cd3 ea1cd299 dac9b99c deba98f7 fcfffe13 f7586959 48d3e274 6a8e75aa d38f81bb 2a7ae3db 48d3e274 6a8e75aa 1b03c172 6a8e75aa aa90174e 0783e72e 1eff943c 8085b0b4 79fae589 2f54e0a2 56823355 c4e4dc86 13af0096 ee62d15e 479b7d9b 08eb1510 b1febc42 c4e4dc86 a175d6f1 e96afed1 20f1359a 5cd0feba b9e6a98f 547251cd 25cae952 6a8e75aa 6a8e75aa b0ca843d 6a8e75aa 9451ef8c 33af85cc 0b99953a c4e4dc86 fc0f656d ab4225f6 0e8ee839 f21037b7 38ffff4d 2784a4c3 a650f641 81cf6be6 6ec2ecac 85ccee12 01838fce 6a8e75aa 6a8e75aa 991c5523 6a8e75aa d22b3146 fccd59e6 f515d6bf b59efb06 b27d8b6a c4e4dc86 9da88231 a37d0014 c703ee83 ee9de911 1e73703e b64959c7 3e087ce5 aa2cbd06 b32969ab 35ddb762 22b101ba 1e8fae9f a9530441 bb5230c1 74ef85c1 073b6b17 196bc4dc 6a8e75aa f01d2a2f d0879143 6a8e75aa 911a1380 6a8e75aa efdd1db5 39c8e4aa 3468f011 c4e4dc86 5f6acdee f906e33e c6b46893 6cf703fc 18a1a3f5 d916cc80 65e1877d 42f8272f cf477176 6a8e75aa 5c8d33d4 b7b73bfd 1e8f7066 292da488 b30b079d f16e49a9 6a8e75aa a3383dee 6a8e75aa 5daafbfe 0c1b4654 44088e79 cfe5b0db 6a8e75aa afac9ad8 c4e4dc86 7cd0bcb7 7c033f97 6f3bf04e 86e4761b 6299a023 d3678923 a57c4ce9 29909ef5 c4e4dc86 d946732e fbd2b146 b50694f6 7bcf2149 fa2f26dd a0f4665c ae74e1c7 6a8e75aa 357ef8e7 6a8e75aa c68e5ccd 7c9353ad 0d354713 3b1dad33 bb309082 d84470a0 ae74e1c7 6a8e75aa f5fa08d9 ad74e034 6a8e75aa 20dea3ea fd861902 3dc4c8c9 929cadaf 2e7c1213 6a8e75aa 53f4d380 6a8e75aa 5c2f53ed 6a8e75aa a4f3ebeb 3de245dc 4f40089e ff95c761 e87d2139 dc161208 5b6855ff 6a8e75aa 6a8e75aa a3f61826 f59877aa ece3fd20 2538f384 6a8e75aa 2072ecab b19a0c1d 7ff7f4cb c4e4dc86 0a9ab1d3 3a16d499 9a76aa28 75d31d92 9cca095f 5ecb7fe0 e6171eb2 0a53cba3 c4e4dc86 86109429 bd3fa751 4811025f c221e4ca 3da14725 6a8e75aa 97a474b7 260de09c 6a8e75aa b910153d 6a8e75aa 31441db9 d89c289e 2c8bf316 a0738a35 31501da3 747d96f5 37b83511 e499121e 5b833181 2979c414 9ce383e4 6a8e75aa dc13d0ec 6a8e75aa 17a54144 fbf0546a 78e16849 95496b49 27eabf11 d50e1822 c798caf8 86fbb7a7 a829cb83 6a8e75aa 6a8e75aa d6248a47 6a8e75aa 7c90a7f7",
		["aefd4f15"] = "11c35325 5d2eac43 3d99b319 c2887679 827822e6 f387a011 ea086b5c dce37cd1 d463f65f a1f2f69a d6511425 d1c6e2bd 229a201a 77911509 7a9c4cf0 e0f0ff3f de9b8a6c 4e1392c1 bcb822c3 a6a12ca3 f96b60aa 112829e9 461cca40 dcd9729b 63765586 5a219514 c4837678 dba28e47 cd0499ed ddb2d4a6 ffd96ffa 07fcfaf8 bf0f6f62 c2c2e1de e2fb6bb8 4cc3f57c 37909cd5 2191bef8 3006c30f 7679a729 fda0718c 129f566d d59e094c 9efb1709 46bdacb9 c0da6dfe 149edfe9 fae34757 5c000ea5 de7dd1ab a20d0948 4b825063 2d258c8d 3108bbd3 8c27cde6 f80c48a8 1a6c5be4 87c8ac92 3e7dceeb 0b5ff32f e4cae9fb e4b92849 f74cde5b b2ef6a3a 8dbf3eaf ee10d87a 1e33519e f3f72b22 91b6d357 90dd35e9 2da56b90 82367ac5 85ee37bf 6a8e75aa ae92bc10 3273b3c9 6a8e75aa f0db4683 b1579acb ab769554 6d618dde 6a8e75aa 6c7479e1 6a8e75aa 3ee4e2fd 5bf1027b 3f958aa5 c990b5c4 b5e04f78 3af5c21b 3da14725 6a8e75aa 330168c2 6a8e75aa 81efec4f b2ad489c 2a831227 005817f9 85ee37bf 6a8e75aa a667d988 21beacb6 b6109f32 edb3622c b2727185 752b5768 85ee37bf 6a8e75aa 5b3ed71a a217c7e7 f8c3d214 b7c5d24d 6b3f920a a8ddf17d bde64e3e 2c0c9a84 6a8e75aa 5d171fa1 030808ef 4142fd39 8dcbc7b6 a07d3220 6a8e75aa 6a8e75aa e4a7f5ea 30608f55 9b4ee93c 6a8e75aa 7cb4fc52 3b4ed4be e64fb58c 65c8bceb b81e5f26 9a3a0e4d 1c482d04 6a8e75aa 6c8df227 6a8e75aa 1caa6c4b d22f1b6a a42b96ec ac135745 b63ebf35 e2ace3b9 43c11217 d6358bb9 6a8e75aa 3be9c5bd 6a8e75aa bde68d66 c05b9d60 c4e4dc86 05275dba 1e45e89e 75ca1379 7adfd4c5 58adc170 835cdebd df28b857 c4e4dc86 26b98fc3 8e2458e2 23cf7f13 1b7f50a1 1b0cbc72 1927736a 0e61834c 84ea8440 4337c762 7813651a dea6138f 97ff28bd cc1655ad 6a8e75aa d96bd593 b621a8d5 6a8e75aa f7a7bb8e 6a8e75aa ee24088f a9c9d7bc 6a8e75aa 4a7609f5 ab5cd0ac fa4e6170 fd0bb8c9 7d5562d7 dfd13da9 49d8b517 f2f10762 c6bb57b6 19ad9f45 ebbb96e9 100dff79 bf6c6478 fb4d976f 573cf1eb e8afa6c2 e74950a2 173c1929 7af73da6 6d1d7fca 51e818a2 62024962 6a8e75aa e49e7c1a 8512b1ab 3e3d7730 9ae522f9 a29b87cc 74fffd6d ed2b06e7 1b0cbc72 949aa68a 388007b7 21c3ae4f e7604ffd bb75ad2b 945b5a12 2c0c9a84 59e7f008 88863729 bdbf5bf0 69b2cc46 6a8e75aa 5e6b720d 6a8e75aa dffce564 930c7a73 62cc7d46 6a8e75aa 6a8e75aa 0a7211c6 4a7fed6e 58d3359b 29261e89 1d42b909 6a8e75aa b6a1296f 30fd243f 2bc94a99 6a8e75aa 2cb5d30e 314f6dd8 c23a6319 b241b81f 1dc0f27a 225432b6 5fe12624 af8bf40e 6a8e75aa aa14c693 d1b4b7b7 25ca5ab5 cec1e08b b49ee85a 501de75a 2942085e 84633cdd 5fe1f84c 328e964b 92b26588 33b29790 646745c6 7aedb53a 2c0c9a84 4142fd39 1af48bb9 87bcb4e7 6a8e75aa 4142fd39 bdbf5bf0 b49ee85a 6a8e75aa 6a8e75aa 6a8e75aa e615af52 f16d3398 c888772d 2de3f7e8 3f422822 4a135cc8 c72f8a19 a29f7397 b89ec39f a9d177e0 6a8e75aa 5362702d ada0614d 0705b00d 9b3b4532 f9616c3e 6a8e75aa aae9ac12 22971838 6a8e75aa 7360d08f d8888e8d 6a8e75aa 6a8e75aa 63ec09dd 6a8e75aa dbcd3418 d794e923 1e69fc38 eeb3e575 bd2dde43 e2d41384 6a8e75aa 5a04c7d9 bd2dde43 c63fd336 6a8e75aa 8f18f723 55c6c1b5 c46f818f 04e2dec5 c634a5d6 c3647904 e7e250a6 63bf5ca9 61dcd9b3 6a8b396d 417a4d31 d72ca3e9 64a60e2b 6a8e75aa bdbf5bf0 082bacae 7b32721d 54bfdef0 f134c78e feffb694 5176895d a7cbe1e9 a43b562e bbf0bb2f d726d127 1b0cbc72 43085c38 240558a4 fb295baf 231b9a5a a692f61a 48f9babd 96b042f6 3571f177 e7e9a102 7eee3d58 ba82a6d4 2fd56328 2352c127 a7c4654d 1d78869f 612c7f82 2c0c9a84 7bbc63c9 6a8e75aa 6a8e75aa 7368e60f 239689fe c4e4dc86 b8eeea20 9827a213 bf129bc3 c740fd98 f0235f51 636141af 392d28e0 85ee37bf 6a8e75aa bfb27e29 6c96c7a7 777fd2c5 78937b64 7d8a9b17 c9648178 6a8e75aa 6a8e75aa 6fba0711 634d2e20 c7279ec4 6a8e75aa 1323ca3f bad12ee4 4142fd39 eaf84113 6a8e75aa 851165c4 9198bd4b 43944d4e 0076b566 e256a22d 9f6e2037 3a86e1c9 812d728f 3f47251d 85ee37bf 6a8e75aa e9700f86 cfe652f7 1b015805 0131e66b ea203403 5cd6ce9e 4142fd39 6a8e75aa c08c39cd 85ee37bf 6a8e75aa 28d2f450 e2d0360a f0175d10 21102f2c 16cad59a 2c0c9a84 85ee37bf 6a8e75aa 1efd4196 bf1d6861 03678da5 bb9b7867 1ea1b8bc 9e5bd0cf ef5a476e d84050b5 6a8e75aa 6a8e75aa f43474f5 7544f05f 96994f27 cb70bd30 1533950b 70f58b16 20cd1d0f 42669652 4ea37dd2 c3b16004 07b2f2d3 653c27ab 8974925f 9e5bd0cf ef5a476e db23af5e c9648178 6a8e75aa 6a8e75aa fe6db9ed c9648178 6a8e75aa 5fa59f65 6a8e75aa a8bc87fa 55d99364 a5a0ad10 2f7826ce 45f99c03 233d60bd c37873d8 f9736cb7 649c81a6 c8f0fc7e 91008246 4adba7f8 37ab302f f80c48a8 6378025b 7a2e9501 fb8ba5e5 c8f1d009 bb1f0b1c b1f6b56c ffd0b332 66d8856b a74bc25e 2c0c9a84 9a0e9a7d 12e6a78f a3aaa4be 6a8e75aa 8661ccbe 8d0adaf1 a12ef9ec 6a8e75aa 4142fd39 6a8e75aa 594a4997 bb232f38 b54f338b 95f4ad9a a274ace0 ecc37769 03e3e792 0e4d014e 50b83c0c 930c7a73 fc62586d 6a8e75aa 6a8e75aa cc746030 97fadeef 6a8e75aa db96168f",
		["c52d889b"] = "a865c7e1 655631f8 20cd1d0f 99bea73a c267fc95 3a03112e 464a9f0b 02574356 20cd1d0f d1158948 7ebba8e7 8e0ba02e c2bf3ebc 25328b96 afdd92a4 1f2ac47c 20cd1d0f 9c13ef7d 3e1a9156 d45bc733 a5b6ca3f 3e7dceeb 3d157ee7 41bab65b 9985481f 9a683793 2b4f9835 20cd1d0f 533d443e e23b2017 58663d8a c4bac6d1 20cd1d0f 78510af7 c1249267 69a04a0b 95e79d07 7eb341d1 20cd1d0f 198e53c4 58f9b500 3f1d5ab5 de435666 2d1ac7b8 64fc6099 6bf80be9 24dfa63f 530be3af c389f3cc 7fcd2368 6a8e75aa c3f35707 1ce72ac7 a4982830 9169d701 61aaa90b 6a8e75aa a43b45f3 170f71d2 4142fd39 8dcbc7b6 1901d02b 560c81c3 3568a3c0 6a8e75aa 3db803a2 977263bc 6a8e75aa 98252e86 3e340103 c80b607d 28f14488 a22d6d14 27aa01ce fc562313 6a8e75aa 41be74a6 5fe1f84c d8517329 2a80e134 ace0f05e e2344ef0 d84e5e7a cf2de980 6a8e75aa 64428b43 6a8e75aa 6a8e75aa 4142fd39 4142fd39 720c0d79 6ca88ec4 5af3f9c7 67b4a3ce b7cba9ce 3e788e4a 6a8e75aa 6a8e75aa 4142fd39 6a8e75aa 50256fc0",
		["e2838c36"] = "2c300de3 feb45b14 20f15758 b684c773 cab8a330 9385408d 6f73a0a3 b7e41b70 6a8e75aa 0e08805b fd107bcc 965c4101 68d57841 2b80ab02 bf558081 9ee815bb 6a8e75aa 3b348320 d54709fd 6a8e75aa 48995502 78c7a8f3 945e14f1 43ee1151 6a8e75aa b79ce71b 5314bc11 99c5af1f f4391ec3 6a8e75aa",
		["f3fc3bc4"] = "11c35325 96d8b9c4 78c0134b 7602c005 31b926f5 9e2a849e 644cec0d 8ad382d3 130b6734 3006c30f f377c659 d34e2bce 8825a94f e2a9fcde 43429c4e 6a8e75aa 10068fdc c1b7756e 939e680d 21bd6e3e 21fa7de9 ba4816d2 5587a92e 20cd1d0f 170f917b 1ec63145 63e0cb16 032e856f 80df425e cb8fbbca 0b93377e 6a8e75aa 1c4d147e 87f06595 fc46116d dd601dba 3cd13207 a5a78af1 65f9fc98 f287a8fc c4e4dc86 74552ce9 84640e61 428b9856 4f1d7084 f18ae93c a30cec4d 1e849735 36dc8b4d 6a8e75aa d626b0a1 1680f34a 8986f116 6a8e75aa b3ccaf7f 0f7182af 0426034f 7fdd5e74 6a8e75aa b034b297 4142fd39 d6248a47 6a8e75aa 4bd2bce5 c20f0325 7342ada8 7f4dce72 098a9cce 9e71f4ca 599b8bc4 6bf750d1 6a8e75aa 51121878 95bd7df2 31eb2ec3 cadd3adc 2e599ab6 6a8e75aa 6b74a7cd 6a8e75aa 47347eaf 84471ab9 c4e4dc86 a0d23428 526d6714 2c297044 c4e4dc86 013d75df 2e3c989b ed33c4c7 4e1845e8 b9c6608c faf41b24 cff7acc4 a379edf6 3ca75152 f9a990e7 2aea535f d85ac7bf 2fd099f2 444301f2 d0c0e052 cad5cb75 444301f2 ea910fe6 74d6db37 444301f2 1d31d00f 92056114 444301f2 00829994 b96b8b5f 444301f2 f80c48a8 f4738862 83bc2272 95652726 c4e4dc86 a1ae5cd3 ea1cd299 dac9b99c deba98f7 fcfffe13 f7586959 48d3e274 6a8e75aa d38f81bb 2a7ae3db 48d3e274 6a8e75aa 1b03c172 6a8e75aa aa90174e 0783e72e 1eff943c 8085b0b4 79fae589 2f54e0a2 56823355 c4e4dc86 13af0096 ee62d15e 479b7d9b 08eb1510 b1febc42 c4e4dc86 a175d6f1 e96afed1 20f1359a 5cd0feba b9e6a98f 547251cd 25cae952 6a8e75aa 6a8e75aa b0ca843d 6a8e75aa 9451ef8c 33af85cc 0b99953a c4e4dc86 fc0f656d ab4225f6 0e8ee839 f21037b7 38ffff4d 2784a4c3 a650f641 81cf6be6 6ec2ecac 85ccee12 01838fce 6a8e75aa 6a8e75aa 991c5523 6a8e75aa d22b3146 fccd59e6 f515d6bf b59efb06 b27d8b6a c4e4dc86 9da88231 a37d0014 c703ee83 ee9de911 1e73703e b64959c7 3e087ce5 aa2cbd06 b32969ab 35ddb762 22b101ba 1e8fae9f a9530441 bb5230c1 74ef85c1 073b6b17 196bc4dc 6a8e75aa f01d2a2f d0879143 6a8e75aa 911a1380 6a8e75aa efdd1db5 39c8e4aa 3468f011 c4e4dc86 5f6acdee f906e33e c6b46893 6cf703fc 18a1a3f5 d916cc80 65e1877d 42f8272f cf477176 6a8e75aa 5c8d33d4 b7b73bfd 1e8f7066 292da488 b30b079d f16e49a9 6a8e75aa a3383dee 6a8e75aa 5daafbfe 0c1b4654 44088e79 cfe5b0db 6a8e75aa afac9ad8 c4e4dc86 7cd0bcb7 7c033f97 6f3bf04e 86e4761b 6299a023 d3678923 a57c4ce9 29909ef5 c4e4dc86 d946732e fbd2b146 b50694f6 7bcf2149 fa2f26dd a0f4665c ae74e1c7 6a8e75aa 357ef8e7 6a8e75aa c68e5ccd 7c9353ad 0d354713 3b1dad33 bb309082 d84470a0 ae74e1c7 6a8e75aa f5fa08d9 ad74e034 6a8e75aa 20dea3ea fd861902 3dc4c8c9 929cadaf 2e7c1213 6a8e75aa 53f4d380 6a8e75aa 5c2f53ed 6a8e75aa a4f3ebeb 3de245dc 4f40089e ff95c761 e87d2139 dc161208 5b6855ff 6a8e75aa 6a8e75aa a3f61826 f59877aa ece3fd20 2538f384 6a8e75aa 2072ecab b19a0c1d 7ff7f4cb c4e4dc86 0a9ab1d3 3a16d499 9a76aa28 75d31d92 9cca095f 5ecb7fe0 e6171eb2 0a53cba3 c4e4dc86 86109429 bd3fa751 4811025f c221e4ca 3da14725 6a8e75aa 97a474b7 260de09c 6a8e75aa b910153d 6a8e75aa 31441db9 d89c289e 2c8bf316 a0738a35 31501da3 747d96f5 37b83511 e499121e 5b833181 2979c414 9ce383e4 6a8e75aa dc13d0ec 6a8e75aa b0286d0f 48e806c9 b4ea6d42 0a2ab657 788fb33b eb6cdb07 d0dc8ba4 0b7edf46 6a8e75aa 17a54144 fbf0546a 78e16849 95496b49 27eabf11 d50e1822 c798caf8 86fbb7a7 a829cb83 6a8e75aa 6a8e75aa d6248a47 6a8e75aa 7c90a7f7",
		["f6571dd2"] = "11e09238 e71008a7 0c940951 20cd1d0f e5ff8e71 284af3ed 521988e2 20cd1d0f f1aac06a 20cd1d0f b761ed39 335e2935 c022ea35 fc4f663e 39f834e2 20cd1d0f a670685f 91284798 4dec7851 20cd1d0f 46378ae0 a3935575 42a54e43 3d157ee7 b3ddc219 661c537c 30c016bd fc031d99 76dff01f 76e2af7f 3f88535d 9841325f 1a6c5be4 8fea4e00 d01e0127 4e4bc915 0d7031db 64fc6099 6bf80be9 d112ff5f 6c8b028e d5fdcb7d d8a867e5 753eaada 4c0965eb 61aaa90b 6a8e75aa c1ea6f18 880bd470 b9d01f24 ce170006 2c0c9a84 4142fd39 cb929a88 ac631589 12958a6d 6a8e75aa 3f2f7a43 6998cf7f abece2f0 a6e8b408 13b67cb1 f5836b87 51398bd2 6a8e75aa 48d3e274 6a8e75aa 5fe1f84c 9fae39df 6497082a 40249d85 cf16ac37 cc7b726c 6a8e75aa 42038579 2f36339b 1833d4b3 70d785cf 2c0c9a84 85ee37bf 6a8e75aa bb96c10c 232c0491 85ee37bf 6a8e75aa 01aa89b9 6a6c4ead 0f4a8aa5 5fe1f84c 83200190 f0ca900d 83c52dbf f79c179b f80c48a8 199607bf 2c0007b1 6a8e75aa b8e83f96 47a0f51d 4580cb8c e8f65b48 fc562313 6a8e75aa 4142fd39 4142fd39 4142fd39 6a8e75aa c1fb42ab",
	},
}
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="32">
              <Properties>
                <string name="Name">Sources</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Migrations/Sources - the 2.x trees Migrations/FromV2 reads (plan B1),
-- each "<service>/<path under that service's RBLXEssentials>", read by
-- T.migrate with plugins/Official/Tools/Core/Tree.lua (attributes
-- included) and passed to FromV2 as { Settings = node?, Triggers = node? }:
--   Settings  the 2.x Settings folder (the announcement rotation);
--   Triggers  the server module's Triggers folder, whose Enabled attribute
--             on each shipped module was that trigger's switch in 2.x.
-- A source the game deleted is left out of the trees, and FromV2 still
-- runs (plan B0, decision 8): 2.x without Settings announced nothing, and
-- without Triggers started no trigger.
return {
	Settings = "ReplicatedStorage/Packs/NotificationsSystem/Settings",
	Triggers = "ServerScriptService/Packs/NotificationsSystem/Triggers",
}
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
          </Item>
          <Item class="ModuleScript" referent="33">
            <Properties>
              <string name="Name">Notifications</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[--[[
	Notifications.lua - the pure rules. No `game`, no Instances, so Lune can
	test every one of them.

	SHARED (ReplicatedStorage), unlike Codes System's rules module, because
	both sides need these: the server substitutes tokens into the configured
	strings, and the client decides where a card goes. Plugin v2's
	NotificationsModel loads this same file off disk in a lockstep block, so
	the settings UI and the runtime can never disagree about what a valid
	direction is or which fields a template has.
]]

local Notifications = {}

Notifications.DIRECTIONS = { "Down", "Up", "Left", "Right" }

local DIRECTION_SET = {}
for _, d in ipairs(Notifications.DIRECTIONS) do
	DIRECTION_SET[d] = true
end

local FIELD_NAMES = { Title = true, Subtitle = true, Image = true }

-- Which screen edge a sliding card enters from. `Auto` derives it from the
-- stack's own direction, which is what the pack did before this setting
-- existed; the four edges are the buyer overriding that for the whole game
-- (user, 2026-08-25: "una variable que determine de qué lado de la pantalla
-- aparecen las notificaciones y que la posición final sea en la que se
-- encuentra la template").
--
-- It is deliberately about the ENTRY only. Where a card comes to rest is the
-- template's own position, and nothing here moves it.
Notifications.EDGES = { "Auto", "Top", "Bottom", "Left", "Right" }

Notifications.ANIMATIONS = { "Slide", "Fade", "Pop" }

local ANIMATION_SET = {}
for _, a in ipairs(Notifications.ANIMATIONS) do
	ANIMATION_SET[a] = true
end

local EDGE_SET = { Top = true, Bottom = true, Left = true, Right = true }

-- A stack growing Down is fed from the Top, and so on round. This is the
-- mapping `Auto` uses, and it is what the renderer did implicitly before the
-- setting was added.
local EDGE_FOR_DIRECTION = { Down = "Top", Up = "Bottom", Right = "Left", Left = "Right" }

--- Replaces {token} with tokens[token]. An unknown token is left in the text
--- verbatim - a buyer who mistyped {Player} must see their own words, not a
--- hole they cannot explain.
---
--- The replacement is a FUNCTION rather than a string on purpose: Lua uses a
--- function's return value literally, with no `%` processing, so a display
--- name containing `%1` or `%%` is inserted as typed instead of being read
--- as a capture reference. Escaping it by hand here would double the
--- percents instead.
function Notifications.substitute(text, tokens)
	if text == nil then
		return ""
	end
	text = tostring(text)
	if not tokens then
		return text
	end
	local out = text:gsub("{(%w+)}", function(key)
		local value = tokens[key]
		if value == nil then
			return nil -- gsub keeps the original match
		end
		return tostring(value)
	end)
	return out
end

--- Which way a template's stack grows, from where its anchor sits on screen
--- (both coordinates in 0..1 scale). The stack grows AWAY from the nearest
--- edge, so a toast pinned near the top pushes downward. Ties resolve to the
--- vertical answer: toasts stack vertically by convention, and a corner
--- anchor is exactly equidistant from two edges.
function Notifications.stackDirection(x, y, explicit)
	if explicit and DIRECTION_SET[explicit] then
		return explicit
	end
	local top, bottom, left, right = y, 1 - y, x, 1 - x
	local vertical = math.min(top, bottom)
	local horizontal = math.min(left, right)
	if vertical <= horizontal then
		return (top <= bottom) and "Down" or "Up"
	end
	return (left <= right) and "Right" or "Left"
end

--- What a caller may override for ONE notification, and what counts as a
--- usable value for each.
---
--- THE NAMES ARE THE TEMPLATE'S OWN ATTRIBUTE NAMES on purpose: whatever you
--- can set on the frame, you can pass in the call and it wins for that one
--- message. There is nothing new to learn and nothing to look up.
---
--- `StackDirection` IS THE ONE ATTRIBUTE MISSING FROM THIS LIST, and its
--- absence is the design (user, 2026-08-26: "quizá debamos quitar la opción
--- de sobreescribir el stack direction al llamar a una notificación porque
--- se bugea y no tiene mucho use case"). Direction is a property of a
--- COLUMN, not of a card: the stack takes its direction from whichever card
--- is nearest the anchor, so a per-call override applied to a card further
--- down did nothing, and applied to the first card silently redirected every
--- card queued behind it. Both readings are surprising, and neither is worth
--- having. Set it on the template, where it describes the column it belongs
--- to. Everything left in this table is genuinely per-message.
local OVERRIDES = {
	Duration = function(v)
		return type(v) == "number" and v > 0
	end,
	MaxOnScreen = function(v)
		return type(v) == "number" and v >= 0
	end,
	Sound = function(v)
		return type(v) == "string"
	end,
	Animation = function(v)
		return ANIMATION_SET[v] == true
	end,
	SlideFrom = function(v)
		return v == "Auto" or EDGE_SET[v] == true
	end,
}

Notifications.OVERRIDABLE = { "Duration", "MaxOnScreen", "Sound", "Animation", "SlideFrom" }

--- The caller's override for `name`, or nil if they did not give one or gave
--- something the renderer cannot use.
---
--- A BAD VALUE FALLS BACK, it does not raise. A typo in one call should cost
--- that call its override, not the message: nobody wants "Fade " with a
--- trailing space to swallow a server-restart warning.
function Notifications.override(name, data)
	local usable = OVERRIDES[name]
	if not usable or type(data) ~= "table" then
		return nil
	end
	local value = data[name]
	if value == nil or not usable(value) then
		return nil
	end
	return value
end

--- The two banner templates. `Banner` is one line; `BannerSubtitle` adds a
--- second. Named here rather than spelled out at each call site, because
--- three places used to hardcode the string "Banner".
Notifications.BANNER = "Banner"
Notifications.BANNER_SUBTITLE = "BannerSubtitle"

--- Which banner a caller means when they ask for "a banner" without naming
--- a template.
---
--- ASKING FOR A BANNER IS ASKING FOR A SURFACE, not a template, so the right
--- answer is the one that can actually show what they passed. Without this,
--- `Notify.Banner(player, { Title = ..., Subtitle = ... })` -- the call in
--- this pack's own documented example -- would silently drop the subtitle
--- the moment `Banner` became a one-line card.
---
--- `exists` is asked rather than assumed: a buyer can delete either template,
--- and a missing one must fall back rather than drop the notification.
function Notifications.bannerTemplate(data, exists)
	local subtitle = data and data.Subtitle
	if type(subtitle) == "string" and subtitle ~= "" then
		if not exists or exists(Notifications.BANNER_SUBTITLE) then
			return Notifications.BANNER_SUBTITLE
		end
	end
	return Notifications.BANNER
end

--- Which stack a template belongs to. Templates sharing a `StackGroup`
--- share one column and queue behind each other; a template without one
--- gets a stack to itself, keyed by its own name.
---
--- EXPLICIT, NOT DERIVED FROM POSITION (user, 2026-08-26: "deberíamos crear
--- algo tipo StackGroup? Para que no se haga eso automático"). Proximity
--- grouping was built first and thrown away: it meant dragging a template
--- silently changed which other templates it shared a column with, and no
--- amount of tolerance-picking fixes a rule whose answer you cannot read off
--- the frame. This one you can: it is written on the template.
function Notifications.stackGroup(templateName, attributeValue)
	if type(attributeValue) == "string" then
		local trimmed = attributeValue:match("^%s*(.-)%s*$")
		if trimmed ~= "" then
			return "group:" .. trimmed
		end
	end
	return "template:" .. tostring(templateName)
end

--- The box a card actually occupies, in pixels, given the box it DECLARES
--- and the aspect ratio it is constrained to. Roblox's `FitWithinMaxSize`:
--- the largest box of that ratio fitting inside the declared one, so
--- whichever axis binds is the one that shrinks. `aspect` of nil or <= 0
--- means no constraint and the declared box stands.
---
--- WHY THIS IS COMPUTED AND NOT READ (2026-08-30). It used to be
--- `template.AbsoluteSize`, which is a MEASUREMENT and therefore has a date
--- on it. The templates ship hidden, the triggers fire the moment a player
--- joins, and on that frame a template can still carry the size it had
--- while the screen was a different shape - a Studio viewport before the
--- window settles, most of all. The gap came from the CURRENT screen and
--- the heights from the old one, so every card in the stack was stepped by
--- about 0.44 of its height and they landed on top of each other (seen in
--- game 2026-08-30, four toasts overlapping; the same four were spaced
--- perfectly in the plugin's preview, where nothing was resizing). Sizes
--- declared in scale are knowable exactly at any instant, so they are
--- worked out rather than remembered.
function Notifications.fitBox(width, height, aspect)
	width = width or 0
	height = height or 0
	if not aspect or aspect <= 0 or width <= 0 or height <= 0 then
		return width, height
	end
	if width / height > aspect then
		return height * aspect, height
	end
	return width, width / aspect
end

--- How far the next card sits from the stack's anchor, in pixels. `ahead` is
--- the cards already between the anchor and this one, nearest first, each
--- `{ width = , height = }`.
---
--- IT ACCUMULATES REAL SIZES rather than multiplying an index by one height,
--- which is what it used to do. That was fine while every stack held one
--- template; now that a 52px card and an 84px card share a stack, a uniform
--- step lands them on top of each other.
function Notifications.stackOffset(direction, ahead, gap)
	local vertical = (direction == "Down" or direction == "Up")
	local lead = 0
	for _, size in ipairs(ahead or {}) do
		lead = lead + (vertical and (size.height or 0) or (size.width or 0)) + (gap or 0)
	end
	if direction == "Down" then
		return 0, lead
	elseif direction == "Up" then
		return 0, -lead
	elseif direction == "Right" then
		return lead, 0
	end
	return -lead, 0
end

--- Whether another card fits. A cap of nil, 0 or less means unlimited - a
--- buyer who clears the attribute gets no cap rather than no notifications.
function Notifications.admit(liveCount, maxOnScreen)
	return Notifications.evict(liveCount, maxOnScreen) == 0
end

--- How many of this template's cards must GO so that one more fits.
---
--- THE CAP IS A CAP ON WHAT IS VISIBLE, NOT A QUEUE (user, 2026-08-26: "si
--- queremos enseñar una nueva notificación pero ya está el máximo stackeada,
--- no debemos esperar a que acabe la más antigua. podemos descartarla antes
--- de tiempo para enseñar la nueva"). A notification held back until a slot
--- opens arrives describing a moment that has passed - the coins are already
--- spent, the egg already hatched - and under any burst the queue drains at
--- one card per Duration, so the last of ten shows up half a minute late.
--- The newest thing that happened is the thing worth showing.
---
--- Returns 0 when there is room, and 0 for an unlimited cap. It is written
--- as a count rather than a boolean so a cap LOWERED while cards are on
--- screen (a buyer editing MaxOnScreen live, or a per-call override) still
--- resolves in one step instead of leaking a card per notification.
function Notifications.evict(liveCount, maxOnScreen)
	if not maxOnScreen or maxOnScreen <= 0 then
		return 0
	end
	return math.max(0, (liveCount or 0) - maxOnScreen + 1)
end

--- The next announcement index. `roll` is injected so the rule stays
--- deterministic under test; the caller passes `math.random`.
--- Shuffle never returns the message already on screen: a 1-in-N roll
--- landing on the same line reads as a broken rotation, not as chance.
function Notifications.nextAnnouncement(prevIndex, count, shuffle, roll)
	if not count or count <= 0 then
		return 0
	end
	if count == 1 then
		return 1
	end
	if shuffle then
		roll = roll or math.random
		local pick = roll(count)
		if pick == prevIndex then
			pick = (pick % count) + 1
		end
		return pick
	end
	return ((prevIndex or 0) % count) + 1
end

--- The screen edge a template sits nearest. Ties resolve vertically, the
--- same convention `stackDirection` uses.
function Notifications.nearestEdge(x, y)
	local best, edge = y or 0, "Top"
	local function closer(distance, name)
		if distance < best then
			best, edge = distance, name
		end
	end
	closer(1 - (y or 0), "Bottom")
	closer(x or 0, "Left")
	closer(1 - (x or 0), "Right")
	return edge
end

--- Which screen edge a card slides in from. `override` is the template's own
--- `SlideFrom`; anything that is not one of the four edges (including
--- "Auto", an empty string, or a typo) means derive it.
---
--- AUTO DERIVES FROM WHERE THE TEMPLATE SITS, not from which way its stack
--- grows (user, 2026-08-26: "esas templates ya están más hacia la derecha
--- que arriba, eso no haría que auto haga que salgan desde la derecha?").
--- It used to read the stack direction, which agreed with the position only
--- because the direction was itself derived from it. Pinning
--- `StackDirection` broke that agreement and made a card in the top-right
--- corner drop in from the top. The two are separate questions: which way
--- the column grows, and which edge a card flies in from.
---
--- `x`/`y` are the template's anchor. Without them it still falls back to
--- the direction, so an older caller is not left with nothing.
function Notifications.entryEdge(direction, override, x, y)
	if override and EDGE_SET[override] then
		return override
	end
	if x ~= nil and y ~= nil then
		return Notifications.nearestEdge(x, y)
	end
	return EDGE_FOR_DIRECTION[direction] or "Top"
end

--- How far off-screen a card starts, relative to where it will come to rest.
--- `margin` is the extra gap beyond the card's own size, so it clears the
--- edge completely before it starts moving.
function Notifications.entryOffset(edge, width, height, margin)
	margin = margin or 0
	if edge == "Top" then
		return 0, -(height + margin)
	elseif edge == "Bottom" then
		return 0, height + margin
	elseif edge == "Left" then
		return -(width + margin), 0
	end
	return width + margin, 0
end

-- Screen-normalized anchor position that clears the WHOLE viewport edge.
-- entryOffset remains unchanged for existing short-slide templates.
function Notifications.offscreenPosition(edge, x, y, w, h, ax, ay, margin)
	if edge == 'Left' then return -w * (1 - ax) - margin, y
	elseif edge == 'Right' then return 1 + w * ax + margin, y
	elseif edge == 'Top' then return x, -h * (1 - ay) - margin
	elseif edge == 'Bottom' then return x, 1 + h * ay + margin end
	return x, y
end

--- Which of Title/Subtitle/Image a template can display, from the names of
--- its children. Anything else (UIStroke, UICorner, a decorative Frame) is
--- not a field. This is what makes a buyer's redesign safe: the renderer
--- fills what exists and skips what does not.
function Notifications.fields(childNames)
	local out = { Title = false, Subtitle = false, Image = false }
	for _, name in ipairs(childNames or {}) do
		if FIELD_NAMES[name] then
			out[name] = true
		end
	end
	return out
end

return Notifications
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="ModuleScript" referent="34">
            <Properties>
              <string name="Name">Notify</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[--[[
	Notify.lua - the front door for the buyer's OWN code.

	    local Notify = require(game:GetService("ReplicatedStorage")
	        .RBLXEssentials.Packs.NotificationsSystem.Notify)

	    -- server
	    Notify.Toast(player, "TitleSubtitle", { Title = "Well done", Subtitle = "You found the secret!" })
	    Notify.ToastAll("TitleOnly", { Title = "The boss has spawned!" })
	    Notify.Chat("Double XP is live for the next hour!", Color3.fromRGB(255, 215, 0))
	    Notify.ChatTo(player, "Welcome back!")
	    Notify.Banner(player, { Title = "Round starting", Subtitle = "Get to the arena" })
	    Notify.BannerAll({ Title = "Server restarting in 5 minutes" })

	    -- client (a LocalScript): the same names WITHOUT the player argument
	    Notify.Toast("TitleOnly", { Title = "Saved!" })

	`data` fields the shipped templates read: Title, Subtitle, Image (an asset
	id), ImageUserId (resolved to that user's headshot on the client), Color.
	A template with no matching child simply does not render that field, so a
	Title-only card given a Subtitle just ignores it.

	PACKS DO NOT USE THIS. They use `ctx.kernel.Notify`, which is silent when
	this pack is not installed. The asymmetry is the point: a pack wants
	silence, a person writing code wants to be told. Requiring this module
	when the pack is absent fails loudly at the require line, which is the
	correct feedback for a human - and there is exactly one implementation,
	because this forwards to that same facade rather than duplicating it.
]]

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local kernel = ReplicatedStorage:WaitForChild("RBLXEssentials"):WaitForChild("Kernel")
local Facade = require(kernel:WaitForChild("Notify"))

local Notify = {}

function Notify.Toast(...)
	Facade:Toast(...)
end

function Notify.ToastAll(...)
	Facade:ToastAll(...)
end

function Notify.Chat(...)
	Facade:Chat(...)
end

function Notify.ChatTo(...)
	Facade:ChatTo(...)
end

function Notify.Banner(...)
	Facade:Banner(...)
end

function Notify.BannerAll(...)
	Facade:BannerAll(...)
end

return Notify
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="ModuleScript" referent="35">
            <Properties>
              <string name="Name">Pieces</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[-- Pieces.lua - the interface piece Notifications System 3.0 drives (plain
-- data; Kernel/Contracts.lua checks it). The pack's own copy is
-- StarterGui.RBLXEssentials.NotificationsSystem.NotificationsSystemGUI, the
-- ScreenGui itself carrying RBLXE_Piece and RBLXE_Contract (a Layer piece:
-- its own entry, never inside another ScreenGui); a game's fork in
-- StarterGui.RBLXEssentials.Interface replaces it when it satisfies this
-- contract, templates the game added included.
--
-- The contract asks only what 2.x itself needed (plan B1): a child named
-- Templates, of any class, since 2.x found it with FindFirstChild. Each
-- template is looked up there by name when a notification names it, and a
-- missing or unusable one drops that notification with a warning, as in
-- 2.x, so no template, field or attribute is required here: a fork 2.x
-- showed is never refused for them.
return {
	NotificationLayer = {
		contract = 1,
		kind = "Layer",
		doc = "The ScreenGui the notification cards are drawn in. Its Templates child holds one GuiObject per template, found by name: TitleOnly, TitleSubtitle, ImageTitle, ImageTitleSubtitle, Banner, BannerSubtitle, Alert and any the game adds. A card fills the Title and Subtitle TextLabels and the Image it has, and reads Duration, MaxOnScreen, Sound, Animation, SlideFrom, StackGroup, StackDirection, SlideAcrossScreen and ExitTo from its template's attributes.",
		requires = {
			{ path = "Templates", class = "Instance" },
		},
	},
}
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="ModuleScript" referent="36">
            <Properties>
              <string name="Name">Schema</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[-- Schema.lua - the options a game sets for Notifications System 3.0, in the
-- Kernel's Schema language (docs/kernel-api.md, section 8). The game's
-- values live in ReplicatedStorage.RBLXEssentials.Config.NotificationsSystem,
-- a module no update replaces; it returns only what the game changes, and
-- everything else is the default below.
-- T.config.reference("NotificationsSystem") prints this as a reference.
--
-- Every option is shared (plan B1): 2.x kept its Settings in
-- ReplicatedStorage, and every text here is shown to players, so nothing is
-- a secret. The defaults are exactly what 2.x shipped (2.1.1: the Settings
-- values, the Enabled attribute of each trigger module and the constants at
-- the top of each trigger), so a new game behaves as a new 2.x game did;
-- tests/identity.spec.luau compares them with the published 2.1.1 release.
--
-- It accepts every value 2.x ran (Migrations/FromV2 converts them): any
-- finite IntervalMinutes (2.x ran anything under half a minute every 30
-- seconds; that floor stays a runtime rule in Triggers/Announcements, never
-- a minimum here that would refuse an old value), messages exactly as
-- written (no trim, no length limit, duplicates, {braces} and rich text
-- included), and an empty message list (no rotation).
--
-- A trigger of the game's own has no option here: it lives in
-- ServerScriptService.RBLXEssentials.Extensions.NotificationsSystem and its
-- Enabled attribute is its switch, as in 2.x.
--
-- Self-contained on purpose: Tools loads this module as a clone with no
-- Parent, so it uses no `script` and requires nothing (Color3 is a datatype).
return function(S)
	local function finiteMinutes(value)
		if value == math.huge or value == -math.huge then
			return { { message = "must be a finite number of minutes" } }
		end
		return {}
	end

	local function template(default, doc)
		return S.string({ default = default, minLength = 1, doc = doc })
	end

	return S.config({
		Announcements = S.record({
			IntervalMinutes = S.number({
				default = 5,
				doc = "Minutes between two announcements, and before the first. Anything under half a minute (0 and negative numbers included) runs every 30 seconds.",
				check = finiteMinutes,
				checkDoc = "A finite number of minutes",
			}),
			Surface = S.enum({ "Chat", "Banner" }, {
				default = "Chat",
				doc = "Chat: a system line in the chat. Banner: the Banner template, shown to every player.",
			}),
			Shuffle = S.boolean({
				default = false,
				doc = "Pick the next message at random instead of in order. It never shows the same message twice in a row.",
			}),
			Messages = S.list(S.string({
				pattern = "%S",
				patternDoc = "text that is not only spaces",
				doc = "One announcement, shown exactly as written: {tokens} are not replaced.",
			}), {
				default = { "Join our group for free rewards!", "Type codes in the Codes menu for gifts!", "Like the game if you are having fun!" },
				doc = "The rotation, in order. An empty list announces nothing.",
			}),
		}, { doc = "Rotating messages on a timer (the Announcements trigger)." }),
		Triggers = S.record({
			Announcements = S.boolean({ default = true, doc = "Rotate the Announcements messages." }),
			FriendJoined = S.boolean({ default = true, doc = "Show a toast, with their headshot, when a player's friend joins the server. Both sides are told." }),
			JoinLeave = S.boolean({ default = false, doc = "A chat line every time anyone joins or leaves. Off by default: most places already announce this their own way." }),
			Purchases = S.boolean({ default = true, doc = "When someone buys a gamepass or developer product: a line to the whole server and a toast to the buyer. Needs Datastore & Purchase System; silent without it." }),
		}, { doc = "The switches of the four shipped triggers. A trigger of the game's own, in ServerScriptService.RBLXEssentials.Extensions.NotificationsSystem, runs unless its Enabled attribute is false." }),
		FriendJoined = S.record({
			Template = template("ImageTitleSubtitle", "The template the toast uses, by name."),
			Title = S.string({ default = "Friend joined!", doc = "The toast's title. {player} is the friend's display name." }),
			Subtitle = S.string({ default = "{player} is in your server", doc = "The toast's subtitle. {player} is the friend's display name." }),
		}, { doc = "What the FriendJoined trigger shows." }),
		JoinLeave = S.record({
			JoinMessage = S.string({ default = "{player} joined the game", doc = "The chat line when someone joins. {player} is their display name." }),
			LeaveMessage = S.string({ default = "{player} left the game", doc = "The chat line when someone leaves. {player} is their display name." }),
			Color = S.color({ default = Color3.fromRGB(170, 170, 170), doc = "The colour of both lines." }),
		}, { doc = "What the JoinLeave trigger says in the chat." }),
		Purchases = S.record({
			AnnounceInChat = S.boolean({ default = true, doc = "Tell the whole server in the chat." }),
			ChatMessage = S.string({ default = "{player} just bought {item}!", doc = "The chat line. {player} is the buyer's display name, {item} the product or pass name, {price} the Robux spent." }),
			ChatColor = S.color({ default = Color3.fromRGB(255, 215, 0), doc = "The colour of the chat line." }),
			NotifyBuyer = S.boolean({ default = true, doc = "Also show the buyer a toast of their own." }),
			BuyerTemplate = template("TitleSubtitle", "The template the buyer's toast uses, by name."),
			BuyerTitle = S.string({ default = "Purchase complete", doc = "The buyer's toast title. {player}, {item} and {price} as in ChatMessage." }),
			BuyerSubtitle = S.string({ default = "Thanks for buying {item}!", doc = "The buyer's toast subtitle. {player}, {item} and {price} as in ChatMessage." }),
		}, { doc = "What the Purchases trigger says." }),
	})
end
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="ModuleScript" referent="37">
            <Properties>
              <string name="Name">manifest</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <ContentId name="LinkedSource">
                <null>
                </null>
              </ContentId>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <string name="Source"><![CDATA[return {
	id = "NotificationsSystem",
	version = "3.0.1",
	-- EMPTY ON PURPOSE, and it is the pack's central design decision.
	-- Nothing is declared here, and no other pack declares this one: every
	-- pack emits through the kernel's `Notify` facade (kernel 2.1.0), which
	-- is a silent no-op when this pack is absent. A dependency in either
	-- direction would make an optional companion mandatory - the plugin
	-- refuses to install a pack whose declared deps are missing, so a buyer
	-- who only wants toasts and dev messages could not buy this alone, and a
	-- buyer who owns Easy Pet System could not install it without this.
	deps = {},
	-- The registry wins over this field, so once the site is live the pack
	-- card draws from registry.json either way. This is the offline fallback,
	-- and without it the card is the only blank one in the list.
	thumbnail = "rbxassetid://99897208312655",
}
]]></string>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
          </Item>
          <Item class="Folder" referent="38">
            <Properties>
              <string name="Name">Assets</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <Color3 name="IconTint">
                <R>0</R>
                <G>0</G>
                <B>0</B>
              </Color3>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
            <Item class="Frame" referent="39">
              <Properties>
                <string name="Name">CounterEffects</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>0</X>
                  <Y>0</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>0.6392157</R>
                  <G>0.63529414</G>
                  <B>0.64705884</B>
                </Color3>
                <float name="BackgroundTransparency">1</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">1</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0</XS>
                  <XO>0</XO>
                  <YS>0</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>1</XS>
                  <XO>0</XO>
                  <YS>1</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">true</bool>
                <int name="ZIndex">90</int>
              </Properties>
              <Item class="Frame" referent="40">
                <Properties>
                  <string name="Name">CounterGain</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0.5</X>
                    <Y>0.5</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">1</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.5</XS>
                    <XO>0</XO>
                    <YS>0.5</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.12</XS>
                    <XO>0</XO>
                    <YS>0.065</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">false</bool>
                  <int name="ZIndex">90</int>
                </Properties>
                <Item class="UIAspectRatioConstraint" referent="41">
                  <Properties>
                    <string name="Name">UIAspectRatioConstraint</string>
                    <float name="AspectRatio">3.3</float>
                    <token name="AspectType">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <token name="DominantAxis">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                  </Properties>
                </Item>
                <Item class="UIScale" referent="42">
                  <Properties>
                    <string name="Name">Pulse</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <float name="Scale">1</float>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                  </Properties>
                </Item>
                <Item class="ImageLabel" referent="43">
                  <Properties>
                    <string name="Name">Icon</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>0.6392157</R>
                      <G>0.63529414</G>
                      <B>0.64705884</B>
                    </Color3>
                    <float name="BackgroundTransparency">1</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">1</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <Color3 name="ImageColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <Content name="ImageContent">
                      <uri>rbxassetid://140169854106988</uri>
                    </Content>
                    <Vector2 name="ImageRectOffset">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <Vector2 name="ImageRectSize">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <float name="ImageTransparency">0</float>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0</XS>
                      <XO>0</XO>
                      <YS>0</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="ResampleMode">0</token>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <token name="ScaleType">3</token>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.3</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <Rect2D name="SliceCenter">
                      <min>
                        <X>0</X>
                        <Y>0</Y>
                      </min>
                      <max>
                        <X>0</X>
                        <Y>0</Y>
                      </max>
                    </Rect2D>
                    <float name="SliceScale">1</float>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim2 name="TileSize">
                      <XS>1</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">90</int>
                  </Properties>
                </Item>
                <Item class="TextLabel" referent="44">
                  <Properties>
                    <string name="Name">Amount</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>0.6392157</R>
                      <G>0.63529414</G>
                      <B>0.64705884</B>
                    </Color3>
                    <float name="BackgroundTransparency">1</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">1</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <Font name="FontFace">
                      <Family>
                        <url>rbxasset://fonts/families/FredokaOne.json</url>
                      </Family>
                      <Weight>400</Weight>
                      <Style>Normal</Style>
                      <CachedFaceId>
                        <url>rbxasset://fonts/FredokaOne-Regular.ttf</url>
                      </CachedFaceId>
                    </Font>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <float name="LineHeight">1</float>
                    <string name="LocalizationMatchIdentifier"></string>
                    <string name="LocalizationMatchedSourceText"></string>
                    <int name="MaxVisibleGraphemes">-1</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <string name="OpenTypeFeatures"></string>
                    <UDim2 name="Position">
                      <XS>0.32</XS>
                      <XO>0</XO>
                      <YS>0</YS>
                      <YO>0</YO>
                    </UDim2>
                    <bool name="RichText">false</bool>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.68</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <string name="Text">+100</string>
                    <Color3 name="TextColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <token name="TextDirection">0</token>
                    <bool name="TextScaled">true</bool>
                    <float name="TextSize">8</float>
                    <Color3 name="TextStrokeColor3">
                      <R>0</R>
                      <G>0</G>
                      <B>0</B>
                    </Color3>
                    <float name="TextStrokeTransparency">1</float>
                    <float name="TextTransparency">0</float>
                    <token name="TextTruncate">0</token>
                    <bool name="TextWrapped">true</bool>
                    <token name="TextXAlignment">0</token>
                    <token name="TextYAlignment">1</token>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">91</int>
                  </Properties>
                  <Item class="UIStroke" referent="45">
                    <Properties>
                      <string name="Name">UIStroke</string>
                      <token name="ApplyStrokeMode">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.065</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                </Item>
              </Item>
            </Item>
            <Item class="Folder" referent="46">
              <Properties>
                <string name="Name">Designs</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <Color3 name="IconTint">
                  <R>0</R>
                  <G>0</G>
                  <B>0</B>
                </Color3>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
              <Item class="Folder" referent="47">
                <Properties>
                  <string name="Name">Toy</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="IconTint">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
                <Item class="Frame" referent="48">
                  <Properties>
                    <string name="Name">TitleOnly</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABBACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.062962964</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="49">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">5.647059</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="50">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="51">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.74509805 0.627451 1 0 1 0.47058824 0.3137255 0.9411765 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="52">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.073529415</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="53">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.073529415</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.026041666</XS>
                        <XO>0</XO>
                        <YS>0.14705883</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="54">
                    <Properties>
                      <string name="Name">Shine</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.78</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.018229166</XS>
                        <XO>0</XO>
                        <YS>0.073529415</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9635417</XS>
                        <XO>0</XO>
                        <YS>0.36764705</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">1</int>
                    </Properties>
                    <Item class="UICorner" referent="55">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="56">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.052083332</XS>
                        <XO>0</XO>
                        <YS>0.22058824</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.90625</XS>
                        <XO>0</XO>
                        <YS>0.4117647</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="57">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="58">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.55</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.052083332</XS>
                        <XO>0</XO>
                        <YS>0.7794118</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9010417</XS>
                        <XO>0</XO>
                        <YS>0.0882353</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="59">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="60">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="61">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="62">
                  <Properties>
                    <string name="Name">TitleSubtitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABRACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.07777778</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="63">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">4.571429</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="64">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="65">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.43137255 0.9254902 0.8627451 0 1 0.078431375 0.627451 0.6745098 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="66">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.05952381</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="67">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.05952381</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.026041666</XS>
                        <XO>0</XO>
                        <YS>0.11904762</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="68">
                    <Properties>
                      <string name="Name">Shine</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.78</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.018229166</XS>
                        <XO>0</XO>
                        <YS>0.05952381</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9635417</XS>
                        <XO>0</XO>
                        <YS>0.3690476</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">1</int>
                    </Properties>
                    <Item class="UICorner" referent="69">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="70">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.052083332</XS>
                        <XO>0</XO>
                        <YS>0.13095239</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.90625</XS>
                        <XO>0</XO>
                        <YS>0.33333334</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="71">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="72">
                    <Properties>
                      <string name="Name">Subtitle</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.052083332</XS>
                        <XO>0</XO>
                        <YS>0.52380955</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.90625</XS>
                        <XO>0</XO>
                        <YS>0.22619048</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Subtitle</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>0.972549</G>
                        <B>0.8235294</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="73">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="74">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.55</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.052083332</XS>
                        <XO>0</XO>
                        <YS>0.8214286</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9010417</XS>
                        <XO>0</XO>
                        <YS>0.071428575</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="75">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="76">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="77">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="78">
                  <Properties>
                    <string name="Name">ImageTitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABRACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.062962964</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="79">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">5.647059</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="80">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.23529412</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="81">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.5882353 0.9411765 0.43137255 0 1 0.15686275 0.6862745 0.27450982 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="82">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.073529415</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="83">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.073529415</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.026041666</XS>
                        <XO>0</XO>
                        <YS>0.14705883</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="84">
                    <Properties>
                      <string name="Name">Shine</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.78</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.018229166</XS>
                        <XO>0</XO>
                        <YS>0.073529415</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9635417</XS>
                        <XO>0</XO>
                        <YS>0.36764705</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">1</int>
                    </Properties>
                    <Item class="UICorner" referent="85">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.4</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="86">
                    <Properties>
                      <string name="Name">Image</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>-0.0625</XS>
                        <XO>0</XO>
                        <YS>-0.14705883</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">-8</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.21354167</XS>
                        <XO>0</XO>
                        <YS>1.2058823</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UICorner" referent="87">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="UIGradient" referent="88">
                      <Properties>
                        <string name="Name">Shade</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <ColorSequence name="Color">0 1 1 1 0 1 0.84313726 0.88235295 1 0 </ColorSequence>
                        <bool name="Enabled">true</bool>
                        <Vector2 name="Offset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="Rotation">90</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <float name="Scale">1</float>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <token name="TileMode">0</token>
                        <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                        <token name="Type">0</token>
                      </Properties>
                    </Item>
                    <Item class="UIStroke" referent="89">
                      <Properties>
                        <string name="Name">Ring</string>
                        <token name="ApplyStrokeMode">1</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.06097561</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                    <Item class="UIShadow" referent="90">
                      <Properties>
                        <string name="Name">Lip</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BlurRadius">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <bool name="Inset">false</bool>
                        <token name="Mode">0</token>
                        <UDim2 name="Offset">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0.06097561</YS>
                          <YO>0</YO>
                        </UDim2>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <bool name="ShowBehindParent">true</bool>
                        <int64 name="SourceAssetId">-1</int64>
                        <UDim2 name="Spread">
                          <XS>0.12195122</XS>
                          <XO>0</XO>
                          <YS>0.12195122</YS>
                          <YO>0</YO>
                        </UDim2>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">-1</int>
                      </Properties>
                    </Item>
                    <Item class="UIAspectRatioConstraint" referent="91">
                      <Properties>
                        <string name="Name">UIAspectRatioConstraint</string>
                        <float name="AspectRatio">1</float>
                        <token name="AspectType">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <token name="DominantAxis">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                      </Properties>
                    </Item>
                    <Item class="ImageLabel" referent="92">
                      <Properties>
                        <string name="Name">Content</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0.5</X>
                          <Y>0.5</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.6392157</R>
                          <G>0.63529414</G>
                          <B>0.64705884</B>
                        </Color3>
                        <float name="BackgroundTransparency">1</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <Color3 name="ImageColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <Content name="ImageContent">
                          <uri>rbxassetid://95862633182393</uri>
                        </Content>
                        <Vector2 name="ImageRectOffset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <Vector2 name="ImageRectSize">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="ImageTransparency">0</float>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0.5</XS>
                          <XO>0</XO>
                          <YS>0.5</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="ResampleMode">0</token>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <token name="ScaleType">3</token>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>0.76</XS>
                          <XO>0</XO>
                          <YS>0.76</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <Rect2D name="SliceCenter">
                          <min>
                            <X>0</X>
                            <Y>0</Y>
                          </min>
                          <max>
                            <X>0</X>
                            <Y>0</Y>
                          </max>
                        </Rect2D>
                        <float name="SliceScale">1</float>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim2 name="TileSize">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">5</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="93">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.1875</XS>
                        <XO>0</XO>
                        <YS>0.22058824</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.7708333</XS>
                        <XO>0</XO>
                        <YS>0.4117647</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="94">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="95">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.55</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.1875</XS>
                        <XO>0</XO>
                        <YS>0.7794118</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.765625</XS>
                        <XO>0</XO>
                        <YS>0.0882353</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="96">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="97">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="98">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="99">
                  <Properties>
                    <string name="Name">ImageTitleSubtitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABhACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.07777778</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="100">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">4.571429</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="101">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.1904762</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="102">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.43137255 0.8039216 1 0 1 0.15686275 0.47058824 1 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="103">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.05952381</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="104">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.05952381</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.026041666</XS>
                        <XO>0</XO>
                        <YS>0.11904762</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="105">
                    <Properties>
                      <string name="Name">Shine</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.78</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.018229166</XS>
                        <XO>0</XO>
                        <YS>0.05952381</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9635417</XS>
                        <XO>0</XO>
                        <YS>0.3690476</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">1</int>
                    </Properties>
                    <Item class="UICorner" referent="106">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.32258064</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="107">
                    <Properties>
                      <string name="Name">Image</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>-0.0625</XS>
                        <XO>0</XO>
                        <YS>-0.023809524</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">-8</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.21354167</XS>
                        <XO>0</XO>
                        <YS>0.97619045</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UICorner" referent="108">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="UIGradient" referent="109">
                      <Properties>
                        <string name="Name">Shade</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <ColorSequence name="Color">0 1 1 1 0 1 0.84313726 0.88235295 1 0 </ColorSequence>
                        <bool name="Enabled">true</bool>
                        <Vector2 name="Offset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="Rotation">90</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <float name="Scale">1</float>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <token name="TileMode">0</token>
                        <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                        <token name="Type">0</token>
                      </Properties>
                    </Item>
                    <Item class="UIStroke" referent="110">
                      <Properties>
                        <string name="Name">Ring</string>
                        <token name="ApplyStrokeMode">1</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.06097561</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                    <Item class="UIShadow" referent="111">
                      <Properties>
                        <string name="Name">Lip</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BlurRadius">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <bool name="Inset">false</bool>
                        <token name="Mode">0</token>
                        <UDim2 name="Offset">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0.06097561</YS>
                          <YO>0</YO>
                        </UDim2>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <bool name="ShowBehindParent">true</bool>
                        <int64 name="SourceAssetId">-1</int64>
                        <UDim2 name="Spread">
                          <XS>0.12195122</XS>
                          <XO>0</XO>
                          <YS>0.12195122</YS>
                          <YO>0</YO>
                        </UDim2>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">-1</int>
                      </Properties>
                    </Item>
                    <Item class="UIAspectRatioConstraint" referent="112">
                      <Properties>
                        <string name="Name">UIAspectRatioConstraint</string>
                        <float name="AspectRatio">1</float>
                        <token name="AspectType">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <token name="DominantAxis">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                      </Properties>
                    </Item>
                    <Item class="ImageLabel" referent="113">
                      <Properties>
                        <string name="Name">Content</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0.5</X>
                          <Y>0.5</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.6392157</R>
                          <G>0.63529414</G>
                          <B>0.64705884</B>
                        </Color3>
                        <float name="BackgroundTransparency">1</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <Color3 name="ImageColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <Content name="ImageContent">
                          <uri>rbxassetid://91427328378865</uri>
                        </Content>
                        <Vector2 name="ImageRectOffset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <Vector2 name="ImageRectSize">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="ImageTransparency">0</float>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0.5</XS>
                          <XO>0</XO>
                          <YS>0.5</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="ResampleMode">0</token>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <token name="ScaleType">3</token>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>0.76</XS>
                          <XO>0</XO>
                          <YS>0.76</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <Rect2D name="SliceCenter">
                          <min>
                            <X>0</X>
                            <Y>0</Y>
                          </min>
                          <max>
                            <X>0</X>
                            <Y>0</Y>
                          </max>
                        </Rect2D>
                        <float name="SliceScale">1</float>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim2 name="TileSize">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">5</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="114">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.1875</XS>
                        <XO>0</XO>
                        <YS>0.13095239</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.7708333</XS>
                        <XO>0</XO>
                        <YS>0.33333334</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="115">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="116">
                    <Properties>
                      <string name="Name">Subtitle</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.1875</XS>
                        <XO>0</XO>
                        <YS>0.52380955</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.7708333</XS>
                        <XO>0</XO>
                        <YS>0.22619048</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Subtitle</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>0.972549</G>
                        <B>0.8235294</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="117">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="118">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.55</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.1875</XS>
                        <XO>0</XO>
                        <YS>0.8214286</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.765625</XS>
                        <XO>0</XO>
                        <YS>0.071428575</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="119">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="120">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="121">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="122">
                  <Properties>
                    <string name="Name">Banner</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBAAAAEZhZGUIAAAARHVyYXRpb24GAAAAAAAAIEALAAAATWF4T25TY3JlZW4GAAAAAAAA8D8JAAAAU2xpZGVGcm9tAgQAAABBdXRvBQAAAFNvdW5kAggAAABMZXZlbF9VcA4AAABTdGFja0RpcmVjdGlvbgIEAAAARG93bgoAAABTdGFja0dyb3VwAgYAAABCYW5uZXI=</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.25</XS>
                      <XO>0</XO>
                      <YS>0.06666667</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="123">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">6.6666665</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="124">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.2777778</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.2777778</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.2777778</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.2777778</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="125">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 1 0.8392157 0.2509804 0 1 1 0.54901963 0.101960786 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="126">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.083333336</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="127">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.083333336</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.025</XS>
                        <XO>0</XO>
                        <YS>0.16666667</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="128">
                    <Properties>
                      <string name="Name">Shine</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.72</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.014583333</XS>
                        <XO>0</XO>
                        <YS>0.06944445</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.97083336</XS>
                        <XO>0</XO>
                        <YS>0.375</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">1</int>
                    </Properties>
                    <Item class="UICorner" referent="129">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.37037036</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.37037036</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.37037036</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.37037036</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="130">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.033333335</XS>
                        <XO>0</XO>
                        <YS>0.18055555</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.93333334</XS>
                        <XO>0</XO>
                        <YS>0.5833333</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text"><![CDATA[This is a test banner notification title! ]]></string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="131">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="132">
                    <Properties>
                      <string name="Name">StarLeft</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>-0.020833334</XS>
                        <XO>0</XO>
                        <YS>-0.33333334</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">-15</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.104166664</XS>
                        <XO>0</XO>
                        <YS>0.6944444</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">★</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>0.9254902</G>
                        <B>0.47058824</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UIStroke" referent="133">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="134">
                    <Properties>
                      <string name="Name">StarRight</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.9166667</XS>
                        <XO>0</XO>
                        <YS>-0.33333334</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">15</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.104166664</XS>
                        <XO>0</XO>
                        <YS>0.6944444</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">★</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>0.9254902</G>
                        <B>0.47058824</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UIStroke" referent="135">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="136">
                  <Properties>
                    <string name="Name">BannerSubtitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBAAAAEZhZGUIAAAARHVyYXRpb24GAAAAAAAAIEALAAAATWF4T25TY3JlZW4GAAAAAAAA8D8JAAAAU2xpZGVGcm9tAgQAAABBdXRvBQAAAFNvdW5kAggAAABMZXZlbF9VcA4AAABTdGFja0RpcmVjdGlvbgIEAAAARG93bgoAAABTdGFja0dyb3VwAgYAAABCYW5uZXI=</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.08888888</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.25</XS>
                      <XO>0</XO>
                      <YS>0.085185185</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="137">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">5.2173915</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="138">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.2173913</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.2173913</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.2173913</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.2173913</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="139">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 1 0.8392157 0.2509804 0 1 1 0.54901963 0.101960786 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="140">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.06521739</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="141">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.06521739</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.025</XS>
                        <XO>0</XO>
                        <YS>0.13043478</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="142">
                    <Properties>
                      <string name="Name">Shine</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0.72</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.014583333</XS>
                        <XO>0</XO>
                        <YS>0.054347824</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.97083336</XS>
                        <XO>0</XO>
                        <YS>0.36956522</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">1</int>
                    </Properties>
                    <Item class="UICorner" referent="143">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.29411766</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.29411766</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.29411766</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.29411766</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="144">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.033333335</XS>
                        <XO>0</XO>
                        <YS>0.08695652</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.93333334</XS>
                        <XO>0</XO>
                        <YS>0.45652175</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text"><![CDATA[This is a test banner notification title! ]]></string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="145">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="146">
                    <Properties>
                      <string name="Name">Subtitle</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.033333335</XS>
                        <XO>0</XO>
                        <YS>0.6086956</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.93333334</XS>
                        <XO>0</XO>
                        <YS>0.23913044</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">This is a test subtitle!</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="147">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.1</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="148">
                    <Properties>
                      <string name="Name">StarLeft</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>-0.020833334</XS>
                        <XO>0</XO>
                        <YS>-0.26086956</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">-15</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.104166664</XS>
                        <XO>0</XO>
                        <YS>0.54347825</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">★</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>0.9254902</G>
                        <B>0.47058824</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UIStroke" referent="149">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="150">
                    <Properties>
                      <string name="Name">StarRight</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.9166667</XS>
                        <XO>0</XO>
                        <YS>-0.26086956</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">15</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.104166664</XS>
                        <XO>0</XO>
                        <YS>0.54347825</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">★</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>0.9254902</G>
                        <B>0.47058824</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UIStroke" referent="151">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="152">
                  <Properties>
                    <string name="Name">Alert</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>1</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAAAhACwAAAE1heE9uU2NyZWVuBgAAAAAAAAhACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIKAAAAQ29kZV9FcnJvcg4AAABTdGFja0RpcmVjdGlvbgICAAAAVXAKAAAAU3RhY2tHcm91cAIAAAAA</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.88</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.26666668</XS>
                      <XO>0</XO>
                      <YS>0.05</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="153">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">9.481482</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="154">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="155">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 1 0.3764706 0.3764706 0 1 0.8392157 0.11764706 0.20392157 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="156">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.09259259</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="157">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.09259259</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.01953125</XS>
                        <XO>0</XO>
                        <YS>0.18518518</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="TextLabel" referent="158">
                    <Properties>
                      <string name="Name">Mark</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.03125</XS>
                        <XO>0</XO>
                        <YS>0.16666667</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.0703125</XS>
                        <XO>0</XO>
                        <YS>0.6666667</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">!</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="159">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="160">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.109375</XS>
                        <XO>0</XO>
                        <YS>0.24074075</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.84375</XS>
                        <XO>0</XO>
                        <YS>0.5185185</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">This is an error notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="161">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.09</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                </Item>
              </Item>
              <Item class="Folder" referent="162">
                <Properties>
                  <string name="Name">Sleek</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="IconTint">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
                <Item class="Frame" referent="163">
                  <Properties>
                    <string name="Name">TitleOnly</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABBACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.062962964</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="164">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">5.647059</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="165">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="166">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.101960786 0.1254902 0.36078432 0 1 0.039215688 0.05490196 0.21960784 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="167">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.05882353</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="168">
                    <Properties>
                      <string name="Name">Shadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.0882353</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0.55</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="TextLabel" referent="169">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.057291668</XS>
                        <XO>0</XO>
                        <YS>0.2647059</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9010417</XS>
                        <XO>0</XO>
                        <YS>0.38235295</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="170">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="171">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.15686275</R>
                        <G>0.1882353</G>
                        <B>0.43137255</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.057291668</XS>
                        <XO>0</XO>
                        <YS>0.8088235</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.8958333</XS>
                        <XO>0</XO>
                        <YS>0.05882353</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="172">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="173">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.64705884</R>
                          <G>0.49019608</G>
                          <B>1</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="174">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="175">
                  <Properties>
                    <string name="Name">TitleSubtitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABRACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.07777778</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="176">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">4.571429</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="177">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="178">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.101960786 0.1254902 0.36078432 0 1 0.039215688 0.05490196 0.21960784 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="179">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.04761905</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="180">
                    <Properties>
                      <string name="Name">Shadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.071428575</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0.55</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="TextLabel" referent="181">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.057291668</XS>
                        <XO>0</XO>
                        <YS>0.15476191</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9010417</XS>
                        <XO>0</XO>
                        <YS>0.30952382</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="182">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="183">
                    <Properties>
                      <string name="Name">Subtitle</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.057291668</XS>
                        <XO>0</XO>
                        <YS>0.53571427</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.9010417</XS>
                        <XO>0</XO>
                        <YS>0.21428572</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Subtitle</string>
                      <Color3 name="TextColor3">
                        <R>0.6901961</R>
                        <G>0.7294118</G>
                        <B>0.9019608</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="184">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.15686275</R>
                        <G>0.1882353</G>
                        <B>0.43137255</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.057291668</XS>
                        <XO>0</XO>
                        <YS>0.8452381</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.8958333</XS>
                        <XO>0</XO>
                        <YS>0.04761905</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="185">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="186">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.23529412</R>
                          <G>0.84313726</G>
                          <B>0.78431374</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="187">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="188">
                  <Properties>
                    <string name="Name">ImageTitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABRACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.062962964</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="189">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">5.647059</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="190">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.19117647</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="191">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.101960786 0.1254902 0.36078432 0 1 0.039215688 0.05490196 0.21960784 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="192">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.05882353</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="193">
                    <Properties>
                      <string name="Name">Shadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.0882353</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0.55</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="194">
                    <Properties>
                      <string name="Name">Image</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.046875</XS>
                        <XO>0</XO>
                        <YS>0.05882353</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.15625</XS>
                        <XO>0</XO>
                        <YS>0.88235295</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UICorner" referent="195">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="UIGradient" referent="196">
                      <Properties>
                        <string name="Name">Shade</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <ColorSequence name="Color">0 0.45588237 0.89705884 0.60294116 0 1 0.27450982 0.8627451 0.47058824 0 </ColorSequence>
                        <bool name="Enabled">true</bool>
                        <Vector2 name="Offset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="Rotation">90</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <float name="Scale">1</float>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <token name="TileMode">0</token>
                        <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                        <token name="Type">0</token>
                      </Properties>
                    </Item>
                    <Item class="UIStroke" referent="197">
                      <Properties>
                        <string name="Name">Ring</string>
                        <token name="ApplyStrokeMode">1</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.05</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                    <Item class="UIAspectRatioConstraint" referent="198">
                      <Properties>
                        <string name="Name">UIAspectRatioConstraint</string>
                        <float name="AspectRatio">1</float>
                        <token name="AspectType">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <token name="DominantAxis">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                      </Properties>
                    </Item>
                    <Item class="ImageLabel" referent="199">
                      <Properties>
                        <string name="Name">Content</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0.5</X>
                          <Y>0.5</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.6392157</R>
                          <G>0.63529414</G>
                          <B>0.64705884</B>
                        </Color3>
                        <float name="BackgroundTransparency">1</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <Color3 name="ImageColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <Content name="ImageContent">
                          <uri>rbxassetid://95862633182393</uri>
                        </Content>
                        <Vector2 name="ImageRectOffset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <Vector2 name="ImageRectSize">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="ImageTransparency">0</float>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0.5</XS>
                          <XO>0</XO>
                          <YS>0.5</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="ResampleMode">0</token>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <token name="ScaleType">3</token>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>0.76</XS>
                          <XO>0</XO>
                          <YS>0.76</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <Rect2D name="SliceCenter">
                          <min>
                            <X>0</X>
                            <Y>0</Y>
                          </min>
                          <max>
                            <X>0</X>
                            <Y>0</Y>
                          </max>
                        </Rect2D>
                        <float name="SliceScale">1</float>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim2 name="TileSize">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">5</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="200">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.23958333</XS>
                        <XO>0</XO>
                        <YS>0.2647059</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.71875</XS>
                        <XO>0</XO>
                        <YS>0.38235295</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="201">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="Frame" referent="202">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.15686275</R>
                        <G>0.1882353</G>
                        <B>0.43137255</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.23958333</XS>
                        <XO>0</XO>
                        <YS>0.8088235</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.7135417</XS>
                        <XO>0</XO>
                        <YS>0.05882353</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="203">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="204">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.27450982</R>
                          <G>0.8627451</G>
                          <B>0.47058824</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="205">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="206">
                  <Properties>
                    <string name="Name">ImageTitleSubtitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>1</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABhACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.975</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.2</XS>
                      <XO>0</XO>
                      <YS>0.07777778</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="207">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">4.571429</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="208">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.15476191</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="209">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.101960786 0.1254902 0.36078432 0 1 0.039215688 0.05490196 0.21960784 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="210">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0.015686275</R>
                        <G>0.015686275</G>
                        <B>0.20784314</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.04761905</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="211">
                    <Properties>
                      <string name="Name">Shadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.071428575</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0.55</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="212">
                    <Properties>
                      <string name="Name">Image</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.046875</XS>
                        <XO>0</XO>
                        <YS>0.14285715</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.15625</XS>
                        <XO>0</XO>
                        <YS>0.71428573</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">4</int>
                    </Properties>
                    <Item class="UICorner" referent="213">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.2</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="UIGradient" referent="214">
                      <Properties>
                        <string name="Name">Shade</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <ColorSequence name="Color">0 1 0.8264706 0.36764705 0 1 1 0.76862746 0.15686275 0 </ColorSequence>
                        <bool name="Enabled">true</bool>
                        <Vector2 name="Offset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="Rotation">90</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <float name="Scale">1</float>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <token name="TileMode">0</token>
                        <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                        <token name="Type">0</token>
                      </Properties>
                    </Item>
                    <Item class="UIStroke" referent="215">
                      <Properties>
                        <string name="Name">Ring</string>
                        <token name="ApplyStrokeMode">1</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.05</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                    <Item class="UIAspectRatioConstraint" referent="216">
                      <Properties>
                        <string name="Name">UIAspectRatioConstraint</string>
                        <float name="AspectRatio">1</float>
                        <token name="AspectType">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <token name="DominantAxis">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                      </Properties>
                    </Item>
                    <Item class="ImageLabel" referent="217">
                      <Properties>
                        <string name="Name">Content</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0.5</X>
                          <Y>0.5</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.6392157</R>
                          <G>0.63529414</G>
                          <B>0.64705884</B>
                        </Color3>
                        <float name="BackgroundTransparency">1</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <Color3 name="ImageColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <Content name="ImageContent">
                          <uri>rbxassetid://91427328378865</uri>
                        </Content>
                        <Vector2 name="ImageRectOffset">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <Vector2 name="ImageRectSize">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <float name="ImageTransparency">0</float>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0.5</XS>
                          <XO>0</XO>
                          <YS>0.5</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="ResampleMode">0</token>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <token name="ScaleType">3</token>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>0.76</XS>
                          <XO>0</XO>
                          <YS>0.76</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <Rect2D name="SliceCenter">
                          <min>
                            <X>0</X>
                            <Y>0</Y>
                          </min>
                          <max>
                            <X>0</X>
                            <Y>0</Y>
                          </max>
                        </Rect2D>
                        <float name="SliceScale">1</float>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim2 name="TileSize">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">5</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="218">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.23958333</XS>
                        <XO>0</XO>
                        <YS>0.15476191</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.71875</XS>
                        <XO>0</XO>
                        <YS>0.30952382</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="219">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.07</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="220">
                    <Properties>
                      <string name="Name">Subtitle</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.23958333</XS>
                        <XO>0</XO>
                        <YS>0.53571427</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.71875</XS>
                        <XO>0</XO>
                        <YS>0.21428572</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">Test Subtitle</string>
                      <Color3 name="TextColor3">
                        <R>0.6901961</R>
                        <G>0.7294118</G>
                        <B>0.9019608</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="221">
                    <Properties>
                      <string name="Name">Timer</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.15686275</R>
                        <G>0.1882353</G>
                        <B>0.43137255</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.23958333</XS>
                        <XO>0</XO>
                        <YS>0.8452381</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.7135417</XS>
                        <XO>0</XO>
                        <YS>0.04761905</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">2</int>
                    </Properties>
                    <Item class="UICorner" referent="222">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="Frame" referent="223">
                      <Properties>
                        <string name="Name">Fill</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>1</R>
                          <G>0.76862746</G>
                          <B>0.15686275</B>
                        </Color3>
                        <float name="BackgroundTransparency">0</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0</YS>
                          <YO>0</YO>
                        </UDim2>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>1</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="Style">0</token>
                        <BinaryString name="Tags"></BinaryString>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">2</int>
                      </Properties>
                      <Item class="UICorner" referent="224">
                        <Properties>
                          <string name="Name">UICorner</string>
                          <BinaryString name="AttributesSerialize"></BinaryString>
                          <UDim name="BottomLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="BottomRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                          <bool name="DefinesCapabilities">false</bool>
                          <BinaryString name="SerializedOverrides">
                          </BinaryString>
                          <int64 name="SourceAssetId">-1</int64>
                          <BinaryString name="Tags"></BinaryString>
                          <UDim name="TopLeftRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                          <UDim name="TopRightRadius">
                            <S>0.5</S>
                            <O>0</O>
                          </UDim>
                        </Properties>
                      </Item>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="225">
                  <Properties>
                    <string name="Name">Banner</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBAAAAEZhZGUIAAAARHVyYXRpb24GAAAAAAAAIEALAAAATWF4T25TY3JlZW4GAAAAAAAA8D8JAAAAU2xpZGVGcm9tAgQAAABBdXRvBQAAAFNvdW5kAggAAABMZXZlbF9VcA4AAABTdGFja0RpcmVjdGlvbgIEAAAARG93bgoAAABTdGFja0dyb3VwAgYAAABCYW5uZXI=</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.25</XS>
                      <XO>0</XO>
                      <YS>0.06666667</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="226">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">6.6666665</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="227">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="228">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.11764706 0.14117648 0.39215687 0 1 0.039215688 0.05490196 0.21960784 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="229">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>1</R>
                        <G>0.76862746</G>
                        <B>0.15686275</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.055555556</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="230">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0.3</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>1</R>
                        <G>0.76862746</G>
                        <B>0.15686275</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.016666668</XS>
                        <XO>0</XO>
                        <YS>0.11111111</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0.35</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="TextLabel" referent="231">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.033333335</XS>
                        <XO>0</XO>
                        <YS>0.22222222</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.93333334</XS>
                        <XO>0</XO>
                        <YS>0.5555556</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text"><![CDATA[This is a test banner notification title! ]]></string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="232">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.06</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                </Item>
                <Item class="Frame" referent="233">
                  <Properties>
                    <string name="Name">BannerSubtitle</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBAAAAEZhZGUIAAAARHVyYXRpb24GAAAAAAAAIEALAAAATWF4T25TY3JlZW4GAAAAAAAA8D8JAAAAU2xpZGVGcm9tAgQAAABBdXRvBQAAAFNvdW5kAggAAABMZXZlbF9VcA4AAABTdGFja0RpcmVjdGlvbgIEAAAARG93bgoAAABTdGFja0dyb3VwAgYAAABCYW5uZXI=</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.08888888</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.25</XS>
                      <XO>0</XO>
                      <YS>0.085185185</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="234">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">5.2173915</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="235">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.19565217</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.19565217</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.19565217</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.19565217</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="236">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.11764706 0.14117648 0.39215687 0 1 0.039215688 0.05490196 0.21960784 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="237">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>1</R>
                        <G>0.76862746</G>
                        <B>0.15686275</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.04347826</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="238">
                    <Properties>
                      <string name="Name">DropShadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0.3</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>1</R>
                        <G>0.76862746</G>
                        <B>0.15686275</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0.016666668</XS>
                        <XO>0</XO>
                        <YS>0.08695652</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0.35</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="TextLabel" referent="239">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.033333335</XS>
                        <XO>0</XO>
                        <YS>0.097826086</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.93333334</XS>
                        <XO>0</XO>
                        <YS>0.4347826</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text"><![CDATA[This is a test banner notification title! ]]></string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UIStroke" referent="240">
                      <Properties>
                        <string name="Name">UIStroke</string>
                        <token name="ApplyStrokeMode">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BorderOffset">
                          <S>0</S>
                          <O>0</O>
                        </UDim>
                        <token name="BorderStrokePosition">0</token>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <Color3 name="Color">
                          <R>0.015686275</R>
                          <G>0.015686275</G>
                          <B>0.20784314</B>
                        </Color3>
                        <bool name="Enabled">true</bool>
                        <token name="LineJoinMode">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <token name="StrokeSizingMode">1</token>
                        <BinaryString name="Tags"></BinaryString>
                        <float name="Thickness">0.06</float>
                        <float name="Transparency">0</float>
                        <int name="ZIndex">1</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="241">
                    <Properties>
                      <string name="Name">Subtitle</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.033333335</XS>
                        <XO>0</XO>
                        <YS>0.6195652</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.93333334</XS>
                        <XO>0</XO>
                        <YS>0.22826087</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">This is a test subtitle!</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>0.8496078</G>
                        <B>0.4519608</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">2</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                  </Item>
                </Item>
                <Item class="Frame" referent="242">
                  <Properties>
                    <string name="Name">Alert</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>1</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAAAhACwAAAE1heE9uU2NyZWVuBgAAAAAAAAhACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIKAAAAQ29kZV9FcnJvcg4AAABTdGFja0RpcmVjdGlvbgICAAAAVXAKAAAAU3RhY2tHcm91cAIAAAAA</BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.88</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.26666668</XS>
                      <XO>0</XO>
                      <YS>0.05</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">false</bool>
                    <int name="ZIndex">1</int>
                  </Properties>
                  <Item class="UIAspectRatioConstraint" referent="243">
                    <Properties>
                      <string name="Name">UIAspectRatioConstraint</string>
                      <float name="AspectRatio">9.481482</float>
                      <token name="AspectType">0</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <token name="DominantAxis">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                    </Properties>
                  </Item>
                  <Item class="UICorner" referent="244">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                  <Item class="UIGradient" referent="245">
                    <Properties>
                      <string name="Name">Gradient</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <ColorSequence name="Color">0 0.0627451 0.078431375 0.26666668 0 1 0.039215688 0.05490196 0.21960784 0 </ColorSequence>
                      <bool name="Enabled">true</bool>
                      <Vector2 name="Offset">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <float name="Rotation">90</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <float name="Scale">1</float>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <token name="TileMode">0</token>
                      <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                      <token name="Type">0</token>
                    </Properties>
                  </Item>
                  <Item class="UIStroke" referent="246">
                    <Properties>
                      <string name="Name">Outline</string>
                      <token name="ApplyStrokeMode">1</token>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BorderOffset">
                        <S>0</S>
                        <O>0</O>
                      </UDim>
                      <token name="BorderStrokePosition">0</token>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>1</R>
                        <G>0.27450982</G>
                        <B>0.3529412</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <token name="LineJoinMode">0</token>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="StrokeSizingMode">1</token>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Thickness">0.074074075</float>
                      <float name="Transparency">0</float>
                      <int name="ZIndex">1</int>
                    </Properties>
                  </Item>
                  <Item class="UIShadow" referent="247">
                    <Properties>
                      <string name="Name">Shadow</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BlurRadius">
                        <S>0.25</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <Color3 name="Color">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <bool name="Enabled">true</bool>
                      <bool name="Inset">false</bool>
                      <token name="Mode">0</token>
                      <UDim2 name="Offset">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0.11111111</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <bool name="ShowBehindParent">true</bool>
                      <int64 name="SourceAssetId">-1</int64>
                      <UDim2 name="Spread">
                        <XS>0</XS>
                        <XO>0</XO>
                        <YS>0</YS>
                        <YO>0</YO>
                      </UDim2>
                      <BinaryString name="Tags"></BinaryString>
                      <float name="Transparency">0.55</float>
                      <int name="ZIndex">-1</int>
                    </Properties>
                  </Item>
                  <Item class="Frame" referent="248">
                    <Properties>
                      <string name="Name">Badge</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>1</R>
                        <G>0.27450982</G>
                        <B>0.3529412</B>
                      </Color3>
                      <float name="BackgroundTransparency">0</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <UDim2 name="Position">
                        <XS>0.0234375</XS>
                        <XO>0</XO>
                        <YS>0.2037037</YS>
                        <YO>0</YO>
                      </UDim2>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.0625</XS>
                        <XO>0</XO>
                        <YS>0.5925926</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <token name="Style">0</token>
                      <BinaryString name="Tags"></BinaryString>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                    <Item class="UICorner" referent="249">
                      <Properties>
                        <string name="Name">UICorner</string>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <UDim name="BottomLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="BottomRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <UDim name="TopLeftRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                        <UDim name="TopRightRadius">
                          <S>0.5</S>
                          <O>0</O>
                        </UDim>
                      </Properties>
                    </Item>
                    <Item class="UIAspectRatioConstraint" referent="250">
                      <Properties>
                        <string name="Name">UIAspectRatioConstraint</string>
                        <float name="AspectRatio">1</float>
                        <token name="AspectType">0</token>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <token name="DominantAxis">0</token>
                        <bool name="DefinesCapabilities">false</bool>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                      </Properties>
                    </Item>
                    <Item class="TextLabel" referent="251">
                      <Properties>
                        <string name="Name">Mark</string>
                        <bool name="Active">false</bool>
                        <Vector2 name="AnchorPoint">
                          <X>0</X>
                          <Y>0</Y>
                        </Vector2>
                        <BinaryString name="AttributesSerialize"></BinaryString>
                        <bool name="AutoLocalize">true</bool>
                        <token name="AutomaticSize">0</token>
                        <Color3 name="BackgroundColor3">
                          <R>0.6392157</R>
                          <G>0.63529414</G>
                          <B>0.64705884</B>
                        </Color3>
                        <float name="BackgroundTransparency">1</float>
                        <Color3 name="BorderColor3">
                          <R>0.105882354</R>
                          <G>0.16470589</G>
                          <B>0.20784314</B>
                        </Color3>
                        <token name="BorderMode">0</token>
                        <int name="BorderSizePixel">0</int>
                        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                        <bool name="ClipsDescendants">false</bool>
                        <bool name="Draggable">false</bool>
                        <Font name="FontFace">
                          <Family>
                            <url>rbxasset://fonts/families/FredokaOne.json</url>
                          </Family>
                          <Weight>400</Weight>
                          <Style>Normal</Style>
                        </Font>
                        <bool name="Interactable">true</bool>
                        <int name="LayoutOrder">0</int>
                        <float name="LineHeight">1</float>
                        <string name="LocalizationMatchIdentifier"></string>
                        <string name="LocalizationMatchedSourceText"></string>
                        <int name="MaxVisibleGraphemes">-1</int>
                        <Ref name="NextSelectionDown">null</Ref>
                        <Ref name="NextSelectionLeft">null</Ref>
                        <Ref name="NextSelectionRight">null</Ref>
                        <Ref name="NextSelectionUp">null</Ref>
                        <string name="OpenTypeFeatures"></string>
                        <UDim2 name="Position">
                          <XS>0</XS>
                          <XO>0</XO>
                          <YS>0.125</YS>
                          <YO>0</YO>
                        </UDim2>
                        <bool name="RichText">false</bool>
                        <Ref name="RootLocalizationTable">null</Ref>
                        <float name="Rotation">0</float>
                        <bool name="DefinesCapabilities">false</bool>
                        <bool name="Selectable">false</bool>
                        <token name="SelectionBehaviorDown">0</token>
                        <token name="SelectionBehaviorLeft">0</token>
                        <token name="SelectionBehaviorRight">0</token>
                        <token name="SelectionBehaviorUp">0</token>
                        <bool name="SelectionGroup">false</bool>
                        <Ref name="SelectionImageObject">null</Ref>
                        <int name="SelectionOrder">0</int>
                        <BinaryString name="SerializedOverrides">
                        </BinaryString>
                        <token name="Sink">0</token>
                        <UDim2 name="Size">
                          <XS>1</XS>
                          <XO>0</XO>
                          <YS>0.75</YS>
                          <YO>0</YO>
                        </UDim2>
                        <token name="SizeConstraint">0</token>
                        <int64 name="SourceAssetId">-1</int64>
                        <BinaryString name="Tags"></BinaryString>
                        <string name="Text">!</string>
                        <Color3 name="TextColor3">
                          <R>1</R>
                          <G>1</G>
                          <B>1</B>
                        </Color3>
                        <token name="TextDirection">0</token>
                        <bool name="TextScaled">true</bool>
                        <float name="TextSize">8</float>
                        <Color3 name="TextStrokeColor3">
                          <R>0</R>
                          <G>0</G>
                          <B>0</B>
                        </Color3>
                        <float name="TextStrokeTransparency">1</float>
                        <float name="TextTransparency">0</float>
                        <token name="TextTruncate">0</token>
                        <bool name="TextWrapped">true</bool>
                        <token name="TextXAlignment">2</token>
                        <token name="TextYAlignment">1</token>
                        <bool name="Visible">true</bool>
                        <int name="ZIndex">4</int>
                      </Properties>
                    </Item>
                  </Item>
                  <Item class="TextLabel" referent="252">
                    <Properties>
                      <string name="Name">Title</string>
                      <bool name="Active">false</bool>
                      <Vector2 name="AnchorPoint">
                        <X>0</X>
                        <Y>0</Y>
                      </Vector2>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <bool name="AutoLocalize">true</bool>
                      <token name="AutomaticSize">0</token>
                      <Color3 name="BackgroundColor3">
                        <R>0.6392157</R>
                        <G>0.63529414</G>
                        <B>0.64705884</B>
                      </Color3>
                      <float name="BackgroundTransparency">1</float>
                      <Color3 name="BorderColor3">
                        <R>0.105882354</R>
                        <G>0.16470589</G>
                        <B>0.20784314</B>
                      </Color3>
                      <token name="BorderMode">0</token>
                      <int name="BorderSizePixel">0</int>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="ClipsDescendants">false</bool>
                      <bool name="Draggable">false</bool>
                      <Font name="FontFace">
                        <Family>
                          <url>rbxasset://fonts/families/FredokaOne.json</url>
                        </Family>
                        <Weight>400</Weight>
                        <Style>Normal</Style>
                      </Font>
                      <bool name="Interactable">true</bool>
                      <int name="LayoutOrder">0</int>
                      <float name="LineHeight">1</float>
                      <string name="LocalizationMatchIdentifier"></string>
                      <string name="LocalizationMatchedSourceText"></string>
                      <int name="MaxVisibleGraphemes">-1</int>
                      <Ref name="NextSelectionDown">null</Ref>
                      <Ref name="NextSelectionLeft">null</Ref>
                      <Ref name="NextSelectionRight">null</Ref>
                      <Ref name="NextSelectionUp">null</Ref>
                      <string name="OpenTypeFeatures"></string>
                      <UDim2 name="Position">
                        <XS>0.109375</XS>
                        <XO>0</XO>
                        <YS>0.25925925</YS>
                        <YO>0</YO>
                      </UDim2>
                      <bool name="RichText">false</bool>
                      <Ref name="RootLocalizationTable">null</Ref>
                      <float name="Rotation">0</float>
                      <bool name="DefinesCapabilities">false</bool>
                      <bool name="Selectable">false</bool>
                      <token name="SelectionBehaviorDown">0</token>
                      <token name="SelectionBehaviorLeft">0</token>
                      <token name="SelectionBehaviorRight">0</token>
                      <token name="SelectionBehaviorUp">0</token>
                      <bool name="SelectionGroup">false</bool>
                      <Ref name="SelectionImageObject">null</Ref>
                      <int name="SelectionOrder">0</int>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <token name="Sink">0</token>
                      <UDim2 name="Size">
                        <XS>0.84375</XS>
                        <XO>0</XO>
                        <YS>0.4814815</YS>
                        <YO>0</YO>
                      </UDim2>
                      <token name="SizeConstraint">0</token>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <string name="Text">This is an error notification</string>
                      <Color3 name="TextColor3">
                        <R>1</R>
                        <G>1</G>
                        <B>1</B>
                      </Color3>
                      <token name="TextDirection">0</token>
                      <bool name="TextScaled">true</bool>
                      <float name="TextSize">8</float>
                      <Color3 name="TextStrokeColor3">
                        <R>0</R>
                        <G>0</G>
                        <B>0</B>
                      </Color3>
                      <float name="TextStrokeTransparency">1</float>
                      <float name="TextTransparency">0</float>
                      <token name="TextTruncate">0</token>
                      <bool name="TextWrapped">true</bool>
                      <token name="TextXAlignment">0</token>
                      <token name="TextYAlignment">1</token>
                      <bool name="Visible">true</bool>
                      <int name="ZIndex">3</int>
                    </Properties>
                  </Item>
                </Item>
              </Item>
            </Item>
          </Item>
        </Item>
      </Item>
    </Item>
    <Item class="Folder" referent="253">
      <Properties>
        <string name="Name">ServerScriptService</string>
        <BinaryString name="AttributesSerialize"></BinaryString>
        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
        <Color3 name="IconTint">
          <R>0</R>
          <G>0</G>
          <B>0</B>
        </Color3>
        <bool name="DefinesCapabilities">false</bool>
        <BinaryString name="SerializedOverrides">
        </BinaryString>
        <int64 name="SourceAssetId">-1</int64>
        <BinaryString name="Tags"></BinaryString>
      </Properties>
      <Item class="Script" referent="254">
        <Properties>
          <string name="Name">Kernel</string>
          <BinaryString name="AttributesSerialize"></BinaryString>
          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
          <bool name="Disabled">false</bool>
          <ContentId name="LinkedSource">
            <null>
            </null>
          </ContentId>
          <token name="RunContext">0</token>
          <bool name="DefinesCapabilities">false</bool>
          <BinaryString name="SerializedOverrides">
          </BinaryString>
          <string name="Source"><![CDATA[-- RBLX Essentials Kernel - server boot. The only Script in the ecosystem.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local StarterGui = game:GetService("StarterGui")
local HttpService = game:GetService("HttpService")

local kernelFolder = ReplicatedStorage:WaitForChild("RBLXEssentials"):WaitForChild("Kernel")
local RootPersistence = require(kernelFolder.UI.RootPersistence)

-- Run first, in its own pcall, before any other require or work: make
-- StarterGui.RBLXEssentials survive character respawns (see
-- UI/RootPersistence.lua) before any character spawns. Guarded: a failure
-- here must never stop the packs from booting, and the piece decision below
-- then uses the Folder root as it is.
local persistOk, persistResult, persistWarnings = pcall(RootPersistence.persist, StarterGui, Instance.new, Enum)
local uiRoot
if persistOk then
	uiRoot = persistResult
	for _, message in ipairs(persistWarnings) do
		warn("[RBLXE] UI root: " .. message)
	end
else
	warn("[RBLXE] could not make StarterGui.RBLXEssentials persistent; menus, HUD buttons and pack interfaces may stop working after a respawn: " .. tostring(persistResult))
	uiRoot = StarterGui:FindFirstChild("RBLXEssentials")
end

local Pieces = require(kernelFolder.UI.Pieces)
local Loader = require(kernelFolder.Loader)
local Version = require(kernelFolder.Version)
local Net = require(kernelFolder.Net)
local SFX = require(kernelFolder.SFX)
local Notify = require(kernelFolder.Notify)
local Signal = require(kernelFolder.Signal)
local Trove = require(kernelFolder.Packages.Trove)
local Schema = require(kernelFolder.Schema)
local Config = require(kernelFolder.Config)
local Contracts = require(kernelFolder.Contracts)

local ssRoot = script.Parent -- ServerScriptService/RBLXEssentials
local rsRoot = ReplicatedStorage.RBLXEssentials
local sharedPacks = rsRoot:WaitForChild("Packs")

rsRoot:SetAttribute("RBLXE_KernelVersion", Version)

-- 3.0 pieces: decide once, here, which copy of every declared interface piece
-- the game uses (a valid StarterGui.RBLXEssentials.Interface override, else the
-- pack's default) and publish it for every client, before any pack boots. The
-- JSON encoding runs inside the same pcall: whatever fails here falls back to
-- LEGACY and never stops the server script before Loader.boot.
-- RT-6: packs whose Pieces declaration is invalid; the Loader fails them.
local pieceFailures = {}
local planOk, encodedOrError = pcall(function()
	local declarations, declarationWarnings, declarationFailures = Pieces.collectDeclarations(sharedPacks, require, Contracts)
	pieceFailures = declarationFailures
	local plan = Pieces.plan({
		declarations = declarations,
		root = uiRoot,
		contracts = Contracts,
	})
	for _, message in ipairs(declarationWarnings) do
		warn("[RBLXE] UI: " .. message)
	end
	for _, message in ipairs(Pieces.strays(StarterGui, uiRoot)) do
		warn("[RBLXE] UI: " .. message)
	end
	for _, line in ipairs(plan.lines) do
		print("[RBLXE] UI: " .. line)
	end
	for _, message in ipairs(plan.warnings) do
		warn("[RBLXE] UI: " .. message)
	end
	return Pieces.encodeDecisions(plan, function(value)
		return HttpService:JSONEncode(value)
	end)
end)
if planOk then
	rsRoot:SetAttribute(Pieces.WINNERS_ATTRIBUTE, encodedOrError)
else
	warn("[RBLXE] UI: piece resolution failed, pieces keep 2.x adoption: " .. tostring(encodedOrError))
	rsRoot:SetAttribute(Pieces.WINNERS_ATTRIBUTE, Pieces.LEGACY)
end

local report = Loader.boot({
	side = "Server",
	sharedPacks = sharedPacks,
	serverPacks = ssRoot:WaitForChild("Packs"),
	kernelApi = { Version = Version, Trove = Trove, Signal = Signal, Net = Net, SFX = SFX, Notify = Notify },
	configLib = Config,
	schemaLib = Schema,
	configRoots = { shared = rsRoot:FindFirstChild("Config"), server = ssRoot:FindFirstChild("Config") },
	pieceFailures = pieceFailures,
	extensions = ssRoot:FindFirstChild("Extensions"),
})

-- RT-5: tell every client which packs did not start here. A reason that may
-- quote server-only values (an invalid configuration, a server module's
-- error) reaches clients as a fixed text (Loader.encodeServerReport); the
-- warnings below print it whole in the server output. The encoding and
-- the attribute write share one pcall: a report that cannot be published
-- must never stop the rest of this boot (the warnings below and
-- RBLXE_ServerBooted).
local reportOk, reportError = pcall(function()
	local encodedReport = Loader.encodeServerReport(report, function(value)
		return HttpService:JSONEncode(value)
	end)
	rsRoot:SetAttribute(Loader.SERVER_REPORT_ATTRIBUTE, encodedReport)
end)
if not reportOk then
	warn("[RBLXE] could not publish the boot report for clients; each client waits 30s for it, then boots every pack: " .. tostring(reportError))
end

print(Loader.formatReport("Server", report))
for id, reason in pairs(report.failed) do
	warn(string.format("[RBLXE] %s failed: %s", id, reason))
end
for id, reason in pairs(report.skipped) do
	warn(string.format("[RBLXE] %s skipped: %s", id, reason))
end
for _, notice in ipairs(report.notices or {}) do
	warn("[RBLXE] " .. notice)
end
ssRoot:SetAttribute("RBLXE_ServerBooted", true)
]]></string>
          <int64 name="SourceAssetId">-1</int64>
          <BinaryString name="Tags"></BinaryString>
        </Properties>
      </Item>
      <Item class="Folder" referent="255">
        <Properties>
          <string name="Name">Packs</string>
          <BinaryString name="AttributesSerialize"></BinaryString>
          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
          <Color3 name="IconTint">
            <R>0</R>
            <G>0</G>
            <B>0</B>
          </Color3>
          <bool name="DefinesCapabilities">false</bool>
          <BinaryString name="SerializedOverrides">
          </BinaryString>
          <int64 name="SourceAssetId">-1</int64>
          <BinaryString name="Tags"></BinaryString>
        </Properties>
        <Item class="ModuleScript" referent="256">
          <Properties>
            <string name="Name">NotificationsSystem</string>
            <BinaryString name="AttributesSerialize">AQAAAAwAAABSQkxYRV9IYXNoZXMCLQUAACNyYmx4ZS1oYXNoZXMgdjEgZm52MWEzMiBsZgpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL0NsaWVudAlkZmRjZDlhMQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL0NsaWVudC9Db3VudGVyRmx5b3V0CTc0YzdlMmMzClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vQ2xpZW50L1RleHRGaWVsZHMJNGUyYjJlNjYKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9DbGllbnQvVG9hc3RlcgkxMGI5NjZjOQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL01pZ3JhdGlvbnMvQ29udGVudAkyOTgzNGFlNQpSZXBsaWNhdGVkU3RvcmFnZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL01pZ3JhdGlvbnMvRnJvbVYyCTc2N2VlM2ZkClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vTWlncmF0aW9ucy9JbnRlcmZhY2UJZTI2M2IxNWYKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9NaWdyYXRpb25zL0tlZXAJZTczMzI3MjkKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9NaWdyYXRpb25zL1NvdXJjZXMJNzkxMWQ2OWYKUmVwbGljYXRlZFN0b3JhZ2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9Ob3RpZmljYXRpb25zCWYzZmMzYmM0ClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vTm90aWZ5CTE1ZWIyMzI4ClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vUGllY2VzCWQwMDg2YzFmClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vU2NoZW1hCWU0MTJmNWNlClJlcGxpY2F0ZWRTdG9yYWdlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vbWFuaWZlc3QJYzg5ODUxNzIKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtCWNiZWU5YTM3ClNlcnZlclNjcmlwdFNlcnZpY2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9UcmlnZ2Vycy9Bbm5vdW5jZW1lbnRzCTI0YTgyNWNiClNlcnZlclNjcmlwdFNlcnZpY2UvUGFja3MvTm90aWZpY2F0aW9uc1N5c3RlbS9UcmlnZ2Vycy9GcmllbmRKb2luZWQJN2QwNDg2YWYKU2VydmVyU2NyaXB0U2VydmljZS9QYWNrcy9Ob3RpZmljYXRpb25zU3lzdGVtL1RyaWdnZXJzL0pvaW5MZWF2ZQljOWRlY2MwMApTZXJ2ZXJTY3JpcHRTZXJ2aWNlL1BhY2tzL05vdGlmaWNhdGlvbnNTeXN0ZW0vVHJpZ2dlcnMvUHVyY2hhc2VzCWUyZTlmNjcy</BinaryString>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <ContentId name="LinkedSource">
              <null>
              </null>
            </ContentId>
            <bool name="DefinesCapabilities">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <string name="Source"><![CDATA[--[[
	NotificationsSystem - server module.

	It does two things: it becomes the SERVER backend of `ctx.kernel.Notify`,
	and it boots the trigger modules.

	TRIGGERS ARE DISCOVERED, NOT LISTED (2026-08-25, user: "que cada Trigger
	sea un module script, cómo cuándo creamos custom modules para los otros
	packs"). Every ModuleScript in the `Triggers` folder is a trigger, and so
	is every ModuleScript of the game's own in
	ServerScriptService.RBLXEssentials.Extensions.NotificationsSystem (3.0,
	plan B1: a game zone no update touches, read with ctx.extensions, the
	same extension shape as the CustomRewards modules in Roulette, Time
	Rewards and Codes). A module there named like a shipped trigger runs
	instead of the shipped one. When it does not start (a 2.x Announcements
	the migration carried still requires 2.x's Config module, which 3.0
	does not ship), the shipped one runs instead, under the same switch: a
	warning says the game's edit is lost, and the ready line names it
	"<Name> (pack instead of game)".

	THE SWITCHES (3.0, plan B1). A shipped trigger (Announcements,
	FriendJoined, JoinLeave, Purchases) is switched by
	Config.NotificationsSystem.Triggers (ctx.config), whoever's module runs
	for it. A trigger of the game's own keeps its 2.x switch, the `Enabled`
	attribute on its module: absent, or anything but the boolean false, is
	ON, because you added it since you wanted it.

	EVERY TRIGGER IS ISOLATED. `require` and `Start` are both pcall-fenced,
	so a buyer's broken module warns and is skipped instead of taking the
	other triggers - and this pack's whole surface - down with it. That is
	the same courtesy the kernel's loader extends to packs.

	Nothing yields at the top level. Each trigger owns its own threads.
]]

local TAG = "[NotificationsSystem]"

return function(ctx)
	local packTrove = ctx.kernel.Trove.new()

	local net = ctx.kernel.Net.server("NotificationsSystem")
	local show = net:event("Show")

	local function payload(kind, template, data)
		return { kind = kind, template = template, data = data or {} }
	end

	-- The server backend. A client renders what it is sent; nothing here
	-- decides what a card looks like.
	ctx.kernel.Notify.setBackend({
		Toast = function(_, player, template, data)
			if player and player:IsA("Player") then
				show:FireClient(player, payload("toast", template, data))
			end
		end,
		ToastAll = function(_, template, data)
			show:FireAllClients(payload("toast", template, data))
		end,
		Banner = function(_, player, data)
			if player and player:IsA("Player") then
				show:FireClient(player, payload("banner", nil, data))
			end
		end,
		BannerAll = function(_, data)
			show:FireAllClients(payload("banner", nil, data))
		end,
		-- A chat line is one fire PER RECIPIENT, not one global broadcast:
		-- the text is rendered by each client's own TextChatService, so
		-- nothing meant for one player can leak through a shared channel.
		Chat = function(_, text, color)
			show:FireAllClients(payload("chat", nil, { Title = text, Color = color }))
		end,
		ChatTo = function(_, player, text, color)
			if player and player:IsA("Player") then
				show:FireClient(player, payload("chat", nil, { Title = text, Color = color }))
			end
		end,
	})

	-- ── triggers ─────────────────────────────────────────────────────────
	-- The backend is registered ABOVE this loop on purpose: a trigger that
	-- announces something the instant it starts must find a live backend.
	local switches = ctx.config.Triggers
	local shipped = script:FindFirstChild("Triggers")
	local started, skipped = {}, {}

	-- start(module, label) -> whether the trigger started. One that did not
	-- warns once and takes nothing else down.
	local function start(module, label)
		local ok, trigger = pcall(require, module)
		if not ok then
			warn(("%s trigger '%s' failed to load: %s"):format(TAG, label, tostring(trigger)))
			return false
		end
		if type(trigger) ~= "table" or type(trigger.Start) ~= "function" then
			warn(("%s trigger '%s' does not return a table with a Start function, so it was skipped"):format(TAG, label))
			return false
		end
		local startedOk, err = pcall(trigger.Start, ctx, packTrove)
		if not startedOk then
			warn(("%s trigger '%s' errored while starting: %s"):format(TAG, label, tostring(err)))
			return false
		end
		return true
	end

	for _, entry in ipairs(ctx.extensions(shipped)) do
		local module = entry.module
		-- A module from the game's zone is named so in the ready line.
		local label = if entry.from == "game" then entry.name .. " (game)" else entry.name
		local on
		if switches[entry.name] ~= nil then
			on = switches[entry.name] == true
		else
			-- Absent means ON: a module a buyer dropped in should run
			-- without them having to find a switch first.
			on = module:GetAttribute("Enabled") ~= false
		end
		if not on then
			table.insert(skipped, label)
			continue
		end
		if start(module, label) then
			table.insert(started, label)
			continue
		end
		-- The game's module for a shipped name did not start: the shipped
		-- one runs instead, under the same switch, so what the game set in
		-- Config.NotificationsSystem still reaches its players.
		local packModule = if entry.from == "game" and shipped ~= nil then shipped:FindFirstChild(entry.name) else nil
		if packModule ~= nil and packModule:IsA("ModuleScript") then
			local fallback = entry.name .. " (pack instead of game)"
			warn(("%s the game's %s in Extensions.NotificationsSystem did not start, so its edit is lost: the pack's %s runs instead, on Config.NotificationsSystem"):format(
				TAG, entry.name, entry.name))
			if start(packModule, fallback) then
				table.insert(started, fallback)
			end
		end
	end

	print(("%s ready. Triggers on: %s%s"):format(
		TAG,
		#started > 0 and table.concat(started, ", ") or "(none)",
		#skipped > 0 and ("; off: " .. table.concat(skipped, ", ")) or ""
	))

	return {}
end
]]></string>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
          </Properties>
          <Item class="Folder" referent="257">
            <Properties>
              <string name="Name">Triggers</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <Color3 name="IconTint">
                <R>0</R>
                <G>0</G>
                <B>0</B>
              </Color3>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
            <Item class="ModuleScript" referent="258">
              <Properties>
                <string name="Name">Announcements</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Announcements - Trigger module
-- Your rotating messages, on a timer.
--
-- 3.0 (plan B1): the messages, the interval, the surface and Shuffle are
-- Config.NotificationsSystem.Announcements (ctx.config; the pack's
-- Schema.lua documents each), and the switch is
-- Config.NotificationsSystem.Triggers.Announcements. A message is shown
-- exactly as written: {tokens} are not replaced, as in 2.x.
--
-- See FriendJoined.lua's header for the trigger contract.

local Announcements = {}

-- A game that sets IntervalMinutes to 0 must get a slow rotation, not a
-- task.wait(0) loop that spams the chat every frame and pins the server.
-- A runtime rule, not a Schema minimum (plan B1): 2.x ran anything under
-- half a minute every 30 seconds, and 3.0 accepts those values.
local MIN_INTERVAL = 30

function Announcements.Start(ctx, trove)
	local rules = require(ctx.folder.Notifications)
	local cfg = ctx.config.Announcements
	local Notify = ctx.kernel.Notify

	local messages = cfg.Messages
	if #messages == 0 then
		return
	end

	local stopped = false
	trove:Add(function()
		stopped = true
	end)

	task.spawn(function()
		local index = 0
		while not stopped do
			task.wait(math.max(MIN_INTERVAL, cfg.IntervalMinutes * 60))
			if stopped then
				return
			end
			index = rules.nextAnnouncement(index, #messages, cfg.Shuffle, math.random)
			if index > 0 then
				local text = messages[index]
				if cfg.Surface == "Banner" then
					Notify:BannerAll({ Title = text })
				else
					Notify:Chat(text)
				end
			end
		end
	end)
end

return Announcements
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="259">
              <Properties>
                <string name="Name">FriendJoined</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- FriendJoined - Trigger module
-- Shows a toast when a player's friend joins the server.
--
-- HOW TRIGGERS WORK (3.0, plan B1). Every ModuleScript in this folder is a
-- shipped trigger, switched by Config.NotificationsSystem.Triggers. A
-- trigger of the game's own is a ModuleScript in
-- ServerScriptService.RBLXEssentials.Extensions.NotificationsSystem, which
-- no update touches; it runs unless its `Enabled` attribute is false, and
-- one named like a shipped trigger runs instead of that one (when it does
-- not start, that one runs after all, and a warning says so).
--
-- A trigger returns a table with `.Start(ctx, trove)`:
--   ctx    the kernel context - `ctx.kernel.Notify` is the notification API,
--          `ctx.folder` this pack's shared folder, `ctx.config` the game's
--          configuration of this pack (Schema.lua). There is no
--          `ctx.settings` in 3.0.
--   trove  connect through it (`trove:Connect(...)`) and your listeners are
--          cleaned up with the pack.
-- Start must not yield. Do slow work inside your own `task.spawn`.
--
-- The wording is Config.NotificationsSystem.FriendJoined (Template, Title,
-- Subtitle): set it in the game's config module, not here.

local Players = game:GetService("Players")

-- ── Rate discipline (read before raising it) ──────────────────────────────
--
-- `Player:IsFriendsWith` is a WEB CALL, so the naive shape - every pair, on
-- every join - is quadratic in a place that can hold fifty players, and
-- would be rate-limited long before it was useful. Three things keep it
-- bounded, and all three matter:
--
--   1. ONE SWEEP of the current roster per join, not every pair: at most
--      (MaxPlayers - 1) calls when someone arrives.
--   2. STAGGERED, so a server filling up at once does not burst the endpoint.
--   3. CACHED per unordered pair for the session. Friendship does not change
--      mid-session in any way worth chasing.
--
-- Friendship is symmetric, so that single sweep notifies BOTH sides: the
-- player who just arrived, and the friend who was already here.

local STAGGER = 0.1 -- seconds between checks

local FriendJoined = {}

function FriendJoined.Start(ctx, trove)
	local rules = require(ctx.folder.Notifications)
	local Notify = ctx.kernel.Notify
	local wording = ctx.config.FriendJoined

	-- key "lowUserId:highUserId" -> boolean
	local cache = {}

	local function key(a: number, b: number): string
		return ("%d:%d"):format(math.min(a, b), math.max(a, b))
	end

	local function areFriends(a: Player, b: Player): boolean
		local k = key(a.UserId, b.UserId)
		local cached = cache[k]
		if cached ~= nil then
			return cached
		end
		local ok, result = pcall(function()
			return a:IsFriendsWith(b.UserId)
		end)
		if not ok then
			-- NOT cached: a transient web failure must not settle the answer
			-- for the rest of the session.
			return false
		end
		cache[k] = result
		return result
	end

	local function tell(target: Player, about: Player)
		local tokens = { player = about.DisplayName }
		Notify:Toast(target, wording.Template, {
			Title = rules.substitute(wording.Title, tokens),
			Subtitle = rules.substitute(wording.Subtitle, tokens),
			ImageUserId = about.UserId,
		})
	end

	trove:Connect(Players.PlayerAdded, function(joiner)
		task.spawn(function()
			for _, other in ipairs(Players:GetPlayers()) do
				if other ~= joiner and other.Parent and joiner.Parent then
					if areFriends(other, joiner) then
						-- Both directions from one answer.
						tell(other, joiner)
						tell(joiner, other)
					end
					task.wait(STAGGER)
				end
			end
		end)
	end)

	trove:Connect(Players.PlayerRemoving, function(player)
		local id = tostring(player.UserId)
		for k in pairs(cache) do
			local low, high = k:match("^(%d+):(%d+)$")
			if low == id or high == id then
				cache[k] = nil
			end
		end
	end)
end

return FriendJoined
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="260">
              <Properties>
                <string name="Name">JoinLeave</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- JoinLeave - Trigger module
-- A chat line for every arrival and departure.
--
-- SHIPS WITH ITS SWITCH OFF (Config.NotificationsSystem.Triggers.JoinLeave
-- is false by default), on purpose: most places already announce this some
-- other way, and two lines per join is noise. It is here so a game that
-- wants it can switch it on instead of writing it.
--
-- 3.0 (plan B1): the two lines and their colour are
-- Config.NotificationsSystem.JoinLeave (ctx.config).
--
-- See FriendJoined.lua's header for the trigger contract.

local Players = game:GetService("Players")

local JoinLeave = {}

function JoinLeave.Start(ctx, trove)
	local rules = require(ctx.folder.Notifications)
	local Notify = ctx.kernel.Notify
	local wording = ctx.config.JoinLeave

	trove:Connect(Players.PlayerAdded, function(player)
		Notify:Chat(rules.substitute(wording.JoinMessage, { player = player.DisplayName }), wording.Color)
	end)

	trove:Connect(Players.PlayerRemoving, function(player)
		Notify:Chat(rules.substitute(wording.LeaveMessage, { player = player.DisplayName }), wording.Color)
	end)
end

return JoinLeave
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
            <Item class="ModuleScript" referent="261">
              <Properties>
                <string name="Name">Purchases</string>
                <BinaryString name="AttributesSerialize"></BinaryString>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <ContentId name="LinkedSource">
                  <null>
                  </null>
                </ContentId>
                <bool name="DefinesCapabilities">false</bool>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <string name="Source"><![CDATA[-- Purchases - Trigger module
-- Announces Robux purchases: a line to the whole server, and a confirmation
-- toast to the buyer.
--
-- NEEDS DATASTORE & PURCHASE SYSTEM, and finds it BY PATH rather than as a
-- declared dependency. That pack owns `ProcessReceipt` (only one script in a
-- place can) and publishes a `PurchaseCompleted` BindableEvent at
--
--   ServerScriptService > RBLXEssentials > Packs > DatastorePurchaseSystem
--
-- fired `(player, kind, id, currencySpent)` after a purchase is recorded as
-- granted. Declaring it in manifest.deps would make it mandatory - the
-- plugin refuses to install a pack whose deps are missing - and a buyer who
-- wants toasts without a datastore pack could not buy this one. So it is
-- looked up, and this trigger simply says nothing when it is absent.
--
-- BOOT ORDER IS NOT GUARANTEED, precisely because it is not a declared
-- dependency: the loader's topological sort knows nothing about this edge.
-- Hence the bounded retry rather than a single FindFirstChild.
--
-- 3.0 (plan B1): what it says is Config.NotificationsSystem.Purchases
-- (ctx.config: AnnounceInChat, ChatMessage, ChatColor, NotifyBuyer,
-- BuyerTemplate, BuyerTitle, BuyerSubtitle; {player}, {item} and {price}
-- in the texts). The path and the arguments of PurchaseCompleted are the
-- same in Datastore & Purchase System 3.0.
--
-- See FriendJoined.lua's header for the trigger contract.

local ServerScriptService = game:GetService("ServerScriptService")
local MarketplaceService = game:GetService("MarketplaceService")

-- ── Wiring ────────────────────────────────────────────────────────────────

local TAG = "[NotificationsSystem]"
local WAIT = 15
local POLL = 0.5

local Purchases = {}

function Purchases.Start(ctx, trove)
	local rules = require(ctx.folder.Notifications)
	local Notify = ctx.kernel.Notify
	local wording = ctx.config.Purchases

	-- id -> display name. The same product is bought over and over, and one
	-- GetProductInfo per purchase is a rate limit waiting to happen.
	local names = {}

	local function itemName(id: number, kind: string): string
		local cached = names[id]
		if cached then
			return cached
		end
		local ok, info = pcall(function()
			return MarketplaceService:GetProductInfo(
				id,
				kind == "gamepass" and Enum.InfoType.GamePass or Enum.InfoType.Product
			)
		end)
		local resolved = (ok and info and info.Name) or tostring(id)
		names[id] = resolved
		return resolved
	end

	local function findHook(): BindableEvent?
		local root = ServerScriptService:FindFirstChild("RBLXEssentials")
		local packs = root and root:FindFirstChild("Packs")
		local ds = packs and packs:FindFirstChild("DatastorePurchaseSystem")
		local hook = ds and ds:FindFirstChild("PurchaseCompleted")
		if hook and hook:IsA("BindableEvent") then
			return hook
		end
		return nil
	end

	task.spawn(function()
		local hook = findHook()
		local deadline = os.clock() + WAIT
		while not hook and os.clock() < deadline do
			task.wait(POLL)
			hook = findHook()
		end
		if not hook then
			warn(
				TAG
					.. " Datastore & Purchase System's PurchaseCompleted was never found, so purchase announcements are off this session"
			)
			return
		end

		trove:Connect(hook.Event, function(player, kind, id, currencySpent)
			if not (player and player:IsA("Player")) then
				return
			end
			-- The name is a web call on first sight of an id, so it gets its
			-- own thread: a slow endpoint must not sit inside the receipt's
			-- own signal.
			task.spawn(function()
				local tokens = {
					player = player.DisplayName,
					item = itemName(id, kind),
					price = currencySpent or 0,
				}
				if wording.AnnounceInChat then
					Notify:Chat(rules.substitute(wording.ChatMessage, tokens), wording.ChatColor)
				end
				if wording.NotifyBuyer then
					Notify:Toast(player, wording.BuyerTemplate, {
						Title = rules.substitute(wording.BuyerTitle, tokens),
						Subtitle = rules.substitute(wording.BuyerSubtitle, tokens),
					})
				end
			end)
		end)
	end)
end

return Purchases
]]></string>
                <int64 name="SourceAssetId">-1</int64>
                <BinaryString name="Tags"></BinaryString>
              </Properties>
            </Item>
          </Item>
        </Item>
      </Item>
    </Item>
    <Item class="Folder" referent="262">
      <Properties>
        <string name="Name">StarterPlayerScripts</string>
        <BinaryString name="AttributesSerialize"></BinaryString>
        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
        <Color3 name="IconTint">
          <R>0</R>
          <G>0</G>
          <B>0</B>
        </Color3>
        <bool name="DefinesCapabilities">false</bool>
        <BinaryString name="SerializedOverrides">
        </BinaryString>
        <int64 name="SourceAssetId">-1</int64>
        <BinaryString name="Tags"></BinaryString>
      </Properties>
      <Item class="LocalScript" referent="263">
        <Properties>
          <string name="Name">KernelClient</string>
          <BinaryString name="AttributesSerialize"></BinaryString>
          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
          <bool name="Disabled">false</bool>
          <ContentId name="LinkedSource">
            <null>
            </null>
          </ContentId>
          <token name="RunContext">0</token>
          <bool name="DefinesCapabilities">false</bool>
          <BinaryString name="SerializedOverrides">
          </BinaryString>
          <string name="Source"><![CDATA[-- RBLX Essentials Kernel - client boot. The only LocalScript in the ecosystem.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local HttpService = game:GetService("HttpService")

-- 3.0: packs, Config modules and the server's piece decisions arrive with the
-- first replication; read them only once it is complete.
if not game:IsLoaded() then
	game.Loaded:Wait()
end

local rsRoot = ReplicatedStorage:WaitForChild("RBLXEssentials")
local kernelFolder = rsRoot:WaitForChild("Kernel")
local Loader = require(kernelFolder:WaitForChild("Loader"))
local Version = require(kernelFolder:WaitForChild("Version"))
local Net = require(kernelFolder:WaitForChild("Net"))
local SFX = require(kernelFolder:WaitForChild("SFX"))
local Notify = require(kernelFolder:WaitForChild("Notify"))
local Signal = require(kernelFolder:WaitForChild("Signal"))
local Trove = require(kernelFolder:WaitForChild("Packages"):WaitForChild("Trove"))
local Schema = require(kernelFolder:WaitForChild("Schema"))
local Config = require(kernelFolder:WaitForChild("Config"))
local uiFolder = kernelFolder:WaitForChild("UI")
local MenuSystem = require(uiFolder:WaitForChild("MenuSystem"))
local Pieces = require(uiFolder:WaitForChild("Pieces"))

local playerGui = Players.LocalPlayer:WaitForChild("PlayerGui")

-- The server publishes its piece decisions before a player can join; this
-- bounded wait only covers a server that is still starting.
local encoded = rsRoot:GetAttribute(Pieces.WINNERS_ATTRIBUTE)
local waited = 0
while encoded == nil and waited < 10 do
	waited += task.wait(0.1)
	encoded = rsRoot:GetAttribute(Pieces.WINNERS_ATTRIBUTE)
end
-- nil: every piece is adopted as in 2.x
local decisions = Pieces.decodeDecisions(encoded, function(text)
	return HttpService:JSONDecode(text)
end)
if decisions == nil then
	warn("[RBLXE] UI: no piece decisions from the server; every piece is adopted as in 2.x")
end

-- RT-5: the server publishes which packs did not start there once its boot
-- is done; wait for it (bounded) so this client does not boot them.
local serverEncoded = rsRoot:GetAttribute(Loader.SERVER_REPORT_ATTRIBUTE)
local waitedReport = 0
while serverEncoded == nil and waitedReport < 30 do
	waitedReport += task.wait(0.1)
	serverEncoded = rsRoot:GetAttribute(Loader.SERVER_REPORT_ATTRIBUTE)
end
local serverReport = Loader.decodeServerReport(serverEncoded, function(text)
	return HttpService:JSONDecode(text)
end)
if serverReport == nil then
	warn("[RBLXE] no boot report from the server within 30s; this client boots every pack")
end

local pieces = Pieces.runtime(decisions, { wait = task.wait, warn = warn, defer = task.defer })
pieces:attach(playerGui)
local ui = MenuSystem.new(playerGui, { pieces = pieces })

local report = Loader.boot({
	side = "Client",
	sharedPacks = rsRoot:WaitForChild("Packs"),
	kernelApi = { Version = Version, Trove = Trove, Signal = Signal, Net = Net, SFX = SFX, Notify = Notify },
	ui = ui,
	configLib = Config,
	schemaLib = Schema,
	configRoots = { shared = rsRoot:FindFirstChild("Config") },
	serverReport = serverReport,
	extensions = rsRoot:FindFirstChild("Extensions"),
})

print(Loader.formatReport("Client", report))
for id, reason in pairs(report.failed) do
	warn(string.format("[RBLXE] %s failed: %s", id, reason))
end
for id, reason in pairs(report.skipped) do
	warn(string.format("[RBLXE] %s skipped: %s", id, reason))
end
for _, notice in ipairs(report.notices or {}) do
	warn("[RBLXE] " .. notice)
end
playerGui:SetAttribute("RBLXE_ClientBooted", true)
]]></string>
          <int64 name="SourceAssetId">-1</int64>
          <BinaryString name="Tags"></BinaryString>
        </Properties>
      </Item>
    </Item>
    <Item class="Folder" referent="264">
      <Properties>
        <string name="Name">StarterGui</string>
        <BinaryString name="AttributesSerialize"></BinaryString>
        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
        <Color3 name="IconTint">
          <R>0</R>
          <G>0</G>
          <B>0</B>
        </Color3>
        <bool name="DefinesCapabilities">false</bool>
        <BinaryString name="SerializedOverrides">
        </BinaryString>
        <int64 name="SourceAssetId">-1</int64>
        <BinaryString name="Tags"></BinaryString>
      </Properties>
      <Item class="Folder" referent="265">
        <Properties>
          <string name="Name">NotificationsSystem</string>
          <BinaryString name="AttributesSerialize"></BinaryString>
          <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
          <Color3 name="IconTint">
            <R>0</R>
            <G>0</G>
            <B>0</B>
          </Color3>
          <bool name="DefinesCapabilities">false</bool>
          <BinaryString name="SerializedOverrides">
          </BinaryString>
          <int64 name="SourceAssetId">-1</int64>
          <BinaryString name="Tags"></BinaryString>
        </Properties>
        <Item class="ScreenGui" referent="266">
          <Properties>
            <string name="Name">NotificationsSystemGUI</string>
            <BinaryString name="AttributesSerialize">AgAAAA4AAABSQkxYRV9Db250cmFjdAYAAAAAAADwPwsAAABSQkxYRV9QaWVjZQIlAAAATm90aWZpY2F0aW9uc1N5c3RlbS5Ob3RpZmljYXRpb25MYXllcg==</BinaryString>
            <bool name="AutoLocalize">true</bool>
            <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
            <bool name="ClipToDeviceSafeArea">true</bool>
            <int name="DisplayOrder">50</int>
            <bool name="Enabled">true</bool>
            <bool name="ResetOnSpawn">false</bool>
            <Ref name="RootLocalizationTable">null</Ref>
            <token name="SafeAreaCompatibility">1</token>
            <bool name="DefinesCapabilities">false</bool>
            <token name="ScreenInsets">2</token>
            <token name="SelectionBehaviorDown">0</token>
            <token name="SelectionBehaviorLeft">0</token>
            <token name="SelectionBehaviorRight">0</token>
            <token name="SelectionBehaviorUp">0</token>
            <bool name="SelectionGroup">false</bool>
            <BinaryString name="SerializedOverrides">
            </BinaryString>
            <int64 name="SourceAssetId">-1</int64>
            <BinaryString name="Tags"></BinaryString>
            <token name="ZIndexBehavior">1</token>
          </Properties>
          <Item class="Folder" referent="267">
            <Properties>
              <string name="Name">Templates</string>
              <BinaryString name="AttributesSerialize"></BinaryString>
              <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
              <Color3 name="IconTint">
                <R>0</R>
                <G>0</G>
                <B>0</B>
              </Color3>
              <bool name="DefinesCapabilities">false</bool>
              <BinaryString name="SerializedOverrides">
              </BinaryString>
              <int64 name="SourceAssetId">-1</int64>
              <BinaryString name="Tags"></BinaryString>
            </Properties>
            <Item class="Frame" referent="268">
              <Properties>
                <string name="Name">TitleOnly</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>1</X>
                  <Y>0</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABBACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>1</R>
                  <G>1</G>
                  <B>1</B>
                </Color3>
                <float name="BackgroundTransparency">0</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">0</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0.975</XS>
                  <XO>0</XO>
                  <YS>0.1</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>0.2</XS>
                  <XO>0</XO>
                  <YS>0.062962964</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">false</bool>
                <int name="ZIndex">1</int>
              </Properties>
              <Item class="UIAspectRatioConstraint" referent="269">
                <Properties>
                  <string name="Name">UIAspectRatioConstraint</string>
                  <float name="AspectRatio">5.647059</float>
                  <token name="AspectType">0</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <token name="DominantAxis">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
              </Item>
              <Item class="UICorner" referent="270">
                <Properties>
                  <string name="Name">UICorner</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BottomLeftRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="BottomRightRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <UDim name="TopLeftRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="TopRightRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                </Properties>
              </Item>
              <Item class="UIGradient" referent="271">
                <Properties>
                  <string name="Name">Gradient</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <ColorSequence name="Color">0 0.74509805 0.627451 1 0 1 0.47058824 0.3137255 0.9411765 0 </ColorSequence>
                  <bool name="Enabled">true</bool>
                  <Vector2 name="Offset">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <float name="Rotation">90</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <float name="Scale">1</float>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <token name="TileMode">0</token>
                  <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                  <token name="Type">0</token>
                </Properties>
              </Item>
              <Item class="UIStroke" referent="272">
                <Properties>
                  <string name="Name">Outline</string>
                  <token name="ApplyStrokeMode">1</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BorderOffset">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <token name="BorderStrokePosition">0</token>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <token name="LineJoinMode">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="StrokeSizingMode">1</token>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Thickness">0.073529415</float>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">1</int>
                </Properties>
              </Item>
              <Item class="UIShadow" referent="273">
                <Properties>
                  <string name="Name">DropShadow</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BlurRadius">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <bool name="Inset">false</bool>
                  <token name="Mode">0</token>
                  <UDim2 name="Offset">
                    <XS>0</XS>
                    <XO>0</XO>
                    <YS>0.073529415</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <bool name="ShowBehindParent">true</bool>
                  <int64 name="SourceAssetId">-1</int64>
                  <UDim2 name="Spread">
                    <XS>0.026041666</XS>
                    <XO>0</XO>
                    <YS>0.14705883</YS>
                    <YO>0</YO>
                  </UDim2>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">-1</int>
                </Properties>
              </Item>
              <Item class="Frame" referent="274">
                <Properties>
                  <string name="Name">Shine</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.78</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.018229166</XS>
                    <XO>0</XO>
                    <YS>0.073529415</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.9635417</XS>
                    <XO>0</XO>
                    <YS>0.36764705</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">1</int>
                </Properties>
                <Item class="UICorner" referent="275">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="276">
                <Properties>
                  <string name="Name">Title</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.052083332</XS>
                    <XO>0</XO>
                    <YS>0.22058824</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.90625</XS>
                    <XO>0</XO>
                    <YS>0.4117647</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">Test Notification</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">0</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="277">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="Frame" referent="278">
                <Properties>
                  <string name="Name">Timer</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.55</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.052083332</XS>
                    <XO>0</XO>
                    <YS>0.7794118</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.9010417</XS>
                    <XO>0</XO>
                    <YS>0.0882353</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">2</int>
                </Properties>
                <Item class="UICorner" referent="279">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
                <Item class="Frame" referent="280">
                  <Properties>
                    <string name="Name">Fill</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0</XS>
                      <XO>0</XO>
                      <YS>0</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>1</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">2</int>
                  </Properties>
                  <Item class="UICorner" referent="281">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                </Item>
              </Item>
            </Item>
            <Item class="Frame" referent="282">
              <Properties>
                <string name="Name">TitleSubtitle</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>1</X>
                  <Y>0</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABRACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>1</R>
                  <G>1</G>
                  <B>1</B>
                </Color3>
                <float name="BackgroundTransparency">0</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">0</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0.975</XS>
                  <XO>0</XO>
                  <YS>0.1</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>0.2</XS>
                  <XO>0</XO>
                  <YS>0.07777778</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">false</bool>
                <int name="ZIndex">1</int>
              </Properties>
              <Item class="UIAspectRatioConstraint" referent="283">
                <Properties>
                  <string name="Name">UIAspectRatioConstraint</string>
                  <float name="AspectRatio">4.571429</float>
                  <token name="AspectType">0</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <token name="DominantAxis">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
              </Item>
              <Item class="UICorner" referent="284">
                <Properties>
                  <string name="Name">UICorner</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BottomLeftRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="BottomRightRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <UDim name="TopLeftRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="TopRightRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                </Properties>
              </Item>
              <Item class="UIGradient" referent="285">
                <Properties>
                  <string name="Name">Gradient</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <ColorSequence name="Color">0 0.43137255 0.9254902 0.8627451 0 1 0.078431375 0.627451 0.6745098 0 </ColorSequence>
                  <bool name="Enabled">true</bool>
                  <Vector2 name="Offset">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <float name="Rotation">90</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <float name="Scale">1</float>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <token name="TileMode">0</token>
                  <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                  <token name="Type">0</token>
                </Properties>
              </Item>
              <Item class="UIStroke" referent="286">
                <Properties>
                  <string name="Name">Outline</string>
                  <token name="ApplyStrokeMode">1</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BorderOffset">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <token name="BorderStrokePosition">0</token>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <token name="LineJoinMode">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="StrokeSizingMode">1</token>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Thickness">0.05952381</float>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">1</int>
                </Properties>
              </Item>
              <Item class="UIShadow" referent="287">
                <Properties>
                  <string name="Name">DropShadow</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BlurRadius">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <bool name="Inset">false</bool>
                  <token name="Mode">0</token>
                  <UDim2 name="Offset">
                    <XS>0</XS>
                    <XO>0</XO>
                    <YS>0.05952381</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <bool name="ShowBehindParent">true</bool>
                  <int64 name="SourceAssetId">-1</int64>
                  <UDim2 name="Spread">
                    <XS>0.026041666</XS>
                    <XO>0</XO>
                    <YS>0.11904762</YS>
                    <YO>0</YO>
                  </UDim2>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">-1</int>
                </Properties>
              </Item>
              <Item class="Frame" referent="288">
                <Properties>
                  <string name="Name">Shine</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.78</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.018229166</XS>
                    <XO>0</XO>
                    <YS>0.05952381</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.9635417</XS>
                    <XO>0</XO>
                    <YS>0.3690476</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">1</int>
                </Properties>
                <Item class="UICorner" referent="289">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="290">
                <Properties>
                  <string name="Name">Title</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.052083332</XS>
                    <XO>0</XO>
                    <YS>0.13095239</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.90625</XS>
                    <XO>0</XO>
                    <YS>0.33333334</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">Test Notification</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">0</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="291">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="292">
                <Properties>
                  <string name="Name">Subtitle</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.052083332</XS>
                    <XO>0</XO>
                    <YS>0.52380955</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.90625</XS>
                    <XO>0</XO>
                    <YS>0.22619048</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">Test Subtitle</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>0.972549</G>
                    <B>0.8235294</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">0</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="293">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="Frame" referent="294">
                <Properties>
                  <string name="Name">Timer</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.55</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.052083332</XS>
                    <XO>0</XO>
                    <YS>0.8214286</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.9010417</XS>
                    <XO>0</XO>
                    <YS>0.071428575</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">2</int>
                </Properties>
                <Item class="UICorner" referent="295">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
                <Item class="Frame" referent="296">
                  <Properties>
                    <string name="Name">Fill</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0</XS>
                      <XO>0</XO>
                      <YS>0</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>1</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">2</int>
                  </Properties>
                  <Item class="UICorner" referent="297">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                </Item>
              </Item>
            </Item>
            <Item class="Frame" referent="298">
              <Properties>
                <string name="Name">ImageTitle</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>1</X>
                  <Y>0</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABRACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>1</R>
                  <G>1</G>
                  <B>1</B>
                </Color3>
                <float name="BackgroundTransparency">0</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">0</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0.975</XS>
                  <XO>0</XO>
                  <YS>0.1</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>0.2</XS>
                  <XO>0</XO>
                  <YS>0.062962964</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">false</bool>
                <int name="ZIndex">1</int>
              </Properties>
              <Item class="UIAspectRatioConstraint" referent="299">
                <Properties>
                  <string name="Name">UIAspectRatioConstraint</string>
                  <float name="AspectRatio">5.647059</float>
                  <token name="AspectType">0</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <token name="DominantAxis">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
              </Item>
              <Item class="UICorner" referent="300">
                <Properties>
                  <string name="Name">UICorner</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BottomLeftRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="BottomRightRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <UDim name="TopLeftRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="TopRightRadius">
                    <S>0.23529412</S>
                    <O>0</O>
                  </UDim>
                </Properties>
              </Item>
              <Item class="UIGradient" referent="301">
                <Properties>
                  <string name="Name">Gradient</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <ColorSequence name="Color">0 0.5882353 0.9411765 0.43137255 0 1 0.15686275 0.6862745 0.27450982 0 </ColorSequence>
                  <bool name="Enabled">true</bool>
                  <Vector2 name="Offset">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <float name="Rotation">90</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <float name="Scale">1</float>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <token name="TileMode">0</token>
                  <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                  <token name="Type">0</token>
                </Properties>
              </Item>
              <Item class="UIStroke" referent="302">
                <Properties>
                  <string name="Name">Outline</string>
                  <token name="ApplyStrokeMode">1</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BorderOffset">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <token name="BorderStrokePosition">0</token>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <token name="LineJoinMode">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="StrokeSizingMode">1</token>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Thickness">0.073529415</float>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">1</int>
                </Properties>
              </Item>
              <Item class="UIShadow" referent="303">
                <Properties>
                  <string name="Name">DropShadow</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BlurRadius">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <bool name="Inset">false</bool>
                  <token name="Mode">0</token>
                  <UDim2 name="Offset">
                    <XS>0</XS>
                    <XO>0</XO>
                    <YS>0.073529415</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <bool name="ShowBehindParent">true</bool>
                  <int64 name="SourceAssetId">-1</int64>
                  <UDim2 name="Spread">
                    <XS>0.026041666</XS>
                    <XO>0</XO>
                    <YS>0.14705883</YS>
                    <YO>0</YO>
                  </UDim2>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">-1</int>
                </Properties>
              </Item>
              <Item class="Frame" referent="304">
                <Properties>
                  <string name="Name">Shine</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.78</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.018229166</XS>
                    <XO>0</XO>
                    <YS>0.073529415</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.9635417</XS>
                    <XO>0</XO>
                    <YS>0.36764705</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">1</int>
                </Properties>
                <Item class="UICorner" referent="305">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.4</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
              </Item>
              <Item class="Frame" referent="306">
                <Properties>
                  <string name="Name">Image</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>-0.0625</XS>
                    <XO>0</XO>
                    <YS>-0.14705883</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">-8</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.21354167</XS>
                    <XO>0</XO>
                    <YS>1.2058823</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">4</int>
                </Properties>
                <Item class="UICorner" referent="307">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
                <Item class="UIGradient" referent="308">
                  <Properties>
                    <string name="Name">Shade</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <ColorSequence name="Color">0 1 1 1 0 1 0.84313726 0.88235295 1 0 </ColorSequence>
                    <bool name="Enabled">true</bool>
                    <Vector2 name="Offset">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <float name="Rotation">90</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <float name="Scale">1</float>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <token name="TileMode">0</token>
                    <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                    <token name="Type">0</token>
                  </Properties>
                </Item>
                <Item class="UIStroke" referent="309">
                  <Properties>
                    <string name="Name">Ring</string>
                    <token name="ApplyStrokeMode">1</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.06097561</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
                <Item class="UIShadow" referent="310">
                  <Properties>
                    <string name="Name">Lip</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BlurRadius">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <bool name="Inset">false</bool>
                    <token name="Mode">0</token>
                    <UDim2 name="Offset">
                      <XS>0</XS>
                      <XO>0</XO>
                      <YS>0.06097561</YS>
                      <YO>0</YO>
                    </UDim2>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <bool name="ShowBehindParent">true</bool>
                    <int64 name="SourceAssetId">-1</int64>
                    <UDim2 name="Spread">
                      <XS>0.12195122</XS>
                      <XO>0</XO>
                      <YS>0.12195122</YS>
                      <YO>0</YO>
                    </UDim2>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">-1</int>
                  </Properties>
                </Item>
                <Item class="UIAspectRatioConstraint" referent="311">
                  <Properties>
                    <string name="Name">UIAspectRatioConstraint</string>
                    <float name="AspectRatio">1</float>
                    <token name="AspectType">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <token name="DominantAxis">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                  </Properties>
                </Item>
                <Item class="ImageLabel" referent="312">
                  <Properties>
                    <string name="Name">Content</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>0.5</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>0.6392157</R>
                      <G>0.63529414</G>
                      <B>0.64705884</B>
                    </Color3>
                    <float name="BackgroundTransparency">1</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <Color3 name="ImageColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <Content name="ImageContent">
                      <uri>rbxassetid://95862633182393</uri>
                    </Content>
                    <Vector2 name="ImageRectOffset">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <Vector2 name="ImageRectSize">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <float name="ImageTransparency">0</float>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.5</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="ResampleMode">0</token>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <token name="ScaleType">3</token>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.76</XS>
                      <XO>0</XO>
                      <YS>0.76</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <Rect2D name="SliceCenter">
                      <min>
                        <X>0</X>
                        <Y>0</Y>
                      </min>
                      <max>
                        <X>0</X>
                        <Y>0</Y>
                      </max>
                    </Rect2D>
                    <float name="SliceScale">1</float>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim2 name="TileSize">
                      <XS>1</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">5</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="313">
                <Properties>
                  <string name="Name">Title</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.1875</XS>
                    <XO>0</XO>
                    <YS>0.22058824</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.7708333</XS>
                    <XO>0</XO>
                    <YS>0.4117647</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">Test Notification</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">0</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="314">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="Frame" referent="315">
                <Properties>
                  <string name="Name">Timer</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.55</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.1875</XS>
                    <XO>0</XO>
                    <YS>0.7794118</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.765625</XS>
                    <XO>0</XO>
                    <YS>0.0882353</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">2</int>
                </Properties>
                <Item class="UICorner" referent="316">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
                <Item class="Frame" referent="317">
                  <Properties>
                    <string name="Name">Fill</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0</XS>
                      <XO>0</XO>
                      <YS>0</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>1</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">2</int>
                  </Properties>
                  <Item class="UICorner" referent="318">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                </Item>
              </Item>
            </Item>
            <Item class="Frame" referent="319">
              <Properties>
                <string name="Name">ImageTitleSubtitle</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>1</X>
                  <Y>0</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAABhACwAAAE1heE9uU2NyZWVuBgAAAAAAABBACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIMAAAAUmV3YXJkX0NsYWltDgAAAFN0YWNrRGlyZWN0aW9uAgQAAABEb3duCgAAAFN0YWNrR3JvdXACBgAAAFRvYXN0cw==</BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>1</R>
                  <G>1</G>
                  <B>1</B>
                </Color3>
                <float name="BackgroundTransparency">0</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">0</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0.975</XS>
                  <XO>0</XO>
                  <YS>0.1</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>0.2</XS>
                  <XO>0</XO>
                  <YS>0.07777778</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">false</bool>
                <int name="ZIndex">1</int>
              </Properties>
              <Item class="UIAspectRatioConstraint" referent="320">
                <Properties>
                  <string name="Name">UIAspectRatioConstraint</string>
                  <float name="AspectRatio">4.571429</float>
                  <token name="AspectType">0</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <token name="DominantAxis">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
              </Item>
              <Item class="UICorner" referent="321">
                <Properties>
                  <string name="Name">UICorner</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BottomLeftRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="BottomRightRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <UDim name="TopLeftRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="TopRightRadius">
                    <S>0.1904762</S>
                    <O>0</O>
                  </UDim>
                </Properties>
              </Item>
              <Item class="UIGradient" referent="322">
                <Properties>
                  <string name="Name">Gradient</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <ColorSequence name="Color">0 0.43137255 0.8039216 1 0 1 0.15686275 0.47058824 1 0 </ColorSequence>
                  <bool name="Enabled">true</bool>
                  <Vector2 name="Offset">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <float name="Rotation">90</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <float name="Scale">1</float>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <token name="TileMode">0</token>
                  <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                  <token name="Type">0</token>
                </Properties>
              </Item>
              <Item class="UIStroke" referent="323">
                <Properties>
                  <string name="Name">Outline</string>
                  <token name="ApplyStrokeMode">1</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BorderOffset">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <token name="BorderStrokePosition">0</token>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <token name="LineJoinMode">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="StrokeSizingMode">1</token>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Thickness">0.05952381</float>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">1</int>
                </Properties>
              </Item>
              <Item class="UIShadow" referent="324">
                <Properties>
                  <string name="Name">DropShadow</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BlurRadius">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <bool name="Inset">false</bool>
                  <token name="Mode">0</token>
                  <UDim2 name="Offset">
                    <XS>0</XS>
                    <XO>0</XO>
                    <YS>0.05952381</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <bool name="ShowBehindParent">true</bool>
                  <int64 name="SourceAssetId">-1</int64>
                  <UDim2 name="Spread">
                    <XS>0.026041666</XS>
                    <XO>0</XO>
                    <YS>0.11904762</YS>
                    <YO>0</YO>
                  </UDim2>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">-1</int>
                </Properties>
              </Item>
              <Item class="Frame" referent="325">
                <Properties>
                  <string name="Name">Shine</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.78</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.018229166</XS>
                    <XO>0</XO>
                    <YS>0.05952381</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.9635417</XS>
                    <XO>0</XO>
                    <YS>0.3690476</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">1</int>
                </Properties>
                <Item class="UICorner" referent="326">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.32258064</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
              </Item>
              <Item class="Frame" referent="327">
                <Properties>
                  <string name="Name">Image</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>-0.0625</XS>
                    <XO>0</XO>
                    <YS>-0.023809524</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">-8</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.21354167</XS>
                    <XO>0</XO>
                    <YS>0.97619045</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">4</int>
                </Properties>
                <Item class="UICorner" referent="328">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
                <Item class="UIGradient" referent="329">
                  <Properties>
                    <string name="Name">Shade</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <ColorSequence name="Color">0 1 1 1 0 1 0.84313726 0.88235295 1 0 </ColorSequence>
                    <bool name="Enabled">true</bool>
                    <Vector2 name="Offset">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <float name="Rotation">90</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <float name="Scale">1</float>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <token name="TileMode">0</token>
                    <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                    <token name="Type">0</token>
                  </Properties>
                </Item>
                <Item class="UIStroke" referent="330">
                  <Properties>
                    <string name="Name">Ring</string>
                    <token name="ApplyStrokeMode">1</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.06097561</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
                <Item class="UIShadow" referent="331">
                  <Properties>
                    <string name="Name">Lip</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BlurRadius">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <bool name="Inset">false</bool>
                    <token name="Mode">0</token>
                    <UDim2 name="Offset">
                      <XS>0</XS>
                      <XO>0</XO>
                      <YS>0.06097561</YS>
                      <YO>0</YO>
                    </UDim2>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <bool name="ShowBehindParent">true</bool>
                    <int64 name="SourceAssetId">-1</int64>
                    <UDim2 name="Spread">
                      <XS>0.12195122</XS>
                      <XO>0</XO>
                      <YS>0.12195122</YS>
                      <YO>0</YO>
                    </UDim2>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">-1</int>
                  </Properties>
                </Item>
                <Item class="UIAspectRatioConstraint" referent="332">
                  <Properties>
                    <string name="Name">UIAspectRatioConstraint</string>
                    <float name="AspectRatio">1</float>
                    <token name="AspectType">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <token name="DominantAxis">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                  </Properties>
                </Item>
                <Item class="ImageLabel" referent="333">
                  <Properties>
                    <string name="Name">Content</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0.5</X>
                      <Y>0.5</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>0.6392157</R>
                      <G>0.63529414</G>
                      <B>0.64705884</B>
                    </Color3>
                    <float name="BackgroundTransparency">1</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <Color3 name="ImageColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <Content name="ImageContent">
                      <uri>rbxassetid://91427328378865</uri>
                    </Content>
                    <Vector2 name="ImageRectOffset">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <Vector2 name="ImageRectSize">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <float name="ImageTransparency">0</float>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0.5</XS>
                      <XO>0</XO>
                      <YS>0.5</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="ResampleMode">0</token>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <token name="ScaleType">3</token>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>0.76</XS>
                      <XO>0</XO>
                      <YS>0.76</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <Rect2D name="SliceCenter">
                      <min>
                        <X>0</X>
                        <Y>0</Y>
                      </min>
                      <max>
                        <X>0</X>
                        <Y>0</Y>
                      </max>
                    </Rect2D>
                    <float name="SliceScale">1</float>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim2 name="TileSize">
                      <XS>1</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">5</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="334">
                <Properties>
                  <string name="Name">Title</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.1875</XS>
                    <XO>0</XO>
                    <YS>0.13095239</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.7708333</XS>
                    <XO>0</XO>
                    <YS>0.33333334</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">Test Notification</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">0</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="335">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="336">
                <Properties>
                  <string name="Name">Subtitle</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.1875</XS>
                    <XO>0</XO>
                    <YS>0.52380955</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.7708333</XS>
                    <XO>0</XO>
                    <YS>0.22619048</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">Test Subtitle</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>0.972549</G>
                    <B>0.8235294</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">0</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="337">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="Frame" referent="338">
                <Properties>
                  <string name="Name">Timer</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.55</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.1875</XS>
                    <XO>0</XO>
                    <YS>0.8214286</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.765625</XS>
                    <XO>0</XO>
                    <YS>0.071428575</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">2</int>
                </Properties>
                <Item class="UICorner" referent="339">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.5</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
                <Item class="Frame" referent="340">
                  <Properties>
                    <string name="Name">Fill</string>
                    <bool name="Active">false</bool>
                    <Vector2 name="AnchorPoint">
                      <X>0</X>
                      <Y>0</Y>
                    </Vector2>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <bool name="AutoLocalize">true</bool>
                    <token name="AutomaticSize">0</token>
                    <Color3 name="BackgroundColor3">
                      <R>1</R>
                      <G>1</G>
                      <B>1</B>
                    </Color3>
                    <float name="BackgroundTransparency">0</float>
                    <Color3 name="BorderColor3">
                      <R>0.105882354</R>
                      <G>0.16470589</G>
                      <B>0.20784314</B>
                    </Color3>
                    <token name="BorderMode">0</token>
                    <int name="BorderSizePixel">0</int>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="ClipsDescendants">false</bool>
                    <bool name="Draggable">false</bool>
                    <bool name="Interactable">true</bool>
                    <int name="LayoutOrder">0</int>
                    <Ref name="NextSelectionDown">null</Ref>
                    <Ref name="NextSelectionLeft">null</Ref>
                    <Ref name="NextSelectionRight">null</Ref>
                    <Ref name="NextSelectionUp">null</Ref>
                    <UDim2 name="Position">
                      <XS>0</XS>
                      <XO>0</XO>
                      <YS>0</YS>
                      <YO>0</YO>
                    </UDim2>
                    <Ref name="RootLocalizationTable">null</Ref>
                    <float name="Rotation">0</float>
                    <bool name="DefinesCapabilities">false</bool>
                    <bool name="Selectable">false</bool>
                    <token name="SelectionBehaviorDown">0</token>
                    <token name="SelectionBehaviorLeft">0</token>
                    <token name="SelectionBehaviorRight">0</token>
                    <token name="SelectionBehaviorUp">0</token>
                    <bool name="SelectionGroup">false</bool>
                    <Ref name="SelectionImageObject">null</Ref>
                    <int name="SelectionOrder">0</int>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <token name="Sink">0</token>
                    <UDim2 name="Size">
                      <XS>1</XS>
                      <XO>0</XO>
                      <YS>1</YS>
                      <YO>0</YO>
                    </UDim2>
                    <token name="SizeConstraint">0</token>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="Style">0</token>
                    <BinaryString name="Tags"></BinaryString>
                    <bool name="Visible">true</bool>
                    <int name="ZIndex">2</int>
                  </Properties>
                  <Item class="UICorner" referent="341">
                    <Properties>
                      <string name="Name">UICorner</string>
                      <BinaryString name="AttributesSerialize"></BinaryString>
                      <UDim name="BottomLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="BottomRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                      <bool name="DefinesCapabilities">false</bool>
                      <BinaryString name="SerializedOverrides">
                      </BinaryString>
                      <int64 name="SourceAssetId">-1</int64>
                      <BinaryString name="Tags"></BinaryString>
                      <UDim name="TopLeftRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                      <UDim name="TopRightRadius">
                        <S>0.5</S>
                        <O>0</O>
                      </UDim>
                    </Properties>
                  </Item>
                </Item>
              </Item>
            </Item>
            <Item class="Frame" referent="342">
              <Properties>
                <string name="Name">Banner</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>0.5</X>
                  <Y>0</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBAAAAEZhZGUIAAAARHVyYXRpb24GAAAAAAAAIEALAAAATWF4T25TY3JlZW4GAAAAAAAA8D8JAAAAU2xpZGVGcm9tAgQAAABBdXRvBQAAAFNvdW5kAggAAABMZXZlbF9VcA4AAABTdGFja0RpcmVjdGlvbgIEAAAARG93bgoAAABTdGFja0dyb3VwAgYAAABCYW5uZXI=</BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>1</R>
                  <G>1</G>
                  <B>1</B>
                </Color3>
                <float name="BackgroundTransparency">0</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">0</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0.5</XS>
                  <XO>0</XO>
                  <YS>0.1</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>0.25</XS>
                  <XO>0</XO>
                  <YS>0.06666667</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">false</bool>
                <int name="ZIndex">1</int>
              </Properties>
              <Item class="UIAspectRatioConstraint" referent="343">
                <Properties>
                  <string name="Name">UIAspectRatioConstraint</string>
                  <float name="AspectRatio">6.6666665</float>
                  <token name="AspectType">0</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <token name="DominantAxis">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
              </Item>
              <Item class="UICorner" referent="344">
                <Properties>
                  <string name="Name">UICorner</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BottomLeftRadius">
                    <S>0.2777778</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="BottomRightRadius">
                    <S>0.2777778</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <UDim name="TopLeftRadius">
                    <S>0.2777778</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="TopRightRadius">
                    <S>0.2777778</S>
                    <O>0</O>
                  </UDim>
                </Properties>
              </Item>
              <Item class="UIGradient" referent="345">
                <Properties>
                  <string name="Name">Gradient</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <ColorSequence name="Color">0 1 0.8392157 0.2509804 0 1 1 0.54901963 0.101960786 0 </ColorSequence>
                  <bool name="Enabled">true</bool>
                  <Vector2 name="Offset">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <float name="Rotation">90</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <float name="Scale">1</float>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <token name="TileMode">0</token>
                  <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                  <token name="Type">0</token>
                </Properties>
              </Item>
              <Item class="UIStroke" referent="346">
                <Properties>
                  <string name="Name">Outline</string>
                  <token name="ApplyStrokeMode">1</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BorderOffset">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <token name="BorderStrokePosition">0</token>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <token name="LineJoinMode">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="StrokeSizingMode">1</token>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Thickness">0.083333336</float>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">1</int>
                </Properties>
              </Item>
              <Item class="UIShadow" referent="347">
                <Properties>
                  <string name="Name">DropShadow</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BlurRadius">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <bool name="Inset">false</bool>
                  <token name="Mode">0</token>
                  <UDim2 name="Offset">
                    <XS>0</XS>
                    <XO>0</XO>
                    <YS>0.083333336</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <bool name="ShowBehindParent">true</bool>
                  <int64 name="SourceAssetId">-1</int64>
                  <UDim2 name="Spread">
                    <XS>0.025</XS>
                    <XO>0</XO>
                    <YS>0.16666667</YS>
                    <YO>0</YO>
                  </UDim2>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">-1</int>
                </Properties>
              </Item>
              <Item class="Frame" referent="348">
                <Properties>
                  <string name="Name">Shine</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.72</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.014583333</XS>
                    <XO>0</XO>
                    <YS>0.06944445</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.97083336</XS>
                    <XO>0</XO>
                    <YS>0.375</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">1</int>
                </Properties>
                <Item class="UICorner" referent="349">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.37037036</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.37037036</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.37037036</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.37037036</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="350">
                <Properties>
                  <string name="Name">Title</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.033333335</XS>
                    <XO>0</XO>
                    <YS>0.18055555</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.93333334</XS>
                    <XO>0</XO>
                    <YS>0.5833333</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text"><![CDATA[This is a test banner notification title! ]]></string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="351">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="352">
                <Properties>
                  <string name="Name">StarLeft</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>-0.020833334</XS>
                    <XO>0</XO>
                    <YS>-0.33333334</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">-15</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.104166664</XS>
                    <XO>0</XO>
                    <YS>0.6944444</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">★</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>0.9254902</G>
                    <B>0.47058824</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">4</int>
                </Properties>
                <Item class="UIStroke" referent="353">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.07</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="354">
                <Properties>
                  <string name="Name">StarRight</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.9166667</XS>
                    <XO>0</XO>
                    <YS>-0.33333334</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">15</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.104166664</XS>
                    <XO>0</XO>
                    <YS>0.6944444</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">★</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>0.9254902</G>
                    <B>0.47058824</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">4</int>
                </Properties>
                <Item class="UIStroke" referent="355">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.07</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
            </Item>
            <Item class="Frame" referent="356">
              <Properties>
                <string name="Name">BannerSubtitle</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>0.5</X>
                  <Y>0</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBAAAAEZhZGUIAAAARHVyYXRpb24GAAAAAAAAIEALAAAATWF4T25TY3JlZW4GAAAAAAAA8D8JAAAAU2xpZGVGcm9tAgQAAABBdXRvBQAAAFNvdW5kAggAAABMZXZlbF9VcA4AAABTdGFja0RpcmVjdGlvbgIEAAAARG93bgoAAABTdGFja0dyb3VwAgYAAABCYW5uZXI=</BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>1</R>
                  <G>1</G>
                  <B>1</B>
                </Color3>
                <float name="BackgroundTransparency">0</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">0</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0.5</XS>
                  <XO>0</XO>
                  <YS>0.08888888</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>0.25</XS>
                  <XO>0</XO>
                  <YS>0.085185185</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">false</bool>
                <int name="ZIndex">1</int>
              </Properties>
              <Item class="UIAspectRatioConstraint" referent="357">
                <Properties>
                  <string name="Name">UIAspectRatioConstraint</string>
                  <float name="AspectRatio">5.2173915</float>
                  <token name="AspectType">0</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <token name="DominantAxis">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
              </Item>
              <Item class="UICorner" referent="358">
                <Properties>
                  <string name="Name">UICorner</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BottomLeftRadius">
                    <S>0.2173913</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="BottomRightRadius">
                    <S>0.2173913</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <UDim name="TopLeftRadius">
                    <S>0.2173913</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="TopRightRadius">
                    <S>0.2173913</S>
                    <O>0</O>
                  </UDim>
                </Properties>
              </Item>
              <Item class="UIGradient" referent="359">
                <Properties>
                  <string name="Name">Gradient</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <ColorSequence name="Color">0 1 0.8392157 0.2509804 0 1 1 0.54901963 0.101960786 0 </ColorSequence>
                  <bool name="Enabled">true</bool>
                  <Vector2 name="Offset">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <float name="Rotation">90</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <float name="Scale">1</float>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <token name="TileMode">0</token>
                  <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                  <token name="Type">0</token>
                </Properties>
              </Item>
              <Item class="UIStroke" referent="360">
                <Properties>
                  <string name="Name">Outline</string>
                  <token name="ApplyStrokeMode">1</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BorderOffset">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <token name="BorderStrokePosition">0</token>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <token name="LineJoinMode">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="StrokeSizingMode">1</token>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Thickness">0.06521739</float>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">1</int>
                </Properties>
              </Item>
              <Item class="UIShadow" referent="361">
                <Properties>
                  <string name="Name">DropShadow</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BlurRadius">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <bool name="Inset">false</bool>
                  <token name="Mode">0</token>
                  <UDim2 name="Offset">
                    <XS>0</XS>
                    <XO>0</XO>
                    <YS>0.06521739</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <bool name="ShowBehindParent">true</bool>
                  <int64 name="SourceAssetId">-1</int64>
                  <UDim2 name="Spread">
                    <XS>0.025</XS>
                    <XO>0</XO>
                    <YS>0.13043478</YS>
                    <YO>0</YO>
                  </UDim2>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">-1</int>
                </Properties>
              </Item>
              <Item class="Frame" referent="362">
                <Properties>
                  <string name="Name">Shine</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <float name="BackgroundTransparency">0.72</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <UDim2 name="Position">
                    <XS>0.014583333</XS>
                    <XO>0</XO>
                    <YS>0.054347824</YS>
                    <YO>0</YO>
                  </UDim2>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.97083336</XS>
                    <XO>0</XO>
                    <YS>0.36956522</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="Style">0</token>
                  <BinaryString name="Tags"></BinaryString>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">1</int>
                </Properties>
                <Item class="UICorner" referent="363">
                  <Properties>
                    <string name="Name">UICorner</string>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BottomLeftRadius">
                      <S>0.29411766</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="BottomRightRadius">
                      <S>0.29411766</S>
                      <O>0</O>
                    </UDim>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <BinaryString name="Tags"></BinaryString>
                    <UDim name="TopLeftRadius">
                      <S>0.29411766</S>
                      <O>0</O>
                    </UDim>
                    <UDim name="TopRightRadius">
                      <S>0.29411766</S>
                      <O>0</O>
                    </UDim>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="364">
                <Properties>
                  <string name="Name">Title</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.033333335</XS>
                    <XO>0</XO>
                    <YS>0.08695652</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.93333334</XS>
                    <XO>0</XO>
                    <YS>0.45652175</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text"><![CDATA[This is a test banner notification title! ]]></string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="365">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="366">
                <Properties>
                  <string name="Name">Subtitle</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.033333335</XS>
                    <XO>0</XO>
                    <YS>0.6086956</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.93333334</XS>
                    <XO>0</XO>
                    <YS>0.23913044</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">This is a test subtitle!</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="367">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.1</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="368">
                <Properties>
                  <string name="Name">StarLeft</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>-0.020833334</XS>
                    <XO>0</XO>
                    <YS>-0.26086956</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">-15</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.104166664</XS>
                    <XO>0</XO>
                    <YS>0.54347825</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">★</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>0.9254902</G>
                    <B>0.47058824</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">4</int>
                </Properties>
                <Item class="UIStroke" referent="369">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.07</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="370">
                <Properties>
                  <string name="Name">StarRight</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.9166667</XS>
                    <XO>0</XO>
                    <YS>-0.26086956</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">15</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.104166664</XS>
                    <XO>0</XO>
                    <YS>0.54347825</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">★</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>0.9254902</G>
                    <B>0.47058824</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">4</int>
                </Properties>
                <Item class="UIStroke" referent="371">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.07</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
            </Item>
            <Item class="Frame" referent="372">
              <Properties>
                <string name="Name">Alert</string>
                <bool name="Active">false</bool>
                <Vector2 name="AnchorPoint">
                  <X>0.5</X>
                  <Y>1</Y>
                </Vector2>
                <BinaryString name="AttributesSerialize">BwAAAAkAAABBbmltYXRpb24CBQAAAFNsaWRlCAAAAER1cmF0aW9uBgAAAAAAAAhACwAAAE1heE9uU2NyZWVuBgAAAAAAAAhACQAAAFNsaWRlRnJvbQIEAAAAQXV0bwUAAABTb3VuZAIKAAAAQ29kZV9FcnJvcg4AAABTdGFja0RpcmVjdGlvbgICAAAAVXAKAAAAU3RhY2tHcm91cAIAAAAA</BinaryString>
                <bool name="AutoLocalize">true</bool>
                <token name="AutomaticSize">0</token>
                <Color3 name="BackgroundColor3">
                  <R>1</R>
                  <G>1</G>
                  <B>1</B>
                </Color3>
                <float name="BackgroundTransparency">0</float>
                <Color3 name="BorderColor3">
                  <R>0.105882354</R>
                  <G>0.16470589</G>
                  <B>0.20784314</B>
                </Color3>
                <token name="BorderMode">0</token>
                <int name="BorderSizePixel">0</int>
                <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                <bool name="ClipsDescendants">false</bool>
                <bool name="Draggable">false</bool>
                <bool name="Interactable">true</bool>
                <int name="LayoutOrder">0</int>
                <Ref name="NextSelectionDown">null</Ref>
                <Ref name="NextSelectionLeft">null</Ref>
                <Ref name="NextSelectionRight">null</Ref>
                <Ref name="NextSelectionUp">null</Ref>
                <UDim2 name="Position">
                  <XS>0.5</XS>
                  <XO>0</XO>
                  <YS>0.88</YS>
                  <YO>0</YO>
                </UDim2>
                <Ref name="RootLocalizationTable">null</Ref>
                <float name="Rotation">0</float>
                <bool name="DefinesCapabilities">false</bool>
                <bool name="Selectable">false</bool>
                <token name="SelectionBehaviorDown">0</token>
                <token name="SelectionBehaviorLeft">0</token>
                <token name="SelectionBehaviorRight">0</token>
                <token name="SelectionBehaviorUp">0</token>
                <bool name="SelectionGroup">false</bool>
                <Ref name="SelectionImageObject">null</Ref>
                <int name="SelectionOrder">0</int>
                <BinaryString name="SerializedOverrides">
                </BinaryString>
                <token name="Sink">0</token>
                <UDim2 name="Size">
                  <XS>0.26666668</XS>
                  <XO>0</XO>
                  <YS>0.05</YS>
                  <YO>0</YO>
                </UDim2>
                <token name="SizeConstraint">0</token>
                <int64 name="SourceAssetId">-1</int64>
                <token name="Style">0</token>
                <BinaryString name="Tags"></BinaryString>
                <bool name="Visible">false</bool>
                <int name="ZIndex">1</int>
              </Properties>
              <Item class="UIAspectRatioConstraint" referent="373">
                <Properties>
                  <string name="Name">UIAspectRatioConstraint</string>
                  <float name="AspectRatio">9.481482</float>
                  <token name="AspectType">0</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <token name="DominantAxis">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                </Properties>
              </Item>
              <Item class="UICorner" referent="374">
                <Properties>
                  <string name="Name">UICorner</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BottomLeftRadius">
                    <S>0.5</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="BottomRightRadius">
                    <S>0.5</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <UDim name="TopLeftRadius">
                    <S>0.5</S>
                    <O>0</O>
                  </UDim>
                  <UDim name="TopRightRadius">
                    <S>0.5</S>
                    <O>0</O>
                  </UDim>
                </Properties>
              </Item>
              <Item class="UIGradient" referent="375">
                <Properties>
                  <string name="Name">Gradient</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <ColorSequence name="Color">0 1 0.3764706 0.3764706 0 1 0.8392157 0.11764706 0.20392157 0 </ColorSequence>
                  <bool name="Enabled">true</bool>
                  <Vector2 name="Offset">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <float name="Rotation">90</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <float name="Scale">1</float>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <token name="TileMode">0</token>
                  <NumberSequence name="Transparency">0 0 0 1 0 0 </NumberSequence>
                  <token name="Type">0</token>
                </Properties>
              </Item>
              <Item class="UIStroke" referent="376">
                <Properties>
                  <string name="Name">Outline</string>
                  <token name="ApplyStrokeMode">1</token>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BorderOffset">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <token name="BorderStrokePosition">0</token>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <token name="LineJoinMode">0</token>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <int64 name="SourceAssetId">-1</int64>
                  <token name="StrokeSizingMode">1</token>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Thickness">0.09259259</float>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">1</int>
                </Properties>
              </Item>
              <Item class="UIShadow" referent="377">
                <Properties>
                  <string name="Name">DropShadow</string>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <UDim name="BlurRadius">
                    <S>0</S>
                    <O>0</O>
                  </UDim>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <Color3 name="Color">
                    <R>0.015686275</R>
                    <G>0.015686275</G>
                    <B>0.20784314</B>
                  </Color3>
                  <bool name="Enabled">true</bool>
                  <bool name="Inset">false</bool>
                  <token name="Mode">0</token>
                  <UDim2 name="Offset">
                    <XS>0</XS>
                    <XO>0</XO>
                    <YS>0.09259259</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="DefinesCapabilities">false</bool>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <bool name="ShowBehindParent">true</bool>
                  <int64 name="SourceAssetId">-1</int64>
                  <UDim2 name="Spread">
                    <XS>0.01953125</XS>
                    <XO>0</XO>
                    <YS>0.18518518</YS>
                    <YO>0</YO>
                  </UDim2>
                  <BinaryString name="Tags"></BinaryString>
                  <float name="Transparency">0</float>
                  <int name="ZIndex">-1</int>
                </Properties>
              </Item>
              <Item class="TextLabel" referent="378">
                <Properties>
                  <string name="Name">Mark</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.03125</XS>
                    <XO>0</XO>
                    <YS>0.16666667</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.0703125</XS>
                    <XO>0</XO>
                    <YS>0.6666667</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">!</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">2</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="379">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
              <Item class="TextLabel" referent="380">
                <Properties>
                  <string name="Name">Title</string>
                  <bool name="Active">false</bool>
                  <Vector2 name="AnchorPoint">
                    <X>0</X>
                    <Y>0</Y>
                  </Vector2>
                  <BinaryString name="AttributesSerialize"></BinaryString>
                  <bool name="AutoLocalize">true</bool>
                  <token name="AutomaticSize">0</token>
                  <Color3 name="BackgroundColor3">
                    <R>0.6392157</R>
                    <G>0.63529414</G>
                    <B>0.64705884</B>
                  </Color3>
                  <float name="BackgroundTransparency">1</float>
                  <Color3 name="BorderColor3">
                    <R>0.105882354</R>
                    <G>0.16470589</G>
                    <B>0.20784314</B>
                  </Color3>
                  <token name="BorderMode">0</token>
                  <int name="BorderSizePixel">0</int>
                  <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                  <bool name="ClipsDescendants">false</bool>
                  <bool name="Draggable">false</bool>
                  <Font name="FontFace">
                    <Family>
                      <url>rbxasset://fonts/families/FredokaOne.json</url>
                    </Family>
                    <Weight>400</Weight>
                    <Style>Normal</Style>
                  </Font>
                  <bool name="Interactable">true</bool>
                  <int name="LayoutOrder">0</int>
                  <float name="LineHeight">1</float>
                  <string name="LocalizationMatchIdentifier"></string>
                  <string name="LocalizationMatchedSourceText"></string>
                  <int name="MaxVisibleGraphemes">-1</int>
                  <Ref name="NextSelectionDown">null</Ref>
                  <Ref name="NextSelectionLeft">null</Ref>
                  <Ref name="NextSelectionRight">null</Ref>
                  <Ref name="NextSelectionUp">null</Ref>
                  <string name="OpenTypeFeatures"></string>
                  <UDim2 name="Position">
                    <XS>0.109375</XS>
                    <XO>0</XO>
                    <YS>0.24074075</YS>
                    <YO>0</YO>
                  </UDim2>
                  <bool name="RichText">false</bool>
                  <Ref name="RootLocalizationTable">null</Ref>
                  <float name="Rotation">0</float>
                  <bool name="DefinesCapabilities">false</bool>
                  <bool name="Selectable">false</bool>
                  <token name="SelectionBehaviorDown">0</token>
                  <token name="SelectionBehaviorLeft">0</token>
                  <token name="SelectionBehaviorRight">0</token>
                  <token name="SelectionBehaviorUp">0</token>
                  <bool name="SelectionGroup">false</bool>
                  <Ref name="SelectionImageObject">null</Ref>
                  <int name="SelectionOrder">0</int>
                  <BinaryString name="SerializedOverrides">
                  </BinaryString>
                  <token name="Sink">0</token>
                  <UDim2 name="Size">
                    <XS>0.84375</XS>
                    <XO>0</XO>
                    <YS>0.5185185</YS>
                    <YO>0</YO>
                  </UDim2>
                  <token name="SizeConstraint">0</token>
                  <int64 name="SourceAssetId">-1</int64>
                  <BinaryString name="Tags"></BinaryString>
                  <string name="Text">This is an error notification</string>
                  <Color3 name="TextColor3">
                    <R>1</R>
                    <G>1</G>
                    <B>1</B>
                  </Color3>
                  <token name="TextDirection">0</token>
                  <bool name="TextScaled">true</bool>
                  <float name="TextSize">8</float>
                  <Color3 name="TextStrokeColor3">
                    <R>0</R>
                    <G>0</G>
                    <B>0</B>
                  </Color3>
                  <float name="TextStrokeTransparency">1</float>
                  <float name="TextTransparency">0</float>
                  <token name="TextTruncate">0</token>
                  <bool name="TextWrapped">true</bool>
                  <token name="TextXAlignment">0</token>
                  <token name="TextYAlignment">1</token>
                  <bool name="Visible">true</bool>
                  <int name="ZIndex">3</int>
                </Properties>
                <Item class="UIStroke" referent="381">
                  <Properties>
                    <string name="Name">UIStroke</string>
                    <token name="ApplyStrokeMode">0</token>
                    <BinaryString name="AttributesSerialize"></BinaryString>
                    <UDim name="BorderOffset">
                      <S>0</S>
                      <O>0</O>
                    </UDim>
                    <token name="BorderStrokePosition">0</token>
                    <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
                    <Color3 name="Color">
                      <R>0.015686275</R>
                      <G>0.015686275</G>
                      <B>0.20784314</B>
                    </Color3>
                    <bool name="Enabled">true</bool>
                    <token name="LineJoinMode">0</token>
                    <bool name="DefinesCapabilities">false</bool>
                    <BinaryString name="SerializedOverrides">
                    </BinaryString>
                    <int64 name="SourceAssetId">-1</int64>
                    <token name="StrokeSizingMode">1</token>
                    <BinaryString name="Tags"></BinaryString>
                    <float name="Thickness">0.09</float>
                    <float name="Transparency">0</float>
                    <int name="ZIndex">1</int>
                  </Properties>
                </Item>
              </Item>
            </Item>
          </Item>
        </Item>
      </Item>
    </Item>
    <Item class="Folder" referent="382">
      <Properties>
        <string name="Name">RBLXE_Major3</string>
        <BinaryString name="AttributesSerialize">AQAAAAoAAABSQkxYRV9Ob3RlAnIAAABSQkxYIEVzc2VudGlhbHMgMy54OiBpbnN0YWxsIGl0IHdpdGggdGhlIFJCTFggRXNzZW50aWFscyAzLjAgcGx1Z2luIG9yIFRvb2xzLiBBIDIueCBwbHVnaW4gcmVmdXNlcyB0aGlzIGNvbnRhaW5lci4=</BinaryString>
        <SecurityCapabilities name="Capabilities">0</SecurityCapabilities>
        <Color3 name="IconTint">
          <R>0</R>
          <G>0</G>
          <B>0</B>
        </Color3>
        <bool name="DefinesCapabilities">false</bool>
        <BinaryString name="SerializedOverrides">
        </BinaryString>
        <int64 name="SourceAssetId">-1</int64>
        <BinaryString name="Tags"></BinaryString>
      </Properties>
    </Item>
  </Item>
</roblox>