--[[
    ANXY HUB  v5.0  ·  monochrome marble edition

    * black & white theme with an animated marbled-ink background
    * sidebar tabs: Farming / Upgrades / Eggs / Settings
    * the marble texture is embedded at the bottom of this file. On first run it is
      written to your executor's workspace folder (anxy_marble_v5.jpg) with writefile
      and loaded with getcustomasset. If your executor has neither, the hub falls
      back to a drifting smoke effect made from plain frames.
]]

local Players           = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CoreGui           = game:GetService("CoreGui")
local TweenService      = game:GetService("TweenService")
local UserInputService  = game:GetService("UserInputService")
local RunService        = game:GetService("RunService")

local GUI_NAME = "AnxyHub_v5"
local env = (getgenv and getgenv()) or _G

------------------------------------------------------------------------
-- RE-EXECUTE CLEANUP (stops old loops + removes any older Anxy GUI)
------------------------------------------------------------------------
if env.AnxyHubShutdown then pcall(env.AnxyHubShutdown) end
for _, n in ipairs({ "AnxyHub_v5", "AnxyHub_v4", "AnxyHubGui" }) do
    local stale = CoreGui:FindFirstChild(n)
    if stale then stale:Destroy() end
end

------------------------------------------------------------------------
-- TASK MANAGER
------------------------------------------------------------------------
local TaskManager = { _tasks = {} }

function TaskManager:start(id, fn, interval)
    self:stop(id)
    local entry = { alive = true }
    self._tasks[id] = entry
    task.spawn(function()
        while entry.alive do
            pcall(fn)
            task.wait(interval)
        end
    end)
end

function TaskManager:stop(id)
    local entry = self._tasks[id]
    if entry then
        entry.alive = false
        self._tasks[id] = nil
    end
end

function TaskManager:stopAll()
    for id in pairs(self._tasks) do
        self:stop(id)
    end
end

------------------------------------------------------------------------
-- REMOTES (cached, re-resolved if they disappear)
------------------------------------------------------------------------
local cachedPort
local function port1()
    if cachedPort and cachedPort.Parent then return cachedPort end
    local network = ReplicatedStorage:FindFirstChild("Network")
    cachedPort = network and network:FindFirstChild("Port1")
    return cachedPort
end

local function fire(...)
    local p = port1()
    if p then p:FireServer(...) end
end

local function increaseSpeed()
    local ev = ReplicatedStorage:FindFirstChild("IncreaseSpeed")
    if ev then ev:FireServer() end
end

local punchTarget
local function getPunchTarget()
    if punchTarget and punchTarget.Parent then return punchTarget end
    local folder = workspace:FindFirstChild("PowerTrainingFolder")
    punchTarget = folder and folder:GetChildren()[16]
    return punchTarget
end

------------------------------------------------------------------------
-- PALETTE (strictly monochrome)
------------------------------------------------------------------------
local C = {
    Black     = Color3.fromRGB(0, 0, 0),
    White     = Color3.fromRGB(255, 255, 255),
    Text      = Color3.fromRGB(240, 240, 240),
    TextSub   = Color3.fromRGB(175, 175, 175),
    TextMuted = Color3.fromRGB(125, 125, 125),
    KnobOff   = Color3.fromRGB(135, 135, 135),
    TrackOff  = Color3.fromRGB(30, 30, 30),
}

------------------------------------------------------------------------
-- HELPERS
------------------------------------------------------------------------
local function tw(obj, t, props)
    TweenService:Create(obj,
        TweenInfo.new(t, Enum.EasingStyle.Quart, Enum.EasingDirection.Out),
        props):Play()
end

local function new(class, props, parent)
    local inst = Instance.new(class)
    for k, v in pairs(props) do inst[k] = v end
    inst.Parent = parent
    return inst
end

local function frame(parent, props)
    local p = { BackgroundColor3 = C.Black, BorderSizePixel = 0 }
    for k, v in pairs(props) do p[k] = v end
    return new("Frame", p, parent)
end

local function label(parent, props)
    local p = {
        BackgroundTransparency = 1, BorderSizePixel = 0,
        Font = Enum.Font.Gotham, TextSize = 12, TextColor3 = C.Text,
        TextXAlignment = Enum.TextXAlignment.Left,
    }
    for k, v in pairs(props) do p[k] = v end
    return new("TextLabel", p, parent)
end

local function corner(inst, px)
    return new("UICorner", { CornerRadius = UDim.new(0, px) }, inst)
end

local function round(inst)
    return new("UICorner", { CornerRadius = UDim.new(1, 0) }, inst)
end

local function stroke(inst, color, thickness, transparency)
    return new("UIStroke", {
        Color = color, Thickness = thickness or 1, Transparency = transparency or 0,
    }, inst)
end

local function clamp(x, lo, hi)
    if x < lo then return lo end
    if x > hi then return hi end
    return x
end

-- "TRAINING" -> "T R A I N I N G"  (Roblox text has no letter-spacing property)
local function spaced(s)
    return (s:upper():gsub("(.)", "%1 "):gsub("%s+$", ""))
end

local conns = {}
local function connect(signal, fn)
    local c = signal:Connect(fn)
    conns[#conns + 1] = c
    return c
end

------------------------------------------------------------------------
-- ROOT
------------------------------------------------------------------------
local ScreenGui = new("ScreenGui", {
    Name           = GUI_NAME,
    ResetOnSpawn   = false,
    ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
    IgnoreGuiInset = true,
    DisplayOrder   = 100,
}, nil)
if not pcall(function() ScreenGui.Parent = CoreGui end) then
    ScreenGui.Parent = Players.LocalPlayer:WaitForChild("PlayerGui")
end

local function shutdown()
    TaskManager:stopAll()
    for _, c in ipairs(conns) do pcall(function() c:Disconnect() end) end
    if ScreenGui and ScreenGui.Parent then ScreenGui:Destroy() end
    if env.AnxyHubShutdown == shutdown then env.AnxyHubShutdown = nil end
end
env.AnxyHubShutdown = shutdown

local WIN_W, WIN_H = 480, 504
local NAV_W        = 118
local TOPBAR_H     = 56

------------------------------------------------------------------------
-- WINDOW SHELL: silver animated ring + rounded panel
------------------------------------------------------------------------
local Outer = new("Frame", {
    Name = "Outer",
    Size = UDim2.new(0, WIN_W, 0, WIN_H),
    Position = UDim2.new(0.5, -WIN_W / 2, 0.5, -WIN_H / 2),
    BackgroundTransparency = 1,
}, ScreenGui)

local Ring = frame(Outer, { Name = "Ring", Size = UDim2.new(1, 0, 1, 0), BackgroundColor3 = C.White })
corner(Ring, 18)
local RingGrad = new("UIGradient", {
    Color = ColorSequence.new({
        ColorSequenceKeypoint.new(0.00, Color3.fromRGB(255, 255, 255)),
        ColorSequenceKeypoint.new(0.25, Color3.fromRGB(22, 22, 22)),
        ColorSequenceKeypoint.new(0.50, Color3.fromRGB(190, 190, 190)),
        ColorSequenceKeypoint.new(0.75, Color3.fromRGB(22, 22, 22)),
        ColorSequenceKeypoint.new(1.00, Color3.fromRGB(255, 255, 255)),
    }),
}, Ring)

-- A CanvasGroup clips its children to the rounded corners (a plain Frame does
-- not). If it is unavailable we fall back to a normal clipped Frame.
local canvasOk, Panel = pcall(Instance.new, "CanvasGroup")
local isCanvas = canvasOk
if not canvasOk then Panel = Instance.new("Frame") end
Panel.Name = "Panel"
Panel.Size = UDim2.new(1, -4, 1, -4)
Panel.Position = UDim2.new(0, 2, 0, 2)
Panel.BackgroundColor3 = C.Black
Panel.BorderSizePixel = 0
if not isCanvas then Panel.ClipsDescendants = true end
Panel.Parent = Outer
corner(Panel, 16)

------------------------------------------------------------------------
-- BACKGROUND: animated marble (layer 1 under everything in the panel)
------------------------------------------------------------------------
local Bg = frame(Panel, {
    Name = "Bg", Size = UDim2.new(1, 0, 1, 0), ClipsDescendants = true, ZIndex = 1,
})

local function marbleLayer(size, transparency, z)
    return new("ImageLabel", {
        Name = "Marble",
        AnchorPoint = Vector2.new(0.5, 0.5),
        Position = UDim2.new(0.5, 0, 0.5, 0),
        Size = UDim2.new(0, size, 0, size),
        BackgroundTransparency = 1,
        BorderSizePixel = 0,
        Image = "",
        ImageTransparency = transparency,
        ZIndex = z,
    }, Bg)
end
local LayerA = marbleLayer(840, 0, 1)      -- main marble
local LayerB = marbleLayer(900, 0.76, 2)   -- ghost layer, counter-rotating

-- fallback smoke (only shown when the texture can't be loaded)
local discs = {}
for i, size in ipairs({ 430, 360, 300 }) do
    local f = frame(Bg, {
        Name = "Smoke", AnchorPoint = Vector2.new(0.5, 0.5),
        Position = UDim2.new(0.5, 0, 0.5, 0), Size = UDim2.new(0, size, 0, size),
        BackgroundColor3 = C.White, ZIndex = 2 + i, Visible = false,
    })
    round(f)
    local g = new("UIGradient", {
        Transparency = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 1),
            NumberSequenceKeypoint.new(0.5, 0.78),
            NumberSequenceKeypoint.new(1, 1),
        }),
    }, f)
    discs[i] = { frame = f, grad = g }
end

-- dark veil: keeps text readable; its strength is the "Marble Brightness" slider
local Veil = frame(Bg, {
    Name = "Veil", Size = UDim2.new(1, 0, 1, 0), BackgroundTransparency = 0.64, ZIndex = 10,
})

-- everything interactive lives above the background
local Content = new("Frame", {
    Name = "Content", Size = UDim2.new(1, 0, 1, 0), BackgroundTransparency = 1, ZIndex = 2,
}, Panel)

------------------------------------------------------------------------
-- STATE SHARED WITH THE ANIMATION LOOP
------------------------------------------------------------------------
local minimized   = false
local bgOn        = true
local flow        = 1
local uiT, marbleT = 0, 0
local useFallback = false
local sparkles    = {}

------------------------------------------------------------------------
-- TOP BAR
------------------------------------------------------------------------
local TopBar = frame(Content, {
    Name = "TopBar", Size = UDim2.new(1, 0, 0, TOPBAR_H), BackgroundTransparency = 0.35,
})
local ShineGrad

-- status pill (needs to exist before updateStatus)
local activeCount = 0
local StatusPill = frame(TopBar, {
    Size = UDim2.new(0, 100, 0, 24), Position = UDim2.new(1, -190, 0.5, -12),
    BackgroundTransparency = 0.35,
})
round(StatusPill)
stroke(StatusPill, C.White, 1, 0.7)
local StatusDot = frame(StatusPill, {
    Size = UDim2.new(0, 6, 0, 6), Position = UDim2.new(0, 11, 0.5, -3), BackgroundColor3 = C.TextMuted,
})
round(StatusDot)
local StatusText = label(StatusPill, {
    Size = UDim2.new(1, -26, 1, 0), Position = UDim2.new(0, 24, 0, 0),
    Text = "0 active", TextColor3 = C.TextSub, TextSize = 11, Font = Enum.Font.GothamMedium,
})

local function updateStatus(delta)
    activeCount = math.max(0, activeCount + delta)
    StatusText.Text = activeCount .. " active"
    local on = activeCount > 0
    tw(StatusPill, 0.2, {
        BackgroundColor3 = on and C.White or C.Black,
        BackgroundTransparency = on and 0 or 0.35,
    })
    tw(StatusText, 0.2, { TextColor3 = on and C.Black or C.TextSub })
    tw(StatusDot, 0.2, { BackgroundColor3 = on and C.Black or C.TextMuted })
end

local function sparkle(parent, x, size, phase)
    local root = new("Frame", {
        AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0, x, 0.5, 0),
        Size = UDim2.new(0, size, 0, size), BackgroundTransparency = 1,
    }, parent)
    local parts = {
        frame(root, { AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0.5, 0, 0.5, 0),
            Size = UDim2.new(1, 0, 0, 1), BackgroundColor3 = C.White }),
        frame(root, { AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0.5, 0, 0.5, 0),
            Size = UDim2.new(0, 1, 1, 0), BackgroundColor3 = C.White }),
        frame(root, { AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0.5, 0, 0.5, 0),
            Size = UDim2.new(0, 3, 0, 3), Rotation = 45, BackgroundColor3 = C.White }),
    }
    sparkles[#sparkles + 1] = { root = root, parts = parts, size = size, phase = phase }
end

local function iconButton(xOffset, kind)
    local btn = new("TextButton", {
        Size = UDim2.new(0, 28, 0, 28), Position = UDim2.new(1, xOffset, 0.5, -14),
        BackgroundColor3 = C.White, BackgroundTransparency = 0.9,
        Text = "", AutoButtonColor = false, BorderSizePixel = 0,
    }, TopBar)
    corner(btn, 8)
    local bars = {}
    local function bar(w, h, rot)
        local b = frame(btn, {
            AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0.5, 0, 0.5, 0),
            Size = UDim2.new(0, w, 0, h), Rotation = rot or 0, BackgroundColor3 = C.White,
        })
        bars[#bars + 1] = b
        return b
    end
    local plus
    if kind == "close" then
        bar(12, 2, 45); bar(12, 2, -45)
    else
        bar(11, 2, 0)
        plus = bar(2, 11, 0)
        plus.BackgroundTransparency = 1
    end
    btn.MouseEnter:Connect(function()
        if kind == "close" then
            tw(btn, 0.15, { BackgroundTransparency = 0 })
            for _, b in ipairs(bars) do tw(b, 0.15, { BackgroundColor3 = C.Black }) end
        else
            tw(btn, 0.15, { BackgroundTransparency = 0.75 })
        end
    end)
    btn.MouseLeave:Connect(function()
        tw(btn, 0.15, { BackgroundTransparency = 0.9 })
        if kind == "close" then
            for _, b in ipairs(bars) do tw(b, 0.15, { BackgroundColor3 = C.White }) end
        end
    end)
    return btn, plus
end

do
    -- hairline + travelling shine under the bar
    frame(TopBar, {
        Size = UDim2.new(1, 0, 0, 1), Position = UDim2.new(0, 0, 1, -1),
        BackgroundColor3 = C.White, BackgroundTransparency = 0.88,
    })
    local shine = frame(TopBar, {
        Size = UDim2.new(1, 0, 0, 1), Position = UDim2.new(0, 0, 1, -1), BackgroundColor3 = C.White,
    })
    ShineGrad = new("UIGradient", {
        Transparency = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 1),
            NumberSequenceKeypoint.new(0.4, 1),
            NumberSequenceKeypoint.new(0.5, 0),
            NumberSequenceKeypoint.new(0.6, 1),
            NumberSequenceKeypoint.new(1, 1),
        }),
        Offset = Vector2.new(-1, 0),
    }, shine)

    sparkle(TopBar, 20, 16, 0)
    label(TopBar, {
        Size = UDim2.new(0, 110, 0, 28), Position = UDim2.new(0, 36, 0.5, -14),
        Text = "ANXY  HUB", TextColor3 = C.White, TextSize = 17, Font = Enum.Font.GothamBlack,
    })
    local badge = frame(TopBar, {
        Size = UDim2.new(0, 38, 0, 18), Position = UDim2.new(0, 146, 0.5, -9), BackgroundTransparency = 1,
    })
    round(badge)
    stroke(badge, C.White, 1, 0.55)
    label(badge, {
        Size = UDim2.new(1, 0, 1, 0), Text = "v5.0", TextColor3 = C.TextSub,
        TextSize = 10, Font = Enum.Font.GothamBold, TextXAlignment = Enum.TextXAlignment.Center,
    })
    sparkle(TopBar, 196, 8, 2.1)
end

local MinBtn, MinPlus = iconButton(-74, "min")
local CloseBtn        = iconButton(-40, "close")

MinBtn.MouseButton1Click:Connect(function()
    minimized = not minimized
    tw(Outer, 0.3, { Size = UDim2.new(0, WIN_W, 0, minimized and (TOPBAR_H + 4) or WIN_H) })
    tw(MinPlus, 0.2, { BackgroundTransparency = minimized and 0 or 1 })
end)

CloseBtn.MouseButton1Click:Connect(function()
    TaskManager:stopAll()
    tw(Outer, 0.25, {
        Size = UDim2.new(0, 0, 0, 0),
        Position = UDim2.new(0.5, 0, 0.5, 0),
    })
    task.delay(0.28, shutdown)
end)

------------------------------------------------------------------------
-- DRAG (top bar)
------------------------------------------------------------------------
local dragging, dragOrigin, dragStart = false, nil, nil

local function isPointer(input)
    return input.UserInputType == Enum.UserInputType.MouseButton1
        or input.UserInputType == Enum.UserInputType.Touch
end

TopBar.InputBegan:Connect(function(input)
    if isPointer(input) then
        dragging   = true
        dragOrigin = input.Position
        dragStart  = Outer.Position
    end
end)

connect(UserInputService.InputEnded, function(input)
    if isPointer(input) then dragging = false end
end)

connect(UserInputService.InputChanged, function(input)
    if dragging and (input.UserInputType == Enum.UserInputType.MouseMovement
        or input.UserInputType == Enum.UserInputType.Touch) then
        local d = input.Position - dragOrigin
        Outer.Position = UDim2.new(
            dragStart.X.Scale, dragStart.X.Offset + d.X,
            dragStart.Y.Scale, dragStart.Y.Offset + d.Y
        )
    end
end)

------------------------------------------------------------------------
-- SIDEBAR + CONTENT AREA
------------------------------------------------------------------------
local Sidebar = frame(Content, {
    Name = "Sidebar", Size = UDim2.new(0, NAV_W, 1, -TOPBAR_H), Position = UDim2.new(0, 0, 0, TOPBAR_H),
    BackgroundTransparency = 0.45,
})
frame(Content, {
    Name = "SideRule", Size = UDim2.new(0, 1, 1, -TOPBAR_H), Position = UDim2.new(0, NAV_W, 0, TOPBAR_H),
    BackgroundColor3 = C.White, BackgroundTransparency = 0.88,
})

-- white pill that slides behind the active tab
local NavPill = frame(Sidebar, {
    Size = UDim2.new(1, -16, 0, 38), Position = UDim2.new(0, 8, 0, 12),
    BackgroundColor3 = C.White, ZIndex = 1,
})
corner(NavPill, 10)

local KeyHint = label(Sidebar, {
    Size = UDim2.new(1, -20, 0, 28), Position = UDim2.new(0, 12, 1, -38),
    Text = "RightShift  ·  show / hide", TextColor3 = C.TextMuted, TextSize = 10,
    TextWrapped = true, TextYAlignment = Enum.TextYAlignment.Bottom,
})

local ContentArea = new("Frame", {
    Name = "ContentArea",
    Size = UDim2.new(1, -NAV_W - 1, 1, -TOPBAR_H),
    Position = UDim2.new(0, NAV_W + 1, 0, TOPBAR_H),
    BackgroundTransparency = 1, ClipsDescendants = true,
}, Content)

------------------------------------------------------------------------
-- TABS (buttons are positioned by hand, no layout object to go wrong)
------------------------------------------------------------------------
local tabs = {}
local activeTab = nil
local orders = {}
local function nextOrder(pane)
    orders[pane] = (orders[pane] or 0) + 1
    return orders[pane]
end

local function paintTab(t, on)
    tw(t.name, 0.2, { TextColor3 = on and C.Black or C.TextSub })
    tw(t.num,  0.2, { TextColor3 = on and C.Black or C.TextMuted, TextTransparency = on and 0.35 or 0 })
end

local function selectTab(t)
    if activeTab == t then return end
    if activeTab then
        activeTab.pane.Visible = false
        paintTab(activeTab, false)
    end
    activeTab = t
    t.pane.Visible = true
    t.pane.Position = UDim2.new(0, 0, 0, 10)
    tw(t.pane, 0.25, { Position = UDim2.new(0, 0, 0, 0) })
    paintTab(t, true)
    tw(NavPill, 0.28, { Position = UDim2.new(0, 8, 0, 12 + (t.index - 1) * 44) })
end

local function addTab(title)
    local index = #tabs + 1
    local btn = new("TextButton", {
        Name = title .. "Nav",
        Size = UDim2.new(1, -16, 0, 38),
        Position = UDim2.new(0, 8, 0, 12 + (index - 1) * 44),
        BackgroundTransparency = 1, Text = "", AutoButtonColor = false, BorderSizePixel = 0,
        ZIndex = 2,
    }, Sidebar)
    local num = label(btn, {
        Size = UDim2.new(0, 20, 1, 0), Position = UDim2.new(0, 13, 0, 0),
        Text = string.format("%02d", index), TextColor3 = C.TextMuted, TextSize = 9,
        Font = Enum.Font.GothamBold,
    })
    local name = label(btn, {
        Size = UDim2.new(1, -40, 1, 0), Position = UDim2.new(0, 36, 0, 0),
        Text = title, TextColor3 = C.TextSub, TextSize = 12, Font = Enum.Font.GothamMedium,
    })

    local pane = new("ScrollingFrame", {
        Name = title .. "Pane",
        Size = UDim2.new(1, 0, 1, 0),
        BackgroundTransparency = 1, BorderSizePixel = 0,
        ScrollBarThickness = 3, ScrollBarImageColor3 = C.White, ScrollBarImageTransparency = 0.4,
        ScrollingDirection = Enum.ScrollingDirection.Y,
        AutomaticCanvasSize = Enum.AutomaticSize.Y,
        CanvasSize = UDim2.new(0, 0, 0, 0),
        Visible = false,
    }, ContentArea)
    new("UIListLayout", { SortOrder = Enum.SortOrder.LayoutOrder, Padding = UDim.new(0, 8) }, pane)
    new("UIPadding", {
        PaddingTop = UDim.new(0, 12), PaddingBottom = UDim.new(0, 14),
        PaddingLeft = UDim.new(0, 12), PaddingRight = UDim.new(0, 14),
    }, pane)

    local data = { index = index, btn = btn, num = num, name = name, pane = pane }
    tabs[index] = data

    btn.MouseButton1Click:Connect(function() selectTab(data) end)
    btn.MouseEnter:Connect(function()
        if activeTab ~= data then tw(name, 0.15, { TextColor3 = C.White }) end
    end)
    btn.MouseLeave:Connect(function()
        if activeTab ~= data then tw(name, 0.15, { TextColor3 = C.TextSub }) end
    end)
    return pane
end

------------------------------------------------------------------------
-- COMPONENTS
------------------------------------------------------------------------
local function addSection(pane, title)
    local f = new("Frame", {
        Size = UDim2.new(1, 0, 0, 26), BackgroundTransparency = 1, LayoutOrder = nextOrder(pane),
    }, pane)
    label(f, {
        Size = UDim2.new(1, 0, 0, 14), Position = UDim2.new(0, 2, 0, 8),
        Text = spaced(title), TextColor3 = C.White, TextTransparency = 0.25,
        TextSize = 10, Font = Enum.Font.GothamBold,
    })
    local rule = frame(f, {
        Size = UDim2.new(1, 0, 0, 1), Position = UDim2.new(0, 0, 1, -1),
        BackgroundColor3 = C.White,
    })
    new("UIGradient", {
        Transparency = NumberSequence.new({
            NumberSequenceKeypoint.new(0, 0.55),
            NumberSequenceKeypoint.new(1, 1),
        }),
    }, rule)
end

-- glass card: dark, translucent, hairline border
local function card(pane, height)
    local c = new("Frame", {
        Size = UDim2.new(1, 0, 0, height), BackgroundColor3 = C.Black,
        BackgroundTransparency = 0.3, BorderSizePixel = 0, LayoutOrder = nextOrder(pane),
    }, pane)
    corner(c, 12)
    local s = stroke(c, C.White, 1, 0.84)
    return c, s
end

-- outlined button that inverts on hover
local function addButton(pane, text, height)
    local btn = new("TextButton", {
        Size = UDim2.new(1, 0, 0, height or 44), BackgroundColor3 = C.Black,
        BackgroundTransparency = 0.3, BorderSizePixel = 0, AutoButtonColor = false,
        Text = text, TextColor3 = C.White, TextSize = 13, Font = Enum.Font.GothamBold,
        LayoutOrder = nextOrder(pane),
    }, pane)
    corner(btn, 12)
    stroke(btn, C.White, 1, 0.6)
    btn.MouseEnter:Connect(function()
        tw(btn, 0.15, { BackgroundColor3 = C.White, BackgroundTransparency = 0, TextColor3 = C.Black })
    end)
    btn.MouseLeave:Connect(function()
        tw(btn, 0.15, { BackgroundColor3 = C.Black, BackgroundTransparency = 0.3, TextColor3 = C.White })
    end)
    return btn
end

local featureToggles = {}

-- returns: setter, sublabel
local function addToggle(pane, title, sublabel, callback, opts)
    local countable = not (opts and opts.countable == false)
    local state = false

    local c, cardStroke = card(pane, 58)
    local glow = frame(c, {
        Size = UDim2.new(0, 3, 0.56, 0), Position = UDim2.new(0, 0, 0.22, 0),
        BackgroundColor3 = C.White, BackgroundTransparency = 1,
    })
    round(glow)

    local lbl = label(c, {
        Size = UDim2.new(1, -86, 0, 20), Position = UDim2.new(0, 16, 0, 10),
        Text = title, TextColor3 = C.TextSub, TextSize = 13, Font = Enum.Font.GothamMedium,
    })
    local sub = label(c, {
        Size = UDim2.new(1, -86, 0, 14), Position = UDim2.new(0, 16, 0, 32),
        Text = sublabel or "", TextColor3 = C.TextMuted, TextSize = 10,
    })

    local track = frame(c, {
        Size = UDim2.new(0, 46, 0, 24), Position = UDim2.new(1, -60, 0.5, -12),
        BackgroundColor3 = C.TrackOff,
    })
    round(track)
    local trackStroke = stroke(track, C.White, 1, 0.75)
    local knob = frame(track, {
        Size = UDim2.new(0, 18, 0, 18), Position = UDim2.new(0, 3, 0.5, -9),
        BackgroundColor3 = C.KnobOff,
    })
    round(knob)

    local hit = new("TextButton", {
        Size = UDim2.new(1, 0, 1, 0), BackgroundTransparency = 1, Text = "",
        AutoButtonColor = false, ZIndex = 5,
    }, c)

    local function set(on)
        if on == state then return end
        state = on
        tw(track,       0.22, { BackgroundColor3 = on and C.White or C.TrackOff })
        tw(trackStroke, 0.22, { Transparency = on and 1 or 0.75 })
        tw(knob,        0.22, {
            Position = on and UDim2.new(1, -21, 0.5, -9) or UDim2.new(0, 3, 0.5, -9),
            BackgroundColor3 = on and C.Black or C.KnobOff,
        })
        tw(lbl,         0.22, { TextColor3 = on and C.White or C.TextSub })
        tw(sub,         0.22, { TextColor3 = on and C.TextSub or C.TextMuted })
        tw(cardStroke,  0.22, { Transparency = on and 0.4 or 0.84 })
        tw(glow,        0.22, { BackgroundTransparency = on and 0 or 1 })
        if countable then updateStatus(on and 1 or -1) end
        pcall(callback, on)
    end

    hit.MouseButton1Click:Connect(function() set(not state) end)
    hit.MouseEnter:Connect(function()
        if not state then tw(cardStroke, 0.15, { Transparency = 0.6 }) end
    end)
    hit.MouseLeave:Connect(function()
        if not state then tw(cardStroke, 0.15, { Transparency = 0.84 }) end
    end)

    if countable then featureToggles[#featureToggles + 1] = set end
    return set, sub
end

-- toggle that runs `fn` every `interval` seconds while on
local function addLoop(pane, id, title, sublabel, interval, fn)
    return addToggle(pane, title, sublabel, function(on)
        if on then
            TaskManager:start(id, fn, interval)
        else
            TaskManager:stop(id)
        end
    end)
end

local function addSlider(pane, title, min, max, init, suffix, onChange)
    local c = card(pane, 60)
    label(c, {
        Size = UDim2.new(0.6, 0, 0, 18), Position = UDim2.new(0, 16, 0, 10),
        Text = title, TextColor3 = C.TextSub, TextSize = 13, Font = Enum.Font.GothamMedium,
    })
    local valueLbl = label(c, {
        Size = UDim2.new(0.3, 0, 0, 18), Position = UDim2.new(0.7, -16, 0, 10),
        Text = init .. suffix, TextColor3 = C.White, TextSize = 12, Font = Enum.Font.GothamBold,
        TextXAlignment = Enum.TextXAlignment.Right,
    })
    local rel0 = (init - min) / (max - min)
    local track = frame(c, {
        Size = UDim2.new(1, -32, 0, 4), Position = UDim2.new(0, 16, 0, 41),
        BackgroundColor3 = C.White, BackgroundTransparency = 0.85,
    })
    round(track)
    local fill = frame(track, { Size = UDim2.new(rel0, 0, 1, 0), BackgroundColor3 = C.White })
    round(fill)
    local knob = frame(track, {
        AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(rel0, 0, 0.5, 0),
        Size = UDim2.new(0, 12, 0, 12), BackgroundColor3 = C.White,
    })
    round(knob)
    local hit = new("TextButton", {
        Size = UDim2.new(1, -16, 0, 26), Position = UDim2.new(0, 8, 0, 31),
        BackgroundTransparency = 1, Text = "", AutoButtonColor = false, ZIndex = 5,
    }, c)

    local sliding = false
    local function apply(x)
        local w = math.max(track.AbsoluteSize.X, 1)
        local rel = clamp((x - track.AbsolutePosition.X) / w, 0, 1)
        local v = math.floor(min + (max - min) * rel + 0.5)
        fill.Size = UDim2.new(rel, 0, 1, 0)
        knob.Position = UDim2.new(rel, 0, 0.5, 0)
        valueLbl.Text = v .. suffix
        onChange(v)
    end
    hit.InputBegan:Connect(function(input)
        if isPointer(input) then
            sliding = true
            apply(input.Position.X)
        end
    end)
    connect(UserInputService.InputChanged, function(input)
        if sliding and (input.UserInputType == Enum.UserInputType.MouseMovement
            or input.UserInputType == Enum.UserInputType.Touch) then
            apply(input.Position.X)
        end
    end)
    connect(UserInputService.InputEnded, function(input)
        if isPointer(input) then sliding = false end
    end)
end

------------------------------------------------------------------------
-- BUILD TABS
------------------------------------------------------------------------
local FarmPane     = addTab("Farming")
local UpgradePane  = addTab("Upgrades")
local EggsPane     = addTab("Eggs")
local SettingsPane = addTab("Settings")

-- FARMING
addSection(FarmPane, "Training")
addLoop(FarmPane, "click", "Auto Click",    "Port1  ·  Click  ·  every frame",    0.01, function() fire("Click") end)
addLoop(FarmPane, "punch", "Auto Punching", "Port1  ·  Punching  ·  every frame", 0.01, function()
    local target = getPunchTarget()
    if target then fire("Punching", target) end
end)
addLoop(FarmPane, "run", "Auto Running",  "Port1  ·  Running  ·  every frame",  0.01, function() fire("Running") end)
addLoop(FarmPane, "vit", "Auto Vitality", "Port1  ·  Vitality  ·  every frame", 0.01, function() fire("Vitality") end)

addSection(FarmPane, "Speed")
addLoop(FarmPane, "speed", "Auto Increase Speed", "IncreaseSpeed  ·  20 per second", 0.05, increaseSpeed)

-- UPGRADES
addSection(UpgradePane, "Auto Purchase")
addLoop(UpgradePane, "str",  "Strength",  "Port1  ·  Purchase  ·  Strength",     0.01, function() fire("Purchase", "Strength") end)
addLoop(UpgradePane, "end",  "Endurance", "Port1  ·  PurchaseAll  ·  Endurance", 0.01, function() fire("PurchaseAll", "Endurance") end)
addLoop(UpgradePane, "rank", "Rebirth",   "Port1  ·  Purchase  ·  Rank",         0.01, function() fire("Purchase", "Rank") end)
addLoop(UpgradePane, "ascend", "Ascension", "Port1  ·  Purchase  ·  Ascension",  0.3,  function() fire("Purchase", "Ascension") end)

addSection(UpgradePane, "Economy")
addLoop(UpgradePane, "sell", "Auto Sell Energy", "Port1  ·  SellEnergy  ·  every frame", 0.01, function() fire("SellEnergy") end)

-- EGGS
local Tiers = { "Tier1", "Tier2", "Tier3", "Tier4", "Tier5", "Tier6", "Tier7" }
local selectedTier = "Tier2"
local tierBound = {}   -- sublabels / buttons that show the selected tier

local function tierText(t) return (t:gsub("Tier", "Tier ")) end
local function refreshTierText()
    for _, b in ipairs(tierBound) do b.obj.Text = b.fmt(tierText(selectedTier)) end
end

addSection(EggsPane, "Crate Purchase")

do
    local CLOSED_H, OPEN_H = 60, 142
    local dropCard = card(EggsPane, CLOSED_H)
    dropCard.ClipsDescendants = true

    label(dropCard, {
        Size = UDim2.new(0.5, 0, 0, 20), Position = UDim2.new(0, 16, 0, 11),
        Text = "Select Tier", TextColor3 = C.TextSub, TextSize = 13, Font = Enum.Font.GothamMedium,
    })
    label(dropCard, {
        Size = UDim2.new(0.5, 0, 0, 14), Position = UDim2.new(0, 16, 0, 33),
        Text = "PurchaseCrate target", TextColor3 = C.TextMuted, TextSize = 10,
    })

    local dropBtn = new("TextButton", {
        Size = UDim2.new(0, 108, 0, 30), Position = UDim2.new(1, -122, 0, 15),
        BackgroundColor3 = C.Black, BackgroundTransparency = 0.2, BorderSizePixel = 0,
        Text = "", AutoButtonColor = false,
    }, dropCard)
    corner(dropBtn, 8)
    local dropStroke = stroke(dropBtn, C.White, 1, 0.55)
    local dropLabel = label(dropBtn, {
        Size = UDim2.new(1, -32, 1, 0), Position = UDim2.new(0, 12, 0, 0),
        Text = tierText(selectedTier), TextColor3 = C.White, TextSize = 12, Font = Enum.Font.GothamBold,
    })
    -- chevron drawn from two bars (the old text arrow could render as an empty box)
    local chev = new("Frame", {
        AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(1, -16, 0.5, 0),
        Size = UDim2.new(0, 12, 0, 12), BackgroundTransparency = 1,
    }, dropBtn)
    frame(chev, { AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0.5, -2, 0.5, 0),
        Size = UDim2.new(0, 7, 0, 2), Rotation = 45, BackgroundColor3 = C.White })
    frame(chev, { AnchorPoint = Vector2.new(0.5, 0.5), Position = UDim2.new(0.5, 2, 0.5, 0),
        Size = UDim2.new(0, 7, 0, 2), Rotation = -45, BackgroundColor3 = C.White })

    local chipHolder = new("Frame", {
        Size = UDim2.new(1, -24, 0, 62), Position = UDim2.new(0, 12, 0, 68), BackgroundTransparency = 1,
    }, dropCard)
    new("UIGridLayout", {
        CellSize = UDim2.new(0.25, -5, 0, 28), CellPadding = UDim2.new(0, 6, 0, 6),
        SortOrder = Enum.SortOrder.LayoutOrder,
    }, chipHolder)

    local chips = {}
    local function paintChips()
        for tier, ch in pairs(chips) do
            local on = tier == selectedTier
            tw(ch, 0.15, {
                BackgroundColor3 = on and C.White or C.Black,
                BackgroundTransparency = on and 0 or 0.4,
                TextColor3 = on and C.Black or C.TextSub,
            })
        end
    end

    local dropOpen = false
    local function setOpen(open)
        dropOpen = open
        tw(dropCard, 0.2, { Size = UDim2.new(1, 0, 0, open and OPEN_H or CLOSED_H) })
        tw(chev, 0.2, { Rotation = open and 180 or 0 })
        tw(dropStroke, 0.2, { Transparency = open and 0.2 or 0.55 })
    end

    for i, tier in ipairs(Tiers) do
        local chip = new("TextButton", {
            LayoutOrder = i, BackgroundColor3 = C.Black, BackgroundTransparency = 0.4,
            BorderSizePixel = 0, AutoButtonColor = false,
            Text = tierText(tier), TextColor3 = C.TextSub, TextSize = 11, Font = Enum.Font.GothamBold,
        }, chipHolder)
        corner(chip, 7)
        stroke(chip, C.White, 1, 0.8)
        chips[tier] = chip
        chip.MouseButton1Click:Connect(function()
            selectedTier = tier
            dropLabel.Text = tierText(tier)
            refreshTierText()
            paintChips()
            setOpen(false)
        end)
        chip.MouseEnter:Connect(function()
            if tier ~= selectedTier then tw(chip, 0.1, { BackgroundTransparency = 0.15, TextColor3 = C.White }) end
        end)
        chip.MouseLeave:Connect(function()
            if tier ~= selectedTier then tw(chip, 0.1, { BackgroundTransparency = 0.4, TextColor3 = C.TextSub }) end
        end)
    end
    paintChips()

    dropBtn.MouseButton1Click:Connect(function() setOpen(not dropOpen) end)
end

do
    local _, crateSub = addLoop(EggsPane, "crate", "Auto Purchase Crate", "", 0.1, function()
        fire("PurchaseCrate", selectedTier, 1)
    end)
    tierBound[#tierBound + 1] = { obj = crateSub, fmt = function(t) return t .. "  ·  10 per second" end }

    local _, farmSub = addLoop(EggsPane, "farm_tier", "Farm Selected Tier", "", 0.1, function()
        fire("PurchaseCrate", selectedTier, 1)
        fire("DeleteRarity", "Common")
        fire("DeleteRarity", "Uncommon")
        fire("Evolve")
    end)
    tierBound[#tierBound + 1] = {
        obj = farmSub, fmt = function(t) return t .. "  ·  buy, delete C/U, evolve  ·  10 per second" end,
    }

    local onceBtn = addButton(EggsPane, "", 44)
    tierBound[#tierBound + 1] = { obj = onceBtn, fmt = function(t) return "Buy Once  ·  " .. t end }
    local busy = false
    onceBtn.MouseButton1Click:Connect(function()
        fire("PurchaseCrate", selectedTier, 1)
        if busy then return end
        busy = true
        onceBtn.Text = "Sent"
        task.delay(0.6, function()
            busy = false
            refreshTierText()
        end)
    end)

    refreshTierText()
end

-- SETTINGS
addSection(SettingsPane, "Interface")

local toggleKey = Enum.KeyCode.RightShift
local listening = false
local keyBadge

do
    local c = card(SettingsPane, 58)
    label(c, {
        Size = UDim2.new(0.55, 0, 0, 20), Position = UDim2.new(0, 16, 0, 10),
        Text = "Toggle GUI", TextColor3 = C.TextSub, TextSize = 13, Font = Enum.Font.GothamMedium,
    })
    label(c, {
        Size = UDim2.new(0.6, 0, 0, 14), Position = UDim2.new(0, 16, 0, 32),
        Text = "click the badge, press a key (Esc cancels)", TextColor3 = C.TextMuted, TextSize = 10,
    })
    keyBadge = new("TextButton", {
        Size = UDim2.new(0, 88, 0, 26), Position = UDim2.new(1, -102, 0.5, -13),
        BackgroundColor3 = C.Black, BackgroundTransparency = 0.2, BorderSizePixel = 0,
        Text = toggleKey.Name, TextColor3 = C.White, TextSize = 10, Font = Enum.Font.GothamBold,
        AutoButtonColor = false,
    }, c)
    corner(keyBadge, 7)
    stroke(keyBadge, C.White, 1, 0.55)
    keyBadge.MouseButton1Click:Connect(function()
        listening = true
        keyBadge.Text = "..."
        keyBadge.TextColor3 = C.TextMuted
    end)
end

connect(UserInputService.InputBegan, function(input, processed)
    if listening then
        if input.UserInputType == Enum.UserInputType.Keyboard then
            listening = false
            if input.KeyCode ~= Enum.KeyCode.Escape then
                toggleKey = input.KeyCode
            end
            keyBadge.Text = toggleKey.Name
            keyBadge.TextColor3 = C.White
            KeyHint.Text = toggleKey.Name .. "  ·  show / hide"
        end
        return
    end
    if processed then return end
    if input.KeyCode == toggleKey then
        Outer.Visible = not Outer.Visible
    end
end)

local setBgMotion = addToggle(SettingsPane, "Background Motion", "freeze or animate the marble", function(on)
    bgOn = on
end, { countable = false })
setBgMotion(true)

addSlider(SettingsPane, "Marble Brightness", 0, 100, 65, "%", function(v)
    Veil.BackgroundTransparency = 0.25 + 0.6 * (v / 100)
end)
addSlider(SettingsPane, "Flow Speed", 0, 200, 100, "%", function(v)
    flow = v / 100
end)

addSection(SettingsPane, "Danger Zone")
do
    local stopBtn = addButton(SettingsPane, "Stop All Features", 44)
    stopBtn.MouseButton1Click:Connect(function()
        for _, set in ipairs(featureToggles) do set(false) end
        TaskManager:stopAll()
    end)
end

------------------------------------------------------------------------
-- BACKGROUND ANIMATION LOOP
------------------------------------------------------------------------
local function enableFallback()
    if useFallback then return end
    useFallback = true
    LayerA.Visible = false
    LayerB.Visible = false
    for _, d in ipairs(discs) do d.frame.Visible = true end
end

local lastClock = os.clock()
connect(RunService.RenderStepped, function()
    local now = os.clock()
    local dt = math.min(now - lastClock, 0.1)
    lastClock = now
    if not Outer.Visible then return end

    uiT = uiT + dt
    RingGrad.Rotation = (uiT * 36) % 360
    ShineGrad.Offset = Vector2.new(-1 + (uiT * 0.5) % 2.6, 0)

    for _, s in ipairs(sparkles) do
        local k = 0.5 + 0.5 * math.sin(uiT * 1.9 + s.phase)
        local px = s.size * (0.6 + 0.5 * k)
        s.root.Size = UDim2.new(0, px, 0, px)
        for _, p in ipairs(s.parts) do p.BackgroundTransparency = 0.5 - 0.5 * k end
    end

    if activeCount > 0 then
        StatusDot.BackgroundTransparency = 0.6 * (0.5 + 0.5 * math.sin(uiT * 4))
    else
        StatusDot.BackgroundTransparency = 0
    end

    if not bgOn or minimized then return end
    marbleT = marbleT + dt * flow
    local t = marbleT

    if useFallback then
        for i, d in ipairs(discs) do
            d.frame.Position = UDim2.new(
                0.5 + 0.30 * math.sin(t * 0.30 + i * 2.1), 0,
                0.5 + 0.30 * math.cos(t * 0.23 + i * 1.7), 0)
            d.grad.Rotation = (t * (18 + i * 9)) % 360
        end
    else
        local sA = 840 + 36 * math.sin(t * 0.13)
        LayerA.Rotation = (t * 4.5) % 360
        LayerA.Size = UDim2.new(0, sA, 0, sA)
        LayerA.Position = UDim2.new(0.5, 26 * math.sin(t * 0.21), 0.5, 26 * math.cos(t * 0.17))

        local sB = 900 + 40 * math.sin(t * 0.11 + 1.3)
        LayerB.Rotation = (140 - t * 3.1) % 360
        LayerB.Size = UDim2.new(0, sB, 0, sB)
        LayerB.Position = UDim2.new(0.5, 30 * math.cos(t * 0.15 + 0.8), 0.5, 30 * math.sin(t * 0.19 + 2.0))
        LayerB.ImageTransparency = 0.76 + 0.08 * math.sin(t * 0.35)
    end
end)

------------------------------------------------------------------------
-- START
------------------------------------------------------------------------
selectTab(tabs[1])

-- (the embedded texture lives at the very bottom so the code stays easy to read)
local MARBLE_B64, MARBLE_BYTES

------------------------------------------------------------------------
-- EMBEDDED MARBLE TEXTURE  (512 x 512 JPEG, base64)
------------------------------------------------------------------------
MARBLE_BYTES = 30820
MARBLE_B64 = [==[
/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAkGBwgHBgkIBwgKCgkLDRYPDQwMDRsUFRAWIB0iIiAdHx8kKDQsJCYxJx8fLT0tMTU3Ojo6Iys/RD
84QzQ5Ojf/wAALCAIAAgABAREA/8QAHAAAAAcBAQAAAAAAAAAAAAAAAAECAwQFBgcI/8QAOxAAAgEDAwMDAwMDAwMDBAMAAQIDAAQRBRIhBjFB
EyJRMmFxBxRCI4GRFVKhFjOxJGLBJUNy0TSS8P/aAAgBAQAAPwA+quo3VhZo/LHLkeKhR9UPdS/sbYl0XvIfNL1e5aT+my7VwCRWN1vXZLaI28
BXaRggjINZP9ypuFlfLY78VHlbfIzc8nzSKFChQoUKFChQoUKFGDg1c6ZeRyg2t4FYH6WNXkXT8MlrLPA20IoIB/l+Kr7/AEeT9p6pXaVxnPwf
NZphgkHxRVZaWP8A1GE5H3rs3Qc7NbBnIwg8jNWmowfvGaRyS5qjm6feT+pIxEYOSPmsr1HGsLYQ8jjPmqAWN3PmQnYMfUT4qOtzDpbELiST5q
Fd3M+pSbpCAB2HioUcLSzCNCCScCnTAIyVYZ5xnxRC3aTJTx4FMvG0ZwwxTtndy2km+JipIwcHuKubO5e9LAxKp2+3APJrZaF0s92ivJk58AVv
dF6bTT8Fotq+c9zWqjRdgMmVX+KU/BB6xHGEHYVNVFmwij+mn/JqTx4GBQoU99UYwcYppz/gVUavqEdrCzO2OK5F171IlzavDGSR81yK5kMjks
O/mmKOrHRHK3Sjwa610BIBqKqh92Riul9VLJJpUirySvPNcUvtVurC8OzsTjBqkvOp73S9a9W1nPtbkf8AxWx1vq+TWdJtrqBsMFxIPg1iLfqC
W3vs7sk8EGup9D6whD3D8AgKwzW81LVIbSyVxIC8g9orztAbvV7skEkt9R+BWq07T4dLjJX3O38TVf1Dqa20DZfMh789q57e3RuZM+KjUKFChQ
oUKFChQoUKPsM+aKhR5qfYapPauBuLr2wTWmivJDCSTuRuGXOQcVltWRVu2dV2q/uA+KhVc9OQ+tdEYxxXYej7Vrawkz7iw8+K1VpZ7o0PfPes
v1jrxsG/Z26gvjmsIEmvJWlmbPyT2FRdY1OKG2Fta++Q8Eis/bwQq+6djLM/aNBkj4rR6J0Jq2sESGJoYWPYjxW3h/S0bUXaoVB3ReT/AHqNP+
l4j3gRkjuM96z8nQ15byMEGVB4B71Hboq7uSQYzkfapWl/pncTzgS7gueRiusaJ0lpFjZxwLZrI4GGcjzVzBbR2sey3t0iHyRTsaq7by3qEfy8
Cm3CNLweT2OKsl9sQRRyakRqFQAUdChQLbVPxSPX2ocqMYrn3Xt2P28gL7eM1w7X7tp9xQ4UVQSSM+Nx7UihVtoUUizGQR7gAe447V1P9N3T/U
xvH4NdX1HDx7GzsI/vXCOvbK4tr6WSCJjEHOMfaufX0xnunlYYLHOKsdH1I21pNASMNyM1WeoXud58tmundGTgaeys2C5yOatNV1xLaANNMHdB
hBnNQdH0+HS7PYxElwe7L2NR9W1SKHczOPU+B4rnmq3z3c7EnjNQKFChQoUKFChQoUKMDJxRkFTyKInJyaKhRjmjUhTyAatLHVFgtmikUnPY/F
Q79/UlB8Y4qNjGCRxXQP0/0Zr7MqD62wPxXXLbTv2VusSDcx7iraK3lgh3uRwvb4rlfWA9bVy4U+7jNUPURntBHZwHG5RnHeqG8jli9OziQGRj
kkDkk/euj9BdApAY7vUgDIRu2nxXXLVoUjCQIqqowABTouQOCRmj9Qt8EU1JbW8mS0CnPmop063VwV9mKcEcS5zMu35HBpMV5Hu9KAZGeWJwKk
PaieIOX4BJw3mq67vUii2R4AFLs7hBbo7kFm5B+BVpayesdwHt+al0VChROMjntVXqd26AJHGSDwTWG67tW/YtMy5ULya4Jqlx6s7BMBAeAKg1
pOk+mJtam9WVXW1T6mA7/atNd9OaZZs2y2D8YGT2qukibcyJEqgjHAxitD0U0tvq0RAO3zXY4r22axeaXDKgzz3rjPX2orNI0HYly7geM+K5hf
hRcsF7eKYBxRhGI3AHAqZaard2iMkUhAP/ABSraS81C5WFC0kjnABNdTupfY8gjAwDkj5rmuuXJa4fDdzVP3NFRigRg0VChQoUKFChQoUe4/Jo
Z+1FQoUZowRtxgfmg5Y43HPFPRASlUUe4kCvRv6e9OQ6fo1syrmR1DFvitxBaKGLEAkVV640hBihU4x7iK5jrUe7VEOCQGHFUmqxmbUZrpuY4R
gfmpvQGgNqWsvf3y5SDlVPz4rqaACVIkxkn/FW8ESw7m5O7nHxTU/pMwJVsj4pIuCowi4/Jpcbzt3C4/FJmWU9wD/eoRs1aQfUCT2JqWLH01DN
hR4APenjeQop3ugx2BrPz7bm5Kxdie5pnTZXutRECDdGhxx2rbooRQoAAA8UonNFQowCRkUMZH2pEiRlD7ATWE/UKxu7u3FpaRs6SDnFYjTP0h
aeLffS7CxztXuKnj9INNikRv3EjqPqXGM1p7HQYbO2Fjp0ftHgVMi6KSZd12wz8U1qP6f2c7IYvbjuAanWnTVnZRgpGA4GMgVS9ZanbaTYtAvM
h9xIPb7Vw7XdWa9vJJgAAxrPyv6jk/NSEsZXgMmMY7ferTRLM3EBXZkk4o9Y0B7FlMiMgc4GRWy6T0ODT4FuyoZipOSPmrvrq3h0rRF/ZuxZs7
siuMzsHcl2JbPJHamsYJwf70mhQoUKFChQoUKFChQoUKFGPxRUKWW3AbyeO3FWOgbV1KB3TciuCc+a9R9M3tvNYQiEBDsGI/itAgIFRru3BhcI
Pc3c1yzqBBb6pgjhOSTVBOqyW0q9hISa1n6by4trqJ0A28hs+AK0NkzNPJNnjOB+Kubi59K3Vx/LiockwWMyO2PtVfc6slumQMMfpz5oWVzqF0
26MEg1ax2d/KP6j7M/BojYamhwk6svjcOakxWd23E8i7ceBTF5ospjP7eQZP8AvXNQI+mbvuLrZkYNW2j6JFpg3KdzHuatKM9hRUKUGwuB5oFs
jFJpLRo2Nyg4oLEAOFqHfxbYmZVPbxVHpN40OpbAhJfgj4rVng80iUkKSKynUestpFnPdCZRs458muFdR9Wtqkb27ANlyxc9xWSYgRbm5YngfF
L0+D1pwCOAcmtFJ6aWbM3GOwq56Js2ltpJwn/bwR+SakdZ2xeGAAkkksc+avunEkuNPWD+KqMHFbnqrpq2v9OngnJ4U8jxXmfWLRLLUZraNtwj
bGahUKFChQoUKFChQoUKFChQoUYBoqUGAQrtBz5+KDMWUA+K0PTkcc8LLtzIDxiu0/p4k1vAjSvuIGAD4FdLjb1Ix4pQI7EVyv8AUSD09ST0+A
w5+/NUEMIcPvB2Rjx8+K0nTpjSzuJEBDMh7cZNaTREEllEX4ZvmrlrUOgjIyoqk1ACO4f1Gwq8VndPU32rEy/QjYAroljaxwRjYoGRUmjAJOBR
7f8AdwKDEcYpOaFCjPiioUphhRmk0KMd6N+/FEF3A57VFj0+CKcyhAGNSc9yT2qq1jUVtrZ23KBjuxwBXBf1P6xj1Nk06yGEiJ3sGyGNc/xtVR
sIbuc+aki2a4CAgBh9TeKnwehZR4DDPk/NNyTtqEyRrwmea6F01KtnbJZhAFkIJfGCKidb3e3UVht/+16YGSK2nQcKywIiAFsCtvrYUaRK5Puw
TXlPqOcXOt3kqjAaQ8VW0eeKKhQoUpBlgMZpcqbQDjFNUKFChQoUKFChRgnaRRUKFanomW3F0I7nKqzYLCut9OSPZXeCweDGVY/FamPq+1ico0
kfH3qLd9dwodsCGRj/ALe1ZLWNTbU51lnTBBwq0zCYBvVmyWIxz/nirvS3EURj/hng/ml2GrmG7McknAbAHxXQbRvUgR++RWS6mnEJnJPLe1R8
mmenLQGRG2bW43DPmt0owoHwKOn4wFUE+abl3Zy1NM2O1GtLVcgk9hRUVCjAJOBS3wFA803QpakBSMc0mgCR2omJP3NYzrfqqLQICWb+oeMVwz
qjra/1glDIwiHYA1kCS7ZJyTVvZW4KKZPdjtmiu5HkkEUHAHxRw6cW5lYk/FXWl6VlspGSF5Y48V0C3hEq2MTR4VQCDjkiqX9QrWNNQLRsRtVR
g+c1pf05kZWjfdlVQGtlc3IvrCdVyCIiCD815h6ggNvq9xGwwQ5quPeioUYGaKhRgkHIpYlIXaQCPvSD3oqFChQoUKnWumz3Sn0lycZFD/Sr4E
j9u5x3wKRcabe2yhpraRARnJWouKKhQqXYXX7aTJHH2ronTPUUVxtikmkV1QhQMVPVEckmRs07vWOM+mOfk0wGmn9yg+w53fFM3Cl71ZUYgDvg
YFWaXzQ+iAx3E5/tTkEaz60pMgRH5JrruljZaLGTnaO9Zvq+1A1C2ZxmJiC2Kf0+FYXXZkA81pYpMoGPmnc57U4jZQg+PNMuzEfNITP8qdTG4Z
7U6SGG1eKaoUYGTinMbG45NE5GMHlqboUrOF/NFRVT9R6sNLtTIeOCRzXnPrjqGbV7+SSRyUB9orGsxY5NLgwJVLAEec1obdGYK3pn0z5Palx2
0cJYryzGtBYW8MEIYoGcjksM4NWltdpGrBlXeRtVVAB58mtH0/LCCss7DdGOBWU6/nWXVpJY2DRscDn7VpOhZRBZoC3BAGPvWu0dlFpPO/EZHm
vPfXbwydR3LwfQWNZ2hQpSDLY+aI8GioUKFChR4JoqFClKPvj81tugYRc3qoxzniu06bpNp6YVYUw3yO9J1bQbOVDG0KcjHauI9c9Ly6VePJBE
fSY54HArHUKNVLHCjJqdaaPqF4Cba2eQDuQO1aDTej+oopBcC1dSuCufNaW0XUA2y8tJYpM4LFeKs7O2EkwSVgufqzVhLbW7w+hbhlQHJJ8mq3
UrPbGGiBwveoSzJPPGFGCqYb/NSI9zXSbO+a7H06rDTIi+dxXnNNdQQfuIIiBko/NR4QFYMwwPvVj6ySQhVbkCm4ppE8nGalC4LL7WwaNJH2Ak
5ycU6uTyacFKBwM+fFJoUuJct+KJzljg0mhQoz3ovBqFquoW+l2Uk08iqAO7GuH9edXHUMw28h9Id2J71y68n9WQ4PAqNVro+nm4mDyxj0V+rc
cVrr22RJAPTdIkRTzwMY7VVXTFXiePaiSDlCMkc1obGN50iW3O9sjFTbm3jsJTujAlJGR4qz0mGSdGuWGyFeSfFYvqG4SfUp9n0hj/AJrQdLvK
LQc454JrT/qFrEfTnTAtoz/Wm4Azz+a4DcTPPK0khJZjTdChSg23t3+aTQoUKVgY80QwKNWA7gGgzk/YfApNChQq+6W1AWV9GWcqpPNeiOmLq3
lskcvk4zzVrGy3MjMRUHWtEtdSh2TRggiuSdWfpjPA7T6fllOTtA7Vl9F6E1nU71rcWsihe5Iqxveh7vQpBJdEjbzgjitF0TqdncFo40RZlOXj
8NjzXUNN1CNo/TmUKrdvtT9xbRAFZYhJGw74rO6npkMpD2wCtGOMD/zVMokXIdTuJ7Cpo015ITG5jUNkHLdqo59LTTzLIWV3PCBfNP6BZtNexm
Qd2Ga7BaoI4VAGABUW7G4sM8fFRsB4+2ccGjiRQ2AMGpDZEDZwRUbJ/FOwyuylSB7eQakxSMSATUoHmlgZQn4pNCnhhYs4xTNChRjvRVGv7oW0
BbI3eM1x39RdTluG2vIxXPbPFcj1W4d5duTgVX0Ks7bUJUQLkKOBkCti+oNqunCHcu/bxIMg5rL3m8XBRnJK9zmrPprVJrTUIY0c7Gbsa22r3V
pFILi/G7HZd2M1T3fWLzr6W0Q2n+1OM/YVB6d0qTV7hpmVvS3Z581tRpjwtFbRKBvIH4rMfrXepLq0cCtuKDkfFcyoUKMUbDBpNGpAYEjI+KNx
hjjGDzxSadjjMrrGvnzV/b9KXNzbtLCykKMkk1R3NlcWxxNEy/cimMHOKMxuDgqQfxSigBK/ypGD8UFOGBNXjXyW8CelBGVbB3Y5Brb9OdcIlo
sU2fU+fmug9Oa9FcyEb+SK0z3KIm5j4zTMd4bhtiRbj96kW0vpxliio2cg471metb+xvrdrCbYZWQnI8feuAQTzaNrayjIUSefIzXa9EvhdqjA
kqwBB+RWx0u4DAW8oyP4k0NY04iP17UYdecDzWcWaGdzkenL2YfNVmpalHZkqgLMe1V8Ra5YyyHLH/itj0hpalluJBnyBW3xleKizLgEMcDuKi
vAww0Z3A/FJOU9zsNy9h81JDLLbPsGWPioWdpw3cU9CMvtHmpsEOPc3en8UtWG0qTik0KddtyAAU2FJoqFH4onYKpJPA81zHqnqEyahKokxFEc
Lg96w+r3B1KXP1D5rC9Q24hufb281UU/+4xGqJGgx5IyTRIFJ3SNj7AVoen5Hdn2sfSjXIWod47PcSM3G4+KXYRSCZXjL7xyu0ZxTl7Je30wV1
leQcEHmrjp7pW5vZ0a7U+mPHgV0a1ittLhENsAWHwOBVhosElzeLK2Tg964h1vfDUNduJ1bchbANZ6hRrjPu7UZIH0jFJPPelIu9gP+aUwGcLn
FBQrHBBzjsPNWlnokk6h5XCKfFXcGlWsEe1BlvJq802P0dPuBIzLEyYX/wBxqnuLVZ1OJMEeDzVTPaFH3LFEzA53YqsmM+4+5gT35oreNWOxyE
J7s1NysqSbF5CnBOc5pIjhIOXYHwNtOesY4TEoXB7k8mjtMllwTXUuhYHTE0je3jAzXTYdlzGrSttA4xTkM8VpM6uwjUDDE+BWc6s6g2KVtnwu
ML+K5ml/MLyS4EhLnIBY5rPdSQOAkjA885roX6c3P7nTIdze+IhT+K6ZboUlQ+M960FqBPEynkjxVZfdNxTyh0XBJyaxHVOizLcSbU+k+BTWj2
M81pLtQZXkg963PTksYsVRSNyjBq8hfcO9KkQOpBqPHF6bHLlR80Et45yRuP8Aiigt/TdgDx4py4tI3wfOOajzW7LgpxikrczqdpXd8Yp57iVR
kRcY7Zohdbu4x96kRTI6cHmls6qMscUy97HHnDc1AN/JNNiLsPIqzhfeik98c0vtTE93FEOWFYzrLrGLT7GRYmBcjHBriN7r8t3MwYYBbOfmpt
nchLf3n3Oaotbxvd25z2qgo+9LRS7qo8nFbPR7SGEzxxHO0BWPycc1UyRiS7aNVzg4LVqtG0xoI/Wk2quPPmrS2sFupAY12nPcDFaeGxaC2WJG
IY9yKlRaZuAGD/8AuruwjSxiLOQqqO5ry/fOWY7gM1EoxRUKFSLaMyq6rjcOacs4fVYKfmtVb6LAtqJkjDEDmnRtwBjGPFAPgEIKu5IjLb2UUR
3qI8sfvnmmnsIYlyUqq1j0o4QkQ9xPNUEgB42io8sAcc8Gok0QjHb+9M/egi7z5qbBHJj2Rsfviup9AafdC0WW8DKpOVU+RW0lvf2cfqYBGeAa
y+payP3Ek92QYgOcHsazc2pRXsTzo8jKG2jeMVHtbRZZkA89xRdZ6dJFGgVBjbgZFTv0ycW2Y5QQsg4NdfsG3wjdzjirixyys0Z/qDsPkVNgmM
qZb8EVF1KwR1JYA5qhD20ImjCKJSNqjHGKjWcTwzbg23J7ZrTWje0ZNTAecGidN525wMUI02L2x8GjApX5FNT7im1MA0cUYUAt9VLIU/io95Gn
pEnsPioSzJCgkUMVzzThuIpVG41DubcvkmTYvxQtXhRfTTAz3NWRu4IEI3Z2jPFVOpa0qK2HAX81jNY6nX03EbliOOK5xrEd/fzGR0dlPuHHiq
1rFYoyXBD/AARUaC4ZpNjdxUTXJw7qi+O9VNKXvzVrpFkWU3TdlOEGO7VqWD6ZpplcKXPkeWPeqvQXR3YuAX35Oa18ZLKpl5PhR2FaPTbdlQSF
sMO647CriS4W3tzK3OBmszqP6hW9iWSJGlkx2HYVmdW621HUbR1f2BuNoPisVPp90QWdVA+5ANRGiEDc4c44+BTRhkJB296tLDp69vZESGJmLf
AqyuelFt4mDSMZ1OCAOKpLjTJ0kIgikkUdztoWwNssmR/UYYGPFO6dbO0ntJ5+K6N07YM2mSxlgzEcVBm0HUEO8QlhnxUaSzu4+GtnB/8AxrT6
PBsgihlTaypznvTWpQiIuzfSBkVh9QuPUlYgeeKrsEmksQDyahXEhlO1BmrHSenrm8ZWaNhGfJFa+DpzTrGBZLlfcDnJPBFXFlf6T7ooNPt9p+
xz/mtarxxWqOqemCowpPYVluqdSmuIjbWJBfbxg1z29F4luouXYBicJ5/NWlkrmxjhERBQc/c1aaSskFyjypkfFa+6httWtkjuVCEDAz5qVpfS
lpbODbgjjPetRpkJaSWIMBhcjNTLR2gnD+AeasbNtxkIIwzbgPinZgSCSSayOrW8q3wKqeTwcU/aabMzBpWq9tlEQAfv4FTO+DSwpGWoEk9zRU
KPH2pi5uYrZN0h/tUZtWtxjJPPapSyJMnf2sKj21vHuYHkNwRWZ1qQ2N17XbaDkimX11Jo8Kyk4x35pDahGiDac/JzVRrPUrRR+jCMA8M/gCsl
Pqk9+7RwyMI88nNR5r2K2GxVDMPmpSanbXMDS3p/qKAqIvH/APhVdqpj2bgoKjuM96zFxLAj7yqopyR7stVFPIZZWYmm6ct4zLMiAE7jjitVCE
eSC2tiQFYKqngnPzUnqucqY7OPhY1w3581F0C2KsH5xnmtnpKetMXfJUHAFX0cm64Cpu477R4pfUqTjSsRnYWHOa5hdWjJuYRs7Z7gVDe0v5Yi
6QMqDyRVtrGnohLL38VVRaRNNIPYcfcVdaV0/A86tdPiNe4A5Naq4v47VEh06NY1UYzt5/uaXDLarbJLJEHYj3HHmqm7kiywjt1KvxnHaq0aBA
xyWVQecbafi0aCLsxP4FWFvDJGNlqWU+MVOh1nUNP/AKN2p9M85Iqzg1RdQi2hj8bM0BJaplmO0iqLXr2OWJ0jI/NY0wsxykZdvxRw6Xd3b4WE
r+RirA9LRNF/WlZX+FFTNI6btrVt7J6h/wDdWgSa1s43My4AX2gds1lde1Nr50QuRGvfFQbG7jju4trlY8jdjuK195r2U/b+puUAAEdyKzsEt1
JMzyMqqv0FzgZ+1RNSv40nMIQXDtjfI/k/A+1Wum+o6ZKY3dgKs47a4jT1CQBTd7dSmE7XKlRmtx+neqHU7YRXDASpwPvV8rGDUsAE8kEDyKmX
B9NUYcA1Y2MkbAlM7jyeKlFjjtmm3hWcAMg3DscU3JH6UZ2DmqDULi9WTMQyPtVxpc0slsrzD3eam+ouO/FVmo6/Z2RKl97j+K1TwdTpNOHLNt
3cKK01vdpcRK6kYIqLqGqx2e1ScuxwBVPqd8l1xu5HgGqyKVi4HfHatXpYJiBzk4op3aIH0GIc9yRWU6jkaWFhJ9YHeudtNNbzGVWwEOCfzWmt
pluLDcpySvNZHXrqU7oPpTyfJqqjuzFFshGM9zSfrQtJuyfpph8MwCngdzTsqyzwvIxHpIOMtjJrHTszSsWOeaboVIsZhb3KTEZ2HOKt9JvTJq
8V0+xMSAgHj+1StXJku92c7znNXGmgJCi/5rc6NEJbFgiqFTnNS4tmn6fLdOAZZG2jJ5/tVJdX1xfbo3lO0n3Z7VHjcwDZE7YHb4pLlXQo4GD3
xTVzp0zupVPUU9j8Vb6T0/cXrogZY1JwT5FadOjra1t9sTs8jfUxFIfpCB14DhvnNOHQ9Ms4dk7rlfBNUl7Y6YVYxv8A2FZ+8ltbTn1Pb/4op9
Wso7DNqglkH1OG7fbFVKdTIOM+ewqbb65bzEet/bdzVtaXUeA8KROB/HaKj3ZW5cll9IZ+kGokun28n1Fh96dtbaKMBI1AHkmpjEW2QudxH1Hv
ikbPU49RVBHc5pqSaWJMCRSPtVXe30CnM7CT/wBucCstqV6plb00CqfAqNZzhZgwXJz2q8i9xVic571JnuIo0wyr+KiQW5mzcSrt5GwfNXEUkk
SAAjPilNqUwJDMSB4oizzxSPKfTQipXR2sx298sFtuLx/yHmus2EMrqlzNuWR+QM/NSplWS4it8k7Rlqt7eIRL7RinaME0xcOm0qTWQu+oY7Ke
SBkLMDwagf8AU1/tPpIoUHu3AqJe9YE/05rtFPYiLJP+arXuGuovbLnnvjn/ADUvR7M/uMSds9zWrl9WwMXpyjaw+nPepFzBHNb+pjdJ5zWQvP
VW5zEGG3vS11KL03APvXvWq6Lv/wB3ZuxblW24q4u09+QOCKxHW0y2cAcnl+BXMrufKs24+5sY8VfdOSvHZyO59qjOKzeuXRuLguTktzSLWNVt
HfcfVb24x9K+TUC9u44SsYOB2zUJJxcXKQq22NmAJNHKsZjljY4P8G5qiniMT4JBz5FNUKdUL6LHPuyKVagtMgXvmr68P9VE8ACrrSFM6xJu5Y
963MONMgjIIcEgEHzUTVrxrllVBhQMhR2qLAoCYcHk96f9JR35omiiZeQR96n6FazTzqlx9A5NbCy0+K0l9XDL8Y7CrWS7lCBYwv5qtuJ75M4I
OazV9YXsjtK7k5+az93Zai7GNDtB+1Vc3Sd7cAtcTkJ5pFrpWmaezqqvLKwxuZuBUhbSxY4e2j/sMGkXfTtuw2hiuRkYqkjttS0+9K2jsyferm
3u70sEliDH5xU9nQH38v8AHxRjkZAABpzIxwuT96YnuUtoy87qoH3quXqLS590Lna2eH+aReafDc2263ZWY9j4qil6fnYtukQYGfPNO2+iegsM
oZMkkH3ea02i9PSXzKqKwBOC5XirjVOlbOyiH7iZYQvPuwWasLftDHcMsMq7Y+AO2RUN79whIlAUccHJqadVszAkrEKVADA9yfmqPUeoJZy8cW
RGeAa1X6bWrmX12DFmYHkd677CxFsJXGNi5FRtDzc3ks78nk5q9oUUhKxMyjJHis3f35AZwpDjtWJvGk/cmW6Jyx+rHimdagupbSFbW4DwK2Sm
Mf5rMXlvKZMQx7QMdvn5ra9MWKRWXqTgFvvT8knplin9qr5dUltJPXuJSyL4NOxfqBDDCSNvJwec1Sa51xayg/tgFJ7k1noNdVnJeX6jzXQ/09
1SILKitgswK10aC5SY7CPdXLf1gvorS4gj3e7GcfFcnF7M95DGx9rncBmtGl40CSWynIdeftTVhaLdTO877UQbmbGcUxq7pahzE+8Bc5/8Vj5L
lpZCSSeeAan2KbSsr54OQPk07MxKkgZqvntn2mSUMoAyDjvUGhTypm2eT4YCl2L7LhD96uNUbY6uD3Gad0nUTFjJxtPFbnRddS+Q2s4Uk4Kmrh
reB5W2nsKTNArW21SMjkEVUx3W2TY/c1OaMyR+w4ahpGqX8FxIIQJEx7lbnNb/AEDVbfUIMZKuPqjbxVykET8IRn4pf7MkZ2A4oxpAlAMv0nxU
TUNFsQQpTLfINUOt6Ui2TrbsU4rn0FuZrpomAyDyxHapl9or221luEfcMjFRDFcoAu8EZ4XPP+KOYS2szI4XIHfFJlkkljwihT8/NREglLDc3+
KlpEVHuJNV+r6m9rCfQUA/JrDanqk905Espb7eKrSWAzzVlp+s3VmMRye3/a1WkPVOSBMg/IrQ6Nq2lAiV4HuLnuq49oqyueorm9ljjur6Oxt1
OBGnGB/andX1Tp6KENLqBuWAwFLZNc+1rWbS6ytvAMZ4PaqJpWPY4pGcn3E0qMFpFVRkk4Ar0L+luiCHTlluYisuBjcK2etzrFaekh9zcY+1K6
agK25lP8quqFKUAg5OKg3WnQzksVGT3rPano6tA0fpj7H4rNS6bewodjlogfpPY1C/bvhm9MNjxjtV/pGj3M0PvfYp52iqzU43trh4mzx2PzWN
6yu8WywRMSx74rAyiXO3JA880iVFVRljmmoJz6gUD+9dV6Pv1hktreNASsYdj5ya6bpF7lJ7l/aI181wDrHXJNZ6huJ7l8orEKPGB4qr0iKW8v
v3DH2pz+BV1azK0kjMRuJIqzhmgt4wvqAicANnsOc1m9ZvRh8AHcew7YrPR8uKsrqYQqojIyQPNHZaqbcOjRI6MQee4qPql5+6lUqNqKoAFQaF
OwZbcnOCCf8AFIjzvXHzV9qynbGnnZVUGMZxmp9peSR4KEhh2Iq5tNbvIYn3TZYjvWj0HVHuLRi8g3DwaDTx3c2UXbIp/wA1YLK6x4ZSr4o7L1
7aKS7MeYycZqLDqF4sjT2kTohblweK2PSmvK16sd1NK0rDjJ4rdPqcKL/3M/amG15Eydw/uahPrFty8kqisx1RryvGIrRs57sDVHoETyTSvIoa
MDcw+aTr97PagSTW/pxrwp3ZxVLHqsl3G91GEAiOS7r5p03S3CJJkFW5Zs92qQjoi5YgDFRrjU4Iv5CoN31Bbxxn3qeKxmsau147BWOPFVce0Z
d+fgfNEzgj6cUij4FSYb6aIAIxGPI4NMyzPK5Z3Y5+TSM570VChV/0Zp5v9ah9uURgTmvTdkFsdNjxguEFMw6fLdN6k2fd81fW0KwQrGoxinSO
cUeMUCDtz4oqZmgEo74qNLYp6e0KPvVTPpkSn2IAc98Va6PAiE+oNxx3NZDrFo3lJQYw2a5f1HIEnaIgZPIrNTRB2zJ2+BVdqMsY9sY5qJZnE6
5+a6v0fY51CS5QlgEAXH4rUdbar/onSLxo22e44GO/NcDky+WYnLnvmrbSZP20PtYYbzUi8H7SATxyoyueVHcVSresZCWJOc+aYuJmkYgnj800
hAOaDOWOTRZo15Iycc96VcOHlJHbtTdSoEX0mkzggEfnNJs4mluEVRzkVodUgy27/aOapmhDPuqVHHtQMePwKi/uW9ZizZBOam2t/JA2+MlVzz
963XT15ZSIHwFc/wAj81oNQWGaEyRhd6sFLDzxVJqOpvHCLGNwYkOT9zVTPq9yY0t0YKgOdqjua0mkXx027tpLwBoCAu9lwea1V7rGjMvqJdA5
+DVY+taaTlWdvgZqDe38Uo3KFA+5qnu722jUtNKoHwvNMRdYRWeP2kRkYeMd/wA1C1jXf9bKG5iEez+JPBqlllFtBJBHPlGOSobgVDOvzwxGGM
gKPI5pv/W3xl3LfbNRrvVmmXCrt/vVczvIfcSaLgHtmk0KFChQoUKFCumfovZpdanKzDJjIOK7ZLh50U+1DV5CAsYC9sUuhKDg7DgihE7BfcM/
mlFiftSaFCk7F/2im5tsSFlX/FZLqyyLWjTheCPiuIdUz7NUlO7OO32qDp11CxlEiB2AOFPY1QX5RrlzGu1Se3xTcLbXBrp36eax7lRjg7cEU7
+p9y15HbRrySTgCuY3W9X2vwV9uPin4pcW6pngHJo7q6ElvjJzngVXUKFChTojJgL8Yz801Rjk1OlT0bRUC+48kmrvprTlwtxIMn+NWGsW42e3
jPeqi3si5y3AFJ1G4iSEW8KgyE+5sVWCEry/H2qQqPs3CMlaWLuS228FQT2zXS+n4Jl0wEyMRMMgN/HPmoUXSeu3pDrZtGjtjc3GP7Vtulv09F
k4mvisrnHcdqveoOlrS+tSjRDjyviuW63oL2E7LAJCg8EVRu9zDn2Nj5xUV57yZwkUchJqSnTmpXYB2SOTyFAzVvYdFah6JaTbCD4Pc03qPR9x
Am4SFvn2nisvqGjSRbt7sMfAqgubdoNpZgd3gUzg8fegRgkUoZ29vxRN3pNChQoUKMAnsKeitJ5v+3GzfgUo2F0G2mBwfuKZdGjJVxg10T9JL8
2Fy7qBy3u+4rt9lcRXkIcYwTz9qurR1KbM5K0/SgN3GcUGABx3oqKhQoBsGl5GeRzVV1EDPYupGFANeYusYpIdZmU5NZ+ObZJnJHzRXkqzTFkz
jAHNMr9QrWdHyJFd+1ycLk/mrLq29VYRIXzIuQg+5rBMzOxLHJNPrkQhGyCTk8+KblGAoz3GcfFNUKFChSmcsAOwHYUmpNkhaQtjIRSean28D3
bBOyjlmNadXSztkSLHaozyvICznIphp19BsHBqh9QCZ2HPPBNP2kZnm3v9I+fNSNSuhBH6cQAOO9WXRvSlzq86Xl3lbZfd7v5YrY6jelWFrahm
bthRzXcVjRBgKKXxSCqsMHzVB1DoqXkR2qAfsKz0PRccwwUwT/IipNv0FHDcBmYFceBitNbaPbwxhQi8D4qSLCEAD00x+KrtYsVMLCOANkc1xv
rJLhJXSO19M9s4zXOZ9PvWctLE3f4qHMro+HXb9qapQJPHiiIwfmioUKFGAScAZNOm1mAB2H8ean6fpk8+0RxszHwBW/0jRY3t0SIDcoGSB3NX
cWjR+ntnjAx9qxvWGlQyTRpYwAMTyQKuuhulNSCpIF2RucZrrdrajT7JU7hfqIqRYzs0pZf5H/Aq8XO0Z70dHnzxStwyDjFEzFjk0miJFET3pP
rKq5Y01MI7qJo8gg+K4X+rOjW9tdvPGdkg7jPeuTuQTmk0tE3c9gPNafp9P29s0p+o9s1WdQ3ZmnEW/dt5b4BqutIWmmVFGTVhqcMcJG8/1iPd
iqokk5NFQoUKFGBmn7SFZ5lUk8nkCp8y+huiVRknH9qt9NtBHbhpCQG547mlXky924HwKrpbxsYXOPAqST+6sIIFVlYElz81Bmgj/cCIe0LyxN
MzXaxHZASfFafpHoXUdfnjubpTHbAgkN3YV0TUllRU0bQ7ZhsG1mUd/wC9aTorpEaarXV+Fkun5z32/atkRn81HacpJtcEDxUlGVlJ7/FGBxzz
QAwMDtQoUCcUzNlh7cf3qk1TTLW4Be4hTd/uxWO6j0O2a0c2qIXH2rjfUGnukrewh1PIxWfIKnBGDRUKMAk4AyadEGF3OccdqENvJMcRjJqbba
RJKpL7h8YXvWm6M6Se/wBVCyDEfYFq6j/0FoyYV/6koHO41Q6v0qunSetYlkRPAPap2gtbRlY8Hd5/Na6WCGWIMqg5HJFVP/TsF7JI4AQqM5Na
PTLIWVokMeBjyacvkeCykLt35qN01N+5uJOeEOMVpxVZqN2YmIzgVDg1hQdrtn71YR3ob6SDT6XSN34paTK5wrA0xLeRI2C3OacN1GFDZGD8VQ
6vqQjjcxuA/gVDsdQuFT1pJVxjKqTya45+rGozXupAOxO34Nc/CMTgDmr3SOl72/j9QoEj/wBzVLbp0wSYlkjAH3pjVrw2KJBbsN2O9UUMT3Mo
VeWY1fWUEGmL6kxy+Kp9VuheXskyjCseBUOhQoUKFKXOOKsdMVbcmSQ4dhhR8fenY19a8VMnk+a0lyFijA7YGKo7tycljwKf0+1iltnuJHKy5w
ihc0pfUdlhgR9zecUxJpF3PdRRRghpDtz9vmuidNfpvbQtHNN/Xc84PYGt9d3dvo8AsbJRJdOoBx/GpHTsXpQPJNxM5yxNaeBlZPaQfxTioT2o
pIldRuAyPNBVCjijoUKUMY5FFmiOD3A/xTUkUZQhlBHmslrklnDcLHCBuPDYPFcr6ui/+rNuQBSP81z7WLcx3zKi8N2pgWNwSwEZJXGR+aV/p1
x6kaFCGfsKlNbxWkJPpu8ynkkcCm44JL+5VUUqnxWr0rTI7VsbQTjnitBp1hC9yiTEgMeABW2gtYNKHqRgBhwAPJq903T5p4BO7Dc3OKcuLATZ
hlHJHBNVUOhQ29yzTLtHwKk3M8FvE20gACmtMluG/qlSsZ4X71d2sck0m9hgVK1C1/dWskQOCRgH4rIIL3Q7kvbRF955wc1pNI19bt/TuIWik+
DU+7tkuFORx4rN3ugzqxkt3PftS7GeSACO5Qqfmre3ZGIJbinwNpbYMZGDmok8OVNVEl4sDMjN28VlL+6Z5HfOck1T32sTxKkikgL7cntWZ1ie
PUWJuIQWPZgarIILK1cPMg/Gad1HqR1iEFp7E+1VUd6wZ5rhwzBSVUngmqmaV55GkkOWJyat9BgwGmP4FN6xcZ9uVOfGeRVRRgE9qI8UKFChSl
OGBzVkiLvkkRiQAAP71J0XEmqDPZau9TkREZmPA7Vm5GeU+qwIjJwo+astOF0yAKzBCcgeDWo0jT5B7vqkbu1a7S9DiUqSC0rd2+K1l3KdE0nM
MZlkA4wPNO9Nad+4gF5dIfVk5JI5q7ls4mKL2VfAqRawJbR7Is478mpgG1GyeaaoUYHGaWg5ycDFJc5OcYpNKYYA+TSaBGRg1zzrnTJ7SQ3ls5
2Hkj4rn+p3Qv0V2GXTvUe3sLOaxluJoUadDiPdVe8cMhkeRJHdOWUHxUe1gnv7j90FEUUY2hicAVd3ttA9u8UqBpDgjauN35pyw0uFV3tGEc+B
4qXHYokgYHJqZbI5ullPGzkkil3mtC51OGFpSmW/iMiutaMvpafEMhgR3+amvHHKO1Vmr2m6MMS3HkCq+Kwttp9X3/GKsI/2wChioA7L2AqamN
oKY2/aidmY4UUkouAZFGfjFIlsIJv6iAK/k0uESxDY4LAdiOaX6i45pqSKKZNyqG+QRVfdSQWETOpG442q3YU0NRYweo8kZH+0HtT0N5DLDu3D
B+9ZnqeJV/rQvz9qxz3JlLoTzVH1RdT2tmls6oVA3k+TmscNRIJzkj89qQ0nrZbdior7QeDn70tVj9B2YjdkACmYYvVlAVSRnmr8yLBYlIwAcY
H3NUNxbzxFWmQrvGRnyKaKFc7uDS4pfTBwAc02xLHJoqFChRkYOKtduy3V9ykFc+3/AOaf6bKi5eR/A4pzXrkOyojceahRSNc+lBJJtiQEitHo
ET394kUSlo1wOPiulWdhFAgLAAAVqenbT1m3lfb+KvrjT1uZQJOIUP04+qpRXC7YgBjtSUhf+b5yc8U8BjtS2B8+KTSgB/KiJOeKHehnjFCjc5
OPjik0KouqYP3Foy8HAJx81xuTT5kgmu8BYy5UCnbW32WsgbvwcVVR2k0+ozPEDtEbKcfinLaLei2wwI4+cr/I1YbQBluTS1cgY8k088kaIY1U
s/YuTxUmdmj01TAcsRkk/aq3pKzOq6yJmG4KwwK7vYxCK2SMeBTpUjkUmUFlINUl7bzZIUjB7AVl9VvHtZNvvDD5Herzp3VJLiNFkyAeORWmSI
H3ChJHntQRcDg0sUUkaupFQ2jkt/cTuUnmot5bw3kRDAEVhOoraWwOYmb0T9+xrOxaxdw7lLMyrz38U/JrD3a7QGbjkfFUjEpIJBIG9x9vmq/q
EG+gZ2f3YwB9hWKmiMTjPalmJhE0pYBfAz3pgOxPtFSIbeaYbVQn+3atbpGizLaD0oQz/wAiewp2fShZuJrs5fGVUCl2GnW+p7mu8kBdq58fFZ
rqbTjYTLgYU1RmioUKFOKoVd7f2FL9GRyrtgbj5qXPICr4ACgbRjzSbGUwq7A9xTTM0z5Y5JpQRjIqRjljtGK6v0lpg0yyT25lcZatlpukXWoy
AscRjkgVuLC0W0gWJAM+TUh8lsDtRihSzGQoNAZfv/mgOGOP7UTccZpNLiGc89qSzAnA8UQPNG31GjC5XPn4oMAMYql11giZDYesZeQxS2k0bo
DsJcADjP4qks4cxSF1wWHH4qs2taltrlN/BIqPbD05GRvq+fmpMybo/UU4I7il2MTOwZ8BADyfJpPpkybVORmpOoxMliIkbk9znkVL/SmIRanJ
G38TXZCmFDCizmgy5FNSRYcbh/eoM2jwzSkyorDwSOaOGzjsiAFGz8dqskK7QVOQaOipQXjNAECiO0jBFRLi2AJeHP3X5rLdTWLzRZjQuh+oAd
q5pqVm9tcOhGQ6nbnjFUB35YJJsyeRmgQ4X5z5BqNIJDlVds/B5qKummSTM6lwf9ppH+hO7kRsVHxnNaHTejHlRGkCjAyMjvWmtujY441Zt2Ps
MVbJp6QwiGL2r5rJ9WD9vLsL7iF7Z7VB0hWMLlGKlu1ROpbV7qyVSv8AUUf/ANqxEkEkYyykCmqFCjU4PbNOwmL1R6oYp5qTLudtyZAbhR/7aY
nIDBAeAOfzSkB2gHgGpawiO2MhGWI/wKl9MWv73qC3jHKg5rt9lY/+o24+kYrc6LAILQAdz3qdxu+4o6FLKFeT2oixPmlp2J8DtTZOTmioUWSp
yDg0yobfyKeFK4xTijI58UTAAZ4wap9ZtllQNnDHzXPte1BLW6NtbsASMO57Cq43scZKbgxQY9vYisnruqj1SUfsfntSNO1Rbh4w5ww4zWhmKp
FwfqqTIgVU9PO0oMD7+amWlhtT1D3qNqEahmO7IAwM0r9OXki6glG32E5JrtO4NEKRR54A+9PyHAyRTBYnvSHUMMHsajCMxMdhOPikCSRG97Hm
pCOSM7gaeBIpTLgZHak0KbkiDDjAOc9qz2s9M2t+GMke0nuVrnWs9CXdl6ktt/WiHOB3xWWeExN7gQexBpJXY25Tg0Sxs/8A2h7vtW16a0dYrf
dcRBppOSx52ithp1gigewZPnFSbqFI1IbgjxVFO8aSEscIO5rl2v3ZvtSncEkF8DPxVholtI/IVtiAbiBxTevTieR+cIo2r+KzmsWsZtY1XC58
mssRgkfFFQoU5EwQFuCfg0pp5G8/4pA5bk1YxemI13c4qWIv3NjPKrFdmO3xVn+mnptrw9Q8nya7lproLl2PANaXT5QcIDkYqY2cZFGDkUqlOS
QDng+KSOaU3tyopFChQIzSSMdqUgLUpgBwOaM5202xwKwvW2o3ltZO6sFbJC/iuaXeozi1kkmVT6mAXYZOftVRdXUqKQpwzjLfYfArO3ly0kkl
vE+EJyARyaf04yK4yjDA+K2ml3bXcaKoDsCMCr3Ss3F2iSnAB7mr+8u4YIDHEAingt5NYjV9Reecw2py3bPxW6/TnSPSjM0q+4+TXR1IVNopNK
AyuR4oOecDtSaDuuOeBRbRJ2OaZkiwpyM1WXd5HbIeMYqLZ6+k0hQP2OKuobtv5kFT2NSVYMMg0dGBkH7UVRriBSCQO/cVzLr7poxE3ltGcH6g
BXP1znBq+0DT2DmaYqqrgqG/kDXRdHhUwDdgk8k1bxSpbuGwDjsKrtVdpQXB+5rJdQvKdMlER2le/wBxXPSipKu/nkEitfp1/FJa3KWcZiRIuS
fNZXVElkb2DjzVVrDZtkRsZUc1nGhDt7MjPzRmzlydoDAeaYaNlJBHak1Jig9ZXMRPGODUcggkHuKFOLKQAD2qwS+ZNNe3jwN7e445x8UxpF8+
nX0c8ZwVNd10bV0vtPiuY2BLL7sfNX2j6mwukTOc8YzWzgcSxKw8ilHijXk80ZOaAODRUKPHGaKjUZNGSpGNtDdxgDFJpakFh+KRIuQcc1keuL
D93pLlV98ZzXLOoIf/AEtvGE2hRz9zWWuHeOFZR9ZY5P2rPXGWuN3nNWdv6zJgzGMD3DPk1qek45fXJUFUJ4PxWs0FVGqqkn0k4NVvWV1LDKIo
sjPAqu0S3YsGCkuT3Ndk6TjlSzT1BgeK0VCjycYoqYvLhbW3eV+yisVqPUEgkyWznsuajwdTXUUe1RyDwc1J0/q9o5tl0TgnzWjIt9VgMsBDZH
IFZK8s2sbmcYJBG5cHFXehatZm19O4lIkx3PzV3BNwHQgr/wCang5GaFCkSqzKQpqJeQLdWTQSrkHjJ8VyfqHpVrO/RoVOxm9y4/8AFV0Vtc3e
olXLRLGdu0dsCugdPoxGzwOK0j6dmIYPv+9R5NPYQ7Y03SMMHPYVntb6bv7iExW8a4kADMW7Vgtb6Wk0aTdMSzEcfamrBlXSZAh97v7x9h2qrm
MjMQqEn5qk1SwkDl2cknuKq1QLlaWjHIUjilMqJuXaMP3pueAmGaT0QUTG1sYGKg20ixhj7g+OCDxTD8NnOT5ou5oU4XZ4sZ4XxTZrV9H9RNpw
a2lb+kxyPtXU+mpDdahbsjD3e4CuqWUXpQKpPYU63Jods0VClJ5HiiI+KJCexpRHmgvfmhhfBpNHQPfigOKj3lus0TAj6hiuR9Q2wa4ngI5XJU
nz81jbq2iexaHGJg+V+4rPWtkJp2eT2pH9X3+1TBC7lxtwfA+BW06ADO8wkA/xW1FlblllSPa47n5qu6i0dbuOO5QYI4PFI0TRi5DK3APx3roW
nqYolTb2HirJCe9K5PeipLOAao+pnmfTGNuNw3YIFcnvr947wiQHCt5PirGOeO4VTFIAT4o7iAPES5ww7Gp3R/UP+n3PoTHKMcZroOoafBqFr6
mzcGGQaxusWa2AaaEYA71oelpzc6ersefir63mLMyPjI7VIoU8ECgMf70xKAz5Hb4qDqWnRXsW11G4djVH/wBKHllxknvVxpmkx2UYydz/ADVm
owOaFGOeDVXrWkwajbMkkalscHFcr1zp9tJlZ41PpH6hVYIowmQOPmq3UYBITkd6x+o28ttMykHb4NMRFipz3qXARKwWTgjzU2+WMRrCo9hHPN
Zy8iEbkCo1CjFGnLAZxmiPBoKSrAjuK6t+lt5d3GqxkqXCJgE9hXfYCWhUnvinAR5FAnJJoqFKT6hR7iOKbPDcUsn/AJFHsK4J7UTd6TSlXIJ+
KTQoEZU1zTquJf3oCgb2asVq1iUdDyrBs1VLbq10YwOR7nz5NSTbKrF2GK1XR9i0MDTMMbzxWlvboWsIdhwtQ4dTF4gjZdgzx8GrnSE9MFgBjx
xWitidu6pkZygbwaWjAlR96TI21STUNHW4SVg3YYUfesv1Pd3GmWMgkmCg8Kvya471RfSLMtwDuyeaZ0bXAsi88nsDVnf61Lce3O1R4Hmk6bLL
LOjqPapzXYenNWmnjjViWUpjHxipmt2MdzaScDOOaq9CmWzZIycKOGrTyLnEsZ7VKjbegYeacQZbGcUqRm7HtTdGPvRUKPPGKKjXvQxkGqzUbW
0lQpcMuO/uGax2o9OWUoZUdMk5BU9qz2q9OmNcwksB/eszqOlzemQ8fHyVrJ3sBgdgBVXDdlJcP81Z/uVcBc5OKr9RibO/xVfQoUY70bkFuBik
iu7fpM1g2lwKNouc+7HeuwRf9v8AtR0KFHjjNGrbTmiY5OaIjIzQHalBiPNETnvRUpTgN+KTQpEz+nEW/sK5/wBU2pkkMycspzxWQ1SZZiGOd6
jtUUQqZhKF+pc09Dp8l0BICuD/ABzzWztI1treJOPaoqp6o1FWhS2H15ycUNLjyqNj71sdKmjZQmAD5q8tgOw7VNdcKqjtikIhViTRTcxkVQSO
1lcNvOFY+0/FUPVsUmpQtuX3qOT81xzqBJYInikBxu81muY3BQ+fFT4ryQMEKMTmuldHaJ61utxdsw3fREOP7mumabbJaxrsQDipMkpMb57YrJ
rIRdyjPGeBV/pGroqGGd+3bJq3iuDjdC6sh8ZqXb3IYjcMMPBp+Zs4CmkClHxRUYBPih9qBGO9DOD3qLqF/FZ27PICfsKwvUPU8Ei7I2JmB/HF
UEnUMErZj3QtjlSfNMS6xdcNC4ZfKmoN1q6ySBJwUJ+exrI6vF/WdlHGeBWbvLf37l7nuKejH9Mf7gKe2tdRMqjLAVTMCrEHuKKhRr37ZoEknJ
70tIZH+lCf7V0/9JdPuzcSTh9qxgcGvQVtkQKGPO0ZpfFDIHigR5HalA+ztSKV3H3FEDRnGMCk0KWY/aDn+1JHY0VCmrpd0B+1YzqRv22GYe1/
5VzzUMPJKy+aft2CxgP/AGpcQNu8b5wHyR+M1or6do7e2lVgRJ8eKz2qKJ5A+eVPNW+mSIxjXOB81btI0F0uwkZq/wBNvJTIoc5U1oFlDeewpe
S3JqHdz7OAeajlIr+Ewy4DHsarnsTFIYmy4HGTWd6h6Rtb5WYR8tXI+oOlbnSb0EIzRZ4IFX3TlpaQyxT3kSsc8g10nRBC7blxtPbFXU1wI1JB
7eKr5tSGxhnBPYVkNTv5IJXdBkn4qrj1e5nlwAQa02i625gMZfBB7GtVpd+Z1w7e8cg1dQO0hyalAgUBKjkjIBFKot3PejoqBqn6hdYbUuIyzf
ArC3Npb32XkgCufJGDVVc6Qok3sVb7PVZPYT24MkThufoHxVXqcD3EfqKDuXuKixIuoQlGYLPGPPmqC8h9GUrIuDUbO4gKuT9qetVWMv6ytgqc
Y8Gqm8jKS58NyKYoUtQQQQcHxWr6d6b/ANVRZrpvTiB44wWromm9CWJgRYwzBuM/Fb3p7pa10m1WC3Ugk7nb5NX91dRWkO52AxwKgHXYBEXLAE
eKhv1TbuhCcGrDRdWS/UoGG4dxVrk4xQI4BoZxRUKFClnBC4btQbcBg9qRQoEZGDWb6jiikf0ZUxG44OOxrH6j04NjGJsAjiqb/Tp44S7D2qcU
28bzemowGTIqTOzLbxxNKodRuGT3+1VzzEuS3an9IusSMgbIJytXVzfMyoH4K+aat9bubecbG3AeDW00HXBdkCQYfyK0+8bNw7Yqkup43c4J5q
vlnkt2zk48Uk6rK6F8+1eCzeKft9Uhnm9IHOR9Xyahazp0NxGQ6hlNYi+0OeCb+gGZWPAx2q10zUBbOtv2cD/mrQah6gOW581XajOvpFs8jtis
B1Jq80DHa3c8EGqKTX5YnVNozt9zA8mrrT9ca4CYcgr4zWy0TXD6iK8gH3rodlqsMUWyVxnOc/IqS+pI6H02B++apNT1h4V/9Mw3jyazt9+o99
aQtE1vulBwXA4ArY9H6s+rWK3ErDLeK0lHTc8yRIWYgVmNW1VGYjIIHYVQy3iSOP6eG+RS/wBs90jCJFZsZweKrbHp+6MjyzM8bqcp5FRH0C5E
0rMwZWyc/esR1DYyWU5eIlW8YqjuJzdAK6neKZt4JDPlEYBT7iPFai00r9/E7pE52ofceOcVnrvQbmQewoXHGN1Rl6fv2JURo2B23AUxbaJd3E
3phNh8lqt9L6YupblUZOScbj2NdP0zQYLS3jSeQuQOQOADWx0KfTLCPZ6iAnwzU11N1zZaTFthYSSHsq1hLzr+5vHG6IBc9iaqbnXrm5Zz6xQE
4CioUGoXNu3/AHSRnsTWl6W6hmt9UjIJ93B5rs1tMJ4UbyRzSP31sUDLMjA8jBqhvuqba1uPTmmC58AZqbpOs299JiCYODV1g9wOKKizQ3UYbj
B7UKFCoepW8U0eZY9+O32rKzGTT4n9ZFlO/hSey/eqPqS/gj0vcEVMsWBH4rnMPVDOzqo5zg0h9Zk9dRI27afaTT1xqayn+mQN4yBUrTZZI9jy
ArzwT5q9muklQZkUnHeoyZY7kbgeavenbkrehiTgHFdR08rNbAkg58VBu9M9zNEee+2orWj+huI3p2I8rUGSyEMcnrHEbrlR8mqfYY23R+Kan1
2S1UB1Ljyas7TVbTVNNeGJR6mcuPJFUc9msQaRdo2E96yOq9RmyudiEGji1Zr6FcH6jjFVPVUNnZvsZWkcAE+7jNYuZjK7Mx5NC1uGgfgkVqtL
1ETKq5Icea1lr1I8CBbmPeoXAPmpH/V0EcYEBkYke5Txg1S6jrdzcKZHcqufaoqFba1JO5F3EJEIwf8A91oNAvbmDENtf+jb/B4Yfat9puryoU
X9z6qEe1i2c1anWXk9isN1Q9Rurhkw8keCO4asjq1xKs0SI2SxyMc5PxUGyu7uS4YCMqgbkHxW10NwwJIBJGOa1cFujQLuUZxVBrFt6E4GMI/G
axPU2jCVSsg//FxWL/0iS2WZVlVR/NvOKjWtjDby7xK0pHO1fNXR1eQxNbBorYbeQo9xFV7tbKjMkDuv8nLdqiM8btvhViFORzninrRibgTwhk
lzu3YytXSSTySh7i4jh2qcFRjJqTLc3Jj9M6jH6K85H1E1TXmuW8ZZG9SQnuxbH/AqJa6vatcZECkgZy7E1EuNVsbm4xtCEn+NOSJGgDRsTnmk
nYy5Zj+BV3p13ZxvbiONi8fLSeT/AGrq2gdS2hjSNpQcD8GuNaV1a9o6P60jOMjBfjHxT0uvtcTlzGcHud2a33QMUzzCZNxUjPat/Jqn7eZY34
B71NguEnztINLIxxTM0kSShQxzTqsD2pYFChUe5mhVQkjD39qzmuWj+kzRMW3Ljn4rjvX920Sm3jkKKo9wPzWBgm9Fw2cjPNTpbpZiCO9IWeSK
YOqb8jAz4rVtq4ubKOC4VvVT4/j9qYEb7gXdo1+WqXa3UgYIpYqDgmt50xDHEiTyMFJBKgjJJ+a0un6lPAfecg1pYbhZ4lkHkc03dTlU2R7SfI
rOatq+yNo5QvHAGO1VdvcpMuFxVH1IZEgk2R4wO/zWY6d1N4b9T6jIQecfFa/V763WMvv/AKbggmuN67eRy38npNuUNwaOx1WSCPYD+Ksbyb95
pqzSkeoWKnnk/es63skINFKBjIFS7CaSKRfipupazM0/pkYCDbikWdyzsGd/7Zqwu9Qg2gyEgDwKqptYO7Fsm0fc0dprN4kg3EuvlQau7TXLhU
y/rKo7bTV1pWqXNw/9Bp/yWq0k1O9iBSWRsH5NMLeyidJAfcPcD96vtJm9VvcBzgkj5NbPRUjDoTzlsVqlIxxTV5aJdwlJBwex+Ko5en3GfWk3
xY4XFYXqvRoFSUJCq8bixfaawlnCY43uGBKqe2cZFU93dbHkuZRtZvoQVQT3c80hLu3PgGnLXUp7VSqMdp8Gn11u5Vsjt8VKbqe5cDcuSBgHNI
/6inYEOufwagTX7SsWKD+5pp7mRjnIHGOBTOT80tJ5UzskYZ44NOG9uSADM/H3py31K6glDrK3+a1Fj1EZrdlMpSYDhvNY1WwcnmptleyQuoY+
09q7r+jmtpdCSzkxvxla1fVsLwMZhkIFzkDtVD0/rNxB/VmcmFjw1a+y6hspv6ckiqx7E1H1Sb1HzA4DfnvSdL1YSH0pva6nHPmr2OUEZzRSXV
vGQJJkUntk1C1u7jg06SUNnaMjFYOXX7qWJQCAVOQRV5aa961oGmRW492PFZnqXTNA14lJ5hHK3bkAg1yPqvpltBucRzCaA9iO4qutoRMm+Nhk
eKk24/8AUoCM89qvNNs8XMj3PuYsckdjV3Lai5iEbHCD6ftTFpCsHBXdg+a0FjqGcDecgYwTV9bXhmQLGctWm0mZ0tish5pOo3YjyQfcBWKvpZ
Lm6Z5X4PAFQIbt7O59PceP/FSL++a5iZFOapbfSmM4mj9jAhmx8Zqr6h1X1JZYw3tViMVirmFTzG4fIywxyKibWA3DO35qysbmWeBrUhSD7gT3
GKhXO5XKsDSQwYYNTbaeMYEg7UnU1jZ/ViPtY5FQ/UYcA4omkLDk5pujGe4PanFuJVIxI3H3q007Xp7VhuOVrRwa9HqERiPLY455o9M1gKrW9y
qbgxx/urcaFdQ3UatGRuGMj8VrWdrHT1mUKZC+7APOKdtusLccSI27zgGpEXW1pn3QTKvztprUutoPRK2EEksh8lcCsBq88lyzz6pNulPKRZ9o
rHavqYXKXEqKvhErK6lfLP7YiceSR/4qCoZ2CrySeK0lp0XqNxAJ22ohGeTzVVqWmNYsVZ95HfAqvwaKhR96BGKKhQowxX6SRRClHIOM9u1br9
MtVk07XrWUHgnBH2r0NrskL6WZnxgpnmue6eh/aSCNgUZiQCKho6CVo3LBxyF8H+9BNeitppV9JgCMAbicU7aa7KzepJC7Qn+Q7ipy9XNaEo8+
+LxnvVRqOrpqtyggZlbPB3VYx6zdWsIt70Fx2VjyD9qptQHpp69uS0L+B/E1Xf669hOYGZwSoK7uxz96y/UWoGWcyIWR8ZB7Vmpr64myJZGfPy
c01bzNBKHU4+a1VhBb3yLIpCyDuK1ukRWUc0ZkbcAOVYYGaY13VI4pS0EKqQMDaOKzI1mcSsWQkE5JqwsNWR2HOD8GtPo+pCKYHj3Vt7W+Uwhg
c0ucC5QhWG4+aoLuzltiS/uXNVGr2jRmK5QFlYc8VSPqDW0xYgsmO1Z3XOor4NJFE5i3AcqfFUIvfVUrOTuP889z96iM7Kxw3BHjzSdx24zxVr
omweoSAWI/xUq9tBIQ2Bz2qM9gCuCNuKhS27RvsJB+KP0m/buCfoOQDUSioUY4B+9FQo1ZkYMpII8inIp5I5fUVjuzWz0LVWSATRuysO+PNXkf
Ut06nbOyjtmq2bqMQSEy3LjHhTzn8VBvuubhoRHbghgSS+e9Rx11qPo+m3+QcVXXfUl5cKQeCfOcmqZ3aRtzsWPyaTXQf0y0jSblzd6gwaRThY
ya7L/plnf2RgtQI2I4OKweo/pvf3U7kAYPyajQ/pNesQJEQZpjVv0ouLa2MirnH+0VzrUtDurKZkMTcfIqEkE/IERyPtSZLeZRudGA/FJjglkO
I42b8CnWsZ0YCRQmRnk0/Hp00wxDHuwMk1BkjaJyjjDDgik0bVq+hWjXUIpJQGWM5K57/autz9Q/6vC1lGvpQhcv7s4+wqsl1iysCIg+fkCoN5
q2nXJDMzKw7FO9RZeotPiBCxj1P9z85qOmvTSyozXSRx8gBVHH9qrLjqvTpmaK6i9Qq2A+3G6p2l6hpjyiSHMf4bNXl1LLcw7YnjlU8jmoNjer
cJcWM2IZN2UDcc1Qa/bXMcuLpWH+1ic8fms1fQSyqArFsdlNVLKMfDDuDSKn2c8lqVaN8HPitRYaxFKAsp2P5+Ks5p4zCWYK4x3FU0s9tkj0jm
jghtbhxtBVvtV5Y2u0qPVP4NazRSqtsllO0DzWigEJZNsg5PBzxT2o2hVA25XRxn2nOKrDZNPZNBgs0eWUYzkVl9W0a2uY2ChoXC49ozk1g9W0
4w2ZivV/q5/pS/P2NZmeBoZNhIJ/9pzTe04oU7a3MltKHjPIqyTUfVBZVy/+ylJq4OVnjGO3btTM1/AWysQP3oLeRS28kLLgvjB+KrnjZWIPik
UKFChQoVbadqiWS4ERbIxwfPzSrvXriZCkSJEpGDtHeqksWYljkn5pNChQoVq+gY5ZNQGxTjcOc8D5r0bpVoot1lAYDAHAzzVpHC5wxUgfJ7mp
eOOaIqD3GarrvQNLvH3z2UTt87e9QJOjdEbcRZRKSMfQKotS6C0sji0Q/fFZ3U+l3CNDY2iKFGCwTGax0vTksVwDcAnBwBiri50Q2Vj6oADkZ4
Fc0123MN47E53HOarKFXnSmTqIxnH57VuNPLA6iI8HAPuFYXXbi5W8K+owHjBqtF1ceZ3H96Ss2TmTcx/NGbmUgDe2B2BPamWYscmnIp5IjlGI
q3sdbmEibpGRweGU1pVvI9QX+qpWZR9Y7/mp0V7HNB+y1bJQf9uUdxTM3T1vPGWsLtJG77Tway+paU8Lt6sRDCqWdCGJbhvIxTSsVIIpz1Tu3K
cfarGz1H9vKolkJTyAKsr3U9Nu3zawekMeTzTEV/FbMWRmB7cGrTT9VBxiTj4aroa2XjCxtjH8h3pcV9JkFJD/AJrSaX1CY0VJGOAMVo7HVLaY
EQyFHccikTacJVO4Ak9mFZfWdIjnV4LlMjtkCsjN0Qd2YbgH4BFCPpFohl0BP2qBddNDOdpFVt10+yplMhqp2ge3l2zBk+4pMsTIxGCT3zTWD8
GjCMRkA0plcd1Oe/NN0KFChQoUKPOaKhQoUKdhi3+4sAoIBya7L0XY2NtBausa+njLNnnNdR02Nop1/qbonGVzV6vbBNCiowcHIpX8d33pp0DD
/wCKb9FXyFUZqmu9CtJ3MjIA1Z3rOK2sNHkSRR6mAEPxXCOoxumPwBVBQqbpN2bS7V8nBPNbyz1GK2tJmOfVuOPsBVLq1gtyBIuN1Z+4s3iGWA
IqJsDMAPNETgEbRSTjxRUBwcir2z1iV4lSQjeg2g4xkferW11aKRBFcqAfk1NjCpGbiKQBVI4B71bS/tdRtyBJuYAdx/mszquhBnxGyvntjvWY
vLSS1kKyKRg45plCAwLDI+KXJmQb1QBRxxTYJByKBJPc09BI6HgnFTo7phj3EGrrS75ZXVXbDVfjGM7qVFcywyqyO6qPPetfoXUqSRCC9O1zwG
q+dBMmSiyoR9Q71WyaZGWO0sp8ZFNLpkueCGxUC9sWJIMeftURdG/crn03QZxkjiosnTccVwRcrA8ecHcc/wCKKfQreOTckMEyN8Lgimp+l9Mu
BteH0XPkdqQf09hMOYZsnxiqDXOlb+G1P9IAxDG5f5isbc2dxbNiaJl/IqPQoUKFChQoUKFChTtucP2zn7V1PocmXS1ikYrtYYNdttINlvbFn3
YUHNWY5GfFA0VClp2IPak+aC7VJbBzScIQSRnPNc7/AFNRpbVixxghv/iuJdSpsh3Hy2KqdasF0++eGN98efa2O4qBQHBqzTVZGg9KQZIxtPxV
5ZrJLb5dgp27gc98VRXt+7OyDBA81EhjklLMi5wMmimYPhuM4wQKZoUKUDgZHelieQcFsj71Ns9XntgUyWib6kJ4NWNtrEJIIZomPwato71ZlA
lIYHs61X9QRewI53AjKt5rLUuNtrfY8GkkYJFFSgSpp5ZAftTsU211KnBB71sLTUI/RUuwJxSJdathJsZsUcuowx4aOXdzknNaLROrFgiYNcNw
PaverWDrUM43Ip+x81eadr9hduPVzEx/kO1WLLbXIBjkRifg80zJp8ssqRks6Z+knFN3Gk25bJKhl424/wDmjh0u1znHP2anZdKjPKYYfB70iO
zZf+2/bxSmU7gJ4d4HnFReo+m9O1KxMsVug3LgYHY1wTqHSn0u+eJgdueKqqFChQoUK0/SXTf+u291IzBFgXcTVfqemrBn0weO33qp2nnjtRUK
m6PH6t8iHse9dX6GtTcKEQcBsk12a3VUtIt3xxUxGDLxSqKhS1JA5HBpJ70VEBVF1RoqarZsmMsBxXH9e0NFu2ivoGRcADjOMVlf1DsHtdUdQv
Ck9vFZChRipsF86RBWP0n/AI+KZaWJpC5Tz9OeKU90PQ9KJNmeWI81HHNPrayPGXUZA74qOylTyKKjxxRUKFXWhBmWUE5CgY5q61S0efSBKFOU
HBrGMME0qMD3M2PaM4PmiUb3A+TVhHYNKMRoTjzUaW1aNtrAg1Js9Ke4w5OxM9zV3a6JZhgxfcB4NWf7W0SLcUAA7E0mLp8arxANpbuxGBVHfa
VLZTyW5cOV7Mp4NQfRnRsYbNPQm8DAjNXdhPqBwBV3aPqcBWQNn8HtW+0PWTJboty5D45zV0myX3OQQeaWY4T9IwajXrSLH/SH96pDfTxXGZVY
qTzitFbkT24dCGGOfkUlT6BIbmF/qHxWK/UPpSO9tTPCPeOQR5ril1bSWszRSggj/mmKFChQoVf9L61JpjTRA/05hhh81Ntw007epgo54+1RtV
0YRB5FODjNZ1hg0VLileFw8TFWHkV2H9JbgywKrNl2JzXaBGXVAeAoxipEZUKFBpzxmgMeaWrbBnGaS7bvGKTQoUCAe9Veq6Rb3iEvErPjgkVy
L9XtPNvdyTLFlXGa40wwxFFQFHniioUpWwe1Xml3MAjIbGfIpV7aQzp6tvgkdwPNVuoW4hdf6ZXKg/moROfxRUKFW2gyBHkQn6gK3MIjfT2iJG
Ctc+1G1MF08ZGOSQahgHY3HA7mnLTb667u2a120NEmzhceKHoq31KGx5NOG3kdcIMY+KkwWDJ7iewzT00SzCMO21AeaFxdkuiw5SKIYUA9/vSM
RXC5fGaQ2nqR7Tn7YqRZaNJcOFjjdj8AVqLHo+VFDXTCM/7c8itLZaTY28GCA7dsEZzU+OySI4htBgjIOB2qV+0nMe4x448VXzPJGdre0g+fNL
iZ3T3YqFeAA4MeD80xDdSWjh4zx5HzV4skdxbrKg27/qT4puVRJCYJhkfxzXL+uumYlcyiPCt2IHY1zW8tf27FGByDwah0KFChRgkEEVqtDKT2
kkryhGiAwD5pOqavHIkbeOxHzWZlYM5K/TnikUK6F+kl0y6qIAxyWBAr0duUQjHfHNZfVNWnhuo4omwC3Nau0cyRKW4JHNOUrPs/vSaFChQohz
nNZD9TNH/1DQ5GiXLAEZxXmC8ge3mZH7gkH7Go9CjoqFClKxQ5U4NW+m3H9MMWA2HDr8ip2trHdTmSDmPAC/gVQXUQjPFR6FH4p+yLerhfNXMW
svAuwnOOOaau51vpFcgdsZFQJbMojMJFJ/2+ajNG8eGwfkGpttq08HHcfFThry8Zj581Z2erxyAbWAJ8GraO6MiBYwWJ8DmmL+UhVjhbcDgtgd
j8U2vIAbAyOaGUXsM1oOmJYDKiTwqSScM3P4rdC3ubeFHCIokP8Biplpa75AJRnznNaGPS7SRQ0QAwOc1MggSNcBRUghNuAKrr3TYrgEFRzVHe
aJNCpe2JyPFUUlxMjtHMOR3BpT25O3fswcHG4dqhzXVxbTqwcmNTgrnjFaC2u7e5g3GXa/8AEUNRsreeweO6weOc1zXWukLea3meOTkAlciuUT
IY5XQ91OKRQoUKFSUuZIYikbkBhyPmmHdnxuOcUmhQrZfpVKsXVMRZtpK8fc16INw6xhs5Hn8VQ6pH698HHYCr7R9VVo0hkOJUGDnyKvQcgEdj
Rr3xQIwSKKhQoUYGTj5pm6jSaB4pBlWGCK8x/qhpUVhrcjW/Z2OfzWKIIOCMGiqbFBG1v6pbDBgMYqI/Dkfek0KMY805C+wkeDUu3vig2NytNX
ZEh3K2aiUa/OO1K2kru+9SLAlHZsdhUeRizlj5qVZEkN9qtY19QbeO2e1No6QuUuVBX5py5sbGaMPFKq/bNVj2fpPujdWH3pUc0NvepJtVkz7l
HY1Y/wCsKkh/ZARjwQTnFFHqUinnmlPqbd6biv2Eu7OR5Ga1OlXKukckR5Brqejz/utNheQE7RnJNOHUkhdmB4q+0y+DJtYj3AHg1Zxvn6TkU8
GGKMEHtRMoYVnte0OO7BkjPpyjyPNYy/inidRKNpX25B7480wJC6FZDnHmoyyyW0qtG52Z5HxTfUHU/pwnDkELgDNYObrm99Uh8OgBArJ3c5ub
h5SACxzgUzQoUKFClKrN9IJpNChVhoF21jrFrcKcbJBmvUGlTpqOnwSQncCuGFRb6yeJ+D28VAuIpdweMlWHmrzRtdyf28/deOfNaRWDKGU8Hk
Uff80VClKATg+aMJyVNGEYNk9qauB7Tt7iuG/qzpLlzO68tkg1yC4Uq/PxTVPQs5/pqNwPcU24wxApNChQoUeTRUKl2WCGUjOeaQ8xBIHbtS5S
sdqse0Et7t3kUzBMYmzjI8ipUt6Rj08io01xJN9ZzTWT8mn4CrKVbdu/iwNAQSbmDDjBycUxnHalIzbu5oSFieSTRKxU5Bwa1nTE+UcE9+cV2b
pts6EgHbAPaoOousbkYBB5GaiHUNQjbcrjGMDAqXadRahAPdJj5Oasbfqd2IQye4/eryy1jIAZgSRVzDexsgJYVA1PUkC4QjjvWG1a9/eXChFw
IzksfNZ/Wb86eodFDBu+apx1LFcxGOU+mw/way+samLrK8gL5+azshBb29qTQoUKFClpGz52jOKvtA06Z45XaBnQjwO33qu1WyS2lJR85Paq+h
UqKxuWUSrGxUc5Fd//AE0vHOlxqzBiAAQTW5lRbuDLAb14OKrDYsdw3cfBqovLOaFjcJwY/H2rR9O6ul3CIXOHHbNXlG3z80VGODS2cEZHej3M
zduKZbkGuZfqlG0kAXkgZx9q4DqA2TNGe6niolDt2oUKFChQoUYGTzRU7b7g+VPbvSZCd2fFHNL6pBx2GKboycgUBQJ+aVG5TtznuKeluMxKqM
wJHvFRqFKz80Bye1W+jXCwXCqxwG4rtPQupZtBGQGEfDA+RSdeliiurh4yCncY8VnZ9bS1jw8gB8bqz2p9SCR8Rvn7im9O1w/uUBYjnua3lhqb
Pbq4JJBq8s9XMrom/v8ANWVsiXVzs3knzVbqNskd5IVIOT2+KzOvWiTWsqeD2+1cx1OL9vMYwckHuKrJju45zRxRqeQhJp6Wzkk27YiD8YqL+2
f3HHam1jZkLAZA70ihUhYQ1q7gEsvJ+wqx6e019TukhhOCfqrr9ppFtb6AbeF9hX2Mx8/Ncy6uslso14U729pByaylOwwSzPtiQsftXWOjOl5r
y1SB1HuGWLeBW40jQV0aQQxByRnDgcH7GtVay+m4EvaQYP5pU8iRMzHgLxVBrGr28Q2gbz5FU2mXbNqkZtQVyc4rpkZJjUtw2OacP0ik0sYbOe
DRlcKaJXKjFIrJ9cWBu7CRY1y4GQK81dR2r22oOHGMmqmhQoUpEZzxSnide44ohE5GQpwaSysv1AiioUKdt5DHKGGM9uaDj3Z8H48U2QR3oqFG
OKB55oKcMCRmrCQxXI9SKMow4IA4qA67WwDkUWKKjBxSxISwPY107oO9ZJkQvjcmDk961OpwCeNj4cENjxXM+oNLv4ZSTukj8N9qzyqQ/vyDUi
BC1xGiHJY10rQIXSLDdsVNfek/9EE4OeK0+iRvFF+5kOG2k4zzmm71wGLMwBP371l9QcyLJsY85Arm19bTtcS7snDHmmIdNkcjIPJ7AVbafaxW
7gyAkg5wRU3WtTt9jmKPEjABm4/wPislc3nqJjjNI9UiIlFAB7gVFbk58nvQHcVYPmO1kweHQDn81I6bkuIr6M2+4EsORXaXZ5NGjaYe9+W+9c
m65ud12lqBwhLH+9ZfA/vWw/T+waa9LMo2njmvRGi6dBaW0aouCQCxq0aOM9ximJbMEgh+3YGqnU7a5MjCPJLfTUK36Rlmk3XUmVPg+KtrXpaz
tLiOWEkbTkj5q+AwKP8Aj+KKjPehk4IoqFQdSiDLuI4xXnP9WfSj1kxxqqsTk7awVClIAT7jxS44jK+B2q+stGIhEj52ntRXGnlc7RlTwKZjsV
igZZ0Ykn24aoN9bSCTKqxXHGahsjL9QIpNHmjOMAg8+aPccbs8jigWyMHBFIoUKMHmge9LjmkjGEcgfY1JjiTak8jj3ZJB81FmKtISgwvgUihR
jvWo0q9NrDHL6gUg4HzW50jXPXjAkG4djirN0jaP1VAeM9wRnFUGq9MWeoIXtgIpTzxVbpPSU1rderKd2DxkVs7SxkEWQwSJRyxpxXFsS1tn1G
GCx5qzguNtoFf6z9Tfb4rMarqck15sQ+1fio00oUZc8Dms7qDJNMWUhR5JqOJgQqrgBRimpZAwIVyDVXqY/pKinLE8mokWnSE5bgU1cKUypqKw
waA7ir6S09bSVkHcDmtF+nmnPeXwjJzHEMjjua6zPYq0Kx/xQc1wrreLbr9wVBwSAhqutrCViv8ATJDecV1T9NdEYuHcELuz2rr9vljg984qSA
TGC/fNB1VFB25/vS40Hf8Ax9qd4oHHiio15YCge5FG/cfik0KFV2q3AVfSB9xFeb/1WlWXqNig+lACfk1iaFHg4zjipem49Uk10Cy9OfRlZlJI
4JFRrWNjdoI1JDHB4zxQ1W0gjvJPQDbQ2Du+agvZNMcKKg6jpJRCQp+9Z6eB4jyOKZoUt1KAfcZpFChQpTIygE+aTRjtTqvvjETYGDlTTZGDgj
mi80bKRzRAEnipGJHiVArZXsftVlousXNmwWOVlwe2a32kaz6iBwAVbiRc+fxVxHOp+kKFPnNTLaFbjncWAHOKtYtOnntsQBXjHhm+k1WPavC7
KzLhe5Bqp1TWYowYImyfJFUaS7N0zHJJ4FRJ7p5ZNgPeoEyyTuUiBKr8DmoUrhBtz271Ae5f1vb2+KUzouJbg8+FpmfUd5wnAqPeXImCgdx3qK
Tk0qEbpVGM89q30NiIdDBYjc/ZPtXQ+gNIS2txKEAZ1BOBWi1WVLTT5ZW4OCBXFJtPudZ1p5SpMSNjt963midKyXjxxiARpj6iK3um6EmkwhIj
vYnkjxVwkQVRincD2qDnPendoIxjgUrgDgUVCjAzQOQee9FjmjPiioUa98kZqg1oj90xz9Kc157/AFLbfqQY/cCsVQp5V9R1HYYq20/Ty1wnHB
Ndi6W0u2h0wGeJWVQS2aqrmSzgmleOFYZA2Y9ufNUkz+mjSyoZI2Od4qsj1eH9xsVQFz3qfeahbQxorhDuHmoV9oS38AuLAqdw5TP/AIrH3mm3
Fsz+pEy7TyCKhUZYnGfFFQoUpO+fipLpvmTA3ZxxSb22NvOyAHaOxxTCjLAfNSri3WBFBAZ88nPFMs4bblcEcE/NP+grgFDSjDuBHkUm3tJppd
iIeO5+BVisiQRmP3SMOA2eMZ+KrLpCsxkUYBOeKnabqk1pIJIT7vIrTaZ1JEx/rqqsPJ807e9bJb5jtiWGMHHaocXXF9JKpE5QDjaDgVLuurbi
5gMZcDI5Iqqiujv3OSx+KlLM5BZuPgfFKspIUcTXD4Utjg8/mlaZO+y6Yn0ojnEx8DzVDeyRtK4jcCMdmPdqhteQxp/SGWPkjNQJZDI5Ykn80k
kk5NFQq06dszeajGoHAOTmuiNFG8IyFGwgDnv9q6d01D6NkmRjCAVH6wTdpsMY7uSaj9LaLHZ22+SME/cdzWq0td0/u4CjIAqdJIkX1HFGHV03
DtTkI9u4+aex7CfvSaFCj/jQOfNFnmjPFFQowe1Z/Woz+5kB7OuK4r15oksglYclCSK5kQQSD3FGqlzhRk1c6fps1xArqmPTOCfmt50xoJm2uy
nOPiteBPa20kJQ7CoBPbFVt1p4MbTMuc1ibrVha3E8SJujYbSPvWTlm/8AUtJjaCewpy6kM0Yd2JCjgVcdJaxtuY7WViFY8ZrfdTaIr6Wtw0YJ
Ydx5rjuo2xtbp4/GciotChQo1ODmpUe91BTO5D3HxVibgAojMJFC4cEd6r763Eb74uY2PGD2+1AQSegWkIXHIBPJFR9wI5pSStHyhpxbxh9QBq
2tNXtRZGGVGSTOdwGd32NTbdrCa3xJIm+UYGF+k5qLrOnGxK+kTIpHIxnFVBmVFJCYNRnkZz3/AMUccMkp9qk1PtNOk3ZYY+5qzWzjjILHf9hU
hWjjHtUKaRJNuQqD3qLLKo4z9Pimbq+MVqInBO7lVNVE0rzPuc8/akYJ7CgQR3oqFO28ElxII4lLMe1bvp7SH06APKMSsP8AFK1WdnuLa3hc5E
gLYrtGhiSLTIfWHvZQcfahriGaS1iC528kVMjQiNUUAYHNWlpEIoi2OT5qi1K/dbvBUtGDyRVnbX8MsaJHnJ8VaxZKDd3pxiMACk0KFCjPGKC/
UKBoqFGe/FQdWthPBuH1LXO+pFj9FzMowVIJrgmqRrFfzJH9IY4pm2GZlGcZrq1pZR6bo0TSbQSu9q2PRWraULRQ9xEszngHvWw1K0huIAVZXJ
HBzWcu7F5IjGsZ2njNcu6o6ZubKdpY42ZWOcYrGXVlMspDqVPwRUa7jlVFznFSun7WWTUImETNhgeK7zrIK9JktCS6xAqPiuA6qWkmZn+oGq6h
QoUKk2M5hnU7io7Ej4p50eO4ck7g3Ib5opThcmokkjOeSSBxSKFGAT2GaBGKXBKYpFYeDmrf/XXkJ9mG28EntVW0wbLNyxOakaZ6ZMglUHI4zV
vAkUajHGfgU888e3awP5qE86ocAn+5po3JJ8/2p+K3upQGWJgp7M3akXaRWZYyPvOOxGOapJpGlkLseTSKUGKjANJPNCjVSxwoya3XSGliKP8A
czJgj6QavNSvP21pI7ON5GFWnf076fk1S/8A9Ru1PoRHdz/I12K3gLAyt9K/SKZaLbMWf3SN2+33qM9z6l2ltCfPNTbySZytvb5wo97CmZbVpE
AOAfNO2lt6DhkUM/YVcQBgCXPJ705QFChR03LII1yabhuPUcBRUgnJoEYOKKhQIyCD2Nc+6+sGggcoNyuMiuCa9ZCOd2bKtye3FRNFtGur+JQD
gNk11vqa39Hpbe5wyxYrkEF/NFOHEjDB4wa6P0l1pO8scNxMx54Zm4rrOj6rDeR44LAePNWN5psV3Bl41Jx8Vi9X6MtLsljFtbP1AVTD9PIHYm
RgE8Ve6J0vpmlx+rtTevyRVZ1b1UttaS23pDe6kL8YrjF2++493nNVp7mioUKFKAG0nPIqVHIFiDNISOwH+2o0khfuSaRQoUqNzGwZe9PBRcEC
MYfHI+aRLBJExVgMjg4OaXb2k82WjU7V7t4FNvjIUAZ8keaftSkZYzFlOPaB5qZPqckqJGMBE+njFNpO0vGST9qnR20UaBrpgCfAp5dW020gZE
tN8x7SMe39qr7rXrmQgRttA7faqyeaSeQyTOWY9yabo+1KVSSCRx9/NGY2JJAwM/4pJGO3er3pi1ia6D3ABA5wa2N5qkFtDiPaMdgKzU16+oXy
RRgs8jAADxXftA09bDSrSzRcEIC3GOavHZY41UdhUK4WWbiPIZ+M0LDRTa3H7iSQM2OAKmunoKSow8h5o4rZnOXPBqbFEqDAFKJ5ApZBHeioUK
UDgVGvRkAfemrVCkx44xxUyln3fmkqMsBRUKquo7OO7sW3jlRwa4J1dp7+pJHHGCwbOQKqtJtxaSKTw/k/erPqvXpLvR/2rMfZwfvXOqkWTzLO
iwE7ieAK7n+mcbO5WVyX4yPg11uOFVi/4ojbAqfaCKgJZQyCU457AfFVV5p0VvL6jD1OO3iuZ9e6bPe3GbSAssYA3ecVznW9O/06EPMymZ+Ag/
jVBQoUKFKjYowZcZ+9Bj8f4pNCj4oxt85pfpHGRyPmiCsp3LmiAkzkZzUmC7nhiMSAEHvkUpUlBiuJYwE3YHGM0iVvUnaTbgE8CkMjE9qn2SCG
NpnHI7ZqDdXckzkk8Z7VHJzRUpQD9z8CiIxSokMkiqPJpcuWPPAHAApAU7C2eKci2RruflvAoLcTK25GI/FPJJdXDbcsc10P9PdIsbK8hub+QS
XTH2RDx+a7bYsNjTMRzwBUhIGmO6ThKVvVJBDGm5vtUsDaMyYzUN981xyMAdqnIMClnikjk043YZ+KTQpcYDEg0bKFU1Gu84FNR5WVT3A71Ko8
HbmgGwc0VCm51V42VxlSMEVzvUdCL3ru8Z25PcVzHqKMWGrugHtzms9rbv8Aslc//dc/4FZ+tF0jppu7pZBgsGCqM9j816J6N0CHT7ZJNuHxyf
k1rFcBgM8GlByucUykQV2YfyOTSLlYyvvANY3qG4s9Oglml28c815y13UX1PUpp2wqljtUdgKrqFChRjHmhRUKFChS0kZOx4+KsLXULeOIpLbh
s/V9/wD9U7avYy3AMmUjJ5GaspILJmU26hQvnOc0JdPWdt7yn+/aot29laLtRRI/54qCNRQDP7dQaZub+SddmAq/aodCjAz2qdZ6bcXZxGCFHd
sHAom02ZGKlScHxS47b0QWI93bmmbkqFwoxUfefT2eM5pLHJoqlQ3k0e0RtggYzXSOioVcwSzOzOrZ7cGutaZcJKVbPtU4A8Vd3V7DGq5PBHYU
qxK7Hn8t/wCKfRTIdzZxTgUCj3BRTNxcpGhZmAA7k1SXvUdtD7Y23MfNStG1Q3qNzkqeceKuFYMOKOjFGWJGDUa+OIlP3pqeTbDH9+9SIZA6in
ftRUKFNyttHPaq7UZBFbSSdwFOc81xnqvTUm1ZJd2UK7s4rnvUmordTiCEARRHAx5qlq+6PvGtdWjx2J8+K9FaXqTNZxmOQFSO4NWUF5KQGVwQ
KnW1+szbG+v7VMZsJu8VlepertP0y2kJmR5lBwoNcI6y6wl1l5ESRsMe6nAx8VjKFChQoUKFChQoUKFClCRx2Y/5p/8AfXG0qZCQfFR2Yscscm
ioUuNC7YAJqfb2IPM3Ape61ib2qOPPer3TNRhXTJkhY+rJhdpXikh5VA9QD84qtvJg27bgsO/wKpyrSuec/ej9HaKZPeiqbpFob2+jiUZya67p
1oun2kaIvvYYUVNt7ySW7W1hYssZyzDOM1d2V4Re7NzOV4GD2rY2DboVQnLVZgYAAo8ComoTehAz8ZA4rn2va3N7g8hx/tFZqfUt+08jbV90Dq
YW9miJZi65xn710m1kGQPmpVKBwv3NJqLqP/8AHz/tNRbrDWqODzmnLWUbhk49vH3qwHIo6KhVBrWv2Wnu0V1IUfsBWd1bqnT20+VFuQwxk88k
VxzqXq83s0y2wKpjYo+BWNJJJJ7mipyGZ4JBJExVh5rY6D1lPp9osM8jFPH2roPTvXFvcWpBbOBzmpEPViJdqV5Td4NanVer7OLRJpw3KgjGa8
2a9q02p38spkb0yxKrntVXQoUKFChQoUKl2FrHdOQ8ojx8+av9D6csNQuRDJe7CeORUjqPo9dMYiNztAyG7g1jmUoxU9waKhQoUKXFG0rhEBJN
OtbGNiJWAwccU9DcxQD+mmW+TTjPPd4A4Wpdhoc93KUiG8qNzfYVf2ulCCIQja3uyz4/8VZNYxvHt2+O9ZHU7ER3Tr4+1Nx2WVBA4qLqIMS7QP
71AVQY2Yjt2pFbPoPT23tenjHAre5kmZAvEkh2qf8AaKtbWy9N1srL/uHl5CewrVaZosNsihV/qHua0VtbrCox3+aeoicVnupLxFjI3/SOwrmG
rNcXkuUjbGeMCq39hdvMIgjl27KBWy6Q0K60u8/cXariQbcZ5FdCsxmUH4FTycUhJkkyFIJXg0uo+oDNpJxniq5XBtDk9hUayuQyEkZKtir+Fg
yAg9xTncfih+KMcqB965r+qmnD0xdYzXF9dne1jVRkFs1mSSTk0VChS5H3BQBgAUqGeWE5idl/Bq2stZnVkDtnxV91NqKjRlj35aYDCKe3zmsN
QoUKFChQoUKFKRtrA1c6ZJ6dzHLG5HI5HiurKLbWdNSGRsyAYGTzisB1H0hdWsu+KBmU59y85rM3OmXdtj1oWUHyRUULyc4GO9DGThQSafjsbu
RcpbyEfO2nV0q8MRmaBxEp9zY4FWUEVrb2+6KVlduDnuR5qnvJVkmPp7to+aaXvwM06tw4wM8DxXQuiLhZNIuHUJ6hbYfbzg/er1rA4SRRlceP
mj9HapyMH71m7/TJLi5Zh2JqemlwJbBfbvA81meorARc44Pas7E/ol4yisD80Vram4u4Yh/9w+PzXXdN0pbO0jghXgAAccmtPb6W6K87gKsScE
/NT+n7MrKZpFIJ5yfNbC0jAG49zUoU3JLtOAMmhKSUIHfFUV3o0UhMsrZY8nJ4qM1vZwrsO3d+KkxafbIY7iFFLMMZHepKWy+oz7do8CrC1j2j
PmnmGRVbp7Y1C4T+9WlJlXejL8jFZi99S0eREBZfiq3Sb0fuXibuTnB81pbS8WNtjNkds1aqwIBHY1HsLtLuPehqUOeKzH6hwiXQJSRypFeeuu
EVGt9vfbzWToUKFCjAzQ3HORwanQ7ruJlLFnUcCoLKVbB4NADPc4oEY85oqPBoqFChQoUKkWVy1vKrAAjPINbnTdSLohViGxkEcV1HomJtVtgb
sB1X581Z9SdKafqNq0SwqSB3xXB9Z6NvINVe3t4m2buOK0HTfQE0MqzXI3N/tx2rRdQTW2g6cYUWNZXHYAZP5rAT9QPsaKOIFH+pT5NZ28dcgw
5yR7j4/AqEPzQ88UOMY81tejrxLayEW3mViWJFba3nZoylvKN/gGkvfyKxiu413fOKhXV1nKxx4J+Krbl5Qclsfao+pxfudPbePcnINY6a2f1n
IHYc1p/096en1TUVuSmYoe5+K7RJpCRXVsoBIVdx/NWd5bNLHb2qA+9ssPsKtotPRVQdtvgVMVQowKDduKSseDk0JjsjLVmeoNQaG1JDANWb0d
5724DOW9PP1Gt/awooVV+kVKMSnvQQrkgGlkgDJNV1gUN/cFfIqzAyDzREVEv0xCzhAxA+OaxF5aKt5+4t5VPuPA4wfjFS3u2CNK2dwbNPw9TR
xBA7AZ8E1N6PtL21tSt2ykD6cd60dU/VkYudHuIiQDsJH9q879aabdzTqY4iQi57ViWUqSGBBHg0VChQpWDtOD+aTT9ldPZ3KTIASp7HsatfXs
b0l3jUSvxt7Y+9RZ7BURtjFj/Him7PS7q7lEcMZYnxWotOgrvaDdyJEvf3Hmpv/QEVxATZ3McjjuFbkVR6v0VqemorMqvuOAFOTWdmt5IGKyqV
YHBB8UjYc8EEfNGE45YCg2F44J+aRQpcQDPg1c2d00MSbhwnCkea6l+mvVtohFq7YkY9j5rrcSLdQlhxnkVCfRFkl3yBDk8tjmoGvXFrolm5jA
DY7+Sa4l1Xe3Gs3RdI9iJ7M54/vVAmn4ILsSB9TeKZ1F7dYTFbx5Y/yqp9uwq49w7EU3QOPArT9PXdvJGlu59Mr2PzWiM1xbyL6W1wOxzzV4ij
U4EeVhHKo8+ajPEYmxK6AfOaal9AHwx+3NGlqZ1II9vfbUS40WJ0lfb9XORXRf0/0+Ox0c4jCl/+a2kUSvMSRnAFNRYl1g/ES1a0KFGFJPao2r
M0NqxHfHFc+6gdXX1Z5TsHcCq//qOCCER2bLtC/wDNPaf16tsjreShmyAoB5rRXfWNnFp6XBkHvGQoPNFpPUttc/1BOCjduex+Kn/6ut1KYopA
PHen9NcwXrIQX39yPFXgNK/lxzRMAwOR+axOt6Iz6kJLWZo1z7lB4/xU59Gb9uy7925cZrGaj0vqJlYwnKg8gntXSJ9QhtIZG4wDxSotSjMHqO
ccZrO65rKLZ3Eu4MdhAGeBXPNevTNpscjhDGyhWAAzxXLNSQG4fYMe72rUOWJ4m2yKVPwaRQoUYoqFDt2qRBdSR8F2wfINOw6pdwSb4pmDDtTt
1rupXTAzXchxwOad0nqC9025WaORmweQT3q31Drq8u1ddmM9sntWYubua6cvM2SftTNORxiT2j6viikheM+9SKSqMwyoJoiCO4oAkHIqeb0Swx
xemFZeMjzUzRWFvfxygkFWrvnTvUbLZx+s52Y4J5xVhc9SBI93rDaeQa571ZrdxqDGOHJycA1mYkRFf9zE00nwGwPzVVdkAsGOxCeBnjFV7r6p
2QLmk3Olft4DPOwUfFU7YJ47UAue3f4p+zmWGTLCtXptwtxbPN+5RXHAV2xmrG0vVZhG0xU47Z71Lk/b7dzvn7lqjNfWsZyj5I+Kn2GoNdERwR
5OeAa2Ok6A8wWS4y3yP4itbaQpAiogwif8mrS1OyF5no9MgZXknfgyHj8VPoUeDjOOKVubPftUTUgZoSg7msL1LbRWmmz+pgk+fiuKahdm3mmE
TkL45qi/eSC49Z33HvjNSm1+8Ygb8qPBq50fUpSpAmZFIzgHzW56He6vNSRS7EHvz3rsjGGygBcqmByT5qnXqOKb1fSOTGfp+R81Y6drdre4WN
xv+Keu9QSCQI7AZGax2t6tFNcSLbS4k+RVr0pqzX9i0U5zLEcE/NXBUM59viv/2Q==
]==]

local B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
local function b64decode(data)
    local lookup = {}
    for i = 1, 64 do lookup[B64_CHARS:byte(i)] = i - 1 end
    data = data:gsub("[^%w%+/=]", "")
    local out, n = {}, 0
    for i = 1, #data, 4 do
        local c1, c2, c3, c4 = data:byte(i, i + 3)
        local a, b, c, d = lookup[c1], lookup[c2], lookup[c3], lookup[c4]
        local v = a * 262144 + b * 4096 + (c or 0) * 64 + (d or 0)
        n = n + 1
        if c and d then
            out[n] = string.char(math.floor(v / 65536) % 256, math.floor(v / 256) % 256, v % 256)
        elseif c then
            out[n] = string.char(math.floor(v / 65536) % 256, math.floor(v / 256) % 256)
        else
            out[n] = string.char(math.floor(v / 65536) % 256)
        end
    end
    return table.concat(out)
end

local function loadMarble()
    local getAsset = getcustomasset or getsynasset
    if not (writefile and getAsset) then return nil end
    local name = "anxy_marble_v5.jpg"
    local ok, asset = pcall(function()
        local need = true
        if isfile and readfile and isfile(name) then
            local okRead, existing = pcall(readfile, name)
            if okRead and type(existing) == "string" and #existing == MARBLE_BYTES then need = false end
        end
        if need then writefile(name, b64decode(MARBLE_B64)) end
        return getAsset(name)
    end)
    if ok and type(asset) == "string" and asset ~= "" then return asset end
    return nil
end

local assetUrl = loadMarble()
if assetUrl then
    LayerA.Image = assetUrl
    LayerB.Image = assetUrl
    -- if the engine never manages to load it, show the fallback smoke instead
    task.delay(3, function()
        if not LayerA.Parent then return end
        local okLoaded, loaded = pcall(function() return LayerA.IsLoaded end)
        if okLoaded and loaded == false then enableFallback() end
    end)
else
    enableFallback()
end

------------------------------------------------------------------------
-- ENTRANCE
------------------------------------------------------------------------
Outer.Size = UDim2.new(0, 0, 0, 0)
Outer.Position = UDim2.new(0.5, 0, 0.5, 0)
if isCanvas then
    Panel.GroupTransparency = 1
    tw(Panel, 0.6, { GroupTransparency = 0 })
end
TweenService:Create(Outer,
    TweenInfo.new(0.55, Enum.EasingStyle.Back, Enum.EasingDirection.Out), {
        Size = UDim2.new(0, WIN_W, 0, WIN_H),
        Position = UDim2.new(0.5, -WIN_W / 2, 0.5, -WIN_H / 2),
    }):Play()