local v0 = require(script.Parent.Parent.Parent.LuauPolyfill);
local l_console_0 = v0.console;
local l_Array_0 = v0.Array;
local l_Object_0 = v0.Object;
local v4 = {};
v4.__index = v4;
v4.new = function()
    local v5 = setmetatable({}, v4);
    v5.any_blank_count = 0;
    v5.any_blank_ms = 0;
    v5.any_blank_speed_sum = 0;
    v5.mostly_blank_count = 0;
    v5.mostly_blank_ms = 0;
    v5.pixels_blank = 0;
    v5.pixels_sampled = 0;
    v5.pixels_scrolled = 0;
    v5.total_time_spent = 0;
    v5.sample_count = 0;
    return v5;
end;
local v6 = {};
local v7 = 10;
local v8 = nil;
local v9 = {};
v9.__index = v9;
v9.new = function(v10)
    local v11 = setmetatable({}, v9);
    v11._anyBlankStartTime = nil;
    v11._enabled = false;
    v11._info = v4.new();
    v11._mostlyBlankStartTime = nil;
    v11._samplesStartTime = nil;
    v11._getFrameMetrics = v10;
    if not v8 then
        v11._enabled = math.random() < 0;
    else
        v11._enabled = math.random() < v8;
    end;
    v11:_resetData();
    return v11;
end;
v9.addListener = function(v12)
    if v8 == nil then
        l_console_0.warn("Call `FillRateHelper.setSampleRate` before `addListener`.");
    end;
    table.insert(v6, v12);
    return {
        remove = function()
            v6 = l_Array_0.filter(v6, function(v13)
                return v12 ~= v13;
            end);
        end
    };
end;
v9.setSampleRate = function(v14)
    v8 = v14;
end;
v9.setMinSampleCount = function(v15)
    v7 = v15;
end;
v9.activate = function(v16)
    if v16._enabled and v16._samplesStartTime == nil then
        v16._samplesStartTime = os.clock();
    end;
end;
v9.deactivateAndFlush = function(v17)
    if v17._enabled then
        local l__samplesStartTime_0 = v17._samplesStartTime;
        if l__samplesStartTime_0 == nil then
            return ;
        elseif v17._info.sample_count < v7 then
            v17:_resetData();
            return ;
        else
            local v19 = l_Object_0.assign({}, v17._info, {
                total_time_spent = os.clock() - l__samplesStartTime_0
            });
            l_Array_0.forEach(v6, function(v20)
                return v20(v19);
            end);
            v17:_resetData();
            return ;
        end;
    else
        return ;
    end;
end;
v9.computeBlankness = function(v21, v22, v23, v24)
    if not (v21._enabled and v22.getItemCount(v22.data) ~= 0) or v21._samplesStartTime == nil then
        return 0;
    else
        local l_dOffset_0 = v24.dOffset;
        local l_offset_0 = v24.offset;
        local l_velocity_0 = v24.velocity;
        local l_visibleLength_0 = v24.visibleLength;
        local l__info_0 = v21._info;
        l__info_0.sample_count = l__info_0.sample_count + 1;
        l__info_0 = v21._info;
        l__info_0.pixels_sampled = l__info_0.pixels_sampled + math.round(l_visibleLength_0);
        l__info_0 = v21._info;
        l__info_0.pixels_scrolled = l__info_0.pixels_scrolled + math.round((math.abs(l_dOffset_0 or 0)));
        l__info_0 = math.round(math.abs(l_velocity_0 or 0) * 1000);
        local v30 = os.clock() * 1000;
        if v21._anyBlankStartTime ~= nil then
            local l__info_1 = v21._info;
            l__info_1.any_blank_ms = l__info_1.any_blank_ms + (v30 - v21._anyBlankStartTime);
        end;
        v21._anyBlankStartTime = nil;
        if v21._mostlyBlankStartTime ~= nil then
            local l__info_2 = v21._info;
            l__info_2.mostly_blank_ms = l__info_2.mostly_blank_ms + (v30 - v21._mostlyBlankStartTime);
        end;
        v21._mostlyBlankStartTime = nil;
        local v33 = 0;
        local l_first_0 = v23.first;
        local v35 = v21._getFrameMetrics(l_first_0);
        while not (not (l_first_0 <= v23.last) or v35 and v35.inLayout) do
            v35 = v21._getFrameMetrics(l_first_0);
            l_first_0 = l_first_0 + 1;
        end;
        if v35 and l_first_0 > 1 then
            v33 = math.min(l_visibleLength_0, (math.max(0, v35.offset - l_offset_0)));
        end;
        local v36 = 0;
        local l_last_0 = v23.last;
        local v38 = v21._getFrameMetrics(l_last_0);
        while not (not (v23.first <= l_last_0) or v38 and v38.inLayout) do
            v38 = v21._getFrameMetrics(l_last_0);
            l_last_0 = l_last_0 - 1;
        end;
        if v38 and l_last_0 < v22.getItemCount(v22.data) then
            v36 = math.min(l_visibleLength_0, (math.max(0, (l_offset_0 + l_visibleLength_0) - (v38.offset + v38.length))));
        end;
        local v39 = math.round(v33 + v36);
        local v40 = v39 / l_visibleLength_0;
        if v40 > 0 then
            v21._anyBlankStartTime = v30;
            local l__info_3 = v21._info;
            l__info_3.any_blank_speed_sum = l__info_3.any_blank_speed_sum + l__info_0;
            l__info_3 = v21._info;
            l__info_3.any_blank_count = l__info_3.any_blank_count + 1;
            l__info_3 = v21._info;
            l__info_3.pixels_blank = l__info_3.pixels_blank + v39;
            if v40 > 0.5 then
                v21._mostlyBlankStartTime = v30;
                l__info_3 = v21._info;
                l__info_3.mostly_blank_count = l__info_3.mostly_blank_count + 1;
                return v40;
            end;
        elseif not (l__info_0 >= 0.01) or math.abs(l_dOffset_0 or 0) < 1 then
            v21:deactivateAndFlush();
        end;
        return v40;
    end;
end;
v9.enabled = function(v42)
    return v42._enabled;
end;
v9._resetData = function(v43)
    v43._anyBlankStartTime = nil;
    v43._info = v4.new();
    v43._mostlyBlankStartTime = nil;
    v43._samplesStartTime = nil;
end;
return v9;


return {
    useFocusNavigationScrolling = require(script.useFocusNavigationScrolling)
};


local v0 = require(script.Parent.Parent.Parent.Parent.React);
local _ = require(script.Parent.Parent.FlatList);
return function(v2)
    local v3 = not v2.cellRendererKey and "CellRendererView" or v2.cellRendererKey;
    local v4 = not v2.initialIndex and 1 or v2.initialIndex;
    local l_listRef_0 = v2.listRef;
    local l_onSelectedIndexChanged_0 = v2.onSelectedIndexChanged;
    local l_viewOffset_0 = v2.viewOffset;
    local v8 = not (v2.animated ~= nil) or v2.animated;
    local v9 = v0.useRef(v4);
    local l_data_0 = v2.data;
    return v0.useCallback(function(v11, _, _, v14)
        if not (not v14 or not v14:IsDescendantOf(v11)) then
            local l_v14_FirstAncestor_0 = v14:FindFirstAncestor(v3);
            if l_v14_FirstAncestor_0 and l_v14_FirstAncestor_0.LayoutOrder then
                if not (l_v14_FirstAncestor_0.LayoutOrder ~= v9.current and #l_data_0 >= l_v14_FirstAncestor_0.LayoutOrder) or l_v14_FirstAncestor_0.LayoutOrder < 1 then
                    return nil;
                else
                    v9.current = l_v14_FirstAncestor_0.LayoutOrder;
                    if l_onSelectedIndexChanged_0 then
                        l_onSelectedIndexChanged_0(v9.current);
                    end;
                    if l_listRef_0 and l_listRef_0.current then
                        l_listRef_0.current:scrollToIndex({
                            index = v9.current,
                            animated = v8,
                            viewOffset = l_viewOffset_0
                        });
                    else
                        return nil;
                    end;
                end;
            else
                return nil;
            end;
        end;
        return nil;
    end, {
        l_listRef_0,
        v9,
        v3,
        l_onSelectedIndexChanged_0,
        v8,
        l_viewOffset_0,
        l_data_0
    }), (v0.useCallback(function(v16)
        local v17 = v16.index * v16.averageItemLength;
        if not l_listRef_0 or not l_listRef_0.current then
            warn("Animated scrolling failed, the ref to the ScrollView is nil." .. "This could indicate that you are selecting focus before the ScrollView has mounted.");
            return ;
        else
            l_listRef_0.current:scrollToOffset({
                offset = v17
            });
            return ;
        end;
    end, {
        l_listRef_0
    }));
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Parent.LuauPolyfill);
local l_Array_0 = v1.Array;
local l_Map_0 = v1.Map;
local l_Set_0 = v1.Set;
local l_Object_0 = v1.Object;
local l_console_0 = v1.console;
local l_setTimeout_0 = v1.setTimeout;
local l_clearTimeout_0 = v1.clearTimeout;
local v9 = require(l_Parent_0.jsUtils.invariant);
local v10 = nil;
local v11 = nil;
local v12 = nil;
local v13 = {};
v13.__index = v13;
v13.new = function(v14)
    local v15 = setmetatable({}, v13);
    if v14 == nil then
        v14 = {
            viewAreaCoveragePercentThreshold = 0
        };
    end;
    v15._hasInteracted = false;
    v15._timers = l_Set_0.new();
    v15._viewableIndices = {};
    v15._viewableItems = l_Map_0.new();
    v15._config = v14;
    return v15;
end;
v13.dispose = function(v16)
    v16._timers:forEach(function(v17)
        l_clearTimeout_0(v17);
    end);
end;
v13.computeViewableItems = function(v18, v19, v20, v21, v22, v23)
    local l_itemVisiblePercentThreshold_0 = v18._config.itemVisiblePercentThreshold;
    local l_viewAreaCoveragePercentThreshold_0 = v18._config.viewAreaCoveragePercentThreshold;
    local v26 = l_viewAreaCoveragePercentThreshold_0 ~= nil;
    local v27 = if not v26 then l_itemVisiblePercentThreshold_0 else l_viewAreaCoveragePercentThreshold_0;
    local l_v9_0 = v9;
    local v29 = false;
    if v27 ~= nil then
        v29 = (l_itemVisiblePercentThreshold_0 ~= nil) ~= (l_viewAreaCoveragePercentThreshold_0 ~= nil);
    end;
    l_v9_0(v29, "Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold");
    l_v9_0 = {};
    if v19 == 0 then
        return l_v9_0;
    else
        v29 = 0;
        local v30 = nil;
        local v31 = nil;
        local v32 = v23 or {
            first = 1,
            last = v19
        };
        v30 = v32.first;
        v31 = v32.last;
        if v19 < v31 then
            l_console_0.warn("Invalid render range computing viewability { renderRange = " .. tostring(v23) .. ", itemCount = " .. tostring(v19) .. " }");
            return {};
        else
            v32 = v30;
            while v32 <= v31 do
                local l_v32_0 = v32;
                local v34 = v22(l_v32_0);
                if v34 then
                    local v35 = v34.offset - v20;
                    local v36 = v35 + v34.length;
                    if v35 < v21 and v36 > 0 then
                        v29 = l_v32_0;
                        if v12(v26, v27, v35, v36, v21, v34.length) then
                            table.insert(l_v9_0, l_v32_0);
                        end;
                    elseif not (v29 < 1) then
                        break;
                    end;
                    v32 = v32 + 1;
                else
                    v32 = v32 + 1;
                end;
            end;
            return l_v9_0;
        end;
    end;
end;
v13.onUpdate = function(v37, v38, v39, v40, v41, v42, v43, v44)
    if (not (v37._config.waitForInteraction and not v37._hasInteracted) and v38 ~= 0) and v41(1) then
        local v45 = {};
        if v38 then
            v45 = v37:computeViewableItems(v38, v39, v40, v41, v44);
        end;
        if not (#v37._viewableIndices == #v45) or not l_Array_0.every(v37._viewableIndices, function(v46, v47)
            return v46 == v45[v47];
        end) then
            v37._viewableIndices = v45;
            if not v37._config.minimumViewTime then
                v37:_onUpdateSync(v45, v43, v42);
            else
                local v48 = nil;
                do
                    local l_v48_0 = v48;
                    l_v48_0 = l_setTimeout_0(function()
                        v37._timers:delete(l_v48_0);
                        v37:_onUpdateSync(v45, v43, v42);
                    end, v37._config.minimumViewTime);
                    v37._timers:add(l_v48_0);
                end;
            end;
            return ;
        else
            return ;
        end;
    else
        return ;
    end;
end;
v13.resetViewableIndices = function(v50)
    v50._viewableIndices = {};
end;
v13.recordInteraction = function(v51)
    v51._hasInteracted = true;
end;
v13._onUpdateSync = function(v52, v53, v54, v55)
    v53 = l_Array_0.filter(v53, function(v56)
        return l_Array_0.includes(v52._viewableIndices, v56);
    end);
    local l__viewableItems_0 = v52._viewableItems;
    local v60 = l_Map_0.new(l_Array_0.map(v53, function(v58)
        local v59 = v55(v58, true);
        return {
            v59.key,
            v59
        };
    end));
    local v61 = {};
    for _, v63 in ipairs(v60:keys()) do
        if not l__viewableItems_0:has(v63) then
            table.insert(v61, v60:get(v63));
        end;
    end;
    for _, v65 in ipairs(l__viewableItems_0:keys()) do
        if not v60:has(v65) then
            table.insert(v61, l_Object_0.assign({}, l__viewableItems_0:get(v65), {
                isViewable = false
            }));
        end;
    end;
    if #v61 > 0 then
        v52._viewableItems = v60;
        v54({
            viewableItems = l_Array_0.from(v60:values()),
            changed = v61,
            viewabilityConfig = v52._config
        });
    end;
end;
v12 = function(v66, v67, v68, v69, v70, v71)
    if not v10(v68, v69, v70) then
        local v72 = v11(v68, v69, v70);
        return v67 <= 100 * if not v66 then v72 / v71 else v72 / v70;
    else
        return true;
    end;
end;
v11 = function(v73, v74, v75)
    return (math.max(0, math.min(v74, v75) - math.max(v73, 0)));
end;
v10 = function(v76, v77, v78)
    local v79 = false;
    if v76 >= 0 then
        v79 = false;
        if v77 <= v78 then
            v79 = v76 < v77;
        end;
    end;
    return v79;
end;
return v13;


local l_Parent_0 = script.Parent.Parent;
local l_Error_0 = require(l_Parent_0.Parent.LuauPolyfill).Error;
local l_HttpService_0 = game:GetService("HttpService");
local v3 = {};
local v4 = require(l_Parent_0.jsUtils.invariant);
local function v14(v5, v6, v7)
    local v8 = {};
    local v9 = 0;
    for v10 = 1, v6 do
        local v11 = v7(v10);
        local v12 = v11.offset + v11.length;
        for v13 = 1, #v5 do
            if v8[v13] == nil and v5[v13] <= v12 then
                v8[v13] = v10;
                v9 = v9 + 1;
                if v13 == #v5 then
                    if v9 ~= #v5 then
                        v4(v9 == #v5, "bad offsets input, should be in increasing order: %s", l_HttpService_0:JSONEncode(v5));
                    end;
                    return v8;
                end;
            end;
        end;
    end;
    return v8;
end;
v3.elementsThatOverlapOffsets = v14;
v3.newRangeCount = function(v15, v16)
    return ((v16.last - v16.first) + 1) - math.max(0, (1 + math.min(v16.last, v15.last)) - math.max(v16.first, v15.first));
end;
v3.computeWindowedRenderLimits = function(v17, v18, v19, v20, v21, v22, v23)
    local v24 = v18(v17);
    if v24 == 0 then
        return v21;
    else
        local l_offset_0 = v23.offset;
        local l_velocity_0 = v23.velocity;
        local l_visibleLength_0 = v23.visibleLength;
        local v28 = math.max(0, l_offset_0);
        local v29 = v28 + l_visibleLength_0;
        local v30 = (v20 - 1) * l_visibleLength_0;
        local v31 = l_velocity_0 > 1 and "after" or (l_velocity_0 < -1 and "before" or "none");
        local v32 = math.max(0, v28 - 0.5 * v30);
        local v33 = math.max(0, v29 + 0.5 * v30);
        if v22(v24).offset < v32 then
            return {
                first = math.max(1, v24 - v19),
                last = v24
            };
        else
            local v34, v35, v36, v37 = table.unpack(v14({
                v32,
                v28,
                v29,
                v33
            }, v24, v22), 1, 4);
            if v34 == nil then
                v34 = 1;
            end;
            if v35 == nil then
                v35 = math.max(1, v34);
            end;
            if v37 == nil then
                v37 = v24;
            end;
            if v36 == nil then
                v36 = math.min(v37, (v35 + v19) - 1);
            end;
            local v38 = {
                first = v35,
                last = v36
            };
            local v39 = ((v38.last - v38.first) + 1) - math.max(0, (1 + math.min(v38.last, v21.last)) - math.max(v38.first, v21.first));
            while not (v35 <= v34) or v37 > v36 do
                local v40 = v19 <= v39;
                local v41 = true;
                if v35 > v21.first then
                    v41 = v21.last < v35;
                end;
                local v42 = false;
                if v34 < v35 then
                    v42 = not v40 or not v41;
                end;
                local v43 = true;
                if v21.last > v36 then
                    v43 = v36 < v21.first;
                end;
                local v44 = false;
                if v36 < v37 then
                    v44 = not v40 or not v43;
                end;
                if not (not (not v40 or v42) and not v44) then
                    if not (not v42 or not (not (v31 == "after") or not v44) and v43) then
                        if v41 then
                            v39 = v39 + 1;
                        end;
                        v35 = v35 - 1;
                    end;
                    if not (not v44 or not (not (v31 == "before") or not v42) and v41) then
                        if v43 then
                            v39 = v39 + 1;
                        end;
                        v36 = v36 + 1;
                    end;
                else
                    break;
                end;
            end;
            if not (((((v35 <= v36 and v35 >= 1) and v36 <= v24) and v34 <= v35) and v36 <= v37) and v35 <= v38.first) or v38.last > v36 then
                error(l_Error_0.new("Bad window calculation " .. l_HttpService_0:JSONEncode({
                    first = v35,
                    last = v36,
                    itemCount = v24,
                    overscanFirst = v34,
                    overscanLast = v37,
                    visible = v38
                })));
            end;
            return {
                first = v35,
                last = v36
            };
        end;
    end;
end;
v3.keyExtractor = function(v45, v46)
    if typeof(v45) == "table" and v45.key ~= nil then
        return v45.key;
    elseif typeof(v45) == "table" and v45.id ~= nil then
        return v45.id;
    else
        return (tostring(v46));
    end;
end;
return v3;


local l_Parent_0 = script.Parent.Parent.Parent;
local l_Object_0 = require(l_Parent_0.LuauPolyfill).Object;
local v2 = require(l_Parent_0.React);
local l_useMemo_0 = v2.useMemo;
local l_useContext_0 = v2.useContext;
local v5 = {};
local v6 = v2.createContext(nil);
v5.VirtualizedListContext = v6;
if _G.__DEV__ then
    v6.displayName = "VirtualizedListContext";
end;
v5.VirtualizedListContextResetter = function(v7)
    return v2.createElement(v6.Provider, {
        value = nil
    }, v7.children);
end;
v5.VirtualizedListContextProvider = function(v8)
    local l_children_0 = v8.children;
    local l_value_0 = v8.value;
    return v2.createElement(v6.Provider, {
        value = l_useMemo_0(function()
            return {
                cellKey = nil,
                getScrollMetrics = l_value_0.getScrollMetrics,
                horizontal = l_value_0.horizontal,
                getOutermostParentListRef = l_value_0.getOutermostParentListRef,
                getNestedChildState = l_value_0.getNestedChildState,
                registerAsNestedChild = l_value_0.registerAsNestedChild,
                unregisterAsNestedChild = l_value_0.unregisterAsNestedChild,
                debugInfo = {
                    cellKey = l_value_0.debugInfo.cellKey,
                    horizontal = l_value_0.debugInfo.horizontal,
                    listKey = l_value_0.debugInfo.listKey,
                    parent = l_value_0.debugInfo.parent
                }
            };
        end, {
            l_value_0.getScrollMetrics,
            l_value_0.horizontal,
            l_value_0.getOutermostParentListRef,
            l_value_0.getNestedChildState,
            l_value_0.registerAsNestedChild,
            l_value_0.unregisterAsNestedChild,
            l_value_0.debugInfo.cellKey,
            l_value_0.debugInfo.horizontal,
            l_value_0.debugInfo.listKey,
            l_value_0.debugInfo.parent
        })
    }, l_children_0);
end;
v5.VirtualizedListCellContextProvider = function(v11)
    local l_cellKey_0 = v11.cellKey;
    local l_children_1 = v11.children;
    local v14 = l_useContext_0(v6);
    return v2.createElement(v6.Provider, {
        value = if v14 == nil then nil else l_Object_0.assign(table.clone(v14), {
            cellKey = l_cellKey_0
        })
    }, l_children_1);
end;
return v5;


local l_Parent_0 = script.Parent.Parent;
local l_Parent_1 = l_Parent_0.Parent;
local v2 = require(l_Parent_1.LuauPolyfill);
local l_Array_0 = v2.Array;
local l_Boolean_0 = v2.Boolean;
local l_Object_0 = v2.Object;
local v6 = require(l_Parent_0.jsUtils.invariant);
local _ = require(script.Parent.ViewabilityHelper);
local l_keyExtractor_0 = require(script.Parent.VirtualizeUtils).keyExtractor;
local v9 = require(l_Parent_0.Components.View.View);
local v10 = require(script.Parent.VirtualizedList);
local v11 = require(l_Parent_1.React);
local v12 = nil;
local v13 = v11.PureComponent:extend("VirtualizedSectionList");
v13.init = function(v14)
    v14._updateHighlightMap = {};
    v14._updatePropsMap = {};
    v14._listRef = nil;
    v14._captureRef = function(v15)
        v14._listRef = v15;
    end;
    v14._keyExtractor = function(_, v17)
        local v18 = v14:_subExtractor(v17);
        if not v18 then
            return (tostring(v17));
        else
            return v18.key;
        end;
    end;
    v14._convertViewable = function(v19)
        v6(v19.index ~= nil, "Received a broken ViewToken");
        local v20 = v14:_subExtractor(v19.index);
        if v20 then
            local l_keyExtractor_1 = v20.section.keyExtractor;
            return l_Object_0.assign({}, v19, {
                index = v20.index,
                key = if l_keyExtractor_1 ~= nil then l_keyExtractor_1(v19.item, v20.index) else (if not v14.props.keyExtractor then l_keyExtractor_0 else v14.props.keyExtractor)(v19.item, v20.index == nil and 1 or v20.index),
                section = v20.section
            });
        else
            return nil;
        end;
    end;
    v14._onViewableItemsChanged = function(v22)
        local l_viewableItems_0 = v22.viewableItems;
        local l_changed_0 = v22.changed;
        local l_onViewableItemsChanged_0 = v14.props.onViewableItemsChanged;
        if l_onViewableItemsChanged_0 ~= nil then
            l_onViewableItemsChanged_0({
                viewableItems = l_Array_0.filter(l_Array_0.map(l_viewableItems_0, v14._convertViewable, v14), l_Boolean_0.toJSBoolean),
                changed = l_Array_0.filter(l_Array_0.map(l_changed_0, v14._convertViewable, v14), l_Boolean_0.toJSBoolean)
            });
        end;
    end;
    v14._renderItem = function(v26)
        return function(v27)
            local l_item_0 = v27.item;
            local l_index_0 = v27.index;
            local v30 = v14:_subExtractor(l_index_0);
            if v30 then
                local l_index_1 = v30.index;
                if l_index_1 == nil then
                    local l_section_0 = v30.section;
                    if v30.header == true then
                        local l_renderSectionHeader_0 = v14.props.renderSectionHeader;
                        if not l_Boolean_0.toJSBoolean(l_renderSectionHeader_0) then
                            return nil;
                        else
                            return (l_renderSectionHeader_0({
                                section = l_section_0
                            }));
                        end;
                    else
                        local l_renderSectionFooter_0 = v14.props.renderSectionFooter;
                        if not l_Boolean_0.toJSBoolean(l_renderSectionFooter_0) then
                            return nil;
                        else
                            return (l_renderSectionFooter_0({
                                section = l_section_0
                            }));
                        end;
                    end;
                else
                    local v35 = v30.section.renderItem or v14.props.renderItem;
                    local v36 = v14:_getSeparatorComponent(l_index_0, v30, v26);
                    v6(v35, "no renderItem");
                    return v11.createElement(v12, {
                        SeparatorComponent = v36,
                        LeadingSeparatorComponent = if l_index_1 == 1 then v14.props.SectionSeparatorComponent else nil,
                        cellKey = v30.key,
                        index = l_index_1,
                        item = l_item_0,
                        leadingItem = v30.leadingItem,
                        leadingSection = v30.leadingSection,
                        prevCellKey = (v14:_subExtractor(l_index_0 - 1) or {}).key,
                        setSelfHighlightCallback = v14._setUpdateHighlightFor,
                        setSelfUpdatePropsCallback = v14._setUpdatePropsFor,
                        updateHighlightFor = v14._updateHighlightFor,
                        updatePropsFor = v14._updatePropsFor,
                        renderItem = v35,
                        section = v30.section,
                        trailingItem = v30.trailingItem,
                        trailingSection = v30.trailingSection,
                        inverted = l_Boolean_0.toJSBoolean(v14.props.inverted),
                        horizontal = v14.props.horizontal
                    });
                end;
            else
                return nil;
            end;
        end;
    end;
    v14._updatePropsFor = function(v37, v38)
        local v39 = v14._updatePropsMap[v37];
        if v39 ~= nil then
            v39(v38);
        end;
    end;
    v14._updateHighlightFor = function(v40, v41)
        local v42 = v14._updateHighlightMap[v40];
        if v42 ~= nil then
            v42(v41);
        end;
    end;
    v14._setUpdateHighlightFor = function(v43, v44)
        if v44 ~= nil then
            v14._updateHighlightMap[v43] = v44;
            return ;
        else
            v14._updateHighlightMap[v43] = nil;
            return ;
        end;
    end;
    v14._setUpdatePropsFor = function(v45, v46)
        if v46 ~= nil then
            v14._updatePropsMap[v45] = v46;
            return ;
        else
            v14._updatePropsMap[v45] = nil;
            return ;
        end;
    end;
end;
v13.scrollToLocation = function(v47, v48)
    local l_itemIndex_0 = v48.itemIndex;
    local v50 = 1;
    while v50 < v48.sectionIndex do
        l_itemIndex_0 = l_itemIndex_0 + (v47.props.getItemCount(v47.props.sections[v50].data) + 2);
        v50 = v50 + 1;
    end;
    local v51 = v48.viewOffset or 0;
    if v47._listRef == nil then
        return ;
    else
        if not (not (v48.itemIndex > 1) or not v47.props.stickySectionHeadersEnabled) then
            v51 = v51 + v47._listRef.__getFrameMetricsApprox(l_itemIndex_0 - v48.itemIndex).length;
        end;
        v47._listRef:scrollToIndex((l_Object_0.assign({}, v48, {
            viewOffset = v51,
            index = l_itemIndex_0
        })));
        return ;
    end;
end;
v13.getListRef = function(v52)
    return v52._listRef;
end;
v13.render = function(v53)
    local _ = v53.props.renderItem;
    local _ = v53.props.sections;
    local v56 = l_Object_0.assign({}, v53.props, {
        ItemSeparatorComponent = l_Object_0.None,
        SectionSeparatorComponent = l_Object_0.None,
        renderItem = l_Object_0.None,
        renderSectionFooter = l_Object_0.None,
        renderSectionHeader = l_Object_0.None,
        sections = l_Object_0.None,
        stickySectionHeadersEnabled = l_Object_0.None
    });
    local v57 = not v53.props.ListHeaderComponent and 0 or 1;
    local v58 = if not v53.props.stickySectionHeadersEnabled then nil else {};
    local v59 = 0;
    for _, v61 in ipairs(v53.props.sections) do
        if v58 ~= nil then
            table.insert(v58, v59 + v57);
        end;
        v59 = (v59 + 2) + v53.props.getItemCount(v61.data);
    end;
    return v11.createElement(v10, l_Object_0.assign({}, v56, {
        keyExtractor = v53._keyExtractor,
        stickyHeaderIndices = v58,
        renderItem = v53._renderItem(v59),
        data = v53.props.sections,
        getItem = function(v62, v63)
            return v53:_getItem(v53.props, v62, v63);
        end,
        getItemCount = function()
            return v59;
        end,
        onViewableItemsChanged = if not v53.props.onViewableItemsChanged then nil else v53._onViewableItemsChanged,
        ref = v53._captureRef
    }));
end;
v13._getItem = function(_, v65, v66, v67)
    if v66 then
        local v68 = v67 - 1;
        local v69 = 1;
        while true do
            if v69 <= #v66 then
                local v70 = v66[v69];
                local l_data_0 = v70.data;
                local v72 = v65.getItemCount(l_data_0);
                if not (v68 ~= 0) or v68 == v72 + 1 then
                    return v70;
                elseif v68 <= v72 then
                    return v65.getItem(l_data_0, v68);
                else
                    v68 = v68 - (v72 + 2);
                    v69 = v69 + 1;
                end;
            else
                return nil;
            end;
        end;
    else
        return nil;
    end;
end;
v13._subExtractor = function(v73, v74)
    local l_v74_0 = v74;
    local v76 = nil;
    local v77 = nil;
    local v78 = nil;
    local v79 = nil;
    local l_props_0 = v73.props;
    v76 = l_props_0.getItem;
    v77 = l_props_0.getItemCount;
    v78 = l_props_0.keyExtractor;
    v79 = l_props_0.sections;
    l_props_0 = 1;
    while true do
        if l_props_0 <= #v79 then
            local v81 = v79[l_props_0];
            local l_data_1 = v81.data;
            local v83 = if not l_Boolean_0.toJSBoolean(v81.key) then tostring(l_props_0) else tostring(v81.key);
            l_v74_0 = l_v74_0 - 1;
            if v77(l_data_1) + 1 < l_v74_0 then
                l_v74_0 = l_v74_0 - (v77(l_data_1) + 1);
                l_props_0 = l_props_0 + 1;
            elseif l_v74_0 == 0 then
                return {
                    section = v81,
                    key = v83 .. ":header",
                    index = nil,
                    header = true,
                    trailingSection = v79[l_props_0 + 1]
                };
            elseif l_v74_0 == v77(l_data_1) + 1 then
                return {
                    section = v81,
                    key = v83 .. ":footer",
                    index = nil,
                    header = false,
                    trailingSection = v79[l_props_0 + 1]
                };
            else
                return {
                    section = v81,
                    key = v83 .. ":" .. tostring(((v81.keyExtractor or v78) or l_keyExtractor_0)(v76(l_data_1, l_v74_0), l_v74_0)),
                    index = l_v74_0,
                    leadingItem = v76(l_data_1, l_v74_0 - 1),
                    leadingSection = v79[l_props_0 - 1],
                    trailingItem = v76(l_data_1, l_v74_0 + 1),
                    trailingSection = v79[l_props_0 + 1]
                };
            end;
        else
            return nil;
        end;
    end;
end;
v13._getSeparatorComponent = function(v84, v85, v86, v87)
    if not v86 then
        v86 = v84:_subExtractor(v85);
    end;
    if v86 then
        local l_v86_0 = v86;
        local v89 = not not l_Boolean_0.toJSBoolean(l_v86_0.section.ItemSeparatorComponent) and l_v86_0.section.ItemSeparatorComponent or v84.props.ItemSeparatorComponent;
        local l_SectionSeparatorComponent_0 = v84.props.SectionSeparatorComponent;
        local v91 = v85 == v87;
        local v92 = l_v86_0.index == v84.props.getItemCount(l_v86_0.section.data);
        if not l_SectionSeparatorComponent_0 or not v92 then
            if (not v89 or v92) or v91 then
                return nil;
            else
                return v89;
            end;
        else
            return l_SectionSeparatorComponent_0;
        end;
    else
        return nil;
    end;
end;
v12 = function(v93)
    local l_LeadingSeparatorComponent_0 = v93.LeadingSeparatorComponent;
    local l_SeparatorComponent_0 = v93.SeparatorComponent;
    local l_cellKey_0 = v93.cellKey;
    local l_prevCellKey_0 = v93.prevCellKey;
    local l_setSelfHighlightCallback_0 = v93.setSelfHighlightCallback;
    local l_updateHighlightFor_0 = v93.updateHighlightFor;
    local l_setSelfUpdatePropsCallback_0 = v93.setSelfUpdatePropsCallback;
    local l_updatePropsFor_0 = v93.updatePropsFor;
    local l_item_1 = v93.item;
    local l_index_2 = v93.index;
    local l_section_1 = v93.section;
    local l_inverted_0 = v93.inverted;
    local v106, v107 = v11.useState(false);
    local v108, v109 = v11.useState(false);
    local v110, v111 = v11.useState({
        leadingItem = v93.leadingItem,
        leadingSection = v93.leadingSection,
        section = v93.section,
        trailingItem = v93.item,
        trailingSection = v93.trailingSection,
        LayoutOrder = -1
    });
    local v112, v113 = v11.useState({
        leadingItem = v93.item,
        leadingSection = v93.leadingSection,
        section = v93.section,
        trailingItem = v93.trailingItem,
        trailingSection = v93.trailingSection,
        LayoutOrder = 1
    });
    v11.useEffect(function()
        l_setSelfHighlightCallback_0(l_cellKey_0, v109);
        l_setSelfUpdatePropsCallback_0(l_cellKey_0, v113);
        return function()
            l_setSelfUpdatePropsCallback_0(l_cellKey_0, nil);
            l_setSelfHighlightCallback_0(l_cellKey_0, nil);
        end;
    end, {
        l_cellKey_0,
        l_setSelfHighlightCallback_0,
        v113,
        l_setSelfUpdatePropsCallback_0
    });
    local v116 = v93.renderItem({
        item = l_item_1,
        index = l_index_2,
        section = l_section_1,
        separators = {
            highlight = function()
                v107(true);
                v109(true);
                if l_prevCellKey_0 ~= nil then
                    l_updateHighlightFor_0(l_prevCellKey_0, true);
                end;
            end,
            unhighlight = function()
                v107(false);
                v109(false);
                if l_prevCellKey_0 ~= nil then
                    l_updateHighlightFor_0(l_prevCellKey_0, false);
                end;
            end,
            updateProps = function(v114, v115)
                if v114 == "leading" then
                    if l_LeadingSeparatorComponent_0 ~= nil then
                        v111(l_Object_0.assign({}, v110, v115));
                        return ;
                    elseif l_prevCellKey_0 ~= nil then
                        l_updatePropsFor_0(l_prevCellKey_0, l_Object_0.assign({}, v110, v115));
                        return ;
                    end;
                elseif v114 == "trailing" and l_SeparatorComponent_0 ~= nil then
                    v113(l_Object_0.assign({}, v112, v115));
                end;
            end
        }
    });
    local v117 = false;
    if l_LeadingSeparatorComponent_0 ~= nil then
        v117 = v11.createElement(l_LeadingSeparatorComponent_0, l_Object_0.assign({
            highlighted = v106
        }, v110));
    end;
    local v118 = false;
    if l_SeparatorComponent_0 ~= nil then
        v118 = v11.createElement(l_SeparatorComponent_0, l_Object_0.assign({
            highlighted = v108
        }, v112));
    end;
    if not v117 and not v118 then
        return v116;
    else
        return (v11.createElement(v9, {
            Size = if not v93.horizontal then UDim2.new(1, 0, 0, 0) else UDim2.new(0, 0, 1, 0),
            AutomaticSize = if not v93.horizontal then Enum.AutomaticSize.Y else Enum.AutomaticSize.X
        }, v11.createElement("UIListLayout", {
            SortOrder = Enum.SortOrder.LayoutOrder,
            FillDirection = if not v93.horizontal then Enum.FillDirection.Vertical else Enum.FillDirection.Horizontal
        }), if l_inverted_0 == false then v117 else v118, v116, if l_inverted_0 == false then v118 else v117));
    end;
end;
return v13;


local v0 = require(script.Parent.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_Object_0 = v0.Object;
return {
    compose = function(v3, v4)
        if v3 ~= nil and v4 ~= nil then
            return {
                v3,
                v4
            };
        elseif v3 ~= nil then
            return v3;
        else
            return v4;
        end;
    end,
    create = function(v5)
        if _G.__DEV__ then
            l_Array_0.forEach(l_Object_0.keys(v5), function(v6)
                if v5[v6] then
                    l_Object_0.freeze(v5[v6]);
                end;
            end);
        end;
        return v5;
    end
};


local _ = require(script.Parent.Parent.Parent.LuauPolyfill);
local function v1(...)
    error("Not implemented. Dependencies used upstream aren't implemented");
end;
return {
    default = function(v2)
        local v3 = {};
        for _, v5 in ipairs(v2.supportedCommands) do
            v3[v5] = function(v6, ...)
                v1(v6, v5, ...);
            end;
        end;
        return v3;
    end
};


local v0 = require(script.Parent.Parent.Parent.Parent.LuauPolyfill);
local l_Array_0 = v0.Array;
local l_Boolean_0 = v0.Boolean;
local v3 = nil;
local function v5(v4)
    v3 = v4;
end;
local function v6(v7, v8, v9, v10)
    local v11 = if v9 ~= nil then v9 else -1;
    local v12 = if typeof(v11) == "number" then v10 else v11;
    local v13 = if typeof(v11) == "number" then v11 else -1;
    if v13 == 0 then
        return true;
    elseif v7 == v8 then
        return false;
    elseif typeof(v7) == "function" and typeof(v8) == "function" then
        local v14 = v12 ~= nil and v12.unsafelyIgnoreFunctions ~= nil;
        local v15 = if v12 ~= nil and v14 then v12.unsafelyIgnoreFunctions else nil;
        if v15 == nil then
            if not ((not (v3 ~= nil) or not l_Boolean_0.toJSBoolean(v3.onDifferentFunctionsIgnored)) or l_Boolean_0.toJSBoolean(v12) and v14) then
                v3.onDifferentFunctionsIgnored(debug.info(v7, "n"), debug.info(v8, "n"));
            end;
            v15 = true;
        end;
        return not v15;
    elseif not (typeof(v7) == "table") or v7 == nil then
        return v7 ~= v8;
    elseif not (typeof(v8) == "table") or v8 == nil then
        return true;
    elseif l_Array_0.isArray(v7) ~= l_Array_0.isArray(v8) then
        return true;
    else
        if not l_Array_0.isArray(v7) then
            for v16 in pairs(v7) do
                if v6(v7[v16], v8[v16], v13 - 1, v12) then
                    return true;
                end;
            end;
            for v17 in pairs(v8) do
                if v7[v17] == nil and v8[v17] ~= nil then
                    return true;
                end;
            end;
        elseif #v8 ~= #v7 then
            return true;
        else
            for v18 = 1, #v7 do
                if v6(v7[v18], v8[v18], v13 - 1, v12) then
                    return true;
                end;
            end;
        end;
        return false;
    end;
end;
return (setmetatable({
    unstable_setLogListeners = v5
}, {
    __call = function(_, v20, v21, v22, v23)
        return (v6(v20, v21, v22, v23));
    end
}));


local l_console_0 = require(script.Parent.Parent.Parent.LuauPolyfill).console;
return function(...)
    return l_console_0.log(...);
end;


local _ = require(script.Parent.Parent.Parent.React);
return function(v1)
    local l_getForwardedRef_0 = v1.getForwardedRef;
    local l_setLocalRef_0 = v1.setLocalRef;
    return function(v4)
        local v5 = l_getForwardedRef_0();
        l_setLocalRef_0(v4);
        if typeof(v5) == "function" then
            v5(v4);
            return ;
        else
            if typeof(v5) == "table" then
                v5.current = v4;
            end;
            return ;
        end;
    end;
end;


local l_Components_0 = script.Components;
local l_Lists_0 = script.Lists;
local v2 = require(l_Components_0.ScrollView.ScrollView);
local v3 = require(l_Lists_0.VirtualizedList);
local l_default_0 = require(l_Lists_0.SectionList).default;
local v5 = require(l_Lists_0.FlatList);
local l_BidirectionalFlatList_0 = require(l_Lists_0.BidirectionalFlatList).BidirectionalFlatList;
local v7 = require(l_Components_0.View.View);
local _ = require(l_Lists_0.ViewabilityHelper);
return {
    ScrollView = v2,
    VirtualizedList = v3,
    SectionList = l_default_0,
    FlatList = v5,
    BidirectionalFlatList = l_BidirectionalFlatList_0,
    View = v7,
    AnimatedFlatList = require(l_Lists_0.AnimatedFlatList),
    Hooks = require(l_Lists_0.Hooks)
};


return {
    displayName = "VirtualizedListLua",
    testMatch = {
        "**/*.spec"
    }
};


local l_Error_0 = require(script.Parent.Parent.Parent.LuauPolyfill).Error;
return function(v1, v2, ...)
    if not v1 then
        error(l_Error_0(string.format(v2, ...)));
    end;
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.LuauPolyfill);
local v2 = require(l_Parent_0.Promise);
local l_instanceof_0 = v1.instanceof;
local l_Boolean_0 = v1.Boolean;
local l_Error_0 = v1.Error;
local l_setTimeout_0 = v1.setTimeout;
local l_Array_0 = v1.Array;
local l_Symbol_0 = v1.Symbol;
local v9 = nil;
local v10 = nil;
local v11 = nil;
local v12 = nil;
local function _(v13)
    if typeof(v13) == "function" then
        return true;
    else
        if typeof(v13) == "table" then
            local v14 = getmetatable(v13);
            if not v14 or not rawget(v14, "__call") then
                if v13._isMockFunction then
                    return true;
                end;
            else
                return true;
            end;
        end;
        return false;
    end;
end;
local function _()
    local v16 = false;
    if typeof(l_Symbol_0) == "table" then
        v16 = typeof(getmetatable(l_Symbol_0).__call) == "function";
    end;
    return v16;
end;
local function _(v18)
    local v19 = false;
    if typeof(l_Symbol_0) == "table" then
        v19 = typeof(getmetatable(l_Symbol_0).__call) == "function";
    end;
    if v19 then
        v19 = l_Boolean_0.toJSBoolean(l_Symbol_0[v18]);
    end;
    return v19;
end;
local function _(v21)
    local v22 = false;
    if typeof(l_Symbol_0) == "table" then
        v22 = typeof(getmetatable(l_Symbol_0).__call) == "function";
    end;
    if v22 then
        v22 = l_Boolean_0.toJSBoolean(l_Symbol_0[v21]);
    end;
    if not v22 then
        return "@@" .. v21;
    else
        return l_Symbol_0[v21];
    end;
end;
local v24 = false;
if typeof(l_Symbol_0) == "table" then
    v24 = typeof(getmetatable(l_Symbol_0).__call) == "function";
end;
if v24 then
    v24 = false;
    if typeof(l_Symbol_0) == "table" then
        v24 = typeof(getmetatable(l_Symbol_0).__call) == "function";
    end;
    if v24 then
        v24 = l_Boolean_0.toJSBoolean(l_Symbol_0.observable);
    end;
    if not v24 then
        l_Symbol_0.observable = l_Symbol_0("observable");
    end;
end;
local v25 = false;
if typeof(l_Symbol_0) == "table" then
    v25 = typeof(getmetatable(l_Symbol_0).__call) == "function";
end;
if v25 then
    v25 = l_Boolean_0.toJSBoolean(l_Symbol_0.iterator);
end;
v24 = if not v25 then "@@" .. "iterator" else l_Symbol_0.iterator;
local v26 = false;
if typeof(l_Symbol_0) == "table" then
    v26 = typeof(getmetatable(l_Symbol_0).__call) == "function";
end;
if v26 then
    v26 = l_Boolean_0.toJSBoolean(l_Symbol_0.observable);
end;
v25 = if not v26 then "@@" .. "observable" else l_Symbol_0.observable;
local v27 = false;
if typeof(l_Symbol_0) == "table" then
    v27 = typeof(getmetatable(l_Symbol_0).__call) == "function";
end;
if v27 then
    v27 = l_Boolean_0.toJSBoolean(l_Symbol_0.species);
end;
v26 = if not v27 then "@@" .. "species" else l_Symbol_0.species;
v27 = function(v28, v29)
    local v30 = v28[v29];
    if v30 == nil then
        return nil;
    else
        local v31;
        if typeof(v30) == "function" then
            v31 = true;
        else
            if typeof(v30) == "table" then
                local v32 = getmetatable(v30);
                if not v32 or not rawget(v32, "__call") then
                    if v30._isMockFunction then
                        v31 = true;
                        goto label0 --[[  true, true  ]];
                    end;
                else
                    v31 = true;
                    goto label0 --[[  true, true  ]];
                end;
            end;
            v31 = false;
        end;
        ::label0::;
        if not v31 then
            error(l_Error_0.new(tostring(v30) .. " is not a function"));
        end;
        return v30;
    end;
end;
local function _(v33)
    local v34 = v33[v26];
    if v34 ~= nil then
        return v34;
    else
        return v9;
    end;
end;
local function _(v36)
    return l_instanceof_0(v36, v9);
end;
local v38 = nil;
v38 = setmetatable({}, {
    __call = function(_, v40)
        if not v38.log then
            l_setTimeout_0(function()
                error(v40);
            end, 0);
            return ;
        else
            v38:log(v40);
            return ;
        end;
    end
});
local function _(v41)
    v2.delay(0):doneCall(function()
        xpcall(v41, function(v42)
            v38(v42);
        end);
    end);
end;
local function v55(v44)
    local l__cleanup_0 = v44._cleanup;
    if l__cleanup_0 == nil then
        return ;
    else
        v44._cleanup = nil;
        if l__cleanup_0 then
            local v46 = true;
            local v47 = nil;
            local v48;
            if typeof(l__cleanup_0) == "function" then
                v48 = true;
            else
                if typeof(l__cleanup_0) == "table" then
                    local v49 = getmetatable(l__cleanup_0);
                    if not v49 or not rawget(v49, "__call") then
                        if l__cleanup_0._isMockFunction then
                            v48 = true;
                            goto label1 --[[  true, true  ]];
                        end;
                    else
                        v48 = true;
                        goto label1 --[[  true, true  ]];
                    end;
                end;
                v48 = false;
            end;
            ::label1::;
            if not v48 then
                local l_unsubscribe_0 = l__cleanup_0.unsubscribe;
                if l_unsubscribe_0 == nil then
                    v48 = nil;
                else
                    local v51;
                    if typeof(l_unsubscribe_0) == "function" then
                        v51 = true;
                    else
                        if typeof(l_unsubscribe_0) == "table" then
                            local v52 = getmetatable(l_unsubscribe_0);
                            if not v52 or not rawget(v52, "__call") then
                                if l_unsubscribe_0._isMockFunction then
                                    v51 = true;
                                    goto label2 --[[  true, true  ]];
                                end;
                            else
                                v51 = true;
                                goto label2 --[[  true, true  ]];
                            end;
                        end;
                        v51 = false;
                    end;
                    ::label2::;
                    if not v51 then
                        error(l_Error_0.new(tostring(l_unsubscribe_0) .. " is not a function"));
                    end;
                    v48 = l_unsubscribe_0;
                end;
                if v48 then
                    local v53;
                    l_unsubscribe_0, v53 = pcall(v48, l__cleanup_0);
                    v46 = l_unsubscribe_0;
                    v47 = v53;
                end;
            else
                local v54;
                v48, v54 = pcall(l__cleanup_0);
                v46 = v48;
                v47 = v54;
            end;
            if not v46 then
                v38(v47);
            end;
            return ;
        else
            return ;
        end;
    end;
end;
local function _(v56)
    v56._observer = nil;
    v56._queue = nil;
    v56._state = "closed";
end;
local function v61(v58)
    local l__queue_0 = v58._queue;
    if l_Boolean_0.toJSBoolean(l__queue_0) then
        v58._queue = nil;
        v58._state = "ready";
        for v60 = 1, #l__queue_0 do
            v11(v58, l__queue_0[v60].type, l__queue_0[v60].value);
            if not (v58._state ~= "closed") then
                break;
            end;
        end;
        return ;
    else
        return ;
    end;
end;
v11 = function(v62, v63, v64)
    v62._state = "running";
    local l__observer_0 = v62._observer;
    local v66 = nil;
    local l_status_0, l_result_0 = pcall(v27, l__observer_0, v63);
    if l_status_0 then
        if v63 == "next" then
            if l_result_0 then
                local l_status_1, l_result_1 = pcall(l_result_0, l__observer_0, v64);
                l_status_0 = l_status_1;
                v66 = l_result_1;
            end;
        elseif v63 == "error" then
            v62._observer = nil;
            v62._queue = nil;
            v62._state = "closed";
            if not l_result_0 then
                v38(v64);
            else
                local l_status_2, l_result_2 = pcall(l_result_0, l__observer_0, v64);
                l_status_0 = l_status_2;
                v66 = l_result_2;
            end;
        elseif v63 == "complete" then
            v62._observer = nil;
            v62._queue = nil;
            v62._state = "closed";
            if l_result_0 then
                local l_status_3, l_result_3 = pcall(l_result_0, l__observer_0, v64);
                l_status_0 = l_status_3;
                v66 = l_result_3;
            end;
        end;
        if not l_status_0 then
            v38(v66);
        end;
        if v62._state == "closed" then
            v55(v62);
            return ;
        else
            if v62._state == "running" then
                v62._state = "ready";
            end;
            return ;
        end;
    else
        v38(l_result_0);
        return ;
    end;
end;
local function v80(v75, v76, v77)
    if v75._state == "closed" then
        return ;
    elseif v75._state == "buffering" then
        assert(v75._queue, "observable subscription queue nil during onNotify");
        table.insert(v75._queue, {
            type = v76,
            value = v77
        });
        return ;
    elseif v75._state ~= "ready" then
        v75._state = "buffering";
        v75._queue = {
            {
                type = v76,
                value = v77
            }
        };
        local function v78()
            return v61(v75);
        end;
        v2.delay(0):doneCall(function()
            xpcall(v78, function(v79)
                v38(v79);
            end);
        end);
        return ;
    else
        v11(v75, v76, v77);
        return ;
    end;
end;
local v81 = {};
v81.__index = function(v82, v83)
    if v83 == "closed" then
        return v82._state == "closed";
    elseif not rawget(v82, v83) then
        if not rawget(v81, v83) then
            return nil;
        else
            return (rawget(v81, v83));
        end;
    else
        return (rawget(v82, v83));
    end;
end;
v81.__newindex = function(v84, v85, v86)
    if v85 == "closed" then
        error("setting getter-only property 'closed'");
    end;
    rawset(v84, v85, v86);
end;
v81.new = function(v87, v88)
    local v89 = setmetatable({}, v81);
    v89._cleanup = nil;
    v89._observer = v87;
    v89._queue = nil;
    v89._state = "initializing";
    local v90 = v10.new(v89);
    local l_status_4, l_result_4 = pcall(v88, v90);
    if not l_status_4 then
        v90:error(l_result_4);
    else
        v89._cleanup = l_result_4;
    end;
    if v89._state == "initializing" then
        v89._state = "ready";
    end;
    return v89;
end;
v81.unsubscribe = function(v93)
    if v93._state ~= "closed" then
        v93._observer = nil;
        v93._queue = nil;
        v93._state = "closed";
        v55(v93);
    end;
end;
v10 = {};
v10.__index = function(v94, v95)
    if v95 == "closed" then
        return v94._subscription._state == "closed";
    elseif not rawget(v10, v95) then
        return (rawget(v94, v95));
    else
        return (rawget(v10, v95));
    end;
end;
v10.__newindex = function(v96, v97, v98)
    if v97 == "closed" then
        error("setting getter-only property 'closed'");
    end;
    rawset(v96, v97, v98);
end;
v10.new = function(v99)
    return (setmetatable({
        _subscription = v99
    }, v10));
end;
v10.next = function(v100, v101)
    v80(v100._subscription, "next", v101);
end;
v10.error = function(v102, v103)
    v80(v102._subscription, "error", v103);
end;
v10.complete = function(v104)
    v80(v104._subscription, "complete");
end;
v9 = {};
v9.__index = v9;
v12 = function(v105)
    local v106 = false;
    if typeof(v105) == "table" then
        v106 = false;
        if v105[v25] == v9[v25] then
            v106 = typeof((rawget(v105, "new"))) == "function";
        end;
    end;
    return v106;
end;
v9.new = function(v107)
    local v108;
    if typeof(v107) == "function" then
        v108 = true;
    else
        if typeof(v107) == "table" then
            local v109 = getmetatable(v107);
            if not v109 or not rawget(v109, "__call") then
                if v107._isMockFunction then
                    v108 = true;
                    goto label3 --[[  true, true  ]];
                end;
            else
                v108 = true;
                goto label3 --[[  true, true  ]];
            end;
        end;
        v108 = false;
    end;
    ::label3::;
    if not v108 then
        error("Observable initializer must be a function");
    end;
    return (setmetatable({
        _subscriber = v107
    }, v9));
end;
v9.subscribe = function(v110, v111, v112, v113)
    if not (typeof(v111) == "table") or v111 == nil then
        v111 = {
            start = nil,
            next = v111,
            error = v112,
            complete = v113
        };
    end;
    return (v81.new(v111, v110._subscriber));
end;
v9.forEach = function(v114, v115)
    return v2.new(function(v116, v117)
        local l_v115_0 = v115;
        local v119;
        if typeof(l_v115_0) == "function" then
            v119 = true;
        else
            if typeof(l_v115_0) == "table" then
                local v120 = getmetatable(l_v115_0);
                if not v120 or not rawget(v120, "__call") then
                    if l_v115_0._isMockFunction then
                        v119 = true;
                        goto label4 --[[  true, true  ]];
                    end;
                else
                    v119 = true;
                    goto label4 --[[  true, true  ]];
                end;
            end;
            v119 = false;
        end;
        ::label4::;
        if v119 then
            v119 = nil;
            l_v115_0 = function()
                v119:unsubscribe();
                v116();
            end;
            v119 = v114:subscribe({
                next = function(_, v122)
                    local l_status_5, l_result_5 = pcall(v115, v122, l_v115_0);
                    if not l_status_5 then
                        v117(l_result_5);
                        v119:unsubscribe();
                    end;
                end,
                error = function(_, v126)
                    v117(v126);
                end,
                complete = function(_)
                    v116();
                end
            });
            return ;
        else
            v117(l_Error_0.new(tostring(v115) .. " is not a function"));
            return ;
        end;
    end);
end;
v9.map = function(v128, v129)
    local v130;
    if typeof(v129) == "function" then
        v130 = true;
    else
        if typeof(v129) == "table" then
            local v131 = getmetatable(v129);
            if not v131 or not rawget(v131, "__call") then
                if v129._isMockFunction then
                    v130 = true;
                    goto label5 --[[  true, true  ]];
                end;
            else
                v130 = true;
                goto label5 --[[  true, true  ]];
            end;
        end;
        v130 = false;
    end;
    ::label5::;
    if not v130 then
        error(l_Error_0.new(tostring(v129) .. " is not a function"));
    end;
    local v132 = v128[v26];
    return (if v132 ~= nil then v132 else v9).new(function(v133)
        return v128:subscribe({
            next = function(_, v135)
                local l_status_6, l_result_6 = pcall(v129, v135);
                if l_status_6 then
                    v133:next(l_result_6);
                    return ;
                else
                    v133:error(l_result_6);
                    return ;
                end;
            end,
            error = function(_, v139)
                v133:error(v139);
            end,
            complete = function(_)
                v133:complete();
            end
        });
    end);
end;
v9.filter = function(v141, v142)
    local v143;
    if typeof(v142) == "function" then
        v143 = true;
    else
        if typeof(v142) == "table" then
            local v144 = getmetatable(v142);
            if not v144 or not rawget(v144, "__call") then
                if v142._isMockFunction then
                    v143 = true;
                    goto label6 --[[  true, true  ]];
                end;
            else
                v143 = true;
                goto label6 --[[  true, true  ]];
            end;
        end;
        v143 = false;
    end;
    ::label6::;
    if not v143 then
        error(l_Error_0.new(tostring(v142) .. " is not a function"));
    end;
    local v145 = v141[v26];
    return (if v145 ~= nil then v145 else v9).new(function(v146)
        return v141:subscribe({
            next = function(_, v148)
                local v150, v151 = xpcall(v142, function(v149)
                    v146:error(v149);
                end, v148);
                if not v150 or l_Boolean_0.toJSBoolean(v151) then
                    if v150 then
                        v146:next(v148);
                        return ;
                    else
                        return ;
                    end;
                else
                    return ;
                end;
            end,
            error = function(_, v153)
                v146:error(v153);
            end,
            complete = function(_)
                v146:complete();
            end
        });
    end);
end;
v9.reduce = function(v155, v156, ...)
    local v157 = {
        v156,
        ...
    };
    local v158;
    if typeof(v156) == "function" then
        v158 = true;
    else
        if typeof(v156) == "table" then
            local v159 = getmetatable(v156);
            if not v159 or not rawget(v159, "__call") then
                if v156._isMockFunction then
                    v158 = true;
                    goto label7 --[[  true, true  ]];
                end;
            else
                v158 = true;
                goto label7 --[[  true, true  ]];
            end;
        end;
        v158 = false;
    end;
    ::label7::;
    if not v158 then
        error(l_Error_0.new(tostring(v156) .. " is not a function"));
    end;
    local v160 = v155[v26];
    v158 = if v160 ~= nil then v160 else v9;
    v160 = #v157 > 1;
    local v161 = false;
    local v162 = v157[2];
    return v158.new(function(v163)
        return v155:subscribe({
            next = function(_, v165)
                local v166 = not v161;
                v161 = true;
                if v166 and not v160 then
                    v162 = v165;
                    return ;
                else
                    local v167 = nil;
                    local v169, v170 = xpcall(v156, function(v168)
                        v163:error(v168);
                    end, v162, v165);
                    v162 = v170;
                    v167 = v169;
                    return ;
                end;
            end,
            error = function(_, v172)
                v163:error(v172);
            end,
            complete = function(_)
                if not (v161 or v160) then
                    v163:error(l_Error_0.new("Cannot reduce an empty sequence"));
                end;
                v163:next(v162);
                v163:complete();
            end
        });
    end);
end;
v9.concat = function(v174, ...)
    local v175 = {
        ...
    };
    local v176 = v174[v26];
    local v177 = if v176 ~= nil then v176 else v9;
    return v177.new(function(v178)
        local v179 = nil;
        local v180 = 1;
        local function v181(v182)
            v179 = v182:subscribe({
                next = function(_, v184)
                    v178:next(v184);
                end,
                error = function(_, v186)
                    v178:error(v186);
                end,
                complete = function(_)
                    if v180 == #v175 + 1 then
                        v179 = nil;
                        v178:complete();
                        return ;
                    else
                        local l_v181_0 = v181;
                        local l_from_0 = v177.from;
                        local l_v175_0 = v175;
                        local l_v180_0 = v180;
                        v180 = v180 + 1;
                        l_v181_0(l_from_0(l_v175_0[l_v180_0]));
                        return ;
                    end;
                end
            });
        end;
        v181(v174);
        return function()
            if l_Boolean_0.toJSBoolean(v179) then
                v179:unsubscribe();
                v179 = nil;
            end;
        end;
    end);
end;
v9.flatMap = function(v192, v193)
    local v194 = nil;
    local v195;
    if typeof(v193) == "function" then
        v195 = true;
    else
        if typeof(v193) == "table" then
            local v196 = getmetatable(v193);
            if not v196 or not rawget(v196, "__call") then
                if v193._isMockFunction then
                    v195 = true;
                    goto label8 --[[  true, true  ]];
                end;
            else
                v195 = true;
                goto label8 --[[  true, true  ]];
            end;
        end;
        v195 = false;
    end;
    ::label8::;
    if not v195 then
        error(l_Error_0.new(tostring(v193) .. " is not a function"));
    end;
    local v197 = v192[v26];
    v195 = if v197 ~= nil then v197 else v9;
    return v195.new(function(v198)
        local v199 = {};
        local v216 = v192:subscribe({
            next = function(_, v201)
                if l_Boolean_0.toJSBoolean(v193) then
                    local v202 = nil;
                    local v204, v205 = xpcall(v193, function(v203)
                        v198:error(v203);
                    end, v201);
                    v202 = v204;
                    v201 = v205;
                end;
                local v206 = nil;
                v206 = v195.from(v201):subscribe({
                    next = function(_, v208)
                        v198:next(v208);
                    end,
                    error = function(_, v210)
                        v198:error(v210);
                    end,
                    complete = function(_)
                        local v212 = l_Array_0.indexOf(v199, v206);
                        if v212 >= 1 then
                            l_Array_0.splice(v199, v212, 1);
                        end;
                        v194();
                    end
                });
                table.insert(v199, v206);
                return nil;
            end,
            error = function(_, v214)
                v198:error(v214);
            end,
            complete = function(_)
                v194();
            end
        });
        v194 = function()
            if v216.closed and #v199 == 0 then
                v198:complete();
            end;
        end;
        return function()
            l_Array_0.forEach(v199, function(v217)
                return v217:unsubscribe();
            end);
            v216:unsubscribe();
        end;
    end);
end;
v9[v25] = function(v218)
    return v218;
end;
v9.from = function(v219, v220)
    local v221 = nil;
    local v222 = nil;
    if not v12(v219) then
        v221 = v9;
        v222 = v219;
    else
        v221 = v219;
        v222 = v220;
    end;
    if v222 == nil then
        error(l_Error_0.new(tostring(v222) .. " is not an object"));
    end;
    local v223 = v222[v25];
    local v224;
    if v223 == nil then
        v224 = nil;
    else
        local v225;
        if typeof(v223) == "function" then
            v225 = true;
        else
            if typeof(v223) == "table" then
                local v226 = getmetatable(v223);
                if not v226 or not rawget(v226, "__call") then
                    if v223._isMockFunction then
                        v225 = true;
                        goto label9 --[[  true, true  ]];
                    end;
                else
                    v225 = true;
                    goto label9 --[[  true, true  ]];
                end;
            end;
            v225 = false;
        end;
        ::label9::;
        if not v225 then
            error(l_Error_0.new(tostring(v223) .. " is not a function"));
        end;
        v224 = v223;
    end;
    if not v224 then
        if not l_Array_0.isArray(v222) then
            error(l_Error_0.new(tostring(v222) .. " is not observable"));
            return ;
        else
            return v9.new(function(v227)
                local function v230()
                    if not v227.closed then
                        for _, v229 in pairs(v222) do
                            v227:next(v229);
                            if v227.closed then
                                return ;
                            end;
                        end;
                        v227:complete();
                        return ;
                    else
                        return ;
                    end;
                end;
                v2.delay(0):doneCall(function()
                    xpcall(v230, function(v231)
                        v38(v231);
                    end);
                end);
            end);
        end;
    else
        local v232 = v224(v222);
        if l_instanceof_0(v232, v9) and v232.new == v221.new then
            return v232;
        else
            return v221.new(function(v233)
                return v232:subscribe(v233);
            end);
        end;
    end;
end;
v9.of = function(v234, ...)
    local v235 = nil;
    local v236 = nil;
    if not v12(v234) then
        v235 = v9;
        v236 = {
            v234,
            ...
        };
    else
        v235 = v234;
        v236 = {
            ...
        };
    end;
    return v235.new(function(v237)
        local function v240()
            if not v237.closed then
                for _, v239 in ipairs(v236) do
                    v237:next(v239);
                    if v237.closed then
                        return ;
                    end;
                end;
                v237:complete();
                return ;
            else
                return ;
            end;
        end;
        v2.delay(0):doneCall(function()
            xpcall(v240, function(v241)
                v38(v241);
            end);
        end);
    end);
end;
local v242 = false;
if typeof(l_Symbol_0) == "table" then
    v242 = typeof(getmetatable(l_Symbol_0).__call) == "function";
end;
if v242 then
    v9[l_Symbol_0("extensions")] = {
        symbol = v25,
        hostReportError = v38
    };
end;
return {
    Observable = v9
};


local function v8(v0, v1)
    local v2 = v1 or tostring(v0);
    return (setmetatable(v0, {
        __index = function(_, v4)
            error(("%q (%s) is not a valid member of %s"):format(tostring(v4), typeof(v4), v2), 2);
        end,
        __newindex = function(_, v6, _)
            error(("%q (%s) is not a valid member of %s"):format(tostring(v6), typeof(v6), v2), 2);
        end
    }));
end;
local function v17(v9, v10, v11, v12, v13)
    local v14 = typeof(v12) == "string";
    assert(v14, "Only string names are supported for enums");
    if v14 then
        assert(v12 ~= "fromRawValue", "fromRawValue is reserved");
        assert(v12 ~= "isEnumValue", "isEnumValue is reserved");
        assert(v12 ~= "allValues", "allValues is reserved");
    end;
    assert(v9[v12] == nil, "Enum value names can only be used once");
    assert(v10[v12] == nil, "Enum values can only be used once");
    local v15 = newproxy(true);
    local v16 = getmetatable(v15);
    v16.__tostring = function()
        return ("%s.%s"):format(v11, v12);
    end;
    v16.__index = v8({
        rawValue = function()
            return v13;
        end
    });
    v9[v12] = v15;
    v10[v13] = v15;
end;
return function(v18, v19)
    assert(typeof(v18) == "string", "Bad argument #1 - enums must be created using a string name");
    assert(typeof(v19) == "table", "Bad argument #2 - enums must be created using a table");
    local v20 = {};
    local v21 = {};
    if v19[1] ~= nil then
        for _, v23 in ipairs(v19) do
            v17(v20, v21, v18, v23, v23);
        end;
    else
        for v24, v25 in pairs(v19) do
            v17(v20, v21, v18, v24, v25);
        end;
    end;
    v20.fromRawValue = function(v26)
        return v21[v26];
    end;
    v20.isEnumValue = function(v27)
        if typeof(v27) ~= "userdata" then
            return false;
        else
            for _, v29 in pairs(v20) do
                if v29 == v27 then
                    return true;
                end;
            end;
            return false;
        end;
    end;
    v20.allValues = function()
        local v30 = {};
        for _, v32 in pairs(v21) do
            table.insert(v30, v32);
        end;
        return v30;
    end;
    local v33 = newproxy(true);
    local v34 = getmetatable(v33);
    v34.__index = v8(v20, v18);
    v34.__tostring = function()
        return v18;
    end;
    return v33;
end;


return function(v0)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    for v3, v4 in pairs(v0) do
        v2[v3] = v4;
    end;
    return v2;
end;


local function v0(v1)
    local v2 = type(v1);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = {};
    for v4, v5 in pairs(v1) do
        if type(v5) == "table" then
            v3[v4] = v0(v5);
        else
            v3[v4] = v5;
        end;
    end;
    return v3;
end;
return v0;


local function v0()
    return true;
end;
return function(v1, v2)
    local v3 = type(v1);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = 0;
    v2 = v2 or v0;
    for v5, v6 in pairs(v1) do
        if v2(v6, v5) then
            v4 = v4 + 1;
        end;
    end;
    return v4;
end;


local v0 = require(script.Parent.Parent.equalObjects);
return function(...)
    if not v0(...) then
        local v1 = select("#", ...);
        for v2 = 1, v1 do
            local v3 = select(v2, ...);
            for v4 = 1, v1 do
                if v4 ~= v2 then
                    local v5 = select(v4, ...);
                    for v6, v7 in pairs(v3) do
                        if v7 ~= v5[v6] then
                            return false;
                        end;
                    end;
                end;
            end;
        end;
        return true;
    else
        return true;
    end;
end;


local v0 = require(script.Parent.Parent.equalObjects);
local function v1(v2, v3)
    if type(v2) == "table" and type(v3) == "table" then
        for v4, v5 in pairs(v2) do
            if not v1(v5, v3[v4]) then
                return false;
            end;
        end;
    elseif v2 ~= v3 then
        return false;
    end;
    return true;
end;
return function(...)
    if not v0(...) then
        local v6 = select("#", ...);
        for v7 = 1, v6 do
            local v8 = select(v7, ...);
            for v9 = 1, v6 do
                if not (not (v9 ~= v7) or v1(v8, (select(v9, ...)))) then
                    return false;
                end;
            end;
        end;
        return true;
    else
        return true;
    end;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    assert(v3 == "function", "expected a function for second argument, got " .. v3);
    for v4, v5 in pairs(v0) do
        if not v1(v5, v4) then
            return false;
        end;
    end;
    return true;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    assert(v3 == "function", "expected a function for second argument, got " .. v3);
    local v4 = {};
    for v5, v6 in pairs(v0) do
        if v1(v6, v5) then
            v4[v5] = v6;
        end;
    end;
    return v4;
end;


local v0 = require(script.Parent.join);
local function v1(v2, v3)
    local v4 = type(v2);
    assert(v4 == "table", "expected a table for first argument, got " .. v4);
    local v5 = type(v3);
    assert(v5 == "function", "expected a function for second argument, got " .. v5);
    local v6 = {};
    for v7, v8 in pairs(v2) do
        if type(v8) == "table" then
            v6 = v0(v1(v8, v3), v6);
        else
            local v9, v10 = v3(v8, v7);
            v6[v10 or v7] = v9;
        end;
    end;
    return v6;
end;
return v1;


local v0 = require(script.Parent.join);
local function v1(v2)
    local v3 = type(v2);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = {};
    for v5, v6 in pairs(v2) do
        if type(v6) == "table" then
            v4 = v0(v1(v6), v4);
        else
            v4[v5] = v6;
        end;
    end;
    return v4;
end;
return v1;


return function(v0)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    for v3, v4 in pairs(v0) do
        v2[v4] = v3;
    end;
    return v2;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    assert(v1 ~= nil, "expected second argument to be anything but nil, got nil");
    return v0[v1];
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    assert(v1 ~= nil, "expected second argument to be anything but nil, got nil");
    return v0[v1] ~= nil;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    for _, v4 in pairs(v0) do
        if v4 == v1 then
            return true;
        end;
    end;
    return false;
end;


return {
    copy = require(script.copy),
    copyDeep = require(script.copyDeep),
    count = require(script.count),
    equals = require(script.equals),
    equalsDeep = require(script.equalsDeep),
    every = require(script.every),
    filter = require(script.filter),
    flatMap = require(script.flatMap),
    flatten = require(script.flatten),
    flip = require(script.flip),
    get = require(script.get),
    has = require(script.has),
    includes = require(script.includes),
    join = require(script.join),
    joinDeep = require(script.joinDeep),
    keys = require(script.keys),
    map = require(script.map),
    removeKey = require(script.removeKey),
    removeValue = require(script.removeValue),
    set = require(script.set),
    some = require(script.some),
    update = require(script.update),
    values = require(script.values)
};


local v0 = require(script.Parent.Parent.None);
return function(...)
    local v1 = {};
    for v2 = 1, select("#", ...) do
        local v3 = select(v2, ...);
        if v3 then
            for v4, v5 in pairs(v3) do
                if v5 == v0 then
                    v1[v4] = nil;
                else
                    v1[v4] = v5;
                end;
            end;
        end;
    end;
    return v1;
end;


local v0 = require(script.Parent.Parent.None);
local v1 = require(script.Parent.copyDeep);
local function v2(...)
    local v3 = {};
    for v4 = 1, select("#", ...) do
        local v5 = select(v4, ...);
        if v5 then
            for v6, v7 in pairs(v5) do
                if v7 == v0 then
                    v3[v6] = nil;
                elseif type(v7) == "table" then
                    if v3[v6] ~= nil and not type(v3[v6] ~= "table") then
                        v3[v6] = v2(v3[v6], v7);
                    else
                        v3[v6] = v1(v7);
                    end;
                else
                    v3[v6] = v7;
                end;
            end;
        end;
    end;
    return v3;
end;
return v2;


return function(v0)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    local v3 = 1;
    for v4, _ in pairs(v0) do
        v2[v3] = v4;
        v3 = v3 + 1;
    end;
    return v2;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    assert(v3 == "function", "expected a function for second argument, got " .. v3);
    local v4 = {};
    for v5, v6 in pairs(v0) do
        local v7, v8 = v1(v6, v5);
        v4[v8 or v5] = v7;
    end;
    return v4;
end;


local v0 = require(script.Parent.copy);
return function(v1, ...)
    local v2 = type(v1);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = v0(v1);
    for v4 = 1, select("#", ...) do
        v3[select(v4, ...)] = nil;
    end;
    return v3;
end;


local v0 = require(script.Parent.Parent.List.toSet);
return function(v1, ...)
    local v2 = type(v1);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = v0({
        ...
    });
    local v4 = {};
    for v5, v6 in pairs(v1) do
        if not v3[v6] then
            v4[v5] = v6;
        end;
    end;
    return v4;
end;


local v0 = require(script.Parent.copy);
return function(v1, v2, v3)
    local v4 = type(v1);
    assert(v4 == "table", "expected a table for first argument, got " .. v4);
    assert(v2 ~= nil, "expected second argument to be anything but nil, got nil");
    local v5 = v0(v1);
    v5[v2] = v3;
    return v5;
end;


return function(v0, v1)
    local v2 = type(v1);
    assert(v2 == "function", "expected a function for second argument, got " .. v2);
    for v3, v4 in pairs(v0) do
        if v1(v4, v3) then
            return true;
        end;
    end;
    return false;
end;


local v0 = require(script.Parent.copy);
local function v3(v1, v2)
    return v1, v2;
end;
local function v5(v4, ...)
    if type(v4) == "function" then
        return v4(...);
    else
        return ;
    end;
end;
return function(v6, v7, v8, v9)
    local v10 = type(v6);
    assert(v10 == "table", "expected a table for first argument, got " .. v10);
    assert(v7 ~= nil, "expected second argument to be anything but nil, got nil");
    local v11 = v0(v6);
    local v12 = nil;
    local v13 = nil;
    v8 = v8 or v3;
    if v11[v7] ~= nil then
        local v14, v15 = v8(v11[v7], v7);
        v12 = v14;
        v13 = v15;
        v5(v9, true, v12, v13 or v7);
    else
        local v16, v17 = v5(v9, false, v7);
        v12 = v16;
        v13 = v17;
    end;
    v11[v13 or v7] = v12;
    return v11;
end;


return function(v0)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    local v3 = 1;
    for _, v5 in pairs(v0) do
        v2[v3] = v5;
        v3 = v3 + 1;
    end;
    return v2;
end;


return function(v0)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    for v3 = 1, #v0 do
        v2[v3] = v0[v3];
    end;
    return v2;
end;


local function v0(v1)
    local v2 = type(v1);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = {};
    for v4 = 1, #v1 do
        if type(v1[v4]) == "table" then
            v3[v4] = v0(v1[v4]);
        else
            v3[v4] = v1[v4];
        end;
    end;
    return v3;
end;
return v0;


local function v0()
    return true;
end;
return function(v1, v2)
    local v3 = type(v1);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    v2 = v2 or v0;
    local v4 = 0;
    for v5 = 1, #v1 do
        if v2(v1[v5], v5) then
            v4 = v4 + 1;
        end;
    end;
    return v4;
end;


local v0 = require(script.Parent.Parent.equalObjects);
return function(...)
    if not v0(...) then
        local v1 = select("#", ...);
        for v2 = 1, v1 do
            local v3 = select(v2, ...);
            for v4 = 1, v1 do
                if v4 ~= v2 then
                    local v5 = select(v4, ...);
                    for v6 = 1, #v3 do
                        if v3[v6] ~= v5[v6] then
                            return false;
                        end;
                    end;
                end;
            end;
        end;
        return true;
    else
        return true;
    end;
end;


local v0 = require(script.Parent.Parent.equalObjects);
local function v1(v2, v3)
    if type(v2) == "table" and type(v3) == "table" then
        for v4 = 1, #v2 do
            if not v1(v2[v4], v3[v4]) then
                return false;
            end;
        end;
    elseif v2 ~= v3 then
        return false;
    end;
    return true;
end;
return function(...)
    if not v0(...) then
        local v5 = select("#", ...);
        for v6 = 1, v5 do
            local v7 = select(v6, ...);
            for v8 = 1, v5 do
                if not (not (v8 ~= v6) or v1(v7, (select(v8, ...)))) then
                    return false;
                end;
            end;
        end;
        return true;
    else
        return true;
    end;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    assert(v3 == "function", "expected a function for second argument, got " .. v3);
    for v4 = 1, #v0 do
        if not v1(v0[v4], v4) then
            return false;
        end;
    end;
    return true;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    assert(v3 == "function", "expected a function for second argument, got " .. v3);
    local v4 = {};
    local v5 = 1;
    for v6 = 1, #v0 do
        if v1(v0[v6], v6) then
            v4[v5] = v0[v6];
            v5 = v5 + 1;
        end;
    end;
    return v4;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    for v4 = v2 or 1, #v0 do
        if v0[v4] == v1 then
            return v4;
        end;
    end;
    return nil;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = v2 or #v0;
    for v5 = v4, 1, -1 do
        if v0[v5] == v1 then
            return v5;
        end;
    end;
    return nil;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = type(v1);
    assert(v4 == "function", "expected a function for second argument, got " .. v4);
    for v5 = v2 or 1, #v0 do
        if v1(v0[v5], v5) then
            return v5;
        end;
    end;
    return nil;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = type(v1);
    assert(v4 == "function", "expected a function for second argument, got " .. v4);
    local v5 = v2 or #v0;
    for v6 = v5, 1, -1 do
        if v1(v0[v6], v6) then
            return v6;
        end;
    end;
    return nil;
end;


local function v0(v1, v2)
    local v3 = type(v1);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = type(v2);
    assert(v4 == "function", "expected a function for second argument, got " .. v4);
    local v5 = {};
    local v6 = 1;
    for v7 = 1, #v1 do
        if type(v1[v7]) == "table" then
            local v8 = v0(v1[v7], v2);
            for v9 = 1, #v8 do
                v5[v6] = v8[v9];
                v6 = v6 + 1;
            end;
        else
            local v10 = v2(v1[v7], v7);
            if v10 ~= nil then
                v5[v6] = v10;
                v6 = v6 + 1;
            end;
        end;
    end;
    return v5;
end;
return v0;


local function v0(v1)
    local v2 = type(v1);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = {};
    local v4 = 1;
    for v5 = 1, #v1 do
        if type(v1[v5]) == "table" then
            local v6 = v0(v1[v5]);
            for v7 = 1, #v6 do
                v3[v4] = v6[v7];
                v4 = v4 + 1;
            end;
        else
            v3[v4] = v1[v5];
            v4 = v4 + 1;
        end;
    end;
    return v3;
end;
return v0;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    local v4 = false;
    if v3 == "number" then
        v4 = v1 % 1 == 0;
    end;
    assert(v4, "expected second argument to be an integer, got " .. v3);
    return v0[v1];
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    for v3 = 1, #v0 do
        if v0[v3] == v1 then
            return true;
        end;
    end;
    return false;
end;


return {
    append = require(script.append),
    copy = require(script.copy),
    copyDeep = require(script.copyDeep),
    count = require(script.count),
    equals = require(script.equals),
    equalsDeep = require(script.equalsDeep),
    every = require(script.every),
    filter = require(script.filter),
    find = require(script.find),
    findLast = require(script.findLast),
    findWhere = require(script.findWhere),
    findWhereLast = require(script.findWhereLast),
    flatMap = require(script.flatMap),
    flatten = require(script.flatten),
    get = require(script.get),
    includes = require(script.includes),
    insert = require(script.insert),
    join = require(script.join),
    joinDeep = require(script.joinDeep),
    map = require(script.map),
    pop = require(script.pop),
    push = require(script.push),
    reduce = require(script.reduce),
    reduceRight = require(script.reduceRight),
    removeIndex = require(script.removeIndex),
    removeValue = require(script.removeValue),
    reverse = require(script.reverse),
    set = require(script.set),
    shift = require(script.shift),
    slice = require(script.slice),
    some = require(script.some),
    sort = require(script.sort),
    splice = require(script.splice),
    toSet = require(script.toSet),
    unshift = require(script.unshift),
    update = require(script.update),
    zip = require(script.zip),
    zipAll = require(script.zipAll)
};


return function(v0, v1, ...)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = #v0;
    local v4 = false;
    if v1 >= 1 then
        v4 = v1 <= v3 + 1;
    end;
    assert(v4, "index must be in bounds of list");
    local v5 = {};
    v4 = 1;
    for v6 = 1, v3 do
        if v6 == v1 then
            for v7 = 1, select("#", ...) do
                v5[v4] = select(v7, ...);
                v4 = v4 + 1;
            end;
        end;
        v5[v4] = v0[v6];
        v4 = v4 + 1;
    end;
    return v5;
end;


local v0 = require(script.Parent.Parent.None);
return function(...)
    local v1 = {};
    local v2 = 1;
    for v3 = 1, select("#", ...) do
        local v4 = select(v3, ...);
        if v4 then
            for v5 = 1, #v4 do
                if v4[v5] ~= v0 then
                    v1[v2] = v4[v5];
                    v2 = v2 + 1;
                end;
            end;
        end;
    end;
    return v1;
end;


local v0 = require(script.Parent.Parent.None);
local v1 = require(script.Parent.copyDeep);
local function v2(...)
    local v3 = {};
    local v4 = 1;
    for v5 = 1, select("#", ...) do
        local v6 = select(v5, ...);
        if v6 then
            for v7 = 1, #v6 do
                if type(v6[v7]) == "table" then
                    if v3[v4] ~= nil and not type(v3[v4] ~= "table") then
                        v3[v4] = v2(v3[v4], v6[v7]);
                    else
                        v3[v4] = v1(v6[v7]);
                    end;
                elseif v6[v7] ~= v0 then
                    v3[v4] = v6[v7];
                end;
                v4 = v4 + 1;
            end;
        end;
    end;
    return v3;
end;
return v2;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    assert(v3 == "function", "expected a function for second argument, got " .. v3);
    local v4 = {};
    local v5 = 1;
    for v6 = 1, #v0 do
        local v7 = v1(v0[v6], v6);
        if v7 ~= nil then
            v4[v5] = v7;
            v5 = v5 + 1;
        end;
    end;
    return v4;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    v1 = v1 or 1;
    local v3 = type(v1);
    local v4 = false;
    if v3 == "number" then
        v4 = v1 % 1 == 0;
    end;
    assert(v4, "expected an integer for second argument, got " .. v3);
    local v5 = {};
    for v6 = 1, #v0 - v1 do
        v5[v6] = v0[v6];
    end;
    return v5;
end;


return function(v0, ...)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    local v3 = #v0;
    for v4 = 1, v3 do
        v2[v4] = v0[v4];
    end;
    for v5 = 1, select("#", ...) do
        v2[v3 + v5] = select(v5, ...);
    end;
    return v2;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = type(v1);
    assert(v4 == "function", "expected a function for second argument, got " .. v4);
    local l_v2_0 = v2;
    if l_v2_0 == nil then
        l_v2_0 = v0[1];
    end;
    local v6 = v2 == nil and 2 or 1;
    for v7 = v6, #v0 do
        l_v2_0 = v1(l_v2_0, v0[v7], v7);
    end;
    return l_v2_0;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = type(v1);
    assert(v4 == "function", "expected a function for second argument, got " .. v4);
    local v5 = #v0;
    local l_v2_0 = v2;
    if l_v2_0 == nil then
        l_v2_0 = v0[v5];
    end;
    local v7 = v2 == nil and v5 - 1 or v5;
    for v8 = v7, 1, -1 do
        l_v2_0 = v1(l_v2_0, v0[v8], v8);
    end;
    return l_v2_0;
end;


local v0 = require(script.Parent.toSet);
return function(v1, ...)
    local v2 = type(v1);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = {};
    local v4 = v0({
        ...
    });
    local v5 = 1;
    for v6 = 1, #v1 do
        if not v4[v6] then
            v3[v5] = v1[v6];
            v5 = v5 + 1;
        end;
    end;
    return v3;
end;


local v0 = require(script.Parent.Parent.List.toSet);
return function(v1, ...)
    local v2 = type(v1);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = v0({
        ...
    });
    local v4 = {};
    local v5 = 1;
    for v6 = 1, #v1 do
        if not v3[v1[v6]] then
            v4[v5] = v1[v6];
            v5 = v5 + 1;
        end;
    end;
    return v4;
end;


return function(v0)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    local v3 = #v0;
    local v4 = v3 + 1;
    for v5 = 1, v3 do
        v2[v5] = v0[v4 - v5];
    end;
    return v2;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = #v0;
    assert(v1 <= v4, "index must be less than or equal to the list length");
    assert(v1 >= 1, "index must be greater than or equal to 1");
    local v5 = {};
    local v6 = 1;
    for v7 = 1, v4 do
        if v7 == v1 then
            v5[v6] = v2;
        else
            v5[v6] = v0[v7];
        end;
        v6 = v6 + 1;
    end;
    return v5;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    v1 = v1 or 1;
    local v3 = type(v1);
    local v4 = false;
    if v3 == "number" then
        v4 = v1 % 1 == 0;
    end;
    assert(v4, "expected an integer for second argument, got " .. v3);
    local v5 = {};
    for v6 = 1 + v1, #v0 do
        v5[v6 - v1] = v0[v6];
    end;
    return v5;
end;


return function(v0, v1, v2)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = #v0;
    v1 = v1 or 1;
    v2 = v2 or v4;
    assert(v1 <= v2, "start index must be less than or equal to end index");
    local v5 = {};
    local v6 = 1;
    for v7 = math.max(1, v1), math.min(v2, v4) do
        v5[v6] = v0[v7];
        v6 = v6 + 1;
    end;
    return v5;
end;


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    local v3 = type(v1);
    assert(v3 == "function", "expected a function for second argument, got " .. v3);
    for v4 = 1, #v0 do
        if v1(v0[v4], v4) then
            return true;
        end;
    end;
    return false;
end;


local v0 = require(script.Parent.copy);
return function(v1, v2)
    local v3 = type(v1);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = v0(v1);
    table.sort(v4, v2);
    return v4;
end;


return function(v0, v1, v2, ...)
    local v3 = type(v0);
    assert(v3 == "table", "expected a table for first argument, got " .. v3);
    local v4 = type(v1);
    local v5 = false;
    if v4 == "number" then
        v5 = v1 % 1 == 0;
    end;
    assert(v5, "expected an integer for second argument, got " .. v4);
    local v6 = type(v2);
    local v7 = false;
    if v6 == "number" then
        v7 = v2 % 1 == 0;
    end;
    assert(v7, "expected an integer for third argument, got " .. v6);
    assert(v1 <= v2, "start index must be less than or equal to end index");
    v5 = {};
    v7 = 1;
    local v8 = #v0;
    v1 = math.max(v1, 1);
    v2 = math.min(v1, v8);
    for v9 = 1, v8 do
        local l_v9_0 = v9;
        if l_v9_0 == v1 then
            for v11 = 1, select("#", ...) do
                v5[v7] = select(v11, ...);
                v7 = v7 + 1;
            end;
            l_v9_0 = v2;
        else
            v5[v7] = v0[l_v9_0];
            v7 = v7 + 1;
        end;
    end;
    return v5;
end;


return function(v0)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = {};
    for v3 = 1, #v0 do
        v2[v0[v3]] = true;
    end;
    return v2;
end;


return function(v0, ...)
    local v1 = type(v0);
    assert(v1 == "table", "expected a table for first argument, got " .. v1);
    local v2 = select("#", ...);
    local v3 = {};
    for v4 = 1, v2 do
        v3[v4] = select(v4, ...);
    end;
    for v5 = 1, #v0 do
        v3[v2 + v5] = v0[v5];
    end;
    return v3;
end;


local v0 = require(script.Parent.copy);
local function v2(v1)
    return v1;
end;
local function v4(v3, ...)
    if type(v3) == "function" then
        return v3(...);
    else
        return ;
    end;
end;
return function(v5, v6, v7, v8)
    local v9 = type(v5);
    assert(v9 == "table", "expected a table for first argument, got " .. v9);
    local v10 = type(v6);
    local v11 = false;
    if v10 == "number" then
        v11 = v6 % 1 == 0;
    end;
    assert(v11, "expected an integer for second argument, got " .. v10);
    local v12 = v0(v5);
    v11 = nil;
    v7 = v7 or v2;
    if v12[v6] ~= nil then
        v11 = v7(v12[v6], v6);
        v4(v8, true, v11, v6);
    else
        v11 = v4(v8, false, v6);
    end;
    v12[v6] = v11;
    return v12;
end;


return function(...)
    local v0 = {};
    local v1 = select("#", ...);
    local v2 = #select(1, ...);
    for v3 = 2, v1 do
        local v4 = #select(v3, ...);
        if v4 < v2 then
            v2 = v4;
        end;
    end;
    for v5 = 1, v2 do
        v0[v5] = {};
        for v6 = 1, v1 do
            v0[v5][v6] = select(v6, ...)[v5];
        end;
    end;
    return v0;
end;


local v0 = require(script.Parent.Parent.None);
return function(...)
    local v1 = {};
    local v2 = select("#", ...);
    local v3 = #select(1, ...);
    for v4 = 2, v2 do
        local v5 = #select(v4, ...);
        if v3 < v5 then
            v3 = v5;
        end;
    end;
    for v6 = 1, v3 do
        v1[v6] = {};
        for v7 = 1, v2 do
            if select(v7, ...)[v6] == nil then
                v1[v6][v7] = v0;
            else
                v1[v6][v7] = select(v7, ...)[v6];
            end;
        end;
    end;
    return v1;
end;


local v0 = newproxy(true);
getmetatable(v0).__tostring = function()
    return "Llama.None";
end;
return v0;


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


return function(v0, v1)
    local v2 = type(v0);
    assert(v2 == "table", "expected a table for first argument, got " .. v2);
    assert(v1 ~= nil, "expected second argument to be anything but nil, got nil");
    return v0[v1] == true;
end;


return {
    add = require(script.add),
    has = require(script.has),
    intersect = require(script.intersect),
    subtract = require(script.subtract),
    toList = require(script.toList),
    union = require(script.union),
    copy = require(script.Parent.Dictionary).copy
};


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