return function(v0, ...)
    local v1 = {};
    for v2, _ in pairs(v0) do
        v1[v2] = true;
    end;
    for v4 = 1, select("#", ...) do
        v1[select(v4, ...)] = nil;
    end;
    return v1;
end;


return function(v0)
    local v1 = {};
    local v2 = 1;
    for v3, _ in pairs(v0) do
        v1[v2] = v3;
        v2 = v2 + 1;
    end;
    return v1;
end;


return function(...)
    local v0 = {};
    for v1 = 1, select("#", ...) do
        for v2, _ in pairs(select(v1, ...)) do
            v0[v2] = true;
        end;
    end;
    return v0;
end;


return function(...)
    for v0 = 1, select("#", ...) - 1 do
        if select(v0, ...) ~= select(v0 + 1, ...) then
            return false;
        end;
    end;
    return true;
end;


return {
    Dictionary = require(script.Dictionary),
    List = require(script.List),
    Set = require(script.Set),
    equalObjects = require(script.equalObjects),
    isEmpty = require(script.isEmpty),
    None = require(script.None)
};


local v0 = require(script.Parent.Parent.Cryo);
local v1 = {};
v1.__index = v1;
v1.Levels = {
    Error = "Error",
    Warning = "Warning",
    Info = "Info",
    Debug = "Debug",
    Trace = "Trace"
};
local v2 = {
    v1.Levels.Error,
    v1.Levels.Warning,
    v1.Levels.Info,
    v1.Levels.Debug,
    v1.Levels.Trace
};
local v3 = {};
for v4, v5 in pairs(v2) do
    v3[v5] = v4;
end;
v1.Levels.fromString = function(v6)
    if type(v6) ~= "string" then
        return nil;
    else
        for _, v8 in pairs(v2) do
            if string.lower(v8) == string.lower(v6) then
                return v8;
            end;
        end;
        return nil;
    end;
end;
v1.new = function(v9, v10)
    local v11 = {
        name = v10,
        sinks = {},
        children = {},
        parent = v9,
        context = {},
        dirty = true,
        active = {},
        cache = {
            sinks = {},
            context = {}
        }
    };
    for v12, _ in pairs(v1.Levels) do
        if not v9 then
            v11.active[v12] = false;
        else
            v11.active[v12] = v9.active[v12];
        end;
    end;
    if v9 then
        v9.children[v11] = true;
    end;
    setmetatable(v11, v1);
    return v11;
end;
local function v14(v15, v16)
    local v17 = v3[v15];
    if v17 then
        for v18 = 1, v17 do
            v16.active[v2[v18]] = true;
        end;
        for v19, _ in pairs(v16.children) do
            v14(v15, v19);
        end;
    end;
end;
local function v21(v22)
    v22.dirty = true;
    for v23, _ in pairs(v22.children) do
        v21(v23);
    end;
end;
local function v25(v26)
    if v26.dirty then
        if v26.parent then
            v25(v26.parent);
            v26.cache.context = v0.Dictionary.join(v26.parent.cache.context, v26.context);
            if not (not v26.parent.cache.context.prefix or not v26.context.prefix) then
                v26.cache.context.prefix = v26.parent.cache.context.prefix .. v26.context.prefix;
            end;
            v26.cache.sinks = v0.List.join(v26.parent.cache.sinks, v26.sinks);
            v26.dirty = false;
            return ;
        else
            v26.cache.context = v26.context;
            v26.cache.sinks = v26.sinks;
            v26.dirty = false;
            return ;
        end;
    else
        return ;
    end;
end;
v1.setParent = function(v27, v28)
    if v27.parent then
        v27.parent.children[v27] = nil;
    end;
    v25(v28);
    v27.parent = v28;
    v27.parent.children[v27] = true;
    local v29 = -1;
    for _, v31 in pairs(v28.cache.sinks) do
        if v3[v31.maxLevel] then
            v29 = math.max(v29, v3[v31.maxLevel]);
        end;
    end;
    if v29 > -1 then
        v14(v2[v29], v27);
    end;
    v27.dirty = true;
    for v32, _ in pairs(v27.children) do
        v21(v32);
    end;
end;
v1.addSink = function(v34, v35)
    v14(v35.maxLevel, v34);
    table.insert(v34.sinks, v35);
    v34.dirty = true;
    for v36, _ in pairs(v34.children) do
        v21(v36);
    end;
end;
v1.setContext = function(v38, v39)
    v38.context = v39;
    v38.dirty = true;
    for v40, _ in pairs(v38.children) do
        v21(v40);
    end;
end;
local function v56(v42, v43, v44)
    if v43.dirty then
        v25(v43);
    end;
    local v45 = {
        level = v42,
        rawMessage = v44,
        loggerName = v43.name
    };
    for v46, v47 in pairs(v43.cache.context) do
        if type(v47) == "function" then
            v45[v46] = v47();
        else
            v45[v46] = v47;
        end;
    end;
    local v48 = nil;
    v48 = v44.n == 0 and "LUMBERYAK INTERNAL: No log message given" or v44[1];
    if v45.prefix then
        v48 = v45.prefix .. v48;
    end;
    if not v48:find("{") then
        if v44.n > 1 then
            v48 = v48 .. "\nLUMBERYAK INTERNAL: Too many arguments given for format string";
        end;
    else
        local v49 = 1;
        do
            local l_v49_0 = v49;
            v48 = v48:gsub("{(.-)}", function(v51)
                if v51 == "" then
                    l_v49_0 = l_v49_0 + 1;
                    return (tostring(v44[l_v49_0]));
                else
                    local v52 = v45[v51];
                    return v52 and tostring(v52);
                end;
            end);
            if l_v49_0 < v44.n then
                v48 = v48 .. "\nLUMBERYAK INTERNAL: Too many arguments given for format string";
            elseif v44.n < l_v49_0 then
                v48 = v48 .. "\nLUMBERYAK INTERNAL: Too few arguments given for format string";
            end;
        end;
    end;
    local v53 = v3[v42];
    for _, v55 in pairs(v43.cache.sinks) do
        if v3[v55.maxLevel] and v53 <= v3[v55.maxLevel] then
            v55:log(v48, v45);
        end;
    end;
end;
v1.error = function(v57, ...)
    if v57.active[v1.Levels.Error] then
        v56(v1.Levels.Error, v57, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.warning = function(v58, ...)
    if v58.active[v1.Levels.Warning] then
        v56(v1.Levels.Warning, v58, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.info = function(v59, ...)
    if v59.active[v1.Levels.Info] then
        v56(v1.Levels.Info, v59, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.debug = function(v60, ...)
    if v60.active[v1.Levels.Debug] then
        v56(v1.Levels.Debug, v60, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.trace = function(v61, ...)
    if v61.active[v1.Levels.Trace] then
        v56(v1.Levels.Trace, v61, table.pack(...));
        return ;
    else
        return ;
    end;
end;
return v1;


local v0 = {
    Levels = {
        Error = "MockError",
        Warning = "MockWarning",
        Info = "MockInfo",
        Debug = "MockDebug",
        Trace = "MockTrace",
        fromString = function()
            return "MockInfo";
        end
    }
};
v0.__index = v0;
v0.new = function()
    return (setmetatable({}, v0));
end;
v0.setParent = function()
end;
v0.setContext = function()
end;
v0.addSink = function()
end;
v0.error = function()
end;
v0.warning = function()
end;
v0.info = function()
end;
v0.debug = function()
end;
v0.trace = function()
end;
return v0;


local v0 = require(game.LoadedCode.Packages.Lumberyak.Logger);
local function v6(v1, v2)
    local v3 = v1();
    local v4 = tick();
    for _ = 1, 2000000 do
        v2(v3);
    end;
    return (tick() - v4) / 2000000;
end;
local function v8(v7)
    v7:info("foo");
end;
local function v10(v9)
    v9:info("foo {}", 2);
end;
local function v17()
    local v11 = 0;
    local v15 = {
        maxLevel = v0.Levels.Info,
        log = function(_, _, v14)
            v11 = v11 + v14.number;
        end
    };
    local v16 = v0.new();
    v16:setContext({
        number = 1
    });
    v16:addSink(v15);
    return v16;
end;
local function v18()
    return {
        info = function()
        end
    };
end;
local function v25()
    local v19 = 0;
    local v23 = {
        maxLevel = v0.Levels.Error,
        log = function(_, _, v22)
            v19 = v19 + v22.number;
        end
    };
    local v24 = v0.new();
    v24:setContext({
        number = 1
    });
    v24:addSink(v23);
    return v24;
end;
local function v33()
    local v26 = 0;
    local v30 = {
        maxLevel = v0.Levels.Info,
        log = function(_, _, v29)
            v26 = v26 + v29.number;
        end
    };
    local v31 = v0.new();
    local v32 = v31:new();
    v31:setContext({
        number = 1
    });
    v31:addSink(v30);
    return v32;
end;
local function v40()
    local v34 = 0;
    local v38 = {
        maxLevel = v0.Levels.Info,
        log = function(_, _, v37)
            v34 = v34 + v37.number;
        end
    };
    local v39 = v0.new();
    v39:setContext({
        number = 1
    });
    v39:addSink(v38);
    return (v39:new():new():new():new());
end;
local function v63()
    local v41 = 0;
    local v45 = {
        maxLevel = v0.Levels.Error,
        log = function(_, _, v44)
            v41 = v41 + v44.number;
        end
    };
    local v49 = {
        maxLevel = v0.Levels.Warning,
        log = function(_, _, v48)
            v41 = v41 + v48.number;
        end
    };
    local v53 = {
        maxLevel = v0.Levels.Info,
        log = function(_, _, v52)
            v41 = v41 + v52.number;
        end
    };
    local v57 = {
        maxLevel = v0.Levels.Debug,
        log = function(_, _, v56)
            v41 = v41 + v56.number;
        end
    };
    local v61 = {
        maxLevel = v0.Levels.Trace,
        log = function(_, _, v60)
            v41 = v41 + v60.number;
        end
    };
    local v62 = v0.new();
    v62:setContext({
        number = 1
    });
    v62:addSink(v45);
    v62:addSink(v49);
    v62:addSink(v53);
    v62:addSink(v57);
    v62:addSink(v61);
    return v62;
end;
local v64 = v6(v18, v8);
local v65 = v6(v18, v10);
local v66 = {
    ["Log level off"] = v25,
    ["Simple logger"] = v17,
    ["Short chain"] = v33,
    ["Long chain"] = v40,
    ["Many sinks"] = v63
};
local function _(v67, v68, v69)
    print(string.format("%-40s %0.3e [%0.4fx]", v67 .. " - " .. v68, v69, v69 / v64));
end;
print(string.format("%-40s %0.3e [%0.4fx]", "Empty function" .. " - " .. "Simple", v64, v64 / v64));
print(string.format("%-40s %0.3e [%0.4fx]", "Empty function" .. " - " .. "Interpolation", v65, v65 / v64));
for v71, v72 in pairs(v66) do
    local v73 = v6(v72, v8);
    print(string.format("%-40s %0.3e [%0.4fx]", v71 .. " - " .. "Simple", v73, v73 / v64));
    local v74 = v6(v72, v10);
    print(string.format("%-40s %0.3e [%0.4fx]", v71 .. " - " .. "Interpolation", v74, v74 / v64));
end;


local v0 = require(script.Parent.Parent.Parent.Logger);
local v1 = {};
v1.new = function(v2)
    local v3 = {
        maxLevel = v2
    };
    setmetatable(v3, v1);
    return v3;
end;
v1.log = function(_, v5, v6)
    if v6.level == v0.Levels.Error then
        error(v5, 5);
        return ;
    elseif v6.level == v0.Levels.Warning then
        warn(v5);
        return ;
    else
        print(v5);
        return ;
    end;
end;
return v1;


local v0 = require(script.Parent.appLogger);
local v1 = require(script.Parent.Parent.page.page);
v0:addSink(require(script.Parent.PrintSink).new(v0.Levels.Error));
return function()
    v0:info("calling {root}");
    v1.init(v0);
    return v1.doSomething();
end;


local v0 = require(script.Parent.Parent.Parent.Logger).new();
v0:setContext({
    root = "root"
});
return v0;


local v0 = require(script.Parent.pageLogger):new();
v0:setContext({
    bar = "bar"
});
return function()
    v0:info("calling {root} {foo} {bar}");
    return "done";
end;


local v0 = require(script.Parent.pageLogger);
local v1 = require(script.Parent.component);
return {
    init = function(v2)
        v0:setParent(v2);
    end,
    doSomething = function()
        v0:info("calling {root} {foo}");
        return v1();
    end
};


local v0 = require(script.Parent.Parent.Parent.Logger).new();
v0:setContext({
    foo = "foo"
});
return v0;


local v0 = {};
v0.__index = v0;
v0.createNode = function(v1)
    local v2 = {
        previous = nil,
        next = nil,
        value = v1
    };
    setmetatable(v2, v0);
    return v2;
end;
v0.CreateNext = function(v3, v4)
    local v5 = {
        previous = v3,
        next = v3.next,
        value = v4 or {}
    };
    if v3.next then
        v3.next.previous = v5;
    end;
    setmetatable(v5, v0);
    v3.next = v5;
    return v5;
end;
v0.CreatePrevious = function(v6, v7)
    local v8 = {
        previous = v6.previous,
        next = v6,
        value = v7 or {}
    };
    if v6.previous then
        v6.previous.next = v8;
    end;
    setmetatable(v8, v0);
    v6.previous = v8;
    return v8;
end;
return v0;


local v0 = require(script.Parent.dependencies);
local l_t_0 = v0.t;
local l_LinkedList_0 = v0.LinkedList;
local l_Promise_0 = v0.Promise;
local v4 = {
    llRoot = nil,
    llIndex = nil,
    _isFetching = false
};
v4.__index = v4;
local v5 = l_t_0.strictInterface({
    pageSize = l_t_0.number,
    fetchWithCursor = l_t_0.callback,
    fetchInit = l_t_0.callback
});
v4.new = function(v6)
    assert(v5(v6));
    local v7 = {};
    for v8, v9 in pairs(v6) do
        v7[v8] = v9;
    end;
    setmetatable(v7, v4);
    v7:_init();
    return v7;
end;
v4._init = function(v10)
    v10._isFetching = true;
    return v10.fetchInit():andThen(function(v11, v12)
        v10.llRoot = l_LinkedList_0.createNode();
        v10.llIndex = v10.llRoot;
        v10.llIndex:CreatePrevious(v11);
        v10.llIndex:CreateNext(v12);
        v10._isFetching = false;
    end);
end;
v4.getCurrent = function(v13)
    return v13.llIndex.value or {};
end;
v4.getNext = function(v14)
    if not v14._isFetching then
        local v15 = v14.llIndex.next.value or "";
        if v15 == "" then
            return l_Promise_0.reject("Next cursor is invalid");
        else
            v14.llIndex = v14.llIndex.next;
            v14._isFetching = true;
            return v14.fetchWithCursor(v15):andThen(function(v16, v17)
                v14.llIndex.previous.value = v16;
                if not v14.llIndex.next then
                    v14.llIndex:CreateNext(v17);
                else
                    v14.llIndex.next.value = v17;
                end;
                v14._isFetching = false;
            end);
        end;
    else
        return l_Promise_0.reject("Paginator is currently busy. Please wait.");
    end;
end;
v4.getPrevious = function(v18)
    if not v18._isFetching then
        local v19 = v18.llIndex.previous.value or "";
        if v19 == "" then
            return l_Promise_0.reject("Previous cursor is invalid");
        else
            v18.llIndex = v18.llIndex.previous;
            v18._isFetching = true;
            return v18.fetchWithCursor(v19, true):andThen(function(v20, v21)
                v18.llIndex.next.value = v21;
                if not v18.llIndex.previous then
                    v18.llIndex:CreatePrevious(v20);
                else
                    v18.llIndex.previous.value = v20;
                end;
                v18._isFetching = false;
            end);
        end;
    else
        return l_Promise_0.reject("Paginator is currently busy. Please wait.");
    end;
end;
v4.isFetching = function(v22)
    return v22._isFetching;
end;
return v4;


local l_Parent_0 = script.Parent;
local l_script_FirstAncestor_0 = script:FindFirstAncestor("Packages");
return {
    t = require(l_script_FirstAncestor_0.t),
    LinkedList = require(l_Parent_0.LinkedList),
    Promise = require(l_script_FirstAncestor_0.Promise)
};


local v0 = require(script:FindFirstAncestor("http-request").Parent.Promise);
local v1 = require(script.Parent.HttpRequest);
return function(v2)
    assert(type(v2.requestFunction) == "function", "Expected requestFunction to be a function");
    return function(v3, v4, v5)
        assert(type(v3) == "string", "Expected url to be a string");
        assert(type(v4) == "string", "Expected requestMethod to be a string");
        assert(not v5 or type(v5) == "table", "Expected options to be a table");
        local v6 = v1.new(v2, v3, string.upper(v4), v5);
        return v0.new(function(v7, v8)
            coroutine.wrap(function()
                v6:start(v7, v8);
            end)();
        end), function()
            v6:cancel();
        end;
    end;
end;


local v0 = {};
v0.__index = v0;
local v1 = newproxy(true);
v0.new = function(v2, v3)
    assert(typeof(v2) == "boolean");
    local v4 = {
        _source = debug.traceback(),
        [v1] = true,
        _status = v2,
        _value = v3
    };
    setmetatable(v4, v0);
    return v4;
end;
v0.success = function(v5)
    return v0.new(true, v5);
end;
v0.error = function(v6)
    return v0.new(false, v6);
end;
v0.is = function(v7)
    if typeof(v7) ~= "table" then
        return false;
    else
        return v7[v1];
    end;
end;
v0.match = function(v8, v9, v10)
    local v11 = true;
    if typeof(v9) ~= "function" then
        v11 = typeof(v9) == "nil";
    end;
    assert(v11, string.format("Result:match expects successHandler to be a function or nil, got %s", (typeof(v9))));
    v11 = true;
    if typeof(v10) ~= "function" then
        v11 = typeof(v10) == "nil";
    end;
    assert(v11, string.format("Result:match expects errorHandler to be a function or nil, got %s", (typeof(v10))));
    local v12 = nil;
    if not v8._status then
        if v10 ~= nil then
            v12 = v10(v8._value);
        else
            return v8;
        end;
    elseif v9 ~= nil then
        v12 = v9(v8._value);
    else
        return v8;
    end;
    if not v0.is(v12) then
        return v0.success(v12);
    else
        return v12;
    end;
end;
v0.matchSuccess = function(v13, v14)
    return v13:match(v14, nil);
end;
v0.matchError = function(v15, v16)
    return v15:match(nil, v16);
end;
v0.unwrap = function(v17)
    return v17._status, v17._value;
end;
return v0;


game:DefineFastFlag("CacheParsePolicy", true);
return function()
    return game:GetFastFlag("CacheParsePolicy");
end;


game:DefineFastFlag("FixAppPolicyDefaultUserId", false);
return function()
    return game:GetFastFlag("FixAppPolicyDefaultUserId");
end;


local v0 = require(script.Parent.Parent.Roact);
local v1 = require(script.Parent.AppPolicyContext);
return function()
    local v2 = v0.Component:extend("PolicyProvider");
    v2.init = function(v3, v4)
        assert(type(v4.policy) == "table", "Provider expects props.policy to be a table");
        v3.policy = {
            presentationPolicy = v4.policy,
            staticExternalPolicy = v4.policyData
        };
    end;
    v2.render = function(v5)
        return v0.createElement(v1.Provider, {
            value = v5.policy
        }, v5.props[v0.Children]);
    end;
    return v2;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Roact);
local v2 = require(l_Parent_0.Cryo);
local v3 = require(script.Parent.Logger);
local v4 = require(script.Parent.AppPolicyContext);
local function v10(v5, v6)
    local v7 = {};
    for _, v9 in ipairs(v6) do
        v7 = v2.Dictionary.join(v7, v9(v5));
    end;
    return v7;
end;
return function(v11)
    assert(v11, "expected getPolicyImpl");
    return function(v12)
        assert(type(v12) == "function", "connect expects mapper to be a function");
        return function(v13)
            local v14 = ("AppPolicy(%s)"):format((tostring(v13)));
            local v15 = v3:new(v14);
            v15:setContext({
                prefix = string.format("%s: ", v14)
            });
            local v16 = string.format("%s: Not a descendent of PolicyProvider", v14);
            local v17 = v1.PureComponent:extend(v14);
            v15:trace("Connected to component: {}", (tostring(v13)));
            v17.init = function(v18, v19)
                v18.policyContext = v19.policy;
                assert(v18.policyContext, v16);
                v18.setWithEmptyPolicy = function()
                    v18.state = {
                        policy = v10({}, v18.policyContext.presentationPolicy)
                    };
                end;
                if not v18.policyContext.staticExternalPolicy then
                    local v20 = v11.read();
                    if not v20 then
                        v18.setWithEmptyPolicy();
                        v15:trace("No app policy data available");
                    else
                        v18.state = {
                            policy = v10(v20, v18.policyContext.presentationPolicy)
                        };
                    end;
                    v18.onPolicyChanged = function(v21)
                        v18:setState({
                            policy = v10(v21, v18.policyContext.presentationPolicy)
                        });
                    end;
                    return ;
                else
                    v18.state = {
                        policy = v10(v18.policyContext.staticExternalPolicy, v18.policyContext.presentationPolicy)
                    };
                    return ;
                end;
            end;
            v17.didMount = function(v22)
                if not v22.policyContext.staticExternalPolicy then
                    v22.connection = v11.onPolicyChanged(function(v23)
                        v15:trace("Received policy update from MemStorageService");
                        v22.onPolicyChanged(v23);
                    end);
                    return ;
                else
                    return ;
                end;
            end;
            v17.render = function(v24)
                return v1.createElement(v13, (v2.Dictionary.join(v24.props.innerProps, (v12(v24.state.policy, v24.props.innerProps)))));
            end;
            v17.willUnmount = function(v25)
                if v25.connection then
                    v25.connection:Disconnect();
                end;
                v25.onPolicyChange = nil;
            end;
            return function(v26)
                return v1.createElement(v4.Consumer, {
                    render = function(v27)
                        return v1.createElement(v17, {
                            innerProps = v26,
                            policy = v27
                        });
                    end
                });
            end;
        end;
    end;
end;


local l_HttpService_0 = game:GetService("HttpService");
local l_MemStorageService_0 = game:GetService("MemStorageService");
local l_Players_0 = game:GetService("Players");
local v3 = require(script.Parent.Parent.Flags.GetFFlagFixAppPolicyDefaultUserId);
local v4 = require(script.Parent.Parent.Flags.GetFFlagCacheParsePolicy);
return function(v5)
    v5 = v5 or {};
    v5.HttpService = v5.HttpService or l_HttpService_0;
    v5.MemStorageService = v5.MemStorageService or l_MemStorageService_0;
    v5.PlayersService = v5.PlayersService or l_Players_0;
    assert(v5.HttpService, "expected dependencies.HttpService");
    assert(v5.MemStorageService, "expected dependencies.MemStorageService");
    assert(v5.PlayersService, "expected dependencies.PlayersService");
    local l_HttpService_1 = v5.HttpService;
    local l_MemStorageService_1 = v5.MemStorageService;
    local l_PlayersService_0 = v5.PlayersService;
    return function(v9)
        assert(v9, "expected behavior");
        local function _()
            local v10 = -1;
            if not v3() then
                if l_PlayersService_0.LocalPlayer then
                    v10 = l_PlayersService_0.LocalPlayer.UserId;
                end;
            else
                local l_LocalPlayer_0 = l_PlayersService_0.LocalPlayer;
                if l_LocalPlayer_0 and l_LocalPlayer_0.UserId > 0 then
                    v10 = l_LocalPlayer_0.UserId;
                end;
            end;
            return "GUAC:" .. v10 .. ":" .. v9;
        end;
        local v13 = nil;
        local v14 = nil;
        local v15 = nil;
        local v16 = nil;
        local l_BindableEvent_0 = Instance.new("BindableEvent");
        local function v21(v18)
            if not (not (v18 ~= v15) or not v18) and #v18 > 0 then
                local l_status_0, l_result_0 = pcall(function()
                    return l_HttpService_1:JSONDecode(v18);
                end);
                if l_status_0 then
                    v15 = v18;
                    if v4() then
                        v16 = l_result_0;
                    end;
                    l_BindableEvent_0:Fire(l_result_0);
                end;
            end;
        end;
        return {
            read = function()
                local v22 = -1;
                if not v3() then
                    if l_PlayersService_0.LocalPlayer then
                        v22 = l_PlayersService_0.LocalPlayer.UserId;
                    end;
                else
                    local l_LocalPlayer_1 = l_PlayersService_0.LocalPlayer;
                    if l_LocalPlayer_1 and l_LocalPlayer_1.UserId > 0 then
                        v22 = l_LocalPlayer_1.UserId;
                    end;
                end;
                v22 = l_MemStorageService_1:GetItem("GUAC:" .. v22 .. ":" .. v9);
                if v22 and #v22 > 0 then
                    local l_status_1, l_result_1 = pcall(function()
                        return l_HttpService_1:JSONDecode(v22);
                    end);
                    if l_status_1 then
                        if v4() then
                            v16 = l_result_1;
                        end;
                        v15 = v22;
                        return l_result_1;
                    end;
                end;
                return nil;
            end,
            onPolicyChanged = function(v26)
                local v27 = -1;
                if not v3() then
                    if l_PlayersService_0.LocalPlayer then
                        v27 = l_PlayersService_0.LocalPlayer.UserId;
                    end;
                else
                    local l_LocalPlayer_2 = l_PlayersService_0.LocalPlayer;
                    if l_LocalPlayer_2 and l_LocalPlayer_2.UserId > 0 then
                        v27 = l_LocalPlayer_2.UserId;
                    end;
                end;
                local v29 = "GUAC:" .. v27 .. ":" .. v9;
                v27 = l_BindableEvent_0.Event:Connect(v26);
                if v14 and v13 == v29 then
                    if not v4() then
                        if v15 then
                            local l_status_2, l_result_2 = pcall(function()
                                return l_HttpService_1:JSONDecode(v15);
                            end);
                            if l_status_2 then
                                v26(l_result_2);
                                return v27;
                            end;
                        end;
                    elseif v16 then
                        v26(v16);
                        return v27;
                    end;
                else
                    if v14 then
                        v14:Disconnect();
                    end;
                    v13 = v29;
                    v14 = l_MemStorageService_1:BindAndFire(v29, v21);
                end;
                return v27;
            end
        };
    end;
end;


local l_PolicyService_0 = game:GetService("PolicyService");
local l_Players_0 = game:GetService("Players");
local l_Parent_0 = script.Parent.Parent;
local v3 = require(l_Parent_0.Parent.Promise);
local v4 = require(l_Parent_0.Logger);
return function(v5)
    v5 = v5 or {};
    v5.PolicyService = v5.PolicyService or l_PolicyService_0;
    v5.PlayersService = v5.PlayersService or l_Players_0;
    assert(v5.PolicyService, "expected dependencies.PolicyService");
    assert(v5.PlayersService, "expected dependencies.PlayersService");
    local l_PolicyService_1 = v5.PolicyService;
    local l_PlayersService_0 = v5.PlayersService;
    return function()
        return {
            read = function()
                return nil;
            end,
            onPolicyChanged = function(v8)
                local l_BindableEvent_0 = Instance.new("BindableEvent");
                local v10 = l_BindableEvent_0.Event:Connect(v8);
                v3.new(function(v11, v12)
                    local l_LocalPlayer_0 = l_PlayersService_0.LocalPlayer;
                    if not l_LocalPlayer_0 then
                        v12("LocalPlayer not found");
                        return ;
                    else
                        local l_status_0, l_result_0 = pcall(function()
                            return l_PolicyService_1:GetPolicyInfoForPlayerAsync(l_LocalPlayer_0);
                        end);
                        if not l_status_0 then
                            v12("GetPolicyInfoForPlayerAsync had an error when calling");
                            return ;
                        elseif not l_result_0 then
                            v12("GetPolicyInfoForPlayerAsync return nil value");
                            return ;
                        else
                            v11(l_result_0);
                            return ;
                        end;
                    end;
                end):andThen(function(v16)
                    l_BindableEvent_0:Fire(v16);
                end):catch(function(v17)
                    v4:warning("Could not fetch from PolicyService due to error: {}", v17);
                end);
                return v10;
            end
        };
    end;
end;


local function v0()
end;
return function()
    return function(v1)
        assert(v1, "expected externalPolicy");
        return {
            read = function()
                return v1;
            end,
            onPolicyChanged = function(v2)
                return Instance.new("BindableEvent").Event:Connect(v2 or v0);
            end
        };
    end;
end;


local v0 = require(script.connect);
local v1 = require(script.Provider);
local v2 = require(script.Logger);
local l_getPolicyImplementations_0 = script.getPolicyImplementations;
return {
    withGetPolicyImplementation = function(v4)
        assert(v4.read, "expected getPolicyImpl to have `read` function");
        assert(v4.onPolicyChanged, "expected getPolicyImpl to have `onPolicyChanged` function");
        return {
            connect = v0(v4),
            Provider = v1()
        };
    end,
    GetPolicyImplementations = {
        MemStorageService = require(l_getPolicyImplementations_0.fromMemStorageService)(),
        PolicyService = require(l_getPolicyImplementations_0.fromPolicyService)(),
        Static = require(l_getPolicyImplementations_0.fromStaticSource)()
    },
    Logger = v2,
    AppPolicyContext = require(script.AppPolicyContext)
};


local v0 = require(script.Parent.Parent.Cryo);
local v1 = {};
v1.__index = v1;
v1.Levels = {
    Error = "Error",
    Warning = "Warning",
    Info = "Info",
    Debug = "Debug",
    Trace = "Trace"
};
local v2 = {
    v1.Levels.Error,
    v1.Levels.Warning,
    v1.Levels.Info,
    v1.Levels.Debug,
    v1.Levels.Trace
};
local v3 = {};
for v4, v5 in pairs(v2) do
    v3[v5] = v4;
end;
v1.Levels.fromString = function(v6)
    if type(v6) ~= "string" then
        return nil;
    else
        for _, v8 in pairs(v2) do
            if string.lower(v8) == string.lower(v6) then
                return v8;
            end;
        end;
        return nil;
    end;
end;
v1.new = function(v9, v10)
    local v11 = {
        name = v10,
        sinks = {},
        children = {},
        parent = v9,
        context = {},
        dirty = true,
        active = {},
        cache = {
            sinks = {},
            context = {}
        }
    };
    for v12, _ in pairs(v1.Levels) do
        if not v9 then
            v11.active[v12] = false;
        else
            v11.active[v12] = v9.active[v12];
        end;
    end;
    if v9 then
        v9.children[v11] = true;
    end;
    setmetatable(v11, v1);
    return v11;
end;
local function v14(v15, v16)
    local v17 = v3[v15];
    if v17 then
        for v18 = 1, v17 do
            v16.active[v2[v18]] = true;
        end;
        for v19, _ in pairs(v16.children) do
            v14(v15, v19);
        end;
    end;
end;
local function v21(v22)
    v22.dirty = true;
    for v23, _ in pairs(v22.children) do
        v21(v23);
    end;
end;
local function v25(v26)
    if v26.dirty then
        if v26.parent then
            v25(v26.parent);
            v26.cache.context = v0.Dictionary.join(v26.parent.cache.context, v26.context);
            if not (not v26.parent.cache.context.prefix or not v26.context.prefix) then
                v26.cache.context.prefix = v26.parent.cache.context.prefix .. v26.context.prefix;
            end;
            v26.cache.sinks = v0.List.join(v26.parent.cache.sinks, v26.sinks);
            v26.dirty = false;
            return ;
        else
            v26.cache.context = v26.context;
            v26.cache.sinks = v26.sinks;
            v26.dirty = false;
            return ;
        end;
    else
        return ;
    end;
end;
v1.setParent = function(v27, v28)
    if v27.parent then
        v27.parent.children[v27] = nil;
    end;
    v25(v28);
    v27.parent = v28;
    v27.parent.children[v27] = true;
    local v29 = -1;
    for _, v31 in pairs(v28.cache.sinks) do
        if v3[v31.maxLevel] then
            v29 = math.max(v29, v3[v31.maxLevel]);
        end;
    end;
    if v29 > -1 then
        v14(v2[v29], v27);
    end;
    v27.dirty = true;
    for v32, _ in pairs(v27.children) do
        v21(v32);
    end;
end;
v1.addSink = function(v34, v35)
    v14(v35.maxLevel, v34);
    table.insert(v34.sinks, v35);
    v34.dirty = true;
    for v36, _ in pairs(v34.children) do
        v21(v36);
    end;
end;
v1.setContext = function(v38, v39)
    v38.context = v39;
    v38.dirty = true;
    for v40, _ in pairs(v38.children) do
        v21(v40);
    end;
end;
local function v57(v42, v43, v44)
    if v43.dirty then
        v25(v43);
    end;
    local v45 = {
        level = v42,
        rawMessage = v44,
        loggerName = v43.name
    };
    for v46, v47 in pairs(v43.cache.context) do
        if type(v47) == "function" and v46 ~= "tostring" then
            v45[v46] = v47();
        else
            v45[v46] = v47;
        end;
    end;
    local v48 = v45.tostring or tostring;
    local v49 = nil;
    v49 = v44.n == 0 and "LUMBERYAK INTERNAL: No log message given" or v44[1];
    if v45.prefix then
        v49 = v45.prefix .. v49;
    end;
    if not v49:find("{") then
        if v44.n > 1 then
            v49 = v49 .. "\nLUMBERYAK INTERNAL: Too many arguments given for format string";
        end;
    else
        local v50 = 1;
        do
            local l_v50_0 = v50;
            v49 = v49:gsub("{(.-)}", function(v52)
                if v52 == "" then
                    l_v50_0 = l_v50_0 + 1;
                    return v48(v44[l_v50_0]);
                else
                    local v53 = v45[v52];
                    return v53 and v48(v53);
                end;
            end);
            if l_v50_0 < v44.n then
                v49 = v49 .. "\nLUMBERYAK INTERNAL: Too many arguments given for format string";
            elseif v44.n < l_v50_0 then
                v49 = v49 .. "\nLUMBERYAK INTERNAL: Too few arguments given for format string";
            end;
        end;
    end;
    local v54 = v3[v42];
    for _, v56 in pairs(v43.cache.sinks) do
        if v3[v56.maxLevel] and v54 <= v3[v56.maxLevel] then
            v56:log(v49, v45);
        end;
    end;
end;
v1.error = function(v58, ...)
    if v58.active[v1.Levels.Error] then
        v57(v1.Levels.Error, v58, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.warning = function(v59, ...)
    if v59.active[v1.Levels.Warning] then
        v57(v1.Levels.Warning, v59, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.info = function(v60, ...)
    if v60.active[v1.Levels.Info] then
        v57(v1.Levels.Info, v60, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.debug = function(v61, ...)
    if v61.active[v1.Levels.Debug] then
        v57(v1.Levels.Debug, v61, table.pack(...));
        return ;
    else
        return ;
    end;
end;
v1.trace = function(v62, ...)
    if v62.active[v1.Levels.Trace] then
        v57(v1.Levels.Trace, v62, table.pack(...));
        return ;
    else
        return ;
    end;
end;
return v1;


local l_networkRequests_0 = script.Parent.networkRequests;
local v1 = require(l_networkRequests_0.createAddToConversation);
local v2 = require(l_networkRequests_0.createRemoveFromConversation);
local v3 = require(l_networkRequests_0.createRenameGroupConversation);
local v4 = require(l_networkRequests_0.createStartGroupConversation);
local v5 = require(l_networkRequests_0.createStartOneToOneConversation);
local v6 = require(l_networkRequests_0.createSetConversationUniverse);
local v7 = require(l_networkRequests_0.createResetConversationUniverse);
local v8 = require(l_networkRequests_0.createSendMessage);
local v9 = require(l_networkRequests_0.createSendGameLinkMessage);
local v10 = require(l_networkRequests_0.createUpdateUserTypingStatus);
local v11 = require(l_networkRequests_0.createMarkAsRead);
local v12 = require(l_networkRequests_0.createMarkAsSeen);
local v13 = require(l_networkRequests_0.createGetMessages);
local v14 = require(l_networkRequests_0.createGetUserConversations);
local v15 = require(l_networkRequests_0.createGetConversations);
local v16 = require(l_networkRequests_0.createGetLatestMessages);
local v17 = require(l_networkRequests_0.createGetUnreadConversationCount);
local v18 = require(l_networkRequests_0.createGetUnreadMessages);
local v19 = require(l_networkRequests_0.createGetChatSettings);
local v20 = require(l_networkRequests_0.createGetRolloutSettings);
local v21 = require(l_networkRequests_0.createGetMetadata);
return function(v22)
    return {
        AddToConversation = v1(v22),
        RemoveFromConversation = v2(v22),
        RenameGroupConversation = v3(v22),
        StartGroupConversation = v4(v22),
        StartOneToOneConversation = v5(v22),
        SetConversationUniverse = v6(v22),
        ResetConversationUniverse = v7(v22),
        SendMessage = v8(v22),
        SendGameLinkMessage = v9(v22),
        UpdateUserTypingStatus = v10(v22),
        MarkAsRead = v11(v22),
        MarkAsSeen = v12(v22),
        GetMessages = v13(v22),
        GetUserConversations = v14(v22),
        GetConversations = v15(v22),
        GetLatestMessages = v16(v22),
        GetUnreadConversationCount = v17(v22),
        GetUnreadMessages = v18(v22),
        GetChatSettings = v19(v22),
        GetRolloutSettings = v20(v22),
        GetMetadata = v21(v22)
    };
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "AddToConversation"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("add-to-conversation"):body({
            participantUserIds = v3,
            conversationId = v4
        }):setStatusIds({
            v4
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetChatSettings"
    }, function(v2)
        return v2(v0):path("v2"):path("chat-settings");
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetConversations"
    }, function(v2, v3)
        return v2(v0):path("v2"):path("get-conversations"):expandedQueryArgsWithIds("conversationIds", v3);
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetLatestMessages"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("multi-get-latest-messages"):queryArgs({
            pageSize = v4
        }):expandedQueryArgsWithIds("conversationIds", v3);
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetMessages"
    }, function(v2, v3, v4, v5)
        return v2(v0):path("v2"):path("get-messages"):queryArgs({
            conversationId = v3,
            pageSize = v4,
            exclusiveStartMessageId = v5
        }):setStatusIds({
            v3
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetMetadata"
    }, function(v2)
        return v2(v0):path("v2"):path("metadata");
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetRolloutSettings"
    }, function(v2, v3)
        return v2(v0):path("v2"):path("get-rollout-settings"):expandedQueryArgsWithIds("featureNames", v3);
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetUnreadConversationCount"
    }, function(v2)
        return v2(v0):path("v2"):path("get-unread-conversation-count");
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetUnreadMessages"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("get-unread-messages"):queryArgs({
            pageSize = v4
        }):expandedQueryArgsWithIds("conversationIds", v3);
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.GET({
        Name = "GetUserConversations"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("get-user-conversations"):queryArgs({
            pageNumber = v3,
            pageSize = v4
        }):setStatusIds({
            v3
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "MarkAsRead"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("mark-as-read"):body({
            conversationId = v3,
            endMessageId = v4
        }):setStatusIds({
            v3
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "MarkAsSeen"
    }, function(v2, v3)
        return v2(v0):path("v2"):path("mark-as-seen"):body({
            conversationsToMarkSeen = v3
        }):setStatusIds(v3);
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "RemoveFromConversation"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("remove-from-conversation"):body({
            participantUserId = v3,
            conversationId = v4
        }):setStatusIds({
            v4
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "RenameGroupConversation"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("rename-group-conversation"):body({
            conversationId = v3,
            newTitle = v4
        }):setStatusIds({
            v3
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "ResetConversationUniverse"
    }, function(v2, v3)
        return v2(v0):path("v2"):path("reset-conversation-universe"):body({
            conversationId = v3
        }):setStatusIds({
            v3
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "SendGameLinkMessage"
    }, function(v2, v3, v4, v5)
        return v2(v0):path("v2"):path("send-game-link-message"):body({
            universeId = v3,
            conversationId = v4,
            decorators = v5
        }):setStatusIds({
            v4
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "SendMessage"
    }, function(v2, v3, v4, v5)
        return v2(v0):path("v2"):path("send-message"):body({
            message = v3,
            conversationId = v4,
            decorators = v5
        }):setStatusIds({
            v4
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "SetConversationUniverse"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("set-conversation-universe"):body({
            conversationId = v3,
            universeId = v4
        }):setStatusIds({
            v3
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "StartGroupConversation"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("start-group-conversation"):body({
            participantUserIds = v3,
            title = v4
        }):setStatusIds(v3);
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "StartOneToOneConversation"
    }, function(v2, v3)
        return v2(v0):path("v2"):path("start-one-to-one-conversation"):body({
            participantUserId = v3
        }):setStatusIds({
            v3
        });
    end);
end;


local v0 = require(script.Parent.Parent.CHAT_URL);
return function(v1)
    return v1.roduxNetworking.POST({
        Name = "UpdateUserTypingStatus"
    }, function(v2, v3, v4)
        return v2(v0):path("v2"):path("update-user-typing-status"):body({
            conversationId = v3,
            isTyping = v4
        }):setStatusIds({
            v3
        });
    end);
end;


local l_networkRequests_0 = script.Parent.networkRequests;
local v1 = require(l_networkRequests_0.createGetSkinnyUsersFromUserIds);
local v2 = require(l_networkRequests_0.createGetUsernameHistoryFromUserId);
local v3 = require(l_networkRequests_0.createGetUserV2FromUserId);
return function(v4)
    return {
        GetSkinnyUsersFromUserIds = v1(v4),
        GetUsernameHistoryFromUserId = v2(v4),
        GetUserV2FromUserId = v3(v4)
    };
end;


local l_RunService_0 = game:GetService("RunService");
local v1 = require(script.Parent.StringSplit);
assertIsType = function(v2, v3, v4)
    if not (not l_RunService_0:IsStudio() and not _G.__TESTEZ_RUNNING_TEST__) then
        assert(typeof(v2) == v3, string.format("expects %s to be a %s %s", v4, v3, (typeof(v2))));
    end;
end;
local function v7(v5)
    assertIsType(v5, "string", "input");
    return (string.gsub(string.gsub(v5, "%%(%x%x)", function(v6)
        return (string.char((tonumber(v6, 16))));
    end), "+", " "));
end;
return function(v8, v9)
    if v8 ~= nil then
        assertIsType(v8, "string", "input");
    end;
    if v9 ~= nil then
        assertIsType(v9, "function", "listKeyMapper");
    end;
    local v10 = type(v9) == "function";
    local v11 = {};
    if v8 and #v8 > 0 then
        for _, v13 in ipairs((v1(v8, "[&;]"))) do
            if v13 and #v13 > 0 then
                local v14, v15 = unpack(string.split(v13, "="));
                if v15 == nil then
                    v15 = "";
                end;
                v14 = v7(v14);
                v15 = v7(v15);
                if not v10 then
                    if v11[v14] == nil then
                        v11[v14] = {};
                    end;
                    table.insert(v11[v14], v15);
                elseif v11[v14] ~= nil then
                    local v16 = v9(v14);
                    if v16 == nil then
                        v16 = v14;
                    end;
                    if type(v11[v16]) ~= "table" then
                        v11[v16] = {
                            v11[v14]
                        };
                    end;
                    table.insert(v11[v16], v15);
                    if v14 ~= v16 then
                        v11[v14] = v15;
                    end;
                else
                    v11[v14] = v15;
                end;
            end;
        end;
    end;
    return v11;
end;


return function(v0, v1)
    if type(v0) ~= "string" then
        return "";
    elseif type(v1) ~= "table" then
        return v0;
    else
        local l_v0_0 = v0;
        for v3, v4 in pairs(v1) do
            if type(v3) == "string" and type(v4) == "string" then
                l_v0_0 = string.gsub(l_v0_0, v3, v4);
            end;
        end;
        return l_v0_0;
    end;
end;


local function v0(v1, v2, v3)
    if #v1 == 0 then
        if not string.find(v1, v2) then
            return {
                ""
            };
        else
            return {};
        end;
    else
        if not v3 then
            v3 = -1;
        end;
        if v3 == 1 then
            return {
                v1
            };
        else
            if not v2 then
                v2 = "%s+";
            end;
            local v4, v5 = string.find(v1, v2);
            if v4 then
                if v5 < 1 then
                    local v6, v7 = string.find(string.sub(v1, 2), v2);
                    v4 = v6;
                    v5 = v7;
                    v4 = v4 + 1;
                    v5 = v5 + 1;
                end;
                local v8 = string.sub(v1, 1, v4 - 1);
                local v9 = string.sub(v1, v5 + 1);
                if #v9 == 0 and v4 <= v5 then
                    return {
                        v8,
                        v9
                    };
                else
                    local v10 = v0(v9, v2, v3 - 1);
                    table.insert(v10, 1, v8);
                    return v10;
                end;
            else
                return {
                    v1
                };
            end;
        end;
    end;
end;
return v0;


return function(v0, v1, v2)
    if not v1 then
        v1 = "%s";
    end;
    if #v1 == 0 then
        return v0;
    else
        if not v2 then
            v2 = {
                left = true,
                right = true
            };
        end;
        local l_v0_0 = v0;
        if v2.left then
            local v4 = string.find(l_v0_0, "[^" .. v1 .. "]");
            if v4 then
                l_v0_0 = string.sub(l_v0_0, v4);
            else
                return "";
            end;
        end;
        if v2.right then
            local v5 = string.find(l_v0_0, "[" .. v1 .. "]+$");
            if v5 then
                l_v0_0 = string.sub(l_v0_0, 1, v5 - 1);
            else
                return l_v0_0;
            end;
        end;
        return l_v0_0;
    end;
end;


return {
    ParseQuery = require(script.ParseQuery),
    StringReplaceAll = require(script.StringReplaceAll),
    StringSplit = require(script.StringSplit),
    StringTrim = require(script.StringTrim)
};


local v0 = typeof or type;
local function _(v1)
    return function(v2)
        local v3 = v0(v2);
        if v3 == v1 then
            return true;
        else
            return false, string.format("%s expected, got %s", v1, v3);
        end;
    end;
end;
local v6 = {
    any = function(v5)
        if v5 ~= nil then
            return true;
        else
            return false, "any expected, got nil";
        end;
    end
};
local v7 = "boolean";
local l_v7_0 = v7 --[[ copy: 4 -> 5 ]];
v6.boolean = function(v9)
    local v10 = v0(v9);
    if v10 == l_v7_0 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_0, v10);
    end;
end;
v7 = "thread";
local l_v7_1 = v7 --[[ copy: 4 -> 6 ]];
v6.thread = function(v12)
    local v13 = v0(v12);
    if v13 == l_v7_1 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_1, v13);
    end;
end;
v7 = "function";
local l_v7_2 = v7 --[[ copy: 4 -> 7 ]];
v6.callback = function(v15)
    local v16 = v0(v15);
    if v16 == l_v7_2 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_2, v16);
    end;
end;
v7 = "nil";
local l_v7_3 = v7 --[[ copy: 4 -> 8 ]];
v6.none = function(v18)
    local v19 = v0(v18);
    if v19 == l_v7_3 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_3, v19);
    end;
end;
v7 = "string";
local l_v7_4 = v7 --[[ copy: 4 -> 9 ]];
v6.string = function(v21)
    local v22 = v0(v21);
    if v22 == l_v7_4 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_4, v22);
    end;
end;
v7 = "table";
local l_v7_5 = v7 --[[ copy: 4 -> 10 ]];
v6.table = function(v24)
    local v25 = v0(v24);
    if v25 == l_v7_5 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_5, v25);
    end;
end;
v7 = "userdata";
local l_v7_6 = v7 --[[ copy: 4 -> 11 ]];
v6.userdata = function(v27)
    local v28 = v0(v27);
    if v28 == l_v7_6 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_6, v28);
    end;
end;
v6.number = function(v29)
    local v30 = v0(v29);
    if v30 == "number" then
        if v29 == v29 then
            return true;
        else
            return false, "unexpected NaN value";
        end;
    else
        return false, string.format("number expected, got %s", v30);
    end;
end;
v6.nan = function(v31)
    if v31 ~= v31 then
        return true;
    else
        return false, "unexpected non-NaN value";
    end;
end;
v7 = "Axes";
local l_v7_7 = v7 --[[ copy: 4 -> 12 ]];
v6.Axes = function(v33)
    local v34 = v0(v33);
    if v34 == l_v7_7 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_7, v34);
    end;
end;
v7 = "BrickColor";
local l_v7_8 = v7 --[[ copy: 4 -> 13 ]];
v6.BrickColor = function(v36)
    local v37 = v0(v36);
    if v37 == l_v7_8 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_8, v37);
    end;
end;
v7 = "CFrame";
local l_v7_9 = v7 --[[ copy: 4 -> 14 ]];
v6.CFrame = function(v39)
    local v40 = v0(v39);
    if v40 == l_v7_9 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_9, v40);
    end;
end;
v7 = "Color3";
local l_v7_10 = v7 --[[ copy: 4 -> 15 ]];
v6.Color3 = function(v42)
    local v43 = v0(v42);
    if v43 == l_v7_10 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_10, v43);
    end;
end;
v7 = "ColorSequence";
local l_v7_11 = v7 --[[ copy: 4 -> 16 ]];
v6.ColorSequence = function(v45)
    local v46 = v0(v45);
    if v46 == l_v7_11 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_11, v46);
    end;
end;
v7 = "ColorSequenceKeypoint";
local l_v7_12 = v7 --[[ copy: 4 -> 17 ]];
v6.ColorSequenceKeypoint = function(v48)
    local v49 = v0(v48);
    if v49 == l_v7_12 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_12, v49);
    end;
end;
v7 = "DockWidgetPluginGuiInfo";
local l_v7_13 = v7 --[[ copy: 4 -> 18 ]];
v6.DockWidgetPluginGuiInfo = function(v51)
    local v52 = v0(v51);
    if v52 == l_v7_13 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_13, v52);
    end;
end;
v7 = "Faces";
local l_v7_14 = v7 --[[ copy: 4 -> 19 ]];
v6.Faces = function(v54)
    local v55 = v0(v54);
    if v55 == l_v7_14 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_14, v55);
    end;
end;
v7 = "Instance";
local l_v7_15 = v7 --[[ copy: 4 -> 20 ]];
v6.Instance = function(v57)
    local v58 = v0(v57);
    if v58 == l_v7_15 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_15, v58);
    end;
end;
v7 = "NumberRange";
local l_v7_16 = v7 --[[ copy: 4 -> 21 ]];
v6.NumberRange = function(v60)
    local v61 = v0(v60);
    if v61 == l_v7_16 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_16, v61);
    end;
end;
v7 = "NumberSequence";
local l_v7_17 = v7 --[[ copy: 4 -> 22 ]];
v6.NumberSequence = function(v63)
    local v64 = v0(v63);
    if v64 == l_v7_17 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_17, v64);
    end;
end;
v7 = "NumberSequenceKeypoint";
local l_v7_18 = v7 --[[ copy: 4 -> 23 ]];
v6.NumberSequenceKeypoint = function(v66)
    local v67 = v0(v66);
    if v67 == l_v7_18 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_18, v67);
    end;
end;
v7 = "PathWaypoint";
local l_v7_19 = v7 --[[ copy: 4 -> 24 ]];
v6.PathWaypoint = function(v69)
    local v70 = v0(v69);
    if v70 == l_v7_19 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_19, v70);
    end;
end;
v7 = "PhysicalProperties";
local l_v7_20 = v7 --[[ copy: 4 -> 25 ]];
v6.PhysicalProperties = function(v72)
    local v73 = v0(v72);
    if v73 == l_v7_20 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_20, v73);
    end;
end;
v7 = "Random";
local l_v7_21 = v7 --[[ copy: 4 -> 26 ]];
v6.Random = function(v75)
    local v76 = v0(v75);
    if v76 == l_v7_21 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_21, v76);
    end;
end;
v7 = "Ray";
local l_v7_22 = v7 --[[ copy: 4 -> 27 ]];
v6.Ray = function(v78)
    local v79 = v0(v78);
    if v79 == l_v7_22 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_22, v79);
    end;
end;
v7 = "Rect";
local l_v7_23 = v7 --[[ copy: 4 -> 28 ]];
v6.Rect = function(v81)
    local v82 = v0(v81);
    if v82 == l_v7_23 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_23, v82);
    end;
end;
v7 = "Region3";
local l_v7_24 = v7 --[[ copy: 4 -> 29 ]];
v6.Region3 = function(v84)
    local v85 = v0(v84);
    if v85 == l_v7_24 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_24, v85);
    end;
end;
v7 = "Region3int16";
local l_v7_25 = v7 --[[ copy: 4 -> 30 ]];
v6.Region3int16 = function(v87)
    local v88 = v0(v87);
    if v88 == l_v7_25 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_25, v88);
    end;
end;
v7 = "TweenInfo";
local l_v7_26 = v7 --[[ copy: 4 -> 31 ]];
v6.TweenInfo = function(v90)
    local v91 = v0(v90);
    if v91 == l_v7_26 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_26, v91);
    end;
end;
v7 = "UDim";
local l_v7_27 = v7 --[[ copy: 4 -> 32 ]];
v6.UDim = function(v93)
    local v94 = v0(v93);
    if v94 == l_v7_27 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_27, v94);
    end;
end;
v7 = "UDim2";
local l_v7_28 = v7 --[[ copy: 4 -> 33 ]];
v6.UDim2 = function(v96)
    local v97 = v0(v96);
    if v97 == l_v7_28 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_28, v97);
    end;
end;
v7 = "Vector2";
local l_v7_29 = v7 --[[ copy: 4 -> 34 ]];
v6.Vector2 = function(v99)
    local v100 = v0(v99);
    if v100 == l_v7_29 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_29, v100);
    end;
end;
v7 = "Vector3";
local l_v7_30 = v7 --[[ copy: 4 -> 35 ]];
v6.Vector3 = function(v102)
    local v103 = v0(v102);
    if v103 == l_v7_30 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_30, v103);
    end;
end;
v7 = "Vector3int16";
local l_v7_31 = v7 --[[ copy: 4 -> 36 ]];
v6.Vector3int16 = function(v105)
    local v106 = v0(v105);
    if v106 == l_v7_31 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_31, v106);
    end;
end;
v7 = "Enum";
local l_v7_32 = v7 --[[ copy: 4 -> 37 ]];
v6.Enum = function(v108)
    local v109 = v0(v108);
    if v109 == l_v7_32 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_32, v109);
    end;
end;
v7 = "EnumItem";
local l_v7_33 = v7 --[[ copy: 4 -> 38 ]];
v6.EnumItem = function(v111)
    local v112 = v0(v111);
    if v112 == l_v7_33 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_33, v112);
    end;
end;
v7 = "RBXScriptSignal";
local l_v7_34 = v7 --[[ copy: 4 -> 39 ]];
v6.RBXScriptSignal = function(v114)
    local v115 = v0(v114);
    if v115 == l_v7_34 then
        return true;
    else
        return false, string.format("%s expected, got %s", l_v7_34, v115);
    end;
end;
v7 = "RBXScriptConnection";
v6.RBXScriptConnection = function(v116)
    local v117 = v0(v116);
    if v117 == v7 then
        return true;
    else
        return false, string.format("%s expected, got %s", v7, v117);
    end;
end;
v6.literal = function(...)
    local v118 = select("#", ...);
    if v118 == 1 then
        local v119 = ...;
        return function(v120)
            if v120 ~= v119 then
                return false, string.format("expected %s, got %s", tostring(v119), (tostring(v120)));
            else
                return true;
            end;
        end;
    else
        local v121 = {};
        for v122 = 1, v118 do
            v121[v122] = v6.literal((select(v122, ...)));
        end;
        return v6.union(unpack(v121));
    end;
end;
v6.exactly = v6.literal;
v6.keyOf = function(v123)
    local v124 = {};
    for v125 in pairs(v123) do
        v124[#v124 + 1] = v125;
    end;
    return v6.literal(unpack(v124));
end;
v6.valueOf = function(v126)
    local v127 = {};
    for _, v129 in pairs(v126) do
        v127[#v127 + 1] = v129;
    end;
    return v6.literal(unpack(v127));
end;
v6.integer = function(v130)
    local v131, v132 = v6.number(v130);
    if v131 then
        if v130 % 1 == 0 then
            return true;
        else
            return false, string.format("integer expected, got %s", v130);
        end;
    else
        return false, v132 or "";
    end;
end;
v6.numberMin = function(v133)
    return function(v134)
        local v135, v136 = v6.number(v134);
        if v135 then
            if v133 <= v134 then
                return true;
            else
                return false, string.format("number >= %s expected, got %s", v133, v134);
            end;
        else
            return false, v136 or "";
        end;
    end;
end;
v6.numberMax = function(v137)
    return function(v138)
        local v139, v140 = v6.number(v138);
        if v139 then
            if v138 <= v137 then
                return true;
            else
                return false, string.format("number <= %s expected, got %s", v137, v138);
            end;
        else
            return false, v140;
        end;
    end;
end;
v6.numberMinExclusive = function(v141)
    return function(v142)
        local v143, v144 = v6.number(v142);
        if v143 then
            if v141 < v142 then
                return true;
            else
                return false, string.format("number > %s expected, got %s", v141, v142);
            end;
        else
            return false, v144 or "";
        end;
    end;
end;
v6.numberMaxExclusive = function(v145)
    return function(v146)
        local v147, v148 = v6.number(v146);
        if v147 then
            if v146 < v145 then
                return true;
            else
                return false, string.format("number < %s expected, got %s", v145, v146);
            end;
        else
            return false, v148 or "";
        end;
    end;
end;
v6.numberPositive = v6.numberMinExclusive(0);
v6.numberNegative = v6.numberMaxExclusive(0);
v6.numberConstrained = function(v149, v150)
    assert(v6.number(v149) and v6.number(v150));
    local v151 = v6.numberMin(v149);
    local v152 = v6.numberMax(v150);
    return function(v153)
        local v154, v155 = v151(v153);
        if v154 then
            local v156, v157 = v152(v153);
            if v156 then
                return true;
            else
                return false, v157 or "";
            end;
        else
            return false, v155 or "";
        end;
    end;
end;
v6.numberConstrainedExclusive = function(v158, v159)
    assert(v6.number(v158) and v6.number(v159));
    local v160 = v6.numberMinExclusive(v158);
    local v161 = v6.numberMaxExclusive(v159);
    return function(v162)
        local v163, v164 = v160(v162);
        if v163 then
            local v165, v166 = v161(v162);
            if v165 then
                return true;
            else
                return false, v166 or "";
            end;
        else
            return false, v164 or "";
        end;
    end;
end;
v6.match = function(v167)
    assert(v6.string(v167));
    return function(v168)
        local v169, v170 = v6.string(v168);
        if v169 then
            if string.match(v168, v167) == nil then
                return false, string.format("\"%s\" failed to match pattern \"%s\"", v168, v167);
            else
                return true;
            end;
        else
            return false, v170;
        end;
    end;
end;
v6.optional = function(v171)
    assert(v6.callback(v171));
    return function(v172)
        if v172 == nil then
            return true;
        else
            local v173, v174 = v171(v172);
            if not v173 then
                return false, string.format("(optional) %s", v174 or "");
            else
                return true;
            end;
        end;
    end;
end;
v6.tuple = function(...)
    local v175 = {
        ...
    };
    return function(...)
        local v176 = {
            ...
        };
        for v177 = 1, #v175 do
            local v178, v179 = v175[v177](v176[v177]);
            if v178 == false then
                return false, string.format("Bad tuple index #%s:\n\t%s", v177, v179 or "");
            end;
        end;
        return true;
    end;
end;
v6.keys = function(v180)
    assert(v6.callback(v180));
    return function(v181)
        local v182, v183 = v6.table(v181);
        if v182 == false then
            return false, v183 or "";
        else
            for v184 in pairs(v181) do
                local v185, v186 = v180(v184);
                if v185 == false then
                    return false, string.format("bad key %s:\n\t%s", tostring(v184), v186 or "");
                end;
            end;
            return true;
        end;
    end;
end;
v6.values = function(v187)
    assert(v6.callback(v187));
    return function(v188)
        local v189, v190 = v6.table(v188);
        if v189 == false then
            return false, v190 or "";
        else
            for v191, v192 in pairs(v188) do
                local v193, v194 = v187(v192);
                if v193 == false then
                    return false, string.format("bad value for key %s:\n\t%s", tostring(v191), v194 or "");
                end;
            end;
            return true;
        end;
    end;
end;
v6.map = function(v195, v196)
    assert(v6.callback(v195), v6.callback(v196));
    local v197 = v6.keys(v195);
    local v198 = v6.values(v196);
    return function(v199)
        local v200, v201 = v197(v199);
        if v200 then
            local v202, v203 = v198(v199);
            if v202 then
                return true;
            else
                return false, v203 or "";
            end;
        else
            return false, v201 or "";
        end;
    end;
end;
local v204 = v6.keys(v6.integer);
local l_v204_0 = v204 --[[ copy: 3 -> 40 ]];
v6.array = function(v206)
    assert(v6.callback(v206));
    local v207 = v6.values(v206);
    return function(v208)
        local v209, v210 = l_v204_0(v208);
        if v209 == false then
            return false, string.format("[array] %s", v210 or "");
        else
            local v211 = 0;
            for _, _ in ipairs(v208) do
                v211 = v211 + 1;
            end;
            for v214 in pairs(v208) do
                if not (v214 >= 1) or v211 < v214 then
                    return false, string.format("[array] key %s must be sequential", (tostring(v214)));
                end;
            end;
            local v215, v216 = v207(v208);
            if v215 then
                return true;
            else
                return false, string.format("[array] %s", v216 or "");
            end;
        end;
    end;
end;
v204 = v6.array(v6.callback);
local l_v204_1 = v204 --[[ copy: 3 -> 41 ]];
v6.union = function(...)
    local v218 = {
        ...
    };
    assert(l_v204_1(v218));
    return function(v219)
        for _, v221 in pairs(v218) do
            if v221(v219) then
                return true;
            end;
        end;
        return false, "bad type for union";
    end;
end;
v6.some = v6.union;
v6.intersection = function(...)
    local v222 = {
        ...
    };
    assert(l_v204_1(v222));
    return function(v223)
        for _, v225 in pairs(v222) do
            local v226, v227 = v225(v223);
            if not v226 then
                return false, v227 or "";
            end;
        end;
        return true;
    end;
end;
v6.every = v6.intersection;
v204 = v6.map(v6.any, v6.callback);
local l_v204_2 = v204 --[[ copy: 3 -> 42 ]];
v6.interface = function(v229)
    assert(l_v204_2(v229));
    return function(v230)
        local v231, v232 = v6.table(v230);
        if v231 == false then
            return false, v232 or "";
        else
            for v233, v234 in pairs(v229) do
                local v235, v236 = v234(v230[v233]);
                if v235 == false then
                    return false, string.format("[interface] bad value for %s:\n\t%s", tostring(v233), v236 or "");
                end;
            end;
            return true;
        end;
    end;
end;
v6.strictInterface = function(v237)
    assert(l_v204_2(v237));
    return function(v238)
        local v239, v240 = v6.table(v238);
        if v239 == false then
            return false, v240 or "";
        else
            for v241, v242 in pairs(v237) do
                local v243, v244 = v242(v238[v241]);
                if v243 == false then
                    return false, string.format("[interface] bad value for %s:\n\t%s", tostring(v241), v244 or "");
                end;
            end;
            for v245 in pairs(v238) do
                if not v237[v245] then
                    return false, string.format("[interface] unexpected field '%s'", (tostring(v245)));
                end;
            end;
            return true;
        end;
    end;
end;
v6.instanceOf = function(v246, v247)
    assert(v6.string(v246));
    local v248 = nil;
    if v247 ~= nil then
        v248 = v6.children(v247);
    end;
    return function(v249)
        local v250, v251 = v6.Instance(v249);
        if v250 then
            if v249.ClassName ~= v246 then
                return false, string.format("%s expected, got %s", v246, v249.ClassName);
            else
                if v248 then
                    local v252, v253 = v248(v249);
                    if not v252 then
                        return false, v253;
                    end;
                end;
                return true;
            end;
        else
            return false, v251 or "";
        end;
    end;
end;
v6.instance = v6.instanceOf;
v6.instanceIsA = function(v254, v255)
    assert(v6.string(v254));
    local v256 = nil;
    if v255 ~= nil then
        v256 = v6.children(v255);
    end;
    return function(v257)
        local v258, v259 = v6.Instance(v257);
        if v258 then
            if v257:IsA(v254) then
                if v256 then
                    local v260, v261 = v256(v257);
                    if not v260 then
                        return false, v261;
                    end;
                end;
                return true;
            else
                return false, string.format("%s expected, got %s", v254, v257.ClassName);
            end;
        else
            return false, v259 or "";
        end;
    end;
end;
v6.enum = function(v262)
    assert(v6.Enum(v262));
    return function(v263)
        local v264, v265 = v6.EnumItem(v263);
        if v264 then
            if v263.EnumType == v262 then
                return true;
            else
                return false, string.format("enum of %s expected, got enum of %s", tostring(v262), (tostring(v263.EnumType)));
            end;
        else
            return false, v265;
        end;
    end;
end;
v204 = v6.tuple(v6.callback, v6.callback);
local l_v204_3 = v204 --[[ copy: 3 -> 43 ]];
v6.wrap = function(v267, v268)
    assert(l_v204_3(v267, v268));
    return function(...)
        assert(v268(...));
        return v267(...);
    end;
end;
v6.strict = function(v269)
    return function(...)
        assert(v269(...));
    end;
end;
v204 = v6.map(v6.string, v6.callback);
v6.children = function(v270)
    assert(v204(v270));
    return function(v271)
        local v272, v273 = v6.Instance(v271);
        if v272 then
            local v274 = {};
            for _, v276 in pairs(v271:GetChildren()) do
                local l_Name_0 = v276.Name;
                if v270[l_Name_0] then
                    if not v274[l_Name_0] then
                        v274[l_Name_0] = v276;
                    else
                        return false, string.format("Cannot process multiple children with the same name \"%s\"", l_Name_0);
                    end;
                end;
            end;
            for v278, v279 in pairs(v270) do
                local v280, v281 = v279(v274[v278]);
                if not v280 then
                    return false, string.format("[%s.%s] %s", v271:GetFullName(), v278, v281 or "");
                end;
            end;
            return true;
        else
            return false, v273 or "";
        end;
    end;
end;
return v6;


local v0 = typeof or type;
local function _(v1)
    return function(v2)
        if v0(v2) == v1 then
            return true;
        else
            return false;
        end;
    end;
end;
local v5 = {
    any = function(v4)
        if v4 ~= nil then
            return true;
        else
            return false;
        end;
    end
};
local v6 = "boolean";
local l_v6_0 = v6 --[[ copy: 4 -> 5 ]];
v5.boolean = function(v8)
    if v0(v8) == l_v6_0 then
        return true;
    else
        return false;
    end;
end;
v6 = "thread";
local l_v6_1 = v6 --[[ copy: 4 -> 6 ]];
v5.thread = function(v10)
    if v0(v10) == l_v6_1 then
        return true;
    else
        return false;
    end;
end;
v6 = "function";
local l_v6_2 = v6 --[[ copy: 4 -> 7 ]];
v5.callback = function(v12)
    if v0(v12) == l_v6_2 then
        return true;
    else
        return false;
    end;
end;
v6 = "nil";
local l_v6_3 = v6 --[[ copy: 4 -> 8 ]];
v5.none = function(v14)
    if v0(v14) == l_v6_3 then
        return true;
    else
        return false;
    end;
end;
v6 = "string";
local l_v6_4 = v6 --[[ copy: 4 -> 9 ]];
v5.string = function(v16)
    if v0(v16) == l_v6_4 then
        return true;
    else
        return false;
    end;
end;
v6 = "table";
local l_v6_5 = v6 --[[ copy: 4 -> 10 ]];
v5.table = function(v18)
    if v0(v18) == l_v6_5 then
        return true;
    else
        return false;
    end;
end;
v6 = "userdata";
local l_v6_6 = v6 --[[ copy: 4 -> 11 ]];
v5.userdata = function(v20)
    if v0(v20) == l_v6_6 then
        return true;
    else
        return false;
    end;
end;
v5.number = function(v21)
    if v0(v21) == "number" then
        if v21 == v21 then
            return true;
        else
            return false;
        end;
    else
        return false;
    end;
end;
v5.nan = function(v22)
    if v22 ~= v22 then
        return true;
    else
        return false;
    end;
end;
v6 = "Axes";
local l_v6_7 = v6 --[[ copy: 4 -> 12 ]];
v5.Axes = function(v24)
    if v0(v24) == l_v6_7 then
        return true;
    else
        return false;
    end;
end;
v6 = "BrickColor";
local l_v6_8 = v6 --[[ copy: 4 -> 13 ]];
v5.BrickColor = function(v26)
    if v0(v26) == l_v6_8 then
        return true;
    else
        return false;
    end;
end;
v6 = "CFrame";
local l_v6_9 = v6 --[[ copy: 4 -> 14 ]];
v5.CFrame = function(v28)
    if v0(v28) == l_v6_9 then
        return true;
    else
        return false;
    end;
end;
v6 = "Color3";
local l_v6_10 = v6 --[[ copy: 4 -> 15 ]];
v5.Color3 = function(v30)
    if v0(v30) == l_v6_10 then
        return true;
    else
        return false;
    end;
end;
v6 = "ColorSequence";
local l_v6_11 = v6 --[[ copy: 4 -> 16 ]];
v5.ColorSequence = function(v32)
    if v0(v32) == l_v6_11 then
        return true;
    else
        return false;
    end;
end;
v6 = "ColorSequenceKeypoint";
local l_v6_12 = v6 --[[ copy: 4 -> 17 ]];
v5.ColorSequenceKeypoint = function(v34)
    if v0(v34) == l_v6_12 then
        return true;
    else
        return false;
    end;
end;
v6 = "DockWidgetPluginGuiInfo";
local l_v6_13 = v6 --[[ copy: 4 -> 18 ]];
v5.DockWidgetPluginGuiInfo = function(v36)
    if v0(v36) == l_v6_13 then
        return true;
    else
        return false;
    end;
end;
v6 = "Faces";
local l_v6_14 = v6 --[[ copy: 4 -> 19 ]];
v5.Faces = function(v38)
    if v0(v38) == l_v6_14 then
        return true;
    else
        return false;
    end;
end;
v6 = "Instance";
local l_v6_15 = v6 --[[ copy: 4 -> 20 ]];
v5.Instance = function(v40)
    if v0(v40) == l_v6_15 then
        return true;
    else
        return false;
    end;
end;
v6 = "NumberRange";
local l_v6_16 = v6 --[[ copy: 4 -> 21 ]];
v5.NumberRange = function(v42)
    if v0(v42) == l_v6_16 then
        return true;
    else
        return false;
    end;
end;
v6 = "NumberSequence";
local l_v6_17 = v6 --[[ copy: 4 -> 22 ]];
v5.NumberSequence = function(v44)
    if v0(v44) == l_v6_17 then
        return true;
    else
        return false;
    end;
end;
v6 = "NumberSequenceKeypoint";
local l_v6_18 = v6 --[[ copy: 4 -> 23 ]];
v5.NumberSequenceKeypoint = function(v46)
    if v0(v46) == l_v6_18 then
        return true;
    else
        return false;
    end;
end;
v6 = "PathWaypoint";
local l_v6_19 = v6 --[[ copy: 4 -> 24 ]];
v5.PathWaypoint = function(v48)
    if v0(v48) == l_v6_19 then
        return true;
    else
        return false;
    end;
end;
v6 = "PhysicalProperties";
local l_v6_20 = v6 --[[ copy: 4 -> 25 ]];
v5.PhysicalProperties = function(v50)
    if v0(v50) == l_v6_20 then
        return true;
    else
        return false;
    end;
end;
v6 = "Random";
local l_v6_21 = v6 --[[ copy: 4 -> 26 ]];
v5.Random = function(v52)
    if v0(v52) == l_v6_21 then
        return true;
    else
        return false;
    end;
end;
v6 = "Ray";
local l_v6_22 = v6 --[[ copy: 4 -> 27 ]];
v5.Ray = function(v54)
    if v0(v54) == l_v6_22 then
        return true;
    else
        return false;
    end;
end;
v6 = "Rect";
local l_v6_23 = v6 --[[ copy: 4 -> 28 ]];
v5.Rect = function(v56)
    if v0(v56) == l_v6_23 then
        return true;
    else
        return false;
    end;
end;
v6 = "Region3";
local l_v6_24 = v6 --[[ copy: 4 -> 29 ]];
v5.Region3 = function(v58)
    if v0(v58) == l_v6_24 then
        return true;
    else
        return false;
    end;
end;
v6 = "Region3int16";
local l_v6_25 = v6 --[[ copy: 4 -> 30 ]];
v5.Region3int16 = function(v60)
    if v0(v60) == l_v6_25 then
        return true;
    else
        return false;
    end;
end;
v6 = "TweenInfo";
local l_v6_26 = v6 --[[ copy: 4 -> 31 ]];
v5.TweenInfo = function(v62)
    if v0(v62) == l_v6_26 then
        return true;
    else
        return false;
    end;
end;
v6 = "UDim";
local l_v6_27 = v6 --[[ copy: 4 -> 32 ]];
v5.UDim = function(v64)
    if v0(v64) == l_v6_27 then
        return true;
    else
        return false;
    end;
end;
v6 = "UDim2";
local l_v6_28 = v6 --[[ copy: 4 -> 33 ]];
v5.UDim2 = function(v66)
    if v0(v66) == l_v6_28 then
        return true;
    else
        return false;
    end;
end;
v6 = "Vector2";
local l_v6_29 = v6 --[[ copy: 4 -> 34 ]];
v5.Vector2 = function(v68)
    if v0(v68) == l_v6_29 then
        return true;
    else
        return false;
    end;
end;
v6 = "Vector3";
local l_v6_30 = v6 --[[ copy: 4 -> 35 ]];
v5.Vector3 = function(v70)
    if v0(v70) == l_v6_30 then
        return true;
    else
        return false;
    end;
end;
v6 = "Vector3int16";
local l_v6_31 = v6 --[[ copy: 4 -> 36 ]];
v5.Vector3int16 = function(v72)
    if v0(v72) == l_v6_31 then
        return true;
    else
        return false;
    end;
end;
v6 = "Enum";
local l_v6_32 = v6 --[[ copy: 4 -> 37 ]];
v5.Enum = function(v74)
    if v0(v74) == l_v6_32 then
        return true;
    else
        return false;
    end;
end;
v6 = "EnumItem";
local l_v6_33 = v6 --[[ copy: 4 -> 38 ]];
v5.EnumItem = function(v76)
    if v0(v76) == l_v6_33 then
        return true;
    else
        return false;
    end;
end;
v6 = "RBXScriptSignal";
local l_v6_34 = v6 --[[ copy: 4 -> 39 ]];
v5.RBXScriptSignal = function(v78)
    if v0(v78) == l_v6_34 then
        return true;
    else
        return false;
    end;
end;
v6 = "RBXScriptConnection";
v5.RBXScriptConnection = function(v79)
    if v0(v79) == v6 then
        return true;
    else
        return false;
    end;
end;
v5.literal = function(...)
    local v80 = select("#", ...);
    if v80 == 1 then
        local v81 = ...;
        return function(v82)
            if v82 ~= v81 then
                return false;
            else
                return true;
            end;
        end;
    else
        local v83 = {};
        for v84 = 1, v80 do
            v83[v84] = v5.literal((select(v84, ...)));
        end;
        return v5.union(unpack(v83));
    end;
end;
v5.exactly = v5.literal;
v5.keyOf = function(v85)
    local v86 = {};
    for v87 in pairs(v85) do
        v86[#v86 + 1] = v87;
    end;
    return v5.literal(unpack(v86));
end;
v5.valueOf = function(v88)
    local v89 = {};
    for _, v91 in pairs(v88) do
        v89[#v89 + 1] = v91;
    end;
    return v5.literal(unpack(v89));
end;
v5.integer = function(v92)
    if v5.number(v92) then
        if v92 % 1 == 0 then
            return true;
        else
            return false;
        end;
    else
        return false;
    end;
end;
v5.numberMin = function(v93)
    return function(v94)
        if v5.number(v94) then
            if v93 <= v94 then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v5.numberMax = function(v95)
    return function(v96)
        if v5.number(v96) then
            if v96 <= v95 then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v5.numberMinExclusive = function(v97)
    return function(v98)
        if v5.number(v98) then
            if v97 < v98 then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v5.numberMaxExclusive = function(v99)
    return function(v100)
        if v5.number(v100) then
            if v100 < v99 then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v5.numberPositive = v5.numberMinExclusive(0);
v5.numberNegative = v5.numberMaxExclusive(0);
v5.numberConstrained = function(v101, v102)
    assert(v5.number(v101) and v5.number(v102));
    local v103 = v5.numberMin(v101);
    local v104 = v5.numberMax(v102);
    return function(v105)
        if v103(v105) then
            if v104(v105) then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v5.numberConstrainedExclusive = function(v106, v107)
    assert(v5.number(v106) and v5.number(v107));
    local v108 = v5.numberMinExclusive(v106);
    local v109 = v5.numberMaxExclusive(v107);
    return function(v110)
        if v108(v110) then
            if v109(v110) then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v5.match = function(v111)
    assert(v5.string(v111));
    return function(v112)
        if v5.string(v112) then
            if string.match(v112, v111) == nil then
                return false;
            else
                return true;
            end;
        else
            return false;
        end;
    end;
end;
v5.optional = function(v113)
    assert(v5.callback(v113));
    return function(v114)
        if v114 == nil then
            return true;
        elseif not v113(v114) then
            return false;
        else
            return true;
        end;
    end;
end;
v5.tuple = function(...)
    local v115 = {
        ...
    };
    return function(...)
        local v116 = {
            ...
        };
        for v117 = 1, #v115 do
            if v115[v117](v116[v117]) == false then
                return false;
            end;
        end;
        return true;
    end;
end;
v5.keys = function(v118)
    assert(v5.callback(v118));
    return function(v119)
        if v5.table(v119) == false then
            return false;
        else
            for v120 in pairs(v119) do
                if v118(v120) == false then
                    return false;
                end;
            end;
            return true;
        end;
    end;
end;
v5.values = function(v121)
    assert(v5.callback(v121));
    return function(v122)
        if v5.table(v122) == false then
            return false;
        else
            for _, v124 in pairs(v122) do
                if v121(v124) == false then
                    return false;
                end;
            end;
            return true;
        end;
    end;
end;
v5.map = function(v125, v126)
    assert(v5.callback(v125), v5.callback(v126));
    local v127 = v5.keys(v125);
    local v128 = v5.values(v126);
    return function(v129)
        if v127(v129) then
            if v128(v129) then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
local v130 = v5.keys(v5.integer);
local l_v130_0 = v130 --[[ copy: 3 -> 40 ]];
v5.array = function(v132)
    assert(v5.callback(v132));
    local v133 = v5.values(v132);
    return function(v134)
        if l_v130_0(v134) == false then
            return false;
        else
            local v135 = 0;
            for _, _ in ipairs(v134) do
                v135 = v135 + 1;
            end;
            for v138 in pairs(v134) do
                if not (v138 >= 1) or v135 < v138 then
                    return false;
                end;
            end;
            if v133(v134) then
                return true;
            else
                return false;
            end;
        end;
    end;
end;
v130 = v5.array(v5.callback);
local l_v130_1 = v130 --[[ copy: 3 -> 41 ]];
v5.union = function(...)
    local v140 = {
        ...
    };
    assert(l_v130_1(v140));
    return function(v141)
        for _, v143 in pairs(v140) do
            if v143(v141) then
                return true;
            end;
        end;
        return false;
    end;
end;
v5.intersection = function(...)
    local v144 = {
        ...
    };
    assert(l_v130_1(v144));
    return function(v145)
        for _, v147 in pairs(v144) do
            if not v147(v145) then
                return false;
            end;
        end;
        return true;
    end;
end;
v130 = v5.map(v5.any, v5.callback);
local l_v130_2 = v130 --[[ copy: 3 -> 42 ]];
v5.interface = function(v149)
    assert(l_v130_2(v149));
    return function(v150)
        if v5.table(v150) == false then
            return false;
        else
            for v151, v152 in pairs(v149) do
                if v152(v150[v151]) == false then
                    return false;
                end;
            end;
            return true;
        end;
    end;
end;
v5.strictInterface = function(v153)
    assert(l_v130_2(v153));
    return function(v154)
        if v5.table(v154) == false then
            return false;
        else
            for v155, v156 in pairs(v153) do
                if v156(v154[v155]) == false then
                    return false;
                end;
            end;
            for v157 in pairs(v154) do
                if not v153[v157] then
                    return false;
                end;
            end;
            return true;
        end;
    end;
end;
v5.instanceOf = function(v158)
    assert(v5.string(v158));
    return function(v159)
        if v5.Instance(v159) then
            if v159.ClassName ~= v158 then
                return false;
            else
                return true;
            end;
        else
            return false;
        end;
    end;
end;
v5.instance = v5.instanceOf;
v5.instanceIsA = function(v160)
    assert(v5.string(v160));
    return function(v161)
        if v5.Instance(v161) then
            if v161:IsA(v160) then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v5.enum = function(v162)
    assert(v5.Enum(v162));
    return function(v163)
        if v5.EnumItem(v163) then
            if v163.EnumType == v162 then
                return true;
            else
                return false;
            end;
        else
            return false;
        end;
    end;
end;
v130 = v5.tuple(v5.callback, v5.callback);
local l_v130_3 = v130 --[[ copy: 3 -> 43 ]];
v5.wrap = function(v165, v166)
    assert(l_v130_3(v165, v166));
    return function(...)
        assert(v166(...));
        return v165(...);
    end;
end;
v5.strict = function(v167)
    return function(...)
        assert(v167(...));
    end;
end;
v130 = v5.map(v5.string, v5.callback);
v5.children = function(v168)
    assert(v130(v168));
    return function(v169)
        if v5.Instance(v169) then
            local v170 = {};
            for _, v172 in pairs(v169:GetChildren()) do
                local l_Name_0 = v172.Name;
                if v168[l_Name_0] then
                    if not v170[l_Name_0] then
                        v170[l_Name_0] = v172;
                    else
                        return false;
                    end;
                end;
            end;
            for v174, v175 in pairs(v168) do
                if not v175(v170[v174]) then
                    return false;
                end;
            end;
            return true;
        else
            return false;
        end;
    end;
end;
return v5;