local l_TextService_0 = game:GetService("TextService");
local v1 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v1.Roact;
local l_UIBlox_0 = v1.UIBlox;
local l_t_0 = v1.t;
local l_Cryo_0 = v1.Cryo;
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local l_Images_0 = l_UIBlox_0.App.ImageSet.Images;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local l_Parent_0 = script.Parent.Parent.Parent;
local v11 = require(l_Parent_0.Resources.Assets);
local v12 = require(script.Parent.FillCircle);
local v13 = require(l_Parent_0.Components.ThemedTextLabel);
local l_ImageSetLabel_0 = l_UIBlox_0.Core.ImageSet.ImageSetLabel;
local v15 = l_Roact_0.PureComponent:extend("TextEntryField");
local v16 = l_Images_0["component_assets/circle_17"];
v15.validateProps = l_t_0.strictInterface({
    enabled = l_t_0.boolean,
    text = l_t_0.string,
    textChanged = l_t_0.callback,
    maxTextLength = l_t_0.integer,
    autoFocusOnEnabled = l_t_0.boolean,
    PlaceholderText = l_t_0.string,
    LayoutOrder = l_t_0.optional(l_t_0.integer),
    Size = l_t_0.UDim2,
    Position = l_t_0.optional(l_t_0.UDim2),
    textBoxRef = l_t_0.optional(l_t_0.table)
});
v15.init = function(v17)
    v17.textBoxRef = v17.props.textBoxRef or l_Roact_0.createRef();
    v17.state = {
        textBoxWidth = 100,
        scrollingFrameHeight = 100,
        canvasPosition = 0,
        cursorPosition = 0
    };
end;
v15.calculateNeedsRescroll = function(v18, v19, v20)
    v18:setState(function(v21, v22)
        if v21.cursorPosition == -1 then
            return nil;
        else
            local v23 = v22.text:sub(1, v21.cursorPosition - 1);
            local v24 = v20.RelativeSize * v19.Font.BaseSize;
            local l_l_TextService_0_TextSize_0 = l_TextService_0:GetTextSize(v23, v24, v20.Font, (Vector2.new(v22.textBoxWidth, 10000)));
            if v21.scrollingFrameHeight + v21.canvasPosition < l_l_TextService_0_TextSize_0.Y then
                return {
                    canvasPosition = l_l_TextService_0_TextSize_0.Y - v21.scrollingFrameHeight
                };
            elseif l_l_TextService_0_TextSize_0.Y - v24 < v21.canvasPosition then
                return {
                    canvasPosition = l_l_TextService_0_TextSize_0.Y - v24
                };
            else
                return nil;
            end;
        end;
    end);
end;
v15.renderWithSelectionCursor = function(v26, v27)
    return l_withStyle_0(function(v28)
        local l_TextDefault_0 = v28.Theme.TextDefault;
        local l_Body_0 = v28.Font.Body;
        local l_l_TextService_0_TextSize_1 = l_TextService_0:GetTextSize(v26.props.text, l_Body_0.RelativeSize * v28.Font.BaseSize, l_Body_0.Font, Vector2.new(v26.state.textBoxWidth, 10000));
        local l_ImageRectSize_0 = v16.ImageRectSize;
        local l_ImageRectOffset_0 = v16.ImageRectOffset;
        local l_X_0 = l_ImageRectSize_0.X;
        local v35 = l_X_0 / 2;
        return l_Roact_0.createElement(l_ImageSetLabel_0, {
            BackgroundTransparency = 1,
            Image = v11.Images.RoundedRect.Image,
            ImageColor3 = v28.Theme.BackgroundMuted.Color,
            ImageTransparency = v28.Theme.BackgroundMuted.Transparency,
            Position = v26.props.Position,
            ScaleType = v11.Images.RoundedRect.ScaleType,
            Size = v26.props.Size,
            SliceCenter = v11.Images.RoundedRect.SliceCenter,
            LayoutOrder = v26.props.LayoutOrder
        }, {
            ScrollingFrame = l_Roact_0.createElement("ScrollingFrame", {
                Size = UDim2.new(1, -24, 1, -44),
                AnchorPoint = Vector2.new(0.5, 0),
                Position = UDim2.new(0.5, 0, 0, 7),
                BackgroundTransparency = 1,
                BorderSizePixel = 0,
                CanvasSize = UDim2.new(1, -24, 0, l_l_TextService_0_TextSize_1.Y),
                ScrollBarThickness = 8,
                VerticalScrollBarInset = Enum.ScrollBarInset.Always,
                CanvasPosition = Vector2.new(0, v26.state.canvasPosition),
                Selectable = false,
                [l_Roact_0.Change.CanvasPosition] = function(v36)
                    v26:setState({
                        canvasPosition = v36.CanvasPosition.Y
                    });
                end,
                [l_Roact_0.Change.AbsoluteSize] = function(v37)
                    v26:setState({
                        scrollingFrameHeight = v37.AbsoluteSize.Y
                    }, function()
                        v26:calculateNeedsRescroll(v28, l_Body_0);
                    end);
                end
            }, {
                TextBox = l_Roact_0.createElement("TextBox", {
                    Size = UDim2.new(1, -2, 1, 0),
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    Position = UDim2.new(0.5, 0, 0.5, 0),
                    Text = v26.props.text,
                    ClearTextOnFocus = false,
                    TextEditable = v26.props.enabled,
                    BackgroundTransparency = 1,
                    TextXAlignment = Enum.TextXAlignment.Left,
                    TextYAlignment = Enum.TextYAlignment.Top,
                    TextColor3 = l_TextDefault_0.Color,
                    TextTransparency = l_TextDefault_0.Transparency,
                    Font = l_Body_0.Font,
                    TextSize = l_Body_0.RelativeSize * v28.Font.BaseSize,
                    TextWrapped = true,
                    SelectionImageObject = v27(l_CursorKind_0.InputFields),
                    [l_Roact_0.Ref] = v26.textBoxRef,
                    [l_Roact_0.Change.Text] = function(v38)
                        if v26.props.maxTextLength < utf8.len(utf8.nfcnormalize(v38.Text)) then
                            v38.Text = string.sub(v38.Text, 1, utf8.offset(v38.Text, v26.props.maxTextLength + 1) - 1);
                            return ;
                        else
                            v26.props.textChanged(v38.Text);
                            v26:setState({
                                cursorPosition = v38.CursorPosition
                            }, function()
                                v26:calculateNeedsRescroll(v28, l_Body_0);
                            end);
                            return ;
                        end;
                    end,
                    [l_Roact_0.Change.AbsoluteSize] = function(v39)
                        v26:setState({
                            textBoxWidth = v39.AbsoluteSize.X
                        }, function()
                            v26:calculateNeedsRescroll(v28, l_Body_0);
                        end);
                    end,
                    [l_Roact_0.Change.CursorPosition] = function(v40)
                        v26:setState({
                            cursorPosition = v40.CursorPosition
                        }, function()
                            v26:calculateNeedsRescroll(v28, l_Body_0);
                        end);
                    end
                }, {
                    PlaceholderText = l_Roact_0.createElement(v13, {
                        themeKey = "TextDefault",
                        fontKey = "Body",
                        Text = v26.props.PlaceholderText,
                        Size = UDim2.new(1, 0, 1, 0),
                        Position = UDim2.new(0, 0, 0, 0),
                        TextTransparency = 0.5,
                        TextXAlignment = Enum.TextXAlignment.Left,
                        TextYAlignment = Enum.TextYAlignment.Top,
                        Visible = v26.props.text == ""
                    })
                })
            }),
            BottomBar = l_Roact_0.createElement("ImageLabel", {
                BackgroundTransparency = 1,
                Image = v16.Image,
                ImageColor3 = v28.Theme.BackgroundMuted.Color,
                ImageTransparency = 0,
                ScaleType = Enum.ScaleType.Slice,
                AnchorPoint = Vector2.new(0, 1),
                Position = UDim2.new(0, 0, 1, 0),
                Size = UDim2.new(1, 0, 0, 32),
                SliceCenter = Rect.new(v35 - 1, 0, v35 + 1, 1),
                SliceScale = 1 / l_Images_0.ImagesResolutionScale,
                ImageRectSize = Vector2.new(l_X_0, v35),
                ImageRectOffset = l_ImageRectOffset_0 + Vector2.new(0, v35)
            }, {
                TextAmmountIndicator = l_Roact_0.createElement("Frame", {
                    BackgroundTransparency = 1,
                    Position = UDim2.new(1, -10, 0.5, 0),
                    AnchorPoint = Vector2.new(1, 0.5),
                    Size = UDim2.new(0, 20, 0, 20)
                }, {
                    l_Roact_0.createElement(v12, {
                        Position = UDim2.new(0.5, 0, 0.5, 0),
                        AnchorPoint = Vector2.new(0.5, 0.5),
                        fillFraction = utf8.len(utf8.nfcnormalize(v26.props.text)) / (v26.props.maxTextLength - 10),
                        largerCircleFraction = (v26.props.maxTextLength - 20) / v26.props.maxTextLength,
                        popCircleFraction = 1,
                        shakeCircleFraction = v26.props.maxTextLength / (v26.props.maxTextLength - 10),
                        BackgroundColor = v28.Theme.BackgroundMuted.Color
                    })
                })
            })
        });
    end);
end;
v15.render = function(v41)
    return l_withSelectionCursorProvider_0(function(v42)
        return v41:renderWithSelectionCursor(v42);
    end);
end;
v15.didUpdate = function(v43, v44, _)
    if v43.props.enabled or not v44.enabled then
        if not (((not v43.props.enabled or v44.enabled) or not v43.props.autoFocusOnEnabled) or not v43.textBoxRef.current) then
            v43.textBoxRef.current:CaptureFocus();
        end;
    elseif not (not v43.textBoxRef.current or not v43.textBoxRef.current:IsFocused()) then
        v43.textBoxRef.current:ReleaseFocus();
        return ;
    end;
end;
return l_Roact_0.forwardRef(function(v46, v47)
    return l_Roact_0.createElement(v15, l_Cryo_0.Dictionary.join(v46, {
        textBoxRef = v47
    }));
end);


local l_Players_0 = game:GetService("Players");
local v1 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v1.Roact;
local l_t_0 = v1.t;
local l_Parent_0 = script.Parent.Parent;
local v5 = require(l_Parent_0.Components.PageNavigationWatcher);
local v6 = require(l_Parent_0.Components.Page);
local v7 = require(script.ReportList);
local function v11()
    local v8 = {};
    for _, v10 in ipairs(l_Players_0:GetPlayers()) do
        if v10 ~= l_Players_0.LocalPlayer then
            table.insert(v8, v10);
        end;
    end;
    return v8;
end;
local v12 = l_Roact_0.PureComponent:extend("ReportPage");
v12.validateProps = l_t_0.strictInterface({
    pageTitle = l_t_0.string
});
v12.init = function(v13)
    v13:setState({
        players = v11()
    });
end;
v12.render = function(v14)
    return l_Roact_0.createElement(v6, {
        pageTitle = v14.props.pageTitle
    }, {
        PlayerList = l_Roact_0.createElement(v7, {
            players = v14.state.players
        }),
        Watcher = l_Roact_0.createElement(v5, {
            desiredPage = "Report",
            onNavigateTo = function()
                v14:setState({
                    players = v11()
                });
            end
        })
    });
end;
return v12;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_UserInputService_0 = game:GetService("UserInputService");
local v2 = require(l_CorePackages_0.InGameMenuDependencies);
local l_Roact_0 = v2.Roact;
local l_t_0 = v2.t;
local l_UIBlox_0 = v2.UIBlox;
local l_Cryo_0 = v2.Cryo;
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local l_ImageSetLabel_0 = l_UIBlox_0.Core.ImageSet.ImageSetLabel;
local l_Images_0 = l_UIBlox_0.App.ImageSet.Images;
local v10 = require(script.Parent.Parent.Localization.withLocalization);
local v11 = l_Roact_0.PureComponent:extend("SearchBar");
v11.validateProps = l_t_0.interface({
    size = l_t_0.UDim2,
    text = l_t_0.optional(l_t_0.string),
    onTextChanged = l_t_0.optional(l_t_0.callback),
    onFocused = l_t_0.optional(l_t_0.callback),
    onCancelled = l_t_0.optional(l_t_0.callback),
    onFocusLost = l_t_0.optional(l_t_0.callback),
    autoCaptureFocus = l_t_0.optional(l_t_0.boolean),
    zIndex = l_t_0.optional(l_t_0.number),
    visible = l_t_0.optional(l_t_0.boolean)
});
v11.defaultProps = {
    size = UDim2.fromScale(1, 1),
    autoCaptureFocus = false,
    visible = true
};
v11.init = function(v12)
    v12.textboxRef = l_Roact_0.createRef();
    v12.onAbsoluteSizeChanged = function(v13)
        local v14 = false;
        if v12.width ~= v13.AbsoluteSize.X then
            v12.width = v13.AbsoluteSize.X;
            v14 = true;
        end;
        if v12.height ~= v13.AbsoluteSize.Y then
            v12.height = v13.AbsoluteSize.Y;
            v14 = true;
        end;
        if v14 then
            v12:setState({
                width = v12.width - 2,
                height = v12.height - 2
            });
        end;
    end;
    v12.searchTextChanged = function(v15)
        if v12.props.onTextChanged then
            v12.props.onTextChanged(v15.Text);
        end;
    end;
    v12.searchBoxFocused = function(_)
        if v12.props.onFocused then
            v12.props.onFocused();
        end;
    end;
    v12.searchCancel = function()
        if v12.props.onCancelled then
            v12.props.onCancelled();
        end;
    end;
    v12.onFocusLost = function()
        if v12.props.onFocusLost then
            v12.props.onFocusLost();
        end;
    end;
    v12.onTextboxTouchTap = function()
        if v12.props.onTextboxTouchTap then
            v12.props.onTextboxTouchTap();
        end;
    end;
end;
v11.willUpdate = function(v17, v18)
    if not (not (v17.props.autoCaptureFocus and v17.props.visible == false) or not v18.visible) then
        v17:focus();
    end;
end;
v11.didMount = function(v19)
    if not (not v19.props.autoCaptureFocus or not v19.props.visible) then
        v19:focus();
    end;
end;
v11.focus = function(v20)
    if v20.textboxRef then
        v20.textboxRef.current:CaptureFocus();
    end;
end;
v11.render = function(v21)
    return l_withStyle_0(function(v22)
        return v10({
            search = "CoreScripts.InGameMenu.InviteFriends.Search",
            cancel = "CoreScripts.InGameMenu.Cancel"
        })(function(v23)
            local l_Body_0 = v22.Font.Body;
            local v25 = v22.Font.BaseSize * l_Body_0.RelativeSize;
            local l_Body_1 = v22.Font.Body;
            return l_Roact_0.createElement("CanvasGroup", {
                BackgroundTransparency = 1,
                GroupTransparency = 0.5,
                Size = v21.props.size,
                ZIndex = v21.props.zIndex,
                Visible = v21.props.visible,
                [l_Roact_0.Ref] = v21.props.forwardRef or l_Roact_0.createRef()
            }, {
                SearchPanelLayout = l_Roact_0.createElement("UIListLayout", {
                    FillDirection = Enum.FillDirection.Horizontal,
                    HorizontalAlignment = Enum.HorizontalAlignment.Left,
                    SortOrder = Enum.SortOrder.LayoutOrder,
                    VerticalAlignment = Enum.VerticalAlignment.Center,
                    Padding = UDim.new(0, 9)
                }),
                SearchBorder = l_Roact_0.createElement("Frame", {
                    Size = UDim2.new(1, -66, 0, 38),
                    BackgroundColor3 = Color3.new(136, 136, 136),
                    BackgroundTransparency = 0.8,
                    [l_Roact_0.Change.AbsoluteSize] = v21.onAbsoluteSizeChanged
                }, {
                    BorderRadius = l_Roact_0.createElement("UICorner", {
                        CornerRadius = UDim.new(0, 4)
                    }),
                    SearchContainer = l_Roact_0.createElement("Frame", {
                        BackgroundTransparency = 0,
                        Size = UDim2.fromOffset(v21.state.width, v21.state.height),
                        BackgroundColor3 = Color3.new(0, 0, 0),
                        Position = UDim2.fromOffset(1, 1)
                    }, {
                        SearchContainerLayout = l_Roact_0.createElement("UIListLayout", {
                            FillDirection = Enum.FillDirection.Horizontal,
                            HorizontalAlignment = Enum.HorizontalAlignment.Left,
                            SortOrder = Enum.SortOrder.LayoutOrder,
                            VerticalAlignment = Enum.VerticalAlignment.Center,
                            Padding = UDim.new(0, 10)
                        }),
                        Padding = l_Roact_0.createElement("UIPadding", {
                            PaddingLeft = UDim.new(0, 12),
                            PaddingRight = UDim.new(0, 12)
                        }),
                        BorderRadius = l_Roact_0.createElement("UICorner", {
                            CornerRadius = UDim.new(0, 4)
                        }),
                        SearchImage = l_Roact_0.createElement(l_ImageSetLabel_0, {
                            LayoutOrder = 1,
                            BackgroundTransparency = 1,
                            Image = l_Images_0["icons/common/search_small"],
                            Size = UDim2.fromOffset(18, 18)
                        }),
                        SearchInput = l_Roact_0.createElement("TextBox", {
                            LayoutOrder = 2,
                            BackgroundTransparency = 1,
                            Size = UDim2.new(1, -28, 0, 20),
                            Font = l_Body_1.Font,
                            Text = v21.props.text or "",
                            TextInputType = if l_UserInputService_0:GetPlatform() == Enum.Platform.Android then Enum.TextInputType.PasswordShown else Enum.TextInputType.NoSuggestions,
                            TextSize = v22.Font.BaseSize * l_Body_1.RelativeSize,
                            TextColor3 = v22.Theme.TextEmphasis.Color,
                            TextXAlignment = Enum.TextXAlignment.Left,
                            PlaceholderText = v23.search,
                            PlaceholderColor3 = v22.Theme.TextDefault.Color,
                            ClearTextOnFocus = false,
                            ClipsDescendants = true,
                            [l_Roact_0.Change.Text] = v21.searchTextChanged,
                            [l_Roact_0.Event.Focused] = v21.searchBoxFocused,
                            [l_Roact_0.Event.FocusLost] = v21.onFocusLost,
                            [l_Roact_0.Ref] = v21.textboxRef,
                            [l_Roact_0.Event.TouchTap] = v21.onTextboxTouchTap
                        })
                    })
                }),
                CancelButton = l_Roact_0.createElement("TextButton", {
                    LayoutOrder = 2,
                    BackgroundTransparency = 1,
                    Size = UDim2.fromOffset(57, 20),
                    Font = l_Body_0.Font,
                    TextSize = v25,
                    Text = v23.cancel,
                    TextColor3 = v22.Theme.TextEmphasis.Color,
                    [l_Roact_0.Event.Activated] = v21.searchCancel
                })
            });
        end);
    end);
end;
return l_Roact_0.forwardRef(function(v27, v28)
    return l_Roact_0.createElement(v11, l_Cryo_0.Dictionary.join(v27, {
        forwardRef = v28
    }));
end);


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_t_0 = v0.t;
local l_Roact_0 = v0.Roact;
local l_UIBlox_0 = v0.UIBlox;
local l_Cryo_0 = v0.Cryo;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local l_Parent_0 = script.Parent.Parent.Parent;
local v8 = require(l_Parent_0.Resources.Assets);
local v9 = require(l_Parent_0.GlobalConfig);
local l_ImageSetButton_0 = l_UIBlox_0.Core.ImageSet.ImageSetButton;
local v11 = l_t_0.strictInterface({
    AnchorPoint = l_t_0.optional(l_t_0.Vector2),
    Position = l_t_0.optional(l_t_0.UDim2),
    layoutOrder = l_t_0.optional(l_t_0.integer),
    onActivated = l_t_0.callback,
    onSelectionGained = l_t_0.optional(l_t_0.callback),
    onSelectionLost = l_t_0.optional(l_t_0.callback),
    forwardRef = l_t_0.optional(l_t_0.table)
});
local function v14(v12, v13)
    if v9.propValidation then
        assert(v11(v12));
    end;
    return l_Roact_0.createElement(l_ImageSetButton_0, {
        AnchorPoint = v12.AnchorPoint,
        BackgroundTransparency = 1,
        Image = v8.Images.CloseButton,
        Position = v12.Position,
        Size = UDim2.new(0, 32, 0, 32),
        LayoutOrder = v12.layoutOrder,
        SelectionImageObject = v13(l_CursorKind_0.RoundedRect),
        [l_Roact_0.Event.Activated] = v12.onActivated,
        [l_Roact_0.Event.SelectionGained] = v12.onSelectionGained,
        [l_Roact_0.Event.SelectionLost] = v12.onSelectionLost,
        [l_Roact_0.Ref] = v12.forwardRef
    });
end;
local function v17(v15)
    return l_withSelectionCursorProvider_0(function(v16)
        return v14(v15, v16);
    end);
end;
return l_Roact_0.forwardRef(function(v18, v19)
    return l_Roact_0.createElement(v17, l_Cryo_0.Dictionary.join(v18, {
        forwardRef = v19
    }));
end);


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_t_0 = v0.t;
local l_Roact_0 = v0.Roact;
local l_Cryo_0 = v0.Cryo;
local l_UIBlox_0 = v0.UIBlox;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local v7 = require(script.Parent.Parent.Parent.Components.GameIcon);
local v8 = UDim.new(0, 8);
local v9 = l_Roact_0.PureComponent:extend("GameIconButton");
v9.validateProps = l_t_0.strictInterface({
    anchorPoint = l_t_0.optional(l_t_0.Vector2),
    position = l_t_0.optional(l_t_0.UDim2),
    layoutOrder = l_t_0.optional(l_t_0.integer),
    onActivated = l_t_0.callback,
    onSelectionGained = l_t_0.optional(l_t_0.callback),
    onSelectionLost = l_t_0.optional(l_t_0.callback),
    forwardRef = l_t_0.optional(l_t_0.table)
});
v9.renderWithSelectionCursor = function(v10, v11)
    return l_Roact_0.createElement("TextButton", {
        Text = "",
        AnchorPoint = v10.props.anchorPoint,
        BackgroundTransparency = 1,
        Position = v10.props.position,
        Size = UDim2.fromOffset(32, 32),
        LayoutOrder = v10.props.layoutOrder,
        SelectionImageObject = v11(l_CursorKind_0.RoundedRect),
        [l_Roact_0.Event.Activated] = v10.props.onActivated,
        [l_Roact_0.Event.SelectionGained] = v10.props.onSelectionGained,
        [l_Roact_0.Event.SelectionLost] = v10.props.onSelectionLost,
        [l_Roact_0.Ref] = v10.props.forwardRef
    }, {
        GameIconButton = l_Roact_0.createElement(v7, {
            gameId = game.GameId,
            iconSize = 32,
            cornerRadius = v8
        })
    });
end;
v9.render = function(v12)
    return l_withSelectionCursorProvider_0(function(v13)
        return v12:renderWithSelectionCursor(v13);
    end);
end;
return l_Roact_0.forwardRef(function(v14, v15)
    return l_Roact_0.createElement(v9, l_Cryo_0.Dictionary.join(v14, {
        forwardRef = v15
    }));
end);


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_t_0 = v0.t;
local l_Roact_0 = v0.Roact;
local l_UIBlox_0 = v0.UIBlox;
local l_ImageSetButton_0 = l_UIBlox_0.Core.ImageSet.ImageSetButton;
local l_Images_0 = l_UIBlox_0.App.ImageSet.Images;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local v8 = l_Images_0["icons/menu/home_on"];
local v9 = l_Images_0["icons/menu/home_off"];
local v10 = l_Roact_0.PureComponent:extend("HomeButton");
v10.validateProps = l_t_0.strictInterface({
    on = l_t_0.optional(l_t_0.boolean),
    anchorPoint = l_t_0.optional(l_t_0.Vector2),
    position = l_t_0.optional(l_t_0.UDim2),
    layoutOrder = l_t_0.optional(l_t_0.integer),
    onActivated = l_t_0.callback
});
v10.defaultProps = {
    on = false
};
v10.renderWithSelectionCursor = function(v11, v12)
    return l_Roact_0.createElement("Frame", {
        AnchorPoint = v11.props.anchorPoint,
        BackgroundTransparency = 1,
        Position = v11.props.position,
        Size = UDim2.fromOffset(64, 64),
        LayoutOrder = v11.props.layoutOrder
    }, {
        HomeButton = l_Roact_0.createElement(l_ImageSetButton_0, {
            AnchorPoint = Vector2.new(0.5, 0.5),
            BackgroundTransparency = 1,
            Image = not not v11.props.on and v8 or v9,
            Position = UDim2.fromScale(0.5, 0.5),
            Size = UDim2.fromOffset(32, 32),
            SelectionImageObject = v12(l_CursorKind_0.RoundedRect),
            [l_Roact_0.Event.Activated] = v11.props.onActivated
        })
    });
end;
v10.render = function(v13)
    return l_withSelectionCursorProvider_0(function(v14)
        return v13:renderWithSelectionCursor(v14);
    end);
end;
return v10;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_GuiService_0 = game:GetService("GuiService");
local v2 = require(l_CorePackages_0.InGameMenuDependencies);
local l_t_0 = v2.t;
local l_Roact_0 = v2.Roact;
local v5 = require(script.Parent.CloseMenuButton);
local v6 = require(script.Parent.GameIconButton);
local v7 = l_Roact_0.PureComponent:extend("SystemMenuButton");
v7.validateProps = l_t_0.strictInterface({
    on = l_t_0.optional(l_t_0.boolean),
    anchorPoint = l_t_0.optional(l_t_0.Vector2),
    position = l_t_0.optional(l_t_0.UDim2),
    layoutOrder = l_t_0.optional(l_t_0.integer),
    onActivated = l_t_0.callback,
    onClose = l_t_0.callback,
    canCaptureFocus = l_t_0.optional(l_t_0.boolean)
});
v7.defaultProps = {
    on = false,
    canCaptureFocus = false
};
v7.tryCaptureFocus = function(v8, v9)
    if not (not (v8.props.canCaptureFocus and not v9.canCaptureFocus) and (not (v8.props.canCaptureFocus and v8.props.on ~= v9.on) or not v8.state.isIconFocused)) then
        l_GuiService_0.SelectedCoreObject = v8.iconRef:getValue();
    end;
end;
v7.init = function(v10)
    v10.iconRef = l_Roact_0.createRef();
    v10:setState({
        isIconFocused = false
    });
    v10.onIconSelectionGained = function()
        v10:setState({
            isIconFocused = true
        });
    end;
    v10.onIconSelectionLost = function()
        v10:setState({
            isIconFocused = false
        });
    end;
end;
v7.didMount = function(v11)
    v11:tryCaptureFocus({
        canCaptureFocus = false
    });
end;
v7.didUpdate = function(v12, v13)
    v12:tryCaptureFocus(v13);
end;
v7.render = function(v14)
    if not v14.props.on then
        return l_Roact_0.createElement(v6, {
            onActivated = v14.props.onActivated,
            layoutOrder = v14.props.layoutOrder,
            anchorPoint = v14.props.anchorPoint,
            position = v14.props.position,
            onSelectionGained = v14.onIconSelectionGained,
            onSelectionLost = v14.onIconSelectionLost,
            [l_Roact_0.Ref] = v14.iconRef
        });
    else
        return l_Roact_0.createElement(v5, {
            onActivated = v14.props.onClose,
            layoutOrder = v14.props.layoutOrder,
            AnchorPoint = v14.props.anchorPoint,
            Position = v14.props.position,
            onSelectionGained = v14.onIconSelectionGained,
            onSelectionLost = v14.onIconSelectionLost,
            [l_Roact_0.Ref] = v14.iconRef
        });
    end;
end;
return v7;


local l_UserInputService_0 = game:GetService("UserInputService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_GuiService_0 = game:GetService("GuiService");
local l_ContextActionService_0 = game:GetService("ContextActionService");
local l_RunService_0 = game:GetService("RunService");
local v5 = require(l_CorePackages_0.InGameMenuDependencies);
local l_Roact_0 = v5.Roact;
local l_UIBlox_0 = v5.UIBlox;
local l_t_0 = v5.t;
local l_Otter_0 = v5.Otter;
local v10 = require(script.Parent.Connection.FocusHandler);
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local v14 = require(script.Parent.Parent.Utility.divideTransparency);
local v15 = require(script.Parent.AssetImage);
local l_ImageSetButton_0 = l_UIBlox_0.Core.ImageSet.ImageSetButton;
local v17 = {
    frequency = 5
};
local function v20(v18)
    local v19 = true;
    if v18 ~= Enum.UserInputType.Gamepad1 then
        v19 = true;
        if v18 ~= Enum.UserInputType.Gamepad2 then
            v19 = true;
            if v18 ~= Enum.UserInputType.Gamepad3 then
                v19 = true;
                if v18 ~= Enum.UserInputType.Gamepad4 then
                    v19 = true;
                    if v18 ~= Enum.UserInputType.Gamepad5 then
                        v19 = true;
                        if v18 ~= Enum.UserInputType.Gamepad6 then
                            v19 = true;
                            if v18 ~= Enum.UserInputType.Gamepad7 then
                                v19 = v18 == Enum.UserInputType.Gamepad8;
                            end;
                        end;
                    end;
                end;
            end;
        end;
    end;
    return v19;
end;
local v21 = {};
local function v27()
    local l_l_UserInputService_0_LastInputType_0 = l_UserInputService_0:GetLastInputType();
    if v20(l_l_UserInputService_0_LastInputType_0) then
        if v21[l_l_UserInputService_0_LastInputType_0] == nil then
            local l_l_UserInputService_0_GamepadState_0 = l_UserInputService_0:GetGamepadState(l_l_UserInputService_0_LastInputType_0);
            local v24 = {};
            for _, v26 in ipairs(l_l_UserInputService_0_GamepadState_0) do
                v24[v26.KeyCode] = v26;
            end;
            v21[l_l_UserInputService_0_LastInputType_0] = v24;
        end;
        return v21[l_l_UserInputService_0_LastInputType_0];
    else
        return nil;
    end;
end;
local v28 = l_Roact_0.PureComponent:extend("Slider");
v28.validateProps = l_t_0.intersection(l_t_0.strictInterface({
    min = l_t_0.number,
    max = l_t_0.number,
    stepInterval = l_t_0.numberPositive,
    value = l_t_0.number,
    valueChanged = l_t_0.callback,
    disabled = l_t_0.optional(l_t_0.boolean),
    width = l_t_0.optional(l_t_0.UDim),
    AnchorPoint = l_t_0.optional(l_t_0.Vector2),
    LayoutOrder = l_t_0.optional(l_t_0.integer),
    Position = l_t_0.optional(l_t_0.UDim2),
    canCaptureFocus = l_t_0.optional(l_t_0.boolean),
    isMenuOpen = l_t_0.optional(l_t_0.boolean),
    onSelectionLost = l_t_0.optional(l_t_0.callback),
    onSelectionGained = l_t_0.optional(l_t_0.callback),
    NextSelectionRight = l_t_0.optional(l_t_0.table),
    sliderDotRef = l_t_0.optional(l_t_0.union(l_t_0.callback, l_t_0.table))
}), function(v29)
    if v29.max < v29.min then
        return false, "min must be less than or equal to max";
    elseif not (v29.max >= v29.value) or v29.value < v29.min then
        return false, "value must be within min and max";
    else
        return true;
    end;
end);
v28.defaultProps = {
    width = UDim.new(1, 0),
    disabled = false
};
v28.init = function(v30)
    v30.state = {
        dragging = false,
        hovering = false,
        entryMode = false
    };
    v30.totalMoveTime = 0;
    v30.isFirstMove = true;
    v30.unhandledTime = 0;
    v30.rootButtonRef = l_Roact_0.createRef();
    v30.hoverRef = l_Roact_0.createRef();
    v30.hoverMotor = l_Otter_0.createSingleMotor(0);
    v30.hoverMotor:onStep(function(v31)
        local l_current_0 = v30.hoverRef.current;
        if l_current_0 ~= nil then
            l_current_0.Size = UDim2.new(0, v31, 0, v31);
        end;
    end);
    v30.onInputBegan = function(_, v34)
        if not v30.props.disabled then
            local l_UserInputType_0 = v34.UserInputType;
            if l_UserInputType_0 ~= Enum.UserInputType.MouseButton1 and l_UserInputType_0 ~= Enum.UserInputType.Touch then
                return ;
            else
                v30:processDrag(v34.Position.X);
                v30:startListeningForDrag();
                return ;
            end;
        else
            return ;
        end;
    end;
end;
v28.renderFocusHandler = function(v36)
    return l_Roact_0.createElement(v10, {
        isFocused = v36.state.entryMode and v36.props.canCaptureFocus,
        didFocus = function()
            l_GuiService_0.CoreGuiNavigationEnabled = false;
            v36.joystickListener = l_RunService_0.Heartbeat:Connect(function(v37)
                v36:onMoveStep(v37, (v27()));
            end);
            local l_value_0 = v36.props.value;
            l_ContextActionService_0:BindCoreAction("LeaveEntryMode", function(_, v40)
                if v40 == Enum.UserInputState.End then
                    v36:setState({
                        entryMode = false
                    });
                    v36.props.valueChanged(l_value_0);
                    return Enum.ContextActionResult.Sink;
                else
                    return Enum.ContextActionResult.Pass;
                end;
            end, false, Enum.KeyCode.ButtonB);
        end,
        didBlur = function()
            v36.joystickListener:Disconnect();
            l_GuiService_0.CoreGuiNavigationEnabled = true;
            l_ContextActionService_0:UnbindCoreAction("LeaveEntryMode");
            v36:setState({
                entryMode = false
            });
        end
    }) or nil;
end;
v28.renderWithSelectionCursor = function(v41, v42)
    local l_min_0 = v41.props.min;
    local v44 = (v41.props.value - l_min_0) / (v41.props.max - l_min_0);
    local v45 = math.abs(v44);
    local v46 = v44 / 2;
    local v47 = v41.state.entryMode and v41.props.canCaptureFocus;
    return l_withStyle_0(function(v48)
        return l_Roact_0.createElement(l_ImageSetButton_0, {
            AnchorPoint = v41.props.AnchorPoint,
            BackgroundTransparency = 1,
            Image = "",
            LayoutOrder = v41.props.LayoutOrder,
            Position = v41.props.Position,
            Size = UDim2.new(v41.props.width.Scale, v41.props.width.Offset, 0, 36),
            [l_Roact_0.Ref] = v41.rootButtonRef,
            [l_Roact_0.Event.InputBegan] = v41.onInputBegan,
            Selectable = false
        }, {
            FocusHandler = v41:renderFocusHandler(),
            Gutter = l_Roact_0.createElement(v15.Label, {
                AnchorPoint = Vector2.new(0.5, 0.5),
                BackgroundTransparency = 1,
                imageKey = "SliderCircle",
                ImageColor3 = v48.Theme.UIMuted.Color,
                ImageTransparency = v48.Theme.UIMuted.Transparency,
                Position = UDim2.new(0.5, 0, 0.5, 0),
                Size = UDim2.new(1, 0, 0, 4)
            }, {
                FilledGutter = l_Roact_0.createElement(v15.Label, {
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    BackgroundTransparency = 1,
                    imageKey = "SliderCircle",
                    ImageColor3 = v48.Theme.ContextualPrimaryDefault.Color,
                    ImageTransparency = v14(v48.Theme.ContextualPrimaryDefault.Transparency, not v41.props.disabled and 1 or 2),
                    Position = UDim2.new(v46, 0, 0.5, 0),
                    Size = UDim2.new(v45, 0, 1, 0)
                })
            }),
            DotTrack = l_Roact_0.createElement("Frame", {
                Size = UDim2.new(1, -12, 1, 0),
                BackgroundTransparency = 1,
                AnchorPoint = Vector2.new(0.5, 0.5),
                Position = UDim2.new(0.5, 0, 0.5, 0),
                ZIndex = 4,
                Selectable = false
            }, {
                Dot = l_Roact_0.createElement(v15.Button, {
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    BackgroundTransparency = 1,
                    imageKey = "SliderButton",
                    Position = UDim2.new(v44, 0, 0.5, 0),
                    Size = UDim2.new(0, 42, 0, 42),
                    ImageTransparency = not v41.props.disabled and 0 or 0.5,
                    ZIndex = 2,
                    SelectionImageObject = v42(not not v47 and l_CursorKind_0.SelectedKnob or l_CursorKind_0.UnselectedKnob),
                    [l_Roact_0.Event.Activated] = function(_, v50)
                        if v50.KeyCode == Enum.KeyCode.ButtonA then
                            v41:setState({
                                entryMode = not v41.state.entryMode
                            });
                        end;
                    end,
                    [l_Roact_0.Event.InputBegan] = function(v51, v52)
                        if not v41.props.disabled then
                            if v52.UserInputType == Enum.UserInputType.MouseMovement then
                                v41:setState({
                                    hovering = true
                                });
                                return ;
                            else
                                v41.onInputBegan(v51, v52);
                                return ;
                            end;
                        else
                            return ;
                        end;
                    end,
                    [l_Roact_0.Event.InputEnded] = function(_, v54)
                        if not v41.props.disabled then
                            if v54.UserInputType == Enum.UserInputType.MouseMovement then
                                v41:setState({
                                    hovering = false
                                });
                            end;
                            return ;
                        else
                            return ;
                        end;
                    end,
                    [l_Roact_0.Ref] = v41.props.sliderDotRef,
                    [l_Roact_0.Event.SelectionLost] = v41.props.onSelectionLost,
                    [l_Roact_0.Event.SelectionGained] = v41.props.onSelectionGained,
                    NextSelectionRight = v41.props.NextSelectionRight
                }),
                HoverOverlay = l_Roact_0.createElement(v15.Label, {
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    BackgroundTransparency = 1,
                    imageKey = "SliderHover",
                    Position = UDim2.new(v44, 0, 0.5, 0),
                    Size = UDim2.new(0, 0, 0, 0),
                    [l_Roact_0.Ref] = v41.hoverRef
                })
            })
        });
    end);
end;
v28.render = function(v55)
    return l_withSelectionCursorProvider_0(function(v56)
        return v55:renderWithSelectionCursor(v56);
    end);
end;
v28.didMount = function(v57)
    local l_current_1 = v57.rootButtonRef.current;
    local v59 = nil;
    v59 = l_current_1.AncestryChanged:Connect(function()
        if l_current_1:IsDescendantOf(game) then
            v59:Disconnect();
            v57.canUseUserInputService = l_current_1:FindFirstAncestorWhichIsA("PluginGui") == nil;
            return ;
        else
            return ;
        end;
    end);
    v57.hoverMotor:start();
end;
v28.didUpdate = function(v60)
    if v60.props.disabled then
        v60:stopListeningForDrag();
    end;
    local v61 = 0;
    if not (v60.props.disabled or not v60.state.dragging and not v60.state.hovering) then
        v61 = 42;
    end;
    v60.hoverMotor:setGoal(l_Otter_0.spring(v61, v17));
end;
v28.willUnmount = function(v62)
    v62.hoverMotor:stop();
    v62:disconnectDragEvents();
end;
v28.startListeningForDrag = function(v63)
    local l_current_2 = v63.rootButtonRef.current;
    if l_current_2 == nil then
        return ;
    elseif not v63.state.dragging then
        if not v63.canUseUserInputService then
            local l_l_current_2_FirstAncestorWhichIsA_0 = l_current_2:FindFirstAncestorWhichIsA("PluginGui");
            local l_ImageButton_0 = Instance.new("ImageButton");
            l_ImageButton_0.BackgroundTransparency = 1;
            l_ImageButton_0.Image = "";
            l_ImageButton_0.Name = "SliderPluginGuiInputCapturer";
            l_ImageButton_0.Size = UDim2.new(1, 0, 1, 0);
            l_ImageButton_0.ZIndex = 100000;
            v63.moveConnection = l_ImageButton_0.MouseMoved:Connect(function(v67)
                v63:processDrag(v67);
            end);
            v63.releaseConnection = l_ImageButton_0.MouseButton1Up:Connect(function(v68)
                v63:stopListeningForDrag();
                v63:processDrag(v68);
            end);
            v63.focusLostConnection = l_ImageButton_0.MouseLeave:Connect(function(v69)
                v63:stopListeningForDrag();
                v63:processDrag(v69);
            end);
            l_ImageButton_0.Parent = l_l_current_2_FirstAncestorWhichIsA_0;
            v63.inputCapturerButton = l_ImageButton_0;
        else
            v63.moveConnection = l_UserInputService_0.InputChanged:Connect(function(v70)
                if v63.state.dragging then
                    local l_UserInputType_1 = v70.UserInputType;
                    if l_UserInputType_1 ~= Enum.UserInputType.MouseMovement and l_UserInputType_1 ~= Enum.UserInputType.Touch then
                        return ;
                    elseif v70.UserInputState ~= Enum.UserInputState.Change then
                        return ;
                    else
                        v63:processDrag(v70.Position.X);
                        return ;
                    end;
                else
                    return ;
                end;
            end);
            v63.releaseConnection = l_UserInputService_0.InputEnded:Connect(function(v72)
                local l_UserInputType_2 = v72.UserInputType;
                if l_UserInputType_2 ~= Enum.UserInputType.MouseButton1 and l_UserInputType_2 ~= Enum.UserInputType.Touch then
                    return ;
                else
                    v63:stopListeningForDrag();
                    v63:processDrag(v72.Position.X);
                    return ;
                end;
            end);
            v63.focusLostConnection = l_UserInputService_0.WindowFocusReleased:Connect(function()
                v63:stopListeningForDrag();
            end);
        end;
        v63:setState({
            dragging = true
        });
        return ;
    else
        return ;
    end;
end;
v28.processDrag = function(v74, v75)
    local l_current_3 = v74.rootButtonRef.current;
    if l_current_3 == nil then
        return ;
    else
        local l_min_1 = v74.props.min;
        local l_max_0 = v74.props.max;
        local l_stepInterval_0 = v74.props.stepInterval;
        local l_X_0 = l_current_3.AbsoluteSize.X;
        local v81 = math.floor(((math.clamp(v75 - l_current_3.AbsolutePosition.X, 0, l_X_0) / l_X_0) * (l_max_0 - l_min_1) + l_min_1) / l_stepInterval_0 + 0.5) * l_stepInterval_0;
        if v81 ~= v74.props.value then
            v74.props.valueChanged(v81);
        end;
        return ;
    end;
end;
v28.disconnectDragEvents = function(v82)
    if v82.moveConnection ~= nil then
        v82.moveConnection:Disconnect();
        v82.moveConnection = nil;
    end;
    if v82.releaseConnection ~= nil then
        v82.releaseConnection:Disconnect();
        v82.releaseConnection = nil;
    end;
    if v82.focusLostConnection ~= nil then
        v82.focusLostConnection:Disconnect();
        v82.focusLostConnection = nil;
    end;
    if v82.inputCapturerButton ~= nil then
        v82.inputCapturerButton:Destroy();
        v82.inputCapturerButton = nil;
    end;
end;
v28.stopListeningForDrag = function(v83)
    if v83.state.dragging then
        v83:disconnectDragEvents();
        v83:setState({
            dragging = false
        });
        return ;
    else
        return ;
    end;
end;
v28.processGamepadInput = function(v84, v85, v86)
    local v87 = math.max(math.min(v84.props.value + (v84.props.stepInterval * v85) * v86, v84.props.max), v84.props.min);
    if v87 ~= v84.props.value then
        v84.props.valueChanged(v87);
    end;
end;
v28.onMoveStep = function(v88, v89, v90)
    local l_Position_0 = v90[Enum.KeyCode.Thumbstick1].Position;
    local v92 = l_Position_0.Magnitude > 0.2;
    local v93 = 0;
    local v94 = nil;
    local v95 = nil;
    local v96 = nil;
    v88.totalMoveTime = v88.totalMoveTime + v89;
    if not v92 then
        v95 = (v90[Enum.KeyCode.DPadLeft].UserInputState == Enum.UserInputState.Begin and -1 or 0) + (v90[Enum.KeyCode.DPadRight].UserInputState == Enum.UserInputState.Begin and 1 or 0);
        v94 = 0.5;
        v96 = 8;
    else
        v95 = l_Position_0.x > 0 and 1 or -1;
        v94 = 0.2;
        v96 = 12;
    end;
    if v95 ~= 0 then
        if not v88.isFirstMove then
            if v94 < v88.totalMoveTime then
                local v97 = (v89 - math.max((v94 - v88.totalMoveTime) - v89, 0)) + v88.unhandledTime;
                v93 = math.floor(v96 * v97);
                v88.unhandledTime = v97 - v93 / v96;
            else
                v93 = 0;
                v88.unhandledTime = 0;
            end;
        else
            v88.isFirstMove = false;
            v88.totalMoveTime = 0;
            v88.unhandledTime = 0;
            v93 = 1;
        end;
    else
        v88.totalMoveTime = 0;
        v88.isFirstMove = true;
    end;
    if v93 > 0 then
        v88:processGamepadInput(v95, v93);
    end;
end;
v28.getDerivedStateFromProps = function(v98)
    if v98.isMenuOpen then
        return nil;
    else
        return {
            entryMode = false
        };
    end;
end;
return v28;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_UserInputService_0 = game:GetService("UserInputService");
local l_ContextActionService_0 = game:GetService("ContextActionService");
local l_GuiService_0 = game:GetService("GuiService");
local v4 = require(l_CorePackages_0.InGameMenuDependencies);
local l_Roact_0 = v4.Roact;
local l_UIBlox_0 = v4.UIBlox;
local l_Cryo_0 = v4.Cryo;
local l_t_0 = v4.t;
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local v12 = require(script.Parent.Parent.Utility.ExternalEventConnection);
local v13 = require(script.Parent.Connection.FocusHandler);
local v14 = require(script.Parent.Slider);
local v15 = require(script.Parent.AssetImage);
local v16 = l_Roact_0.PureComponent:extend("SliderWithInput");
v16.defaultProps = {
    width = UDim.new(1, 0)
};
v16.validateProps = l_t_0.intersection(l_t_0.strictInterface({
    min = l_t_0.number,
    max = l_t_0.number,
    stepInterval = l_t_0.numberPositive,
    keyboardInputStepInterval = l_t_0.optional(l_t_0.numberPositive),
    value = l_t_0.number,
    valueChanged = l_t_0.callback,
    disabled = l_t_0.optional(l_t_0.boolean),
    width = l_t_0.optional(l_t_0.UDim),
    AnchorPoint = l_t_0.optional(l_t_0.Vector2),
    LayoutOrder = l_t_0.optional(l_t_0.integer),
    Position = l_t_0.optional(l_t_0.UDim2),
    canCaptureFocus = l_t_0.optional(l_t_0.boolean),
    isMenuOpen = l_t_0.optional(l_t_0.boolean),
    sliderDotRef = l_t_0.optional(l_t_0.table),
    onSelectionLost = l_t_0.callback,
    onSelectionGained = l_t_0.callback
}), function(v17)
    if v17.max < v17.min then
        return false, "min must be less than or equal to max";
    elseif not (v17.max >= v17.value) or v17.value < v17.min then
        return false, "value must be within min and max";
    else
        return true;
    end;
end);
v16.init = function(v18)
    v18.textBoxRef = l_Roact_0.createRef();
    v18.state = {
        textEntryMode = false
    };
end;
v16.renderFocusHandler = function(v19)
    return l_Roact_0.createElement(v13, {
        isFocused = not not v19.props.canCaptureFocus and (v19.state.textEntryMode or false),
        didFocus = function()
            l_GuiService_0.CoreGuiNavigationEnabled = false;
            local l_value_0 = v19.props.value;
            l_ContextActionService_0:BindCoreAction("LeaveTextEntryMode", function(_, v22)
                if v22 == Enum.UserInputState.End then
                    v19:setState({
                        textEntryMode = false
                    });
                    local l_current_0 = v19.textBoxRef.current;
                    l_current_0.Text = l_value_0;
                    l_current_0:ReleaseFocus();
                    return Enum.ContextActionResult.Sink;
                else
                    return Enum.ContextActionResult.Pass;
                end;
            end, false, Enum.KeyCode.ButtonB);
        end,
        didBlur = function()
            l_GuiService_0.CoreGuiNavigationEnabled = true;
            l_ContextActionService_0:UnbindCoreAction("LeaveTextEntryMode");
        end
    }) or nil;
end;
v16.renderWithSelectionCursor = function(v24, v25)
    local l_props_0 = v24.props;
    return l_Roact_0.createElement("Frame", {
        BackgroundTransparency = 1,
        Size = UDim2.new(l_props_0.width.Scale, l_props_0.width.Offset, 0, 36),
        Position = l_props_0.Position,
        LayoutOrder = l_props_0.LayoutOrder
    }, {
        Slider = l_Roact_0.createElement(v14, (l_Cryo_0.Dictionary.join(l_props_0, {
            width = UDim.new(1, -80),
            LayoutOrder = l_Cryo_0.None,
            Position = l_Cryo_0.None,
            AnchorPoint = l_Cryo_0.None,
            keyboardInputStepInterval = l_Cryo_0.None,
            NextSelectionRight = v24.textBoxRef
        }))),
        TextContainer = l_withStyle_0(function(v27)
            local v28 = not not l_props_0.disabled and v27.Theme.TextMuted or v27.Theme.TextDefault;
            return l_Roact_0.createElement(v15.Label, {
                BackgroundTransparency = 1,
                imageKey = "RoundedRect",
                ImageTransparency = v27.Theme.BackgroundUIContrast.Transparency,
                ImageColor3 = v27.Theme.BackgroundUIContrast.Color,
                Size = UDim2.new(0, 64, 0, 36),
                Position = UDim2.new(1, 0, 0.5, 0),
                AnchorPoint = Vector2.new(1, 0.5)
            }, {
                FocusHandler = v24:renderFocusHandler(),
                Box = l_Roact_0.createElement("TextBox", {
                    BackgroundTransparency = 1,
                    Size = UDim2.new(1, 0, 1, 0),
                    AnchorPoint = Vector2.new(0.5, 0.5),
                    Position = UDim2.new(0.5, 0, 0.5, 0),
                    Font = v27.Font.Body.Font,
                    TextScaled = true,
                    ClearTextOnFocus = false,
                    TextEditable = not l_props_0.disabled,
                    TextColor3 = v28.Color,
                    TextTransparency = v28.Transparency,
                    Text = tostring(l_props_0.value),
                    NextSelectionLeft = v24.props.sliderDotRef,
                    SelectionImageObject = v25(l_CursorKind_0.InputFields),
                    [l_Roact_0.Event.SelectionLost] = v24.props.onSelectionLost,
                    [l_Roact_0.Event.SelectionGained] = v24.props.onSelectionGained,
                    [l_Roact_0.Ref] = v24.textBoxRef,
                    [l_Roact_0.Event.Focused] = not not l_props_0.disabled and function(v29)
                        v29:ReleaseFocus(false);
                    end or function()
                        v24:setState({
                            textEntryMode = true
                        });
                    end,
                    [l_Roact_0.Event.FocusLost] = function(v30, _)
                        v24:setState({
                            textEntryMode = false
                        });
                        local v32 = tonumber(v30.Text);
                        if v32 ~= l_props_0.value then
                            if v32 == nil then
                                v30.Text = tostring(l_props_0.value);
                                return ;
                            else
                                local l_stepInterval_0 = l_props_0.stepInterval;
                                if l_props_0.keyboardInputStepInterval then
                                    l_stepInterval_0 = l_props_0.keyboardInputStepInterval;
                                end;
                                local v34 = math.clamp(math.floor(v32 / l_stepInterval_0 + 0.5) * l_stepInterval_0, l_props_0.min, l_props_0.max);
                                v30.Text = tostring(v34);
                                if v34 ~= l_props_0.value then
                                    l_props_0.valueChanged(v34);
                                end;
                            end;
                        end;
                    end
                }, {
                    TextSizeConstraint = l_Roact_0.createElement("UITextSizeConstraint", {
                        MinTextSize = v27.Font.Body.RelativeMinSize * v27.Font.BaseSize,
                        MaxTextSize = v27.Font.Body.RelativeSize * v27.Font.BaseSize
                    })
                })
            });
        end),
        UserInputConnection = not l_props_0.disabled and l_Roact_0.createElement(v12, {
            event = l_UserInputService_0.InputBegan,
            callback = function(v35, _)
                if v35.UserInputType ~= Enum.UserInputType.Keyboard then
                    return ;
                elseif l_UserInputService_0:GetFocusedTextBox() ~= v24.textBoxRef.current then
                    return ;
                else
                    local v37 = 0;
                    if v35.KeyCode == Enum.KeyCode.Up then
                        v37 = 1;
                    elseif v35.KeyCode == Enum.KeyCode.Down then
                        v37 = -1;
                    end;
                    if not (not l_UserInputService_0:IsKeyDown(Enum.KeyCode.LeftShift) and not l_UserInputService_0:IsKeyDown(Enum.KeyCode.RightShift)) then
                        v37 = v37 * 10;
                    end;
                    if v37 ~= 0 then
                        local v38 = math.clamp(math.floor((l_props_0.value + l_props_0.stepInterval * v37) / l_props_0.stepInterval + 0.5) * l_props_0.stepInterval, l_props_0.min, l_props_0.max);
                        if v38 ~= l_props_0.value then
                            l_props_0.valueChanged(v38);
                        end;
                    end;
                    return ;
                end;
            end
        })
    });
end;
v16.render = function(v39)
    return l_withSelectionCursorProvider_0(function(v40)
        return v39:renderWithSelectionCursor(v40);
    end);
end;
return v16;


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v0.Roact;
local l_UIBlox_0 = v0.UIBlox;
local l_t_0 = v0.t;
local l_Parent_0 = script.Parent.Parent;
local v5 = require(l_Parent_0.Resources.Assets);
local v6 = require(l_Parent_0.Utility.divideTransparency);
local l_ImageSetButton_0 = l_UIBlox_0.Core.ImageSet.ImageSetButton;
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local v11 = l_Roact_0.PureComponent:extend("ThemedButton");
v11.validateProps = l_t_0.strictInterface({
    normalThemeKey = l_t_0.string,
    hoverThemeKey = l_t_0.string,
    imageProps = l_t_0.strictInterface({
        Image = l_t_0.union(l_t_0.string, l_t_0.table),
        ScaleType = l_t_0.enum(Enum.ScaleType),
        SliceCenter = l_t_0.Rect
    }),
    enabled = l_t_0.optional(l_t_0.boolean),
    renderChildren = l_t_0.callback,
    onActivated = l_t_0.callback,
    AnchorPoint = l_t_0.optional(l_t_0.Vector2),
    LayoutOrder = l_t_0.optional(l_t_0.integer),
    Position = l_t_0.optional(l_t_0.UDim2),
    Size = l_t_0.optional(l_t_0.UDim2),
    Visible = l_t_0.optional(l_t_0.boolean),
    ButtonRef = l_t_0.optional(l_t_0.union(l_t_0.callback, l_t_0.table))
});
v11.defaultProps = {
    imageProps = v5.Images.RoundedRect,
    enabled = true
};
v11.init = function(v12)
    v12:setState({
        hover = false,
        press = false
    });
end;
v11.renderWithSelectionCursor = function(v13, v14)
    local l_props_0 = v13.props;
    local l_normalThemeKey_0 = l_props_0.normalThemeKey;
    if not (not l_props_0.enabled or not v13.state.hover) then
        l_normalThemeKey_0 = l_props_0.hoverThemeKey;
    end;
    return l_withStyle_0(function(v17)
        local v18 = v17.Theme[l_normalThemeKey_0];
        assert(v18 ~= nil, "theme key " .. l_normalThemeKey_0 .. " is nil");
        local v19 = v6(v18.Transparency, not v13.state.press and 1 or 2);
        if not l_props_0.enabled then
            v19 = 0.5;
        end;
        return l_Roact_0.createElement(l_ImageSetButton_0, {
            Visible = l_props_0.Visible,
            BackgroundTransparency = 1,
            ImageColor3 = v18.Color,
            Position = l_props_0.Position,
            Size = l_props_0.Size,
            AnchorPoint = l_props_0.AnchorPoint,
            ImageTransparency = v19,
            LayoutOrder = l_props_0.LayoutOrder,
            ScaleType = l_props_0.imageProps.ScaleType,
            SliceCenter = l_props_0.imageProps.SliceCenter,
            Image = l_props_0.imageProps.Image,
            SelectionImageObject = v14(l_CursorKind_0.RoundedRectNoInset),
            [l_Roact_0.Event.Activated] = function()
                if l_props_0.enabled then
                    l_props_0.onActivated();
                end;
            end,
            [l_Roact_0.Event.MouseEnter] = function()
                v13:setState({
                    hover = true
                });
            end,
            [l_Roact_0.Event.MouseLeave] = function()
                v13:setState({
                    hover = false,
                    press = false
                });
            end,
            [l_Roact_0.Event.InputBegan] = function(_, v21)
                if not (v21.UserInputType ~= Enum.UserInputType.MouseButton1) or v21.UserInputType == Enum.UserInputType.Touch then
                    v13:setState({
                        press = true
                    });
                end;
            end,
            [l_Roact_0.Event.InputEnded] = function(_, v23)
                if not (v23.UserInputType ~= Enum.UserInputType.MouseButton1) or v23.UserInputType == Enum.UserInputType.Touch then
                    v13:setState({
                        press = false
                    });
                end;
            end,
            [l_Roact_0.Ref] = v13.props.ButtonRef
        }, l_props_0.renderChildren(v19, l_props_0.enabled and v13.state.hover, l_props_0.enabled and v13.state.press));
    end);
end;
v11.render = function(v24)
    return l_withSelectionCursorProvider_0(function(v25)
        return v24:renderWithSelectionCursor(v25);
    end);
end;
return v11;


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v0.Roact;
local l_Cryo_0 = v0.Cryo;
local l_UIBlox_0 = v0.UIBlox;
local l_t_0 = v0.t;
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local v6 = require(script.Parent.Parent.GlobalConfig);
local v7 = l_t_0.strictInterface({
    themeKey = l_t_0.optional(l_t_0.string),
    fontKey = l_t_0.optional(l_t_0.string),
    AnchorPoint = l_t_0.optional(l_t_0.Vector2),
    LayoutOrder = l_t_0.optional(l_t_0.integer),
    Position = l_t_0.optional(l_t_0.UDim2),
    Size = l_t_0.optional(l_t_0.UDim2),
    Text = l_t_0.string,
    TextColor3 = l_t_0.optional(l_t_0.Color3),
    TextTransparency = l_t_0.optional(l_t_0.numberConstrained(0, 1)),
    TextWrapped = l_t_0.optional(l_t_0.boolean),
    TextXAlignment = l_t_0.optional(l_t_0.enum(Enum.TextXAlignment)),
    TextYAlignment = l_t_0.optional(l_t_0.enum(Enum.TextYAlignment)),
    TextTruncate = l_t_0.optional(l_t_0.enum(Enum.TextTruncate)),
    Visible = l_t_0.optional(l_t_0.boolean),
    ZIndex = l_t_0.optional(l_t_0.integer),
    AutomaticSize = l_t_0.optional(l_t_0.enum(Enum.AutomaticSize)),
    [l_Roact_0.Children] = l_t_0.optional(l_t_0.table)
});
return function(v8)
    if v6.propValidation then
        assert(v7(v8));
    end;
    return l_withStyle_0(function(v9)
        local v10 = v9.Theme[v8.themeKey or "TextDefault"];
        local v11 = v9.Font[v8.fontKey or "Body"];
        return l_Roact_0.createElement("TextLabel", (l_Cryo_0.Dictionary.join({
            TextColor3 = v10.Color,
            TextTransparency = v10.Transparency
        }, v8, {
            fontKey = l_Cryo_0.None,
            themeKey = l_Cryo_0.None,
            BackgroundTransparency = 1,
            Font = v11.Font,
            TextSize = v11.RelativeSize * v9.Font.BaseSize
        })));
    end);
end;


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v0.Roact;
local l_UIBlox_0 = v0.UIBlox;
local l_Otter_0 = v0.Otter;
local l_t_0 = v0.t;
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local v8 = require(script.Parent.Parent.Utility.divideTransparency);
local v9 = require(script.Parent.AssetImage);
local v10 = UDim2.new(0, -3, 0.5, 0);
local v11 = UDim2.new(1, -39, 0.5, 0);
local v12 = {
    frequency = 4
};
local v13 = l_Roact_0.PureComponent:extend("ToggleSwitch");
v13.validateProps = l_t_0.strictInterface({
    checked = l_t_0.boolean,
    onToggled = l_t_0.callback,
    disabled = l_t_0.optional(l_t_0.boolean),
    buttonRef = l_t_0.optional(l_t_0.union(l_t_0.callback, l_t_0.table)),
    AnchorPoint = l_t_0.optional(l_t_0.Vector2),
    LayoutOrder = l_t_0.optional(l_t_0.integer),
    Position = l_t_0.optional(l_t_0.UDim2),
    NextSelectionUp = l_t_0.optional(l_t_0.union(l_t_0.Instance, l_t_0.table)),
    onSelectionLost = l_t_0.optional(l_t_0.callback),
    onSelectionGained = l_t_0.optional(l_t_0.callback)
});
v13.init = function(v14)
    local v15 = not v14.props.checked and 0 or 1;
    local v16, v17 = l_Roact_0.createBinding(v15);
    v14.progress = v16;
    v14.setProgress = v17;
    v14.fillTransparency = v14.progress:map(function(v18)
        return v8(1 - v18, not v14.props.disabled and 1 or 4);
    end);
    v14.knobPosition = v14.progress:map(function(v19)
        return v10:lerp(v11, v19);
    end);
    v14.motor = l_Otter_0.createSingleMotor(v15);
    v14.motor:onStep(v14.setProgress);
end;
v13.renderWithSelectionCursor = function(v20, v21)
    return l_withStyle_0(function(v22)
        return l_Roact_0.createElement(v9.Button, {
            Size = UDim2.new(0, 60, 0, 36),
            BackgroundTransparency = 1,
            Position = v20.props.Position,
            LayoutOrder = v20.props.LayoutOrder,
            imageKey = "ToggleOutline",
            AnchorPoint = v20.props.AnchorPoint,
            ImageColor3 = v22.Theme.SecondaryDefault.Color,
            ImageTransparency = v8(v22.Theme.SecondaryDefault.Transparency, not v20.props.disabled and 1 or 4),
            NextSelectionUp = v20.props.NextSelectionUp,
            [l_Roact_0.Event.Activated] = v20.props.onToggled,
            [l_Roact_0.Ref] = v20.props.buttonRef,
            [l_Roact_0.Event.SelectionLost] = v20.props.onSelectionLost,
            [l_Roact_0.Event.SelectionGained] = v20.props.onSelectionGained,
            SelectionImageObject = v21(l_CursorKind_0.Toggle)
        }, {
            Fill = l_Roact_0.createElement(v9.Label, {
                BackgroundTransparency = 1,
                Size = UDim2.new(1, 0, 1, 0),
                imageKey = "ToggleFill",
                ImageColor3 = v22.Theme.Success.Color,
                ImageTransparency = v20.fillTransparency
            }),
            Knob = l_Roact_0.createElement(v9.Label, {
                BackgroundTransparency = 1,
                Size = UDim2.new(0, 42, 0, 42),
                AnchorPoint = Vector2.new(0, 0.5),
                Position = v20.knobPosition,
                imageKey = "ToggleKnob",
                ImageTransparency = v8(0, not v20.props.disabled and 1 or 4),
                ZIndex = 2
            })
        });
    end);
end;
v13.render = function(v23)
    return l_withSelectionCursorProvider_0(function(v24)
        return v23:renderWithSelectionCursor(v24);
    end);
end;
v13.didUpdate = function(v25)
    v25.motor:setGoal(l_Otter_0.spring(not v25.props.checked and 0 or 1, v12));
end;
v13.willUnmount = function(v26)
    v26.motor:destroy();
end;
return v13;


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v0.Roact;
local l_RoactRodux_0 = v0.RoactRodux;
local l_UIBlox_0 = v0.UIBlox;
local l_t_0 = v0.t;
local l_withStyle_0 = l_UIBlox_0.Core.Style.withStyle;
local l_Parent_0 = script.Parent.Parent;
local v7 = require(l_Parent_0.Resources.Constants);
local v8 = require(l_Parent_0.GlobalConfig);
local v9 = require(l_Parent_0.Thunks.CloseMenu);
local v10 = Vector2.new(0, 0);
local v11 = l_t_0.strictInterface({
    currentPage = l_t_0.string,
    open = l_t_0.boolean,
    onActivated = l_t_0.callback,
    occupiedWidth = l_t_0.number,
    screenSize = l_t_0.Vector2
});
return l_RoactRodux_0.UNSTABLE_connect2(function(v12, _)
    return {
        currentPage = v12.menuPage,
        open = v12.isMenuOpen,
        occupiedWidth = 464,
        screenSize = v12.screenSize
    };
end, function(v14)
    return {
        onActivated = function()
            v14(v9);
        end
    };
end)(function(v15)
    if v8.propValidation then
        assert(v11(v15));
    end;
    if v15.screenSize == v10 then
        return nil;
    else
        local v16 = v15.currentPage == v7.InitalPageKey;
        return l_withStyle_0(function(v17)
            return l_Roact_0.createElement("Frame", {
                BackgroundColor3 = v17.Theme.Overlay.Color,
                BackgroundTransparency = v17.Theme.Overlay.Transparency,
                BorderSizePixel = 0,
                Size = UDim2.new(1, 0, 1, 0),
                Visible = not v16 and v15.open,
                ZIndex = 0
            }, {
                InputCapturer = l_Roact_0.createElement("TextButton", {
                    AnchorPoint = Vector2.new(1, 0),
                    BackgroundTransparency = 1,
                    Position = UDim2.new(1, 0, 0, 0),
                    Size = UDim2.new(1, -v15.occupiedWidth, 1, 0),
                    Text = "",
                    [l_Roact_0.Event.Activated] = v15.onActivated
                })
            });
        end);
    end;
end);


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v0.Roact;
local l_RoactRodux_0 = v0.RoactRodux;
local l_t_0 = v0.t;
local l_UIBlox_0 = v0.UIBlox;
local l_withSelectionCursorProvider_0 = l_UIBlox_0.App.SelectionImage.withSelectionCursorProvider;
local l_CursorKind_0 = l_UIBlox_0.App.SelectionImage.CursorKind;
local l_Parent_0 = script.Parent.Parent;
local v8 = require(l_Parent_0.Resources.Constants);
local v9 = require(l_Parent_0.Enums.Direction);
local v10 = require(l_Parent_0.Actions.SetCurrentZone);
local l_PortalSize_0 = v8.Zone.PortalSize;
local v12 = {
    [v9.Up] = {
        size = UDim2.new(1, 0, 0, l_PortalSize_0),
        position = UDim2.new(0, 0, 0, 0)
    },
    [v9.Down] = {
        size = UDim2.new(1, 0, 0, l_PortalSize_0),
        position = UDim2.new(0, 0, 1, -l_PortalSize_0)
    },
    [v9.Left] = {
        size = UDim2.new(0, l_PortalSize_0, 1, 0),
        position = UDim2.new(0, 0, 0, 0)
    },
    [v9.Right] = {
        size = UDim2.new(0, l_PortalSize_0, 1, 0),
        position = UDim2.new(1, -l_PortalSize_0, 0, 0)
    }
};
local v13 = l_Roact_0.PureComponent:extend("ZonePortal");
v13.validateProps = l_t_0.strictInterface({
    targetZone = l_t_0.number,
    direction = v9.isEnumValue,
    setCurrentZone = l_t_0.optional(l_t_0.callback)
});
v13.render = function(v14)
    local v15 = v12[v14.props.direction];
    return l_withSelectionCursorProvider_0(function(v16)
        return l_Roact_0.createElement("Frame", {
            Size = v15.size,
            Position = v15.position,
            BackgroundTransparency = 1,
            Selectable = true,
            ZIndex = 2147483647,
            SelectionImageObject = v16(l_CursorKind_0.Invisible),
            [l_Roact_0.Event.SelectionGained] = function()
                v14.props.setCurrentZone(v14.props.targetZone);
            end
        });
    end);
end;
return (l_RoactRodux_0.UNSTABLE_connect2(nil, function(v17)
    return {
        setCurrentZone = function(v18)
            return v17(v10(v18));
        end
    };
end)(v13));


local v0 = require(game:GetService("CorePackages").Workspace.Packages.ArgCheck);
local v1 = {
    50,
    128,
    150,
    256,
    512
};
return function(v2)
    v0.isNonNegativeNumber(v2, "Game Icon Size");
    local v3 = #v1;
    for _, v5 in ipairs(v1) do
        if v2 <= v5 then
            return v5;
        end;
    end;
    return v1[v3];
end;


return require(game:GetService("CorePackages").enumerate)(script.Name, {
    Up = "Up",
    Down = "Down",
    Left = "Left",
    Right = "Right"
});


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


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


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


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


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


game:DefineFastFlag("SideNavControllerBar", false);
local v0 = require(script.Parent.GetFFlagIGMGamepadSelectionHistory);
return function()
    return game:GetFastFlag("SideNavControllerBar") and v0();
end;


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


game:DefineFastInt("FullscreenTitleBarTriggerDelayMillis", 0);
return function()
    local l_game_FastInt_0 = game:GetFastInt("FullscreenTitleBarTriggerDelayMillis");
    if l_game_FastInt_0 < 0 then
        l_game_FastInt_0 = 0;
    end;
    return l_game_FastInt_0;
end;


return {
    propValidation = false,
    elementTracing = false,
    logStore = false
};


local l_CorePackages_0 = game:GetService("CorePackages");
local l_PolicyProvider_0 = require(l_CorePackages_0.InGameMenuDependencies).PolicyProvider;
local l_GetFFlagUseVoiceExitBetaLanguage_0 = require(l_CorePackages_0.Workspace.Packages.SharedFlags).GetFFlagUseVoiceExitBetaLanguage;
local v3 = l_PolicyProvider_0.withGetPolicyImplementation((l_PolicyProvider_0.GetPolicyImplementations.MemStorageService("app-policy")));
local v4 = require(script.Parent.Parent.Flags.GetFIntEducationalPopupDisplayMaxCount);
local l_isSubjectToDesktopPolicies_0 = require(l_CorePackages_0.Workspace.Packages.SharedFlags).isSubjectToDesktopPolicies;
local v6 = game:DefineFastFlag("UseGUACforDUARPolicy", false);
v3.Mapper = function(v7)
    return {
        enableInGameHomeIcon = function()
            if not v6 then
                return l_isSubjectToDesktopPolicies_0();
            else
                return v7.EnableInGameHomeIcon or false;
            end;
        end,
        enableEducationalPopup = function()
            local l_game_EngineFeature_0 = game:GetEngineFeature("NativeCloseIntercept");
            if not l_isSubjectToDesktopPolicies_0() or not l_game_EngineFeature_0 then
                return false;
            else
                return true;
            end;
        end,
        educationalPopupMaxDisplayCount = function()
            return not not l_isSubjectToDesktopPolicies_0() and v4() or 0;
        end,
        getGameInfoShowChatFeatures = function()
            if not l_GetFFlagUseVoiceExitBetaLanguage_0() then
                return false;
            else
                return v7.GameInfoShowChatFeatures or false;
            end;
        end,
        enableFullscreenTitleBar = function()
            return v7.FullscreenTitleBarEnabled or false;
        end,
        getDisplayCheckboxInVoiceConsent = function()
            if v7.DisplayCheckboxInVoiceConsent == nil then
                return true;
            else
                return v7.DisplayCheckboxInVoiceConsent;
            end;
        end
    };
end;
return v3;


local l_RobloxGui_0 = game:GetService("CoreGui"):WaitForChild("RobloxGui");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_Locales_0 = script.Parent.Locales;
local v3 = require(script.Parent.LocalizationContext);
if not require(l_RobloxGui_0.Modules.Flags.GetFFlagSwitchInExpTranslationsPackage)() then
    local function v10(v4)
        local v5 = v3.getRelevantLanguages(v4);
        local v6 = {};
        for _, v8 in ipairs(v5) do
            local l_l_Locales_0_FirstChild_0 = l_Locales_0:FindFirstChild(v8);
            if l_l_Locales_0_FirstChild_0 then
                v6[v8] = require(l_l_Locales_0_FirstChild_0);
            end;
        end;
        return v6;
    end;
    local v11 = {};
    v11.__index = v11;
    v11.new = function(v12)
        local v13 = {
            locale = v12
        };
        setmetatable(v13, {
            __index = v11
        });
        v13.localizationContext = v3.new((v10(v12)));
        return v13;
    end;
    v11.mock = function()
        return v11.new("en-us");
    end;
    v11.SetLocale = function(v14, v15)
        v14.locale = v15;
        v14.localizationContext:addTranslations((v10(v15)));
    end;
    v11.GetLocale = function(v16)
        return v16.locale;
    end;
    v11.Format = function(v17, v18, v19)
        if not v18 then
            error("ERROR: NO STRING FOR KEY");
        end;
        return v17.localizationContext:getString(v17.locale, v18, v19);
    end;
    return v11;
else
    return require(l_CorePackages_0.Workspace.Packages.InExperienceLocales).Localization;
end;


local l_LocalizationService_0 = game:GetService("LocalizationService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_RobloxGui_0 = game:GetService("CoreGui"):WaitForChild("RobloxGui");
local v3 = require(l_CorePackages_0.InGameMenuDependencies);
local l_t_0 = v3.t;
local l_Roact_0 = v3.Roact;
local v6 = require(script.Parent.Parent.Utility.ExternalEventConnection);
if not require(l_RobloxGui_0.Modules.Flags.GetFFlagSwitchInExpTranslationsPackage)() then
    local v7 = require(script.Parent.LocalizationRoactContext);
    local v8 = l_Roact_0.Component:extend("LocalizationConsumer");
    v8.init = function(v9)
        if v9.props.localization == nil then
            error("LocalizationConsumer must be below a LocalizationProvider.");
        end;
        v9.state = {
            locale = l_LocalizationService_0.RobloxLocaleId
        };
        v9.updateLocalization = function(v10)
            if v10 ~= v9.state.locale then
                v9:setState({
                    locale = v10
                });
            end;
        end;
    end;
    v8.render = function(v11)
        local l_localization_0 = v11.props.localization;
        local l_render_0 = v11.props.render;
        local l_stringsToBeLocalized_0 = v11.props.stringsToBeLocalized;
        assert(l_t_0.callback(l_render_0));
        assert(l_t_0.table(l_stringsToBeLocalized_0));
        local v15 = {};
        for v16, v17 in pairs(l_stringsToBeLocalized_0) do
            if typeof(v17) == "table" then
                if typeof(v17[1]) == "string" then
                    local l_status_0, l_result_0 = pcall(function()
                        return l_localization_0:Format(v17[1], v17);
                    end);
                    assert(l_status_0, string.format("LocalizationConsumer finding value for translation key[%s]: %s", v16, v17[1]));
                    v15[v16] = not not l_status_0 and l_result_0 or "";
                else
                    error(string.format("%s[1] in stringsToBeLocalized must be a string, got %s instead", v16, (typeof(v17[1]))));
                end;
            elseif typeof(v17) == "string" then
                local l_status_1, l_result_1 = pcall(function()
                    return l_localization_0:Format(v17);
                end);
                assert(l_status_1, string.format("LocalizationConsumer finding value for translation key[%s]: %s", v16, v17));
                v15[v16] = not not l_status_1 and l_result_1 or "";
            else
                error(string.format("%s in stringsToBeLocalized must be a string or table, got %s instead", v16, (typeof(v17))));
            end;
        end;
        return l_Roact_0.createElement(v6, {
            event = l_LocalizationService_0:GetPropertyChangedSignal("RobloxLocaleId"),
            callback = v11.updateLocalization
        }, {
            Component = l_render_0(v15)
        });
    end;
    return function(v22)
        return l_Roact_0.createElement(v7.Consumer, {
            render = function(v23)
                return l_Roact_0.createElement(v8, {
                    localization = v23,
                    render = v22.render,
                    stringsToBeLocalized = v22.stringsToBeLocalized
                });
            end
        });
    end;
else
    return require(l_CorePackages_0.Workspace.Packages.Localization).LocalizationConsumer;
end;


local function _(v0)
    return v0:match("^(%w+)[-_]");
end;
local v2 = {};
v2.__index = v2;
v2.new = function(v3)
    local v4 = {
        _translations = v3
    };
    setmetatable(v4, v2);
    return v4;
end;
v2.addTranslations = function(v5, v6)
    v5._translations = v6;
end;
v2.getRelevantLanguages = function(v7)
    local v8 = {};
    table.insert(v8, v7);
    local v9 = v7:match("^(%w+)[-_]");
    if v9 then
        table.insert(v8, v9);
    end;
    table.insert(v8, "en-us");
    return v8;
end;
v2._getSourceString = function(v10, v11, v12)
    local v13 = v10._translations[v11];
    if v13 then
        return v13[v12];
    else
        return nil;
    end;
end;
v2.getString = function(v14, v15, v16, v17)
    local v18 = v14:_getSourceString(v15, v16);
    local v19 = v15:match("^(%w+)[-_]");
    local v20 = nil;
    if v19 then
        v20 = v14:_getSourceString(v19, v16);
    end;
    local v21 = (v18 or v20) or v14:_getSourceString("en-us", v16);
    if not v21 then
        error(("Couldn't find value for translation key %q %s, %s, %s"):format(v16, v15, v19, "en-us"), 2);
    end;
    if not v17 then
        return v21;
    else
        return (v21:gsub("{(.-)}", v17));
    end;
end;
return v2;


local l_CorePackages_0 = game:GetService("CorePackages");
local l_Roact_0 = require(l_CorePackages_0.InGameMenuDependencies).Roact;
if not require(game:GetService("CoreGui"):WaitForChild("RobloxGui").Modules.Flags.GetFFlagSwitchInExpTranslationsPackage)() then
    local v2 = require(script.Parent.LocalizationRoactContext);
    LocalizationProvider = function(v3)
        return l_Roact_0.createElement(v2.Provider, {
            value = v3.localization
        }, v3[l_Roact_0.Children]);
    end;
    return LocalizationProvider;
else
    return require(l_CorePackages_0.Workspace.Packages.Localization).LocalizationProvider;
end;


local v0 = require(game:GetService("CorePackages").InGameMenuDependencies);
local l_Roact_0 = v0.Roact;
local l_t_0 = v0.t;
local v3 = require(script.Parent.LocalizationConsumer);
return function(v4)
    assert(l_t_0.table(v4));
    return function(v5)
        assert(l_t_0.callback(v5));
        return l_Roact_0.createElement(v3, {
            render = v5,
            stringsToBeLocalized = v4
        });
    end;
end;


local v0 = {};
v0.__index = v0;
v0.new = function()
    local l_BindableEvent_0 = Instance.new("BindableEvent");
    local v4 = {
        FullscreenChanged = {
            Connect = function(_, v3)
                return l_BindableEvent_0.Event:Connect(v3);
            end,
            GoFullscreen = function()
                l_BindableEvent_0:Fire(true);
            end
        }
    };
    setmetatable(v4, {
        __index = v0
    });
    return v4;
end;
v0.InFullScreen = function(_)
    return false;
end;
return v0;


local l_HttpService_0 = game:GetService("HttpService");
local v1 = require(script.Parent.Parent.Parent.Network.Url);
return function(v2, v3, v4, v5)
    assert(v2, "requestImpl is required");
    assert(v3, "conversationId is required");
    assert(v4, "universeId is required");
    return v2(string.format("%s/send-game-link-message", v1.CHAT_URL), "POST", {
        postBody = l_HttpService_0:JSONEncode({
            conversationId = v3,
            universeId = v4,
            decorators = v5
        })
    });
end;


local l_HttpService_0 = game:GetService("HttpService");
local v1 = require(script.Parent.Parent.Parent.Network.Url);
return function(v2, v3, v4, v5)
    return v2(string.format("%s/send-message", v1.CHAT_URL), "POST", {
        postBody = l_HttpService_0:JSONEncode({
            conversationId = v3,
            message = v4,
            decorators = v5
        })
    });
end;


local l_HttpService_0 = game:GetService("HttpService");
local v1 = require(script.Parent.Parent.Parent.Network.Url);
return function(v2, v3, _)
    return v2(string.format("%s/start-one-to-one-conversation", v1.CHAT_URL), "POST", {
        postBody = l_HttpService_0:JSONEncode({
            participantuserId = v3
        })
    });
end;


local v0 = require(script.Parent.Parent.Parent.Parent.Network.Url);
return function(v1, v2)
    return v1(string.format("%sv1/games/%d/icon", v0.GAME_URL, v2), "GET");
end;


local v0 = require(script.Parent.Parent.Parent.Network.Url);
return function(v1, v2)
    for v3, v4 in ipairs(v2) do
        v2[v3] = tostring(v4);
    end;
    return v1(string.format("%s/v1/games/multiget-place-details?%s", v0.GAME_URL, (v0:makeQueryString({
        placeIds = v2
    }))), "GET");
end;


local l_UserInputService_0 = game:GetService("UserInputService");
local l_KeyCode_0 = Enum.KeyCode;
local l_UserInputType_0 = Enum.UserInputType;
local v3 = {
    KEYBOARD = "Keyboard",
    GAMEPAD = "Gamepad"
};
local v4 = {
    [Enum.UserInputType.MouseButton2] = v3.KEYBOARD,
    [Enum.UserInputType.MouseButton3] = v3.KEYBOARD,
    [Enum.UserInputType.MouseWheel] = v3.KEYBOARD,
    [Enum.UserInputType.MouseMovement] = v3.KEYBOARD,
    [Enum.UserInputType.Keyboard] = v3.KEYBOARD,
    [Enum.UserInputType.Gamepad1] = v3.GAMEPAD,
    [Enum.UserInputType.Gamepad2] = v3.GAMEPAD,
    [Enum.UserInputType.Gamepad3] = v3.GAMEPAD,
    [Enum.UserInputType.Gamepad4] = v3.GAMEPAD,
    [Enum.UserInputType.Gamepad5] = v3.GAMEPAD,
    [Enum.UserInputType.Gamepad6] = v3.GAMEPAD,
    [Enum.UserInputType.Gamepad7] = v3.GAMEPAD,
    [Enum.UserInputType.Gamepad8] = v3.GAMEPAD
};
local v5 = {
    {
        title = "CoreScripts.InGameMenu.Controls.CharacterMovementTitle",
        controls = {
            {
                desc = "CoreScripts.InGameMenu.Controls.MoveForward",
                inputs = {
                    l_KeyCode_0.Up,
                    l_KeyCode_0.W
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.MoveBackward",
                inputs = {
                    l_KeyCode_0.Down,
                    l_KeyCode_0.S
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.MoveLeft",
                inputs = {
                    l_KeyCode_0.A
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.MoveRight",
                inputs = {
                    l_KeyCode_0.D
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.Jump",
                inputs = {
                    l_KeyCode_0.Space
                }
            }
        }
    },
    {
        title = "CoreScripts.InGameMenu.Controls.CameraMovementTitle",
        controls = {
            {
                desc = "CoreScripts.InGameMenu.Controls.RotateCamera",
                inputs = {
                    l_KeyCode_0.Left,
                    l_KeyCode_0.Right,
                    l_UserInputType_0.MouseButton2
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.ZoomInOutCamera",
                inputs = {
                    l_UserInputType_0.MouseWheel
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.ZoomInCamera",
                inputs = {
                    l_KeyCode_0.I
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.ZoomOutCamera",
                inputs = {
                    l_KeyCode_0.O
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.MouseLock",
                inputs = {
                    l_KeyCode_0.LeftShift
                }
            }
        }
    },
    {
        title = "CoreScripts.InGameMenu.Controls.AccessoriesTitle",
        controls = {
            {
                desc = "CoreScripts.InGameMenu.Controls.EquipUnequipTools",
                inputs = {
                    l_KeyCode_0.One,
                    l_KeyCode_0.Two,
                    l_KeyCode_0.Three
                },
                list = true
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.DropTool",
                inputs = {
                    l_KeyCode_0.Backspace
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.UseTool",
                inputs = {
                    l_UserInputType_0.MouseButton1
                }
            }
        }
    },
    {
        title = "CoreScripts.InGameMenu.Controls.MenuItemsTitle",
        controls = {
            {
                desc = "CoreScripts.InGameMenu.Controls.RobloxMenu",
                inputs = {
                    l_KeyCode_0.Escape
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.Backpack",
                inputs = {
                    l_KeyCode_0.Tilde
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.Playerlist",
                inputs = {
                    l_KeyCode_0.Tab
                }
            },
            {
                desc = "CoreScripts.InGameMenu.Controls.Chat",
                inputs = {
                    l_KeyCode_0.Slash
                }
            }
        }
    }
};
local v6 = {
    title = "CoreScripts.InGameMenu.Controls.MiscellaneousTitle",
    controls = {
        {
            desc = "CoreScripts.InGameMenu.Controls.GameMenuToggleGamepad",
            inputs = {
                l_KeyCode_0.BackSlash
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.Screenshot",
            inputs = {
                {
                    l_KeyCode_0.LeftSuper,
                    l_KeyCode_0.LeftShift,
                    l_KeyCode_0.Three
                }
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.DevConsole",
            inputs = {
                {
                    l_KeyCode_0.LeftMeta,
                    l_KeyCode_0.F9
                },
                l_KeyCode_0.F9
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.GraphicsLevelUp",
            inputs = {
                {
                    l_KeyCode_0.LeftMeta,
                    l_KeyCode_0.F10
                },
                l_KeyCode_0.F10
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.GraphicsLevelDown",
            inputs = {
                {
                    l_KeyCode_0.LeftMeta,
                    l_KeyCode_0.LeftShift,
                    l_KeyCode_0.F10
                },
                {
                    l_KeyCode_0.LeftShift,
                    l_KeyCode_0.F10
                }
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.ToggleFullscreen",
            inputs = {
                {
                    l_KeyCode_0.LeftControl,
                    l_KeyCode_0.LeftSuper,
                    l_KeyCode_0.F
                }
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.PerformanceStats",
            inputs = {
                {
                    l_KeyCode_0.LeftMeta,
                    l_KeyCode_0.LeftAlt,
                    l_KeyCode_0.LeftSuper,
                    l_KeyCode_0.F7
                }
            }
        }
    }
};
local v7 = {
    title = "CoreScripts.InGameMenu.Controls.MiscellaneousTitle",
    controls = {
        {
            desc = "CoreScripts.InGameMenu.Controls.GameMenuToggleGamepad",
            inputs = {
                l_KeyCode_0.BackSlash
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.Screenshot",
            inputs = {
                l_KeyCode_0.Print
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.RecordVideo",
            inputs = {
                l_KeyCode_0.F12
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.DevConsole",
            inputs = {
                l_KeyCode_0.F9
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.GraphicsLevelUp",
            inputs = {
                l_KeyCode_0.F10
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.GraphicsLevelDown",
            inputs = {
                {
                    l_KeyCode_0.LeftShift,
                    l_KeyCode_0.F10
                }
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.ToggleFullscreen",
            inputs = {
                l_KeyCode_0.F11
            }
        },
        {
            desc = "CoreScripts.InGameMenu.Controls.PerformanceStats",
            inputs = {
                {
                    l_KeyCode_0.LeftControl,
                    l_KeyCode_0.LeftShift,
                    l_KeyCode_0.F7
                }
            }
        }
    }
};
if l_UserInputService_0:GetPlatform() == Enum.Platform.OSX then
    table.insert(v5, v6);
else
    table.insert(v5, v7);
end;
return {
    ControlLayouts = v3,
    keybinds = v5,
    inputToControlTypeMap = v4,
    gamepadLabels = {
        left = {
            "CoreScripts.InGameMenu.Controls.SwitchToolGamepad",
            "CoreScripts.InGameMenu.Controls.GameMenuToggleGamepad",
            "CoreScripts.InGameMenu.Controls.MoveGamepad",
            "CoreScripts.InGameMenu.Controls.MenuNavigationGamepad"
        },
        right = {
            "CoreScripts.InGameMenu.Controls.UseTool",
            "CoreScripts.InGameMenu.Controls.RobloxMenu",
            "CoreScripts.InGameMenu.Controls.BackGamepad",
            "CoreScripts.InGameMenu.Controls.Jump"
        },
        camera = {
            "CoreScripts.InGameMenu.Controls.RotateCameraGamepad",
            "CoreScripts.InGameMenu.Controls.CameraZoomGamepad"
        }
    },
    questGamepadLabels = {
        {
            labelKey = "ResetCameraLabel",
            xPosition = -0.015,
            yPosition = 0.335,
            xAlignment = Enum.TextXAlignment.Right,
            width = 0.17
        },
        {
            labelKey = "MenuLabel",
            xPosition = -0.015,
            yPosition = 0.397,
            xAlignment = Enum.TextXAlignment.Right,
            width = 0.17
        },
        {
            labelKey = "SelectItemLabel",
            xPosition = 0.442,
            yPosition = 0.621,
            xAlignment = Enum.TextXAlignment.Center,
            width = 0.09
        },
        {
            labelKey = "BackExitLabel",
            xPosition = 0.818,
            yPosition = 0.287,
            xAlignment = Enum.TextXAlignment.Left,
            width = 0.17
        },
        {
            labelKey = "FirstPersonCameraLabel",
            xPosition = 0.818,
            yPosition = 0.342,
            xAlignment = Enum.TextXAlignment.Left,
            width = 0.17
        },
        {
            labelKey = "JumpSelectLabel",
            xPosition = 0.818,
            yPosition = 0.413,
            xAlignment = Enum.TextXAlignment.Left,
            width = 0.17
        }
    }
};


local v0 = require(game:GetService("CorePackages").Workspace.Packages.ArgCheck);
local v1 = require(script.Parent.GetImageSetData)((game:GetService("GuiService"):GetResolutionScale()));
local v2 = {};
for v3, v4 in pairs(v1) do
    v0.isType(v4, "table", "value");
    local v5 = {};
    for v6, v7 in pairs(v4) do
        if v6 == "ImageSet" then
            v5.Image = string.format("rbxasset://textures/ui/ImageSet/%s.png", v7);
        else
            v5[v6] = v7;
        end;
    end;
    v2[v3] = v5;
end;
setmetatable(v2, {
    __index = function(_, v9)
        error(("%q is not a valid member of Images"):format((tostring(v9))), 2);
    end
});
return v2;


local l_HttpRbxApiService_0 = game:GetService("HttpRbxApiService");
local l_CorePackages_0 = game:GetService("CorePackages");
local l_Parent_0 = script.Parent.Parent;
local v3 = require(l_Parent_0.Actions.SetGameNameAndDescription);
local v4 = require(l_Parent_0.Network.httpRequest)(l_HttpRbxApiService_0);
local l_GetGameNameAndDescription_0 = require(l_CorePackages_0.Workspace.Packages.GameDetailRodux).GetGameNameAndDescription;
return function(v6)
    if game.GameId == 0 then
        return ;
    else
        l_GetGameNameAndDescription_0(v4, game.GameId):andThen(function(v7)
            v6:dispatch(v3(v7.Name, v7.Description));
        end):catch(function()
            warn("Unable to retrieve game name for in game menu");
        end);
        return ;
    end;
end;


return function(v0, v1, v2)
    local v3 = game:SetFastIntForTesting(v0, v1);
    local l_status_0, l_result_0 = pcall(v2);
    game:SetFastIntForTesting(v0, v3);
    assert(l_status_0, l_result_0);
end;


local l_GuiService_0 = game:GetService("GuiService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.SetMenuOpen);
local v3 = require(l_Parent_0.Utility.SendAnalytics);
local v4 = require(l_Parent_0.Resources.Constants);
local v5 = require(l_Parent_0.Actions.SetCurrentPage);
return function(v6)
    l_GuiService_0:SetMenuIsOpen(false, "InGameMenu");
    l_GuiService_0.SelectedCoreObject = nil;
    v6:dispatch(v2(false));
    v6:dispatch(v5(v4.InitalPageKey));
    v3(v4.AnalyticsMenuCloseName, v4.AnalyticsMenuActionName, {});
end;


local l_Parent_0 = script.Parent.Parent;
local v1 = require(l_Parent_0.Actions.SetCurrentPage);
local v2 = require(l_Parent_0.Components.Pages);
return function(v3)
    v3:dispatch(v1(v2.pagesByKey[v3:getState().menuPage].parentPage));
end;


local v0 = require(script.Parent.Parent.Actions.OpenNativeClosePrompt);
return function(v1, v2, v3)
    local function _()
        return tonumber(v2:GetItem("NativeCloseLuaPromptDisplayCount")) or 0;
    end;
    local function _(v5)
        v2:SetItem("NativeCloseLuaPromptDisplayCount", (tostring(v5)));
        v2:flush();
    end;
    local l_v1_NotificationTypeList_0 = v1:GetNotificationTypeList();
    return function(v8)
        local l_closingApp_0 = v8:getState().nativeClosePrompt.closingApp;
        local v10 = tonumber(v2:GetItem("NativeCloseLuaPromptDisplayCount")) or 0;
        if l_closingApp_0 or v3 <= v10 then
            v1:BroadcastNotification("", l_v1_NotificationTypeList_0.NATIVE_EXIT);
            return ;
        else
            v8:dispatch(v0());
            v2:SetItem("NativeCloseLuaPromptDisplayCount", (tostring(v10 + 1)));
            v2:flush();
            return ;
        end;
    end;
end;


local l_GuiService_0 = game:GetService("GuiService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.SetMenuOpen);
local v3 = require(l_Parent_0.Utility.SendAnalytics);
local v4 = require(l_Parent_0.Resources.Constants);
local v5 = require(l_Parent_0.Actions.SetCurrentPage);
local v6 = {
    v4.ReportDialogKey
};
return function(v7, v8)
    return function(v9)
        if not v8 then
            v8 = v4.defaultPageKey;
        end;
        if not table.find(v6, v8) then
            if v8 ~= v4.InitalPageKey then
                l_GuiService_0:SetMenuIsOpen(true, "InGameMenu");
            end;
            v9:dispatch(v2(true));
            v9:dispatch(v5(v8));
        end;
        v3(v4.AnalyticsMenuOpenName, v4.AnalyticsMenuActionName, {
            source = v7
        });
    end;
end;


local l_GuiService_0 = game:GetService("GuiService");
local l_Parent_0 = script.Parent.Parent;
local v2 = require(l_Parent_0.Actions.SetMenuOpen);
local v3 = require(l_Parent_0.Utility.SendAnalytics);
local v4 = require(l_Parent_0.Resources.Constants);
local v5 = require(l_Parent_0.Actions.SetCurrentPage);
local v6 = require(l_Parent_0.Actions.SetMenuIconTooltipOpen);
return function(v7)
    return function(v8)
        l_GuiService_0:SetMenuIsOpen(true, "InGameMenu");
        v8:dispatch(v2(true));
        v8:dispatch(v5(v4.MainPagePageKey));
        if v8:getState().nativeClosePrompt.menuIconTooltipOpen then
            v8:dispatch(v6(false));
        end;
        v3(v4.AnalyticsMenuOpenName, v4.AnalyticsMenuActionName, {
            source = v7
        });
    end;
end;


local l_Players_0 = game:GetService("Players");
local l_RunService_0 = game:GetService("RunService");
local v2 = require(script.Parent.Parent.Actions.OpenReportSentDialog);
return function(v3, v4, v5)
    return function(v6)
        if v5 ~= nil then
            local l_l_Players_0_PlayerByUserId_0 = l_Players_0:GetPlayerByUserId(v5);
            if l_l_Players_0_PlayerByUserId_0 then
                coroutine.wrap(function()
                    l_Players_0:ReportAbuse(l_l_Players_0_PlayerByUserId_0, v3, v4);
                    v6:dispatch(v2());
                end)();
                return ;
            end;
        else
            local v8 = v6:getState();
            local l_name_0 = v8.gameInfo.name;
            local l_description_0 = v8.gameInfo.description;
            if l_name_0 ~= "" then
                local v11 = string.format("User Report: \n    %s \n" .. "Place Title: \n    %s \n" .. "PlaceId: \n    %s \n" .. "Place Description: \n    %s \n", v4, l_name_0, tostring(game.PlaceId), l_description_0);
                coroutine.wrap(function()
                    if not l_RunService_0:IsStudio() then
                        l_Players_0:ReportAbuse(nil, v3, v11);
                    end;
                    v6:dispatch(v2());
                end)();
            end;
        end;
    end;
end;